Я даю вам список из $n$ битвекторов шириной $k$ . Ваша цель - вернуть два битовых вектора из списка, у которых нет общих единиц, или сообщить, что такой пары не существует.

Например, если я дам вам $[00110, 01100, 11000]$ то единственным решением будет $\{00110, 11000\}$ . В качестве альтернативы, вход $[111, 011, 110, 101]$ не имеет решения. И любой список, который содержит нулевой битовый вектор $000...0$ и другой элемент $e$ имеет тривиальное решение $\{e, 000...0\}$ .

Вот немного более сложный пример без решения (каждая строка является битовым вектором, черные квадраты равны 1 с, а белые квадраты равны 0):

■ ■ ■ ■ □ □ □ □ □ □ □ □ □
■ □ □ □ ■ ■ ■ □ □ □ □ □ □ 
■ □ □ □ □ □ □ ■ ■ ■ □ □ □
■ □ □ □ □ □ □ □ □ □ ■ ■ ■
□ ■ □ □ □ ■ □ □ □ ■ ■ □ □
□ ■ □ □ ■ □ □ □ ■ □ □ □ ■
□ ■ □ □ □ □ ■ ■ □ □ □ ■ □ <-- All row pairs share a black square
□ □ ■ □ □ □ ■ □ ■ □ ■ □ □
□ □ ■ □ □ ■ □ ■ □ □ □ □ ■
□ □ ■ □ ■ □ □ □ □ ■ □ ■ □
□ □ □ ■ ■ □ □ ■ □ □ ■ □ □
□ □ □ ■ □ □ ■ □ □ ■ □ □ ■
□ □ □ ■ □ ■ □ □ ■ □ □ ■ □

Насколько эффективно можно найти два непересекающихся битовых вектора или показать, что они не существуют?

Наивным алгоритмом, где вы просто сравниваете каждую возможную пару, является $O(n^2 k)$ . Можно ли сделать лучше?

Разминка: случайные битовые векторы

В качестве разминки мы можем начать со случая, когда каждый битовый вектор выбирается равномерно случайным образом. Тогда оказывается, что проблема может быть решена за $O(n^{1.6} \min(k, \lg n))$ времени (точнее, $1.6$ можно заменить на $\lg 3$ ).

Мы рассмотрим следующий двунаправленный вариант задачи:

С учетом множества из битвекторов, определить , где существует неперекрывающийся пары сек ∈ S , T ∈ T .$S,T \subseteq \{0,1\}^k$$s \in S, t \in T$

Основной метод решения этой проблемы - разделяй и властвуй. Вот алгоритм времени , использующий принцип «разделяй и властвуй»:$O(n^{1.6} k)$

1. Разделите и T на основе первой позиции бита. Другими словами, форма S 0 = { s ∈ S : s 0 = 0 } , S 1 = { s ∈ S : s 0 = 1 } , T 0 = { t ∈ T : t 0 = 0 } , T 1 = { t ∈ T : $S$$T$$S_0 = \{s \in S : s_0=0\}$$S_1 = \{s \in S : s_0 = 1\}$$T_0 = \{t \in T : t_0 = 0\}$ .$T_1 = \{t \in T : t_0 = 1\}$

2. Теперь рекурсивно ищем неперекрывающуюся пару из , из S 0 , T 1 и из T 1 , S 0 . Если какой-либо рекурсивный вызов найдет неперекрывающуюся пару, выведите его, в противном случае выведите «Перекрывающаяся пара не существует».$S_0,T_0$$S_0,T_1$$T_1,S_0$

Поскольку все битовые векторы выбираются случайным образом, мы можем ожидать и | Т б | ≈ | T | / 2 . Таким образом, у нас есть три рекурсивных вызова, и мы уменьшили размер задачи в два раза (оба набора уменьшились в размере в два раза). После разбиения lg min ( | S | , | T | ) один из двух наборов уменьшается до размера 1, и проблема может быть решена за линейное время. Мы получаем рекуррентное соотношение в соответствии с$|S_b| \approx |S|/2$$|T_b| \approx |T|/2$$\lg \min(|S|,|T|)$ , чье решение T ( n ) = O ( n 1.6 k ) . Учет времени работы более точно в случае с двумя наборами, мы видим, что время работы составляет O ( мин ( | S | , | T | ) 0,6 макс ( | S | , |$T(n) = 3T(n/2) + O(nk)$$T(n) = O(n^{1.6} k)$ .$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) k)$

Это можно еще улучшить, отметив, что если , то вероятность того, что непересекающаяся пара существует, экспоненциально мала. В частности, если х , у двух случайных векторов, вероятность того, что они не перекрывающиеся является ( 3 / 4 ) K . Если | S | = | T | = n , существует n 2 таких пар, так что по границе объединения вероятность того, что неперекрывающаяся пара существует, не превышает n 2 ( $k \ge 2.5\lg n+100$$x,y$$(3/4)^k$$|S|=|T|=n$$n^2$ . Когда к ≥ 2,5 Л.Г. п + 100 , это ≤ 1 / 2 100 . Таким образом, в качестве шага предварительной обработки, если k ≥ 2,5 lg n + 100 , мы можем сразу же вернуть «Не существует непересекающейся пары» (вероятность того, что это неверно, пренебрежимо мала), в противном случае мы запускаем описанный выше алгоритм.$n^2 (3/4)^k$$k \ge 2.5 \lg n+100$$\le 1/2^{100}$$k \ge 2.5 \lg n + 100$

Таким образом, мы достигаем время работы (или O ( мин ( | S | , | T | ) 0,6 макс ( | S | , | T | ) min ( k , lg n) ) ) для предложенного выше варианта с двумя наборами), для частного случая, когда битовые векторы выбираются случайным образом равномерно.$O(n^{1.6} \min(k, \lg n))$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) \min(k, \lg n))$

