与えられた2つの整数AとBについて、A = X * YおよびB = X xor YとなるようなXとYのペアを見つけます。


22

私は、競合するプログラミングの本で見つけたこの問題に苦労していますが、それを行う方法の解決策がありません。

与えられた2つの整数AB(64ビット整数型に適合可能)について、Aが奇数の場合、A = X * YとB = X xor YのようなXとYのペアを見つけます。私のアプローチはリストすることでしたAのすべての約数。sqrt(A)の下の数値とsqrt(A)上の数値をペアにして、Aまで乗算し 、それらのxorがBに等しいかどうかを確認します。しかし、それで十分かどうかはわかりません。この問題の良い解決策/アルゴリズムは何でしょうか?


1
整数演算子とビット演算子を混在させるのは奇妙です。それは実際にありますX*YX&Y
Eric Duminil

それは乗算です。(*)
Aster W.

このタスクを解決するためのコード行をすでに記述しましたか?どのプログラミング言語を使用する予定ですか?
Lynx 242

回答:


5

以下は、私たちが知っているルールを遵守する単純な再帰です。(1)奇数の被乗数のみが奇数の倍数を生成するため、XとYの両方の最下位ビットが設定されます。(2)XをBの最上位ビットに設定する場合、Yはsqrt(A)より大きくすることはできません。(3)Bの現在のビットに従ってXまたはYのビットを設定します。

次のPythonコードは、Matt Timmermansのサンプルコードから選んだランダムペアの1つを除いて、300回未満の反復になります。しかし、最初のものは231,199回の反復を行いました:)

from math import sqrt

def f(A, B):
  i = 64
  while not ((1<<i) & B):
    i = i - 1
  X = 1 | (1 << i)

  sqrtA = int(sqrt(A))

  j = 64
  while not ((1<<j) & sqrtA):
    j = j - 1

  if (j > i):
    i = j + 1

  memo = {"it": 0, "stop": False, "solution": []}

  def g(b, x, y):
    memo["it"] = memo["it"] + 1
    if memo["stop"]:
      return []

    if y > sqrtA or y * x > A:
      return []

    if b == 0:
      if x * y == A:
        memo["solution"].append((x, y))
        memo["stop"] = True
        return [(x, y)]
      else:
        return []

    bit = 1 << b

    if B & bit:
      return g(b - 1, x, y | bit) + g(b - 1, x | bit, y)
    else:
      return g(b - 1, x | bit, y | bit) + g(b - 1, x, y)

  g(i - 1, X, 1)
  return memo

vals = [
  (6872997084689100999, 2637233646), # 1048 checks with Matt's code
  (3461781732514363153, 262193934464), # 8756 checks with Matt's code
  (931590259044275343, 5343859294), # 4628 checks with Matt's code
  (2390503072583010999, 22219728382), # 5188 checks with Matt's code
  (412975927819062465, 9399702487040), # 8324 checks with Matt's code
  (9105477787064988985, 211755297373604352), # 3204 checks with Matt's code
  (4978113409908739575,67966612030), # 5232 checks with Matt's code
  (6175356111962773143,1264664368613886), # 3756 checks with Matt's code
  (648518352783802375, 6) # B smaller than sqrt(A)
]

for A, B in vals:
  memo = f(A, B)
  [(x, y)] = memo["solution"]
  print "x, y: %s, %s" % (x, y)
  print "A:   %s" % A
  print "x*y: %s" % (x * y)
  print "B:   %s" % B
  print "x^y: %s" % (x ^ y)
  print "%s iterations" % memo["it"]
  print ""

出力:

x, y: 4251585939, 1616572541
A:   6872997084689100999
x*y: 6872997084689100999
B:   2637233646
x^y: 2637233646
231199 iterations

x, y: 262180735447, 13203799
A:   3461781732514363153
x*y: 3461781732514363153
B:   262193934464
x^y: 262193934464
73 iterations

x, y: 5171068311, 180154313
A:   931590259044275343
x*y: 931590259044275343
B:   5343859294
x^y: 5343859294
257 iterations

x, y: 22180179939, 107776541
A:   2390503072583010999
x*y: 2390503072583010999
B:   22219728382
x^y: 22219728382
67 iterations

x, y: 9399702465439, 43935
A:   412975927819062465
x*y: 412975927819062465
B:   9399702487040
x^y: 9399702487040
85 iterations

x, y: 211755297373604395, 43
A:   9105477787064988985
x*y: 9105477787064988985
B:   211755297373604352
x^y: 211755297373604352
113 iterations

x, y: 68039759325, 73164771
A:   4978113409908739575
x*y: 4978113409908739575
B:   67966612030
x^y: 67966612030
69 iterations

x, y: 1264664368618221, 4883
A:   6175356111962773143
x*y: 6175356111962773143
B:   1264664368613886
x^y: 1264664368613886
99 iterations

x, y: 805306375, 805306369
A:   648518352783802375
x*y: 648518352783802375
B:   6
x^y: 6
59 iterations

