минимальная сумма, необходимая для того, чтобы xor некоторых целых чисел равнялся нулю

вот вопрос, который касается алгоритма и побитовой операции xor. Нам дано x1*x2*x3*....*xn=P, где звезда(*) операция представляет собой операцию XOR(побитовая) и x1 - xn-положительные целые числа. P также является положительным целым числом. Нам нужно найти min(a1+a2+a3+.....Ан)такое, что это отношение имеет-->(x1+a1)*(x2+a2)*(x3+a3)*....*(xn+an)=0. "+"представляет собой нормальную операцию сложения.

12
algorithm xor

3 ответов

повторное утверждение как ограниченная целочисленная задача линейного программирования

проблема может быть переформулирована как следующая ограниченная задача ILP (целочисленного линейного программирования).

Let x1,...,xN be as in the original problem, i.e. the goal is to minimize(a1+...+aN)
under the conditions (x1+a1) XOR ... (xN+aN) = 0, a1,...,aN >= 0.

The following is than an equivalent bounded ILP:
Find b[k,i] (0 <= k <= K, 1 <= i <= N) and s[k] (0 <= k <= K) such that
  (A) b[k,i] in {0, 1} for all i=1..n, k=0..K,
  (B) s[k] is an integer >= 0 for all k=0..K,
  (C) sum(b[k,i]*2^k, k=0..K) >= x[i] for all i = 1..N,
  (D) sum(b[k,i], i=1..N) = 2*s[k] for all k = 0..K
and minimize
  sum(b[k,i]*2^k, i=1..n, k=0..K).

From a solution of the bounded ILP the ai's are obtained by
  a[i] = sum(b[k,i]*2^k, k=0..(K-1)) - x[i]

b[k, i]-это просто k-й бит двоичного представления (xi+ai) здесь (условия (A) и (C)). Чтобы сделать общий XOR нулевым, четное число b[k, i] должно быть 1 для каждого k. Это представлено условиями (B) и (D). (Обратите внимание, что левая сумма в (D) должна быть, даже если она равна to 2 * s[k] и s[k] - целое число).

K, т. е. количество битов (плюс один, фактически), необходимое для представления всех (xi+ai), должно быть определено заранее. Выбор K такой, что все xi

существование решения

игнорирование условие минимальности, проблема может быть переформулирована как

учитывая x, y z с x

учитывая экземпляр вашей исходной проблемы, с N >= 2. Пусть x=x1, y=x2, z=(x3 XOR x4 XOR ... xn). Если вы найдете подходящие a и b, установите a1=a, a2=b, a3=...=an=0 для получения решения исходной задачи.

упрощенная задача решена (опять же,игнорировать минимальности) by

  1. если (y XOR z) > = x, то a: = ((y XOR z) - x), b := 0 является решением (*)
  2. если (x XOR z) > = y, то a := 0, b := ((x XOR z) - y) является решением (*)
  3. в противном случае выберите a такое, что (x+a) XOR z >= y. Такой a всегда существует, вы можете, например, позволить a: = 2^k с 2^k > max (x,y,z). Установка b: = ((x+a) XOR z) - y) дает решение (*)

(*) чтобы увидеть, что это действительно решения, вам просто нужно применить немного алгебра. Например, в случае (1), после замены a и b, вы получаете: (x+(y XOR z)-x) XOR (y+0). Который идентичен: (y XOR z) XOR y и, следовательно,: z. q.e.d. Случай (2) работает аналогично. В случае (3) Вы получаете: (x+a) XOR (y+((x+a) XOR z)-y) = (x+a) XOR ((x+a) XOR z) = z.

это показывает, что для N >= 2, Решение всегда существует.

являются ли эти решения минимальными, я не знаю. В случае (3), это вполне очевидно, зависит от выбора, так по крайней мере вам придется придумать оптимальный выбор для А. Возможно также, что исходная проблема допускает меньшие решения, чем упрощенная проблема. Ануэй, может быть, это повторение помогает кому-то понять полное решение.

кстати, тот факт, что исходные проблемы по существу оставляют вам полную свободу того, как "распределить" значения коррекции ai по xi, заставляет меня задуматься, не эквивалентно ли это какой-то проблеме рюкзака. Если это так, нахождение минимального решение может быть NP-трудной.

замечания относительно минимальности

возьмите следующую проблему

(1+a1) XOR (3+a2) XOR (6+a3) = 0

в двоичном формате, то есть

(001b+a1) XOR (011b+a2) XOR (110b+a3) = 0

остаток для a1=a2=a3=0 равен 001b XOR 011b XOR 110b = 100b. Таким образом,очевидным решением является a1=4,a2=0, a3=0. Или же A1=0, a2=4, a3=0. Это решение не минимальный хотя - следующее решение меньше

a1=1, a2=1, a3=0

это также минимально, так как все меньше решения могут иметь только один ненулевой ai, и все члены (2 XOR 3 XOR 6), (1 XOR 4 XOR 6), (1 XOR 3 XOR 7) ненулевые.