Конечно, это не худший анализ. Случайные битовые векторы значительно проще, чем в худшем случае, но давайте рассмотрим это как разминку, чтобы получить некоторые идеи, которые, возможно, мы сможем применить к общему случаю.

Уроки разминки

Мы можем выучить несколько уроков из разминки выше. Во-первых, «разделяй и властвуй» (разделяя на битовую позицию) кажется полезным. Во- вторых, вы хотите разделить на позицию бита с таким количеством «S в таком положении , как это возможно; чем больше 0 , тем меньше уменьшение размера подзадачи.$1$$0$

В- третьих, это говорит о том, что эта проблема становится все труднее , как плотность «S становится все меньше - если есть очень мало 1 » S среди битвекторов (они в основном 0 «s), проблема выглядит довольно сложно, так как каждый раскол уменьшает размер подзадач немного. Итак, определите плотность Δ, чтобы быть долей битов, которые равны 1 (то есть из всех n k битов), и плотность позиции бита i, чтобы быть долей векторов битов, которые равны 1 в позиции i .$1$$1$$0$$\Delta$$1$$nk$$i$$1$$i$

Обработка очень низкой плотности

В качестве следующего шага мы могли бы задаться вопросом, что произойдет, если плотность чрезвычайно мала. Оказывается, что если плотность в каждой позиции бита меньше , мы гарантируем, что существует неперекрывающаяся пара: существует (неконструктивный) аргумент существования, показывающий, что некоторая непересекающаяся пара должна существовать. Это не помогает нам найти его, но, по крайней мере, мы знаем, что оно существует.$1/\sqrt{k}$

Почему это так? Скажем , что пара битвекторов будет покрыта на битовой позиции я , если х я = у я = 1 . Обратите внимание, что каждая пара перекрывающихся битовых векторов должна быть покрыта некоторой битовой позицией. Теперь, если мы фиксируем конкретную битовую позицию i , количество пар, которые могут быть покрыты этой битовой позицией, составляет самое большее ( n Δ ( i ) ) 2 < n 2 / k . Суммирование по всем $x,y$$i$$x_i=y_i=1$$i$$(n \Delta(i))^2 < n^2/k$$k$из битовых позиций мы находим, что общее количество пар, которые покрыты некоторой битовой позицией, составляет . Это означает, что должна существовать некоторая пара, которая не покрыта какой-либо битовой позицией, что означает, что эта пара не перекрывается. Таким образом, если плотность достаточно низкая в каждой позиции бита, то непересекающаяся пара наверняка существует.$< n^2$

Однако я затрудняюсь определить быстрый алгоритм для нахождения такой неперекрывающейся пары в этих режимах, хотя гарантированно существует такая. Я не сразу вижу какие-либо методы, которые дали бы время выполнения, которое имеет субквадратичную зависимость от . Итак, это хороший особый случай, на котором стоит сосредоточиться, если вы хотите потратить некоторое время на обдумывание этой проблемы.$n$

На пути к общему алгоритму

В общем случае естественная эвристика выглядит так: выберите битовую позицию с наибольшим числом 1 (т. Е. С наибольшей плотностью) и разделите ее. Другими словами:$i$$1$

1. Найдите положение бита которое максимизирует Δ ( i ) .$i$$\Delta(i)$