これは、B <sqrt(A)の場合、たとえばX == Yの場合は機能しません
Matt Timmermans

X == Yは最も単純な例です。Bは、X = 0x30000001、Y = 0x30000007、A = X * Y、B = 6などの任意の数<sqrt(A)にすることができます
Matt Timmermans

@MattTimmermans素晴らしいキャッチ。処理とあなたの例をテストに追加しました。テストは59回の反復で解決されます。他の問題が見つかった場合(またはこの問題が未解決のようである場合)にお知らせください。
גלעדברקן

面白い。あなたがそれを働かせたとき、私はそれが高価であると思っていました。231199のケースでは高価なケースがあることはわかっていますが、それらを特徴付けるのは困難です。とにかく、これは今うまく機能するように見えます。
Matt Timmermans、

9

少なくとも1つの因子がsqrt(A)以下であることを知っています。それを1つのXにします。

Xのビット長は、Aの長さの約半分になります。

したがって、Xの上位ビット(sqrt(A)よりも値が高いもの)はすべて0であり、Bの対応するビットはYの対応するビットと同じ値でなければなりません。

Yの上位ビットを知ると、対応する係数X = A / Yの範囲がかなり小さくなります。Yの可能な最大値と最小値にそれぞれ対応するXminとXmaxを計算します。Xmaxもsqrt(A)以下でなければならないことに注意してください。

次に、XminとXmaxの間のすべての可能なXを試します。あまり多くないので、それほど長くはかかりません。


素敵な解決策!そのようなXがいくつ存在するかの限界はありますか?
ciamej

Yの上位ビットがすべて0の場合、それは最大でsqrt(A)/ 2です。ただし、除数はそれらの数が少なくなります。:あなたはそれを心配している場合は、フェルマーの因子分解法と除数を見つけることによって確認するために数を減らすことができen.wikipedia.org/wiki/Fermat%27s_factorization_method
マット・Timmermans

1
これは良い洞察(+1)ですが、64ビット整数の場合、sqrt(A)/ 2は10億以上になる可能性があります。典型的な「競争プログラミング」の状況では、それでもまだ遅すぎるようです。(免責事項:私はプログラミング競技をしたことがないので、おそらくこれについて間違っています。)おそらく、これと組み合わせることができるさらなる洞察がありますか?
ruakh

2
フェルマーの方法を使用して範囲内の可能な除数を見つける場合、それはsqrt(sqrt(A))に減少すると思います。これは確かに問題ありません
Matt Timmermans

6

この問題を解決するための他の簡単な方法は、下という事実に依存しているn個の XYとX XOR Yのビットは、下部のみに依存のnあなたは下のために可能な答えを使用することができ、したがって、XとYのビットのn制限するビット完了するまで、下位n + 1ビットの可能な回答。

残念ながら、単一のnには複数の可能性があることがわかった。多くの可能性がどのくらいの頻度であるかはわかりませんが、おそらくそれほど頻繁ではないので、これは競争の状況では問題ないかもしれません。確率的には、nビットのソリューションはn + 1ビットに対して0または2つのソリューションを等しい確率で提供するため、可能性はほとんどありません。

ランダム入力ではかなりうまくいくようです。テストに使用したコードは次のとおりです。

public static void solve(long A, long B)
{
    List<Long> sols = new ArrayList<>();
    List<Long> prevSols = new ArrayList<>();
    sols.add(0L);
    long tests=0;
    System.out.print("Solving "+A+","+B+"... ");
    for (long bit=1; (A/bit)>=bit; bit<<=1)
    {
        tests += sols.size();
        {
            List<Long> t = prevSols;
            prevSols = sols;
            sols = t;
        }
        final long mask = bit|(bit-1);
        sols.clear();
        for (long prevx : prevSols)
        {
            long prevy = (prevx^B) & mask;
            if ((((prevx*prevy)^A)&mask) == 0)
            {
                sols.add(prevx);
            }
            long x = prevx | bit;
            long y = (x^B)&mask;
            if ((((x*y)^A)&mask) == 0)
            {
                sols.add(x);
            }
        }
    }
    tests += sols.size();
    {
        List<Long> t = prevSols;
        prevSols = sols;
        sols = t;
    }
    sols.clear();
    for (long testx: prevSols)
    {
        if (A/testx >= testx)
        {
            long testy = B^testx;
            if (testx * testy == A)
            {
                sols.add(testx);
            }
        }
    }

    System.out.println("" + tests + " checks -> X=" + sols);
}
public static void main(String[] args)
{
    Random rand = new Random();
    for (int range=Integer.MAX_VALUE; range > 32; range -= (range>>5))
    {
        long A = rand.nextLong() & Long.MAX_VALUE;
        long X = (rand.nextInt(range)) + 2L;
        X|=1;
        long Y = A/X;
        if (Y==0)
        {
            Y = rand.nextInt(65536);
        }
        Y|=1;
        solve(X*Y, X^Y);
    }
}

ここで結果を確認できます:https : //ideone.com/cEuHkQ

通常は数千回のチェックで済むようです。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.