это показывает, что никакой алгоритм gree, который работает снизу (т. е. самый низкий бит) вверх, не может работать, так как такой алгоритм пропустит первые два бита, так как их остаток равен нулю изначально.

он также показывает, что вы не можете выбрать определенный ненулевой бит k от остатка и еще ноль добавить 2^k to один из xi. Иногда вам нужно добавить его в несколько xi, чтобы найти минимальное решение.

это подталкивает меня немного дальше к убеждению, что найти минимальное решение является сравнительно сложной проблемой.

4

ссылаясь на мой комментарий - на вопрос еще не ответил:

  1. отрицательный ai, по-видимому, необходим: для случая N=1, A1= - x1 является решением проблемы. Поэтому я предполагаю, что отрицательный ИИ разрешен и в общем случае.

  2. тогда для N=2 вообще нет решения ("min"), кроме того, что существует предел тому, какие (отрицательные) числа могут быть представлены в компьютере:

Для N=2 множество: a1=x2+K и a2=x1 + K. Это дает:

(x1+x2+K) XOR (x2+x1+K) = 0, независимо от K

сумма (a1 + a2) = (x1 + x2 + 2*K)

нет минимального решения: мы можем сделать K еще более отрицательным.

аналогично для N>2: для n четных сделайте парные "решения" как для N=2 (с произвольными K); для n нечетных, один из них - обработайте его как для N=1 - а остальные N-1 обрабатываются как для четных N.

во всех случаях вы строите ноль XOR НОЛЬ XOR С НУЛЕМ ... = НУЛЬ, где ноль всегда является парой типа (am = xm+1 + K; am+1 = xm + K), за исключением случаев, когда n нечетно, где у вас есть еще один фактор, т. е. типа {am = -xm). За исключением N=1, решения могут стать настолько отрицательными, насколько вам нравится.

1

возможно, первый шаг к минимуму-N>1, Все a (i) положительные - по следующим линиям. Позвольте мне сначала изложить некоторые термины.

инициализировать y(i) = x(i); y (i) означает(x(i)+a(i)), поэтому мы инициализируем фактически a (i)=0 (для i=1..Северный.) Аналогично, определите Q = y(1)^y (2)^...^y (N) (^означает XOR); первоначально Q=P.

мы отрегулируем y(i), чтобы сделать Q нулевым, всегда сохраняя y(i)>=x(i) - т. е.: a (i)>=0.

рассмотрим для каждого числа (x,y,a,P,Q) его двоичный (bit-)расширение, нумерация битов на m=0,1,2,..: бит m представляет значение 2* * m-часть числа.

обратите внимание, что бит ненулевой в Q тогда и только тогда, когда число y(i), которые имеют тот же бит ненулевой нечетно.

действуйте следующим образом. Сканируйте оскорбительные биты (значение 1) в Q сверху вниз, т. е.: начиная с самого высокого ("в настоящее время оставшегося") бита, который равен 1. Пусть это будет бит #m.

у нас есть два случая:

случай A. существует по крайней мере один y (i), который имеет ноль в бит m. Определите C как совокупность всех таких y (i).

мы выберем один из них (см. ниже) и установим его M-бит на 1, т. е. изменим

 y(i) = y(i)+(2**m). For the moment, just define INCREMENT=(2**m).

чтобы определить наш выбор y (i) в коллекции C, мы пытаемся частично компенсировать приращение (2**m) ДЕКРЕМЕНТОМ как можно большим:

перебирать биты m-1, m-2, ... пока у нас есть немного #N, где (1.) Q имеет 1 (т. е. еще один оскорбительный бит, который мы хотим удалить) и (2.) по крайней мере один из y (i) в C также имеет 1.

если это удастся, то (1.) set:

INCREMENT = INCREMENT - 2**n (note that this remains positive);

(2.) уменьшите коллекцию C, чтобы сохранить только те y (i), которые имеют бит #n ненулевой; и (3.) повторите процесс, сканируя биты еще ниже.

как только мы не сможем продолжить, выберите произвольно один из оставшихся y(i) из C и увеличьте его с шагом. Обновление Q. Это удаляет биты {m,n,...} из Q путем добавления

 (2**m - 2**n - ...)

к выбранному y(i), устанавливает свой бит #m в 1 (он был 0), и свои биты n,... для 0 (это были 1).

случай B. Ни один из y (i) не имеет нуля в бит #m. В этом случае:

перебирать биты k=m+1, m+2, ... пока по крайней мере два y(i) не будут иметь ноль в этом бите. Определите C1 как коллекцию всех таких y (i) и сделайте копию в коллекцию C2. Также определите

INCREMENT1 as (2**k - 2**m) and set INCREMENT2 = 2**k.

Process {C1, INCREMENT1} как мы сделали в случае A.

удалите окончательный выбор y (i) из коллекции C2. Затем обрабатывать {С2, INCREMENT2} аналогичным образом.

повторите все это, пока все биты в Q не будут равны нулю.

1