2. Разделить и T на основе положения бита i . Другими словами, форма S 0 = { s ∈ S : s i = 0 } , S 1 = { s ∈ S : s i = 1 } , T 0 = { t ∈ T : t i = 0 } , T 1 = { t ∈ T $S$$T$$i$$S_0 = \{s \in S : s_i=0\}$$S_1 = \{s \in S : s_i = 1\}$$T_0 = \{t \in T : t_i = 0\}$ .$T_1 = \{t \in T : t_i = 1\}$

3. Теперь рекурсивно ищем неперекрывающуюся пару из , из S 0 , T 1 и из T 1 , S 0 . Если какой-либо рекурсивный вызов найдет неперекрывающуюся пару, выведите его, в противном случае выведите «Перекрывающаяся пара не существует».$S_0,T_0$$S_0,T_1$$T_1,S_0$

Задача состоит в том, чтобы проанализировать его производительность в худшем случае.

Давайте предположим, что в качестве шага предварительной обработки мы сначала вычислим плотность каждой позиции бита. Также, если для каждогоi, предположим, что на этапе предварительной обработки выводится «перекрывающаяся пара» (я понимаю, что это не демонстрирует пример перекрывающейся пары, но давайте отложим это как отдельную задачу). Все это можно сделать заO(nk)раз. Информация о плотности может поддерживаться эффективно, поскольку мы делаем рекурсивные вызовы; это не будет доминирующим фактором времени выполнения.$\Delta(i) < 1/\sqrt{k}$$i$$O(nk)$

Какой будет продолжительность этой процедуры? Я не уверен, но вот несколько замечаний, которые могут помочь. Каждый уровень рекурсии уменьшает размер проблемы примерно на битовых векторов (например, отnбитовых векторов доn-n/$n/\sqrt{k}$$n$ битвекторов). Поэтому рекурсия может идти только о$n-n/\sqrt{k}$ уровней глубоко. Тем не менее, я не сразу уверен, как посчитать количество листьев в дереве рекурсии (их намного меньше, чем3$\sqrt{k}$ уходит), поэтому я не уверен, к какому времени это должно привести.$3^{\sqrt{k}}$

Faster solution when $n \approx k$, using matrix multiplication

Suppose that $n = k$. Our goal is to do better than an $O(n^2k) = O(n^3)$ running time.

We can think of the bitvectors and bit positions as nodes in a graph. There is an edge between a bitvector node and a bit position node when the bitvector has a 1 in that position. The resulting graph is bipartite (with the bitvector-representing nodes on one side and the bitposition-representing nodes on the other), and has $n + k = 2n$ nodes.

Given the adjacency matrix $M$ of a graph, we can tell if there is a two-hop path between two vertices by squaring $M$ and checking if the resulting matrix has an "edge" between those two vertices (i.e. the edge's entry in the squared matrix is non-zero). For our purposes, a zero entry in the squared adjacency matrix corresponds to a non-overlapping pair of bitvectors (i.e. a solution). A lack of any zeroes means there's no solution.

Squaring an n x n matrix can be done in $O(n^\omega)$ time, where $\omega$ is known to be under $2.373$ and conjectured to be $2$.

So the algorithm is:

• Convert the bitvectors and bit positions into a bipartite graph with $n+k$ nodes and at most $nk$ edges. This takes $O(nk)$ time.
• Compute the adjacency matrix of the graph. This takes $O((n+k)^2)$ time and space.
• Square the adjacency matrix. This takes $O((n+k)^\omega)$ time.
• Search the bitvector section of the adjacency matrix for zero entries. This takes $O(n^2)$ time.

The most expensive step is squaring the adjacency matrix. If $n=k$ then the overall algorithm takes $O((n+k)^\omega) = O(n^\omega)$ time, which is better than the naive $O(n^3)$ time.

This solution is also faster when $k$ grows not-too-much-slower and not-too-much-faster than $n$. As long as $k \in \Omega(n^{\omega-2})$ and $k \in O(n^\frac{2}{\omega-1})$, then $(n+k)^\omega$ is better than $n^2 k$. For $w \approx 2.373$ that translates to $n^{0.731} \leq k \leq n^{1.373}$ (asymptotically). If $w$ limits to 2, then the bounds widen towards $n^\epsilon \leq k \leq n^{2-\epsilon}$.

This is equivalent to finding a bit vector which is a subset of the complement of another vector; ie its 1's occur only where 0's occur in the other.

If k (or the number of 1's) is small, you can get $O(n2^k)$ time by simply generating all the subsets of the complement of each bitvector and putting them in a trie (using backtracking). If a bitvector is found in the trie (we can check each before complement-subset insertion) then we have a non-overlapping pair.

If the number of 1's or 0's is bounded to an even lower number than k, then the exponent can be replaced by that. The subset-indexing can be on either each vector or its complement, so long as probing uses the opposite.

There's also a scheme for superset-finding in a trie that only stores each vector only once, but does bit-skipping during probes for what I believe is similar aggregate complexity; ie it has $o(k)$ insertion but $o(2^k)$ searches.

Represent the bit vectors as an $n\times k$ matrix $M$. Take $i$ and $j$ between 1 and $n$.

$(MM^T)_{ij}$, the dot product of the $i$th and $j$th vector, is non-zero if, and only if, vectors $i$ and $j$ share a common 1. So, to find a solution, compute $MM^T$ and return the position of a zero entry, if such an entry exists.

Complexity

Using naive multiplication, this requires $O(n^2k)$ arithmetic operations. If $n=k$, it takes $O(n^{2.37})$ operations using the utterly impractical Coppersmith-Winograd algorithm, or $O(n^{2.8})$ using the Strassen algorithm. If $k=O(n^{0.302})$, then the problem may be solved using $n^{2 + o(1)}$ operations.