Ti do un elenco di bitvector di larghezza . Il tuo obiettivo è quello di restituire due bitvector dall'elenco che non hanno 1 in comune, oppure di segnalare che non esiste tale coppia.$n$$k$

Ad esempio, se ti do l'unica soluzione è . In alternativa, l'ingresso non ha soluzione. E qualsiasi elenco che contiene il bitvector tutto-zero e un altro elemento ha una soluzione banale .{ 00110 , 11000 } [ 111 , 011 , 110 , 101 ] 000 ... 0 e { e , 000 ... 0 $[00110, 01100, 11000]$$\{00110, 11000\}$$[111, 011, 110, 101]$$000...0$$e$$\{e, 000...0\}$

Ecco un esempio leggermente più difficile, senza soluzione (ogni riga è un po 'vettoriale, i quadrati neri sono 1 e i quadrati bianchi sono 0):

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

Con quale efficienza è possibile trovare o visualizzare due non bitvector non sovrapposti?

L'algoritmo ingenuo, in cui si confronta semplicemente ogni coppia possibile, è . È possibile fare di meglio?$O(n^2 k)$

Warmup: bitvector casuali

Come warm-up, possiamo iniziare dal caso in cui ogni bitvector viene scelto in modo uniforme a caso. Quindi si scopre che il problema può essere risolto in tempo (più precisamente, può essere sostituito con ).1,6 lg $O(n^{1.6} \min(k, \lg n))$$1.6$$\lg 3$

Prenderemo in considerazione la seguente variante in due serie del problema:

Insiemi trovati di bitvectors, determinare dove esiste senza sovrapposizione pair . s ∈ S , t ∈ $S,T \subseteq \{0,1\}^k$$s \in S, t \in T$

La tecnica di base per risolvere questo problema è dividere e conquistare. Ecco un algoritmo che usa divide-and-conquer:$O(n^{1.6} k)$

1. Dividi e base alla posizione del primo bit. In altre parole, forma , , , .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 : t 0 = 1 $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. Ora ricorsivamente cercare una coppia non sovrapposta da , da e da . Se una chiamata ricorsiva trova una coppia non sovrapposta, emettila in uscita, altrimenti produce "Non esiste una coppia sovrapposta".S 0 , T 1 T 1 , S $S_0,T_0$$S_0,T_1$$T_1,S_0$

Poiché tutti i bitvector sono scelti a caso, possiamo aspettarci e . Pertanto, abbiamo tre chiamate ricorsive e abbiamo ridotto la dimensione del problema di un fattore due (entrambe le serie sono ridotte di un fattore due). Dopo la divisione di , uno dei due set scende alla dimensione 1 e il problema può essere risolto in tempo lineare. Otteniamo una relazione di ricorrenza lungo le linee di , la cui soluzione è . Considerando il tempo di esecuzione in modo più preciso nel caso di due set, vediamo che il tempo di esecuzione è .| T b | ≈ | T | / 2 lg min ( | S | , | T | ) T ( n ) = 3 T ( n / 2 ) + O ( n k ) T ( n ) = O ( n 1.6 k ) $|S_b| \approx |S|/2$$|T_b| \approx |T|/2$$\lg \min(|S|,|T|)$$T(n) = 3T(n/2) + O(nk)$$T(n) = O(n^{1.6} k)$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) k)$

Questo può essere ulteriormente migliorato, osservando che se , la probabilità che esista una coppia non sovrapposta è esponenzialmente piccola. In particolare, se sono due vettori casuali, la probabilità che non si sovrappongano è . Se , ci sono tali coppie, quindi per un limite di unione, la probabilità che esista una coppia non sovrapposta è al massimo . Quando , questo è . Quindi, come fase di pre-elaborazione, sex , y ( 3 / 4 ) k | S | = | T | = N n 2 n 2 ( 3 / 4 ) k k ≥ 2.5 lg n + 100 ≤ 1 / 2 100 k ≥ 2.5 lg n + $k \ge 2.5\lg n+100$$x,y$$(3/4)^k$$|S|=|T|=n$$n^2$$n^2 (3/4)^k$$k \ge 2.5 \lg n+100$$\le 1/2^{100}$$k \ge 2.5 \lg n + 100$, quindi possiamo immediatamente restituire "Non esiste alcuna coppia non sovrapposta" (la probabilità che ciò non sia corretto è trascurabilmente piccola), altrimenti eseguiamo l'algoritmo sopra.

In questo modo otteniamo un tempo di esecuzione di (o per la variante a due set proposta sopra), per il caso speciale in cui i bitvector vengono scelti in modo uniforme a caso.O ( min ( | S | , | T | ) 0,6 max ( | 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))$

Naturalmente, questa non è un'analisi del caso peggiore. I bitvector casuali sono notevolmente più facili del caso peggiore, ma trattiamolo come un riscaldamento, per avere alcune idee che forse possiamo applicare al caso generale.

Lezioni dal riscaldamento

Possiamo imparare alcune lezioni dal riscaldamento sopra. In primo luogo, dividere e conquistare (dividere in una piccola posizione) sembra utile. In secondo luogo, si desidera dividere in una posizione bit con il maggior numero di in quella posizione possibile; più ci sono, minore è la riduzione della dimensione del sottoproblema.$1$$0$

In terzo luogo, ciò suggerisce che il problema si aggrava man mano che la densità di diminuisce - se ci sono pochissimi tra i bitvector (sono principalmente ), il problema sembra piuttosto difficile, poiché ogni divisione si riduce la dimensione dei sottoproblemi un po '. Quindi, definire la densità come la frazione di bit che sono (cioè, tra tutti i bit ) e la densità della posizione dei bit per essere la frazione di bitvector che sono nella posizione .1 0 Δ 1 n k i 1 $1$$1$$0$$\Delta$$1$$nk$$i$$1$$i$

Gestione di una densità molto bassa

Come passo successivo, potremmo chiederci cosa succede se la densità è estremamente piccola. Si scopre che se la densità in ogni posizione di bit è inferiore a , ci viene garantito che esiste una coppia non sovrapposta: esiste un argomento di esistenza (non costruttiva) che mostra che alcuni non sovrapposti la coppia deve esistere. Questo non ci aiuta a trovarlo, ma almeno sappiamo che esiste.$1/\sqrt{k}$

Perché è così? Diciamo che una coppia di bitvector è coperta dalla posizione bit se . Si noti che ogni coppia di bitvector sovrapposti deve essere coperta da una posizione di bit. Ora, se fissiamo una particolare posizione di bit , il numero di coppie che possono essere coperte da quella posizione di bit è al massimo . Sommando tutte le delle posizioni dei bit, troviamo che il numero totale di coppie coperte da una certa posizione dei bit èi x i = y i = 1 i ( n Δ ( i ) ) 2 < n 2 / k k < n $x,y$$i$$x_i=y_i=1$$i$$(n \Delta(i))^2 < n^2/k$$k$$< n^2$. Ciò significa che deve esistere una coppia che non è coperta da alcuna posizione di bit, il che implica che questa coppia non si sovrappone. Quindi se la densità è sufficientemente bassa in ogni posizione di bit, allora sicuramente esiste una coppia non sovrapposta.

Tuttavia, non riesco a identificare un algoritmo veloce per trovare una coppia così non sovrapposta, in questi regimi, anche se ne è garantito uno. Non vedo immediatamente alcuna tecnica che produrrebbe un tempo di esecuzione che ha una dipendenza sub-quadratica da . Quindi, questo è un bel caso speciale su cui concentrarsi, se vuoi passare un po 'di tempo a pensare a questo problema.$n$

Verso un algoritmo del caso generale

Nel caso generale, un euristico naturale sembra essere: scegliere la posizione del bit con il maggior numero di (ovvero, con la più alta densità) e dividerlo. In altre parole:$i$$1$

1. Trova un po 'la posizione che massimizza .Δ ( i $i$$\Delta(i)$

2. Dividi e base alla posizione dei bit . In altre parole, forma , , , .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 : t i = 1 $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. Ora ricorsivamente cercare una coppia non sovrapposta da , da e da . Se una chiamata ricorsiva trova una coppia non sovrapposta, emettila in uscita, altrimenti produce "Non esiste una coppia sovrapposta".S 0 , T 1 T 1 , S $S_0,T_0$$S_0,T_1$$T_1,S_0$

La sfida è analizzare le sue prestazioni nel peggiore dei casi.

Supponiamo che come fase di pre-elaborazione calcoliamo prima la densità di ogni posizione di bit. Inoltre, se per ogni , supponiamo che la fase di pre-elaborazione produca "Esiste una coppia sovrapposta" (mi rendo conto che questo non mostra un esempio di coppia sovrapposta, ma mettiamolo da parte come una sfida separata). Tutto ciò può essere fatto in tempo. Le informazioni sulla densità possono essere gestite in modo efficiente mentre eseguiamo chiamate ricorsive; non sarà il contributo dominante al tempo di esecuzione. iO(nk$\Delta(i) < 1/\sqrt{k}$$i$$O(nk)$

Quale sarà il tempo di esecuzione di questa procedura? Non ne sono sicuro, ma qui ci sono alcune osservazioni che potrebbero aiutare. Ogni livello di ricorsione riduce la dimensione del problema di circa bitvector (ad esempio, da bitvector a bitvector). Pertanto, la ricorsione può raggiungere solo livelli di . Tuttavia, non sono immediatamente sicuro di come contare il numero di foglie nell'albero di ricorsione (ci sono molte meno di foglie), quindi non sono sicuro del tempo di esecuzione che dovrebbe portare per. nn-n/$n/\sqrt{k}$$n$$n-n/\sqrt{k}$ 3$\sqrt{k}$$3^{\sqrt{k}}$

Soluzione più veloce quando , utilizzando la moltiplicazione della matrice$n \approx k$

Supponiamo che . Il nostro obiettivo è fare meglio di un tempo di esecuzione O ( n 2 k ) = O ( n 3 ) .$n = k$$O(n^2k) = O(n^3)$

Possiamo pensare ai bitvector e alle posizioni dei bit come nodi in un grafico. C'è un limite tra un nodo bitvector e un nodo posizione bit quando il bitvector ha un 1 in quella posizione. Il grafico risultante è bipartito (con i nodi che rappresentano i bitvector su un lato e i nodi che rappresentano i bitpositivi sull'altro) e ha nodi.$n + k = 2n$

Data la matrice di adiacenza di un grafico, possiamo dire se esiste un percorso a due hop tra due vertici quadrando M e controllando se la matrice risultante ha un "bordo" tra quei due vertici (cioè l'ingresso del bordo nella matrice quadrata è diverso da zero). Per i nostri scopi, una voce zero nella matrice di adiacenza quadrata corrisponde a una coppia di bitvector non sovrapposti (cioè una soluzione). La mancanza di zero significa che non esiste soluzione.$M$ $M$

La quadratura di una matrice nxn può essere eseguita in tempo , dove ω è noto per essere inferiore a 2.373 e si ipotizza che sia 2 .$O(n^\omega)$$\omega$$2.373$$2$

Quindi l'algoritmo è:

• Convertire i bitvectors e le posizioni di bit in un grafo bipartito con nodi e al massimo n k bordi. Questo richiede tempo O ( n k ) .$n+k$$nk$$O(nk)$
• Calcola la matrice di adiacenza del grafico. Questo richiede tempo e spazio.$O((n+k)^2)$
• Square la matrice di adiacenza. Questo richiede tempo .$O((n+k)^\omega)$
• Cerca nella sezione bitvector della matrice di adiacenza per zero voci. Questo richiede tempo .$O(n^2)$

Il passo più costoso è la quadratura della matrice di adiacenza. Se l'algoritmo complessivo richiede O ( ( n + k ) ω ) = O ( n ω ) tempo, che è migliore del tempo ingenuo O ( n 3 ) .$n=k$$O((n+k)^\omega) = O(n^\omega)$$O(n^3)$

Questa soluzione è anche più veloce quando diventa non troppo lento e non troppo veloce di n . Finché k ∈ Ω ( n ω - 2 ) e k ∈ O ( n $k$$n$$k \in \Omega(n^{\omega-2})$, quindi(n+k)ωè migliore din2k. Perw≈2.373che si traduce inn0.731≤k≤n1.373(asintoticamente). Sewlimita a 2, i limiti si allargano versonϵ≤k≤n2-ϵ.$k \in O(n^\frac{2}{\omega-1})$$(n+k)^\omega$$n^2 k$$w \approx 2.373$$n^{0.731} \leq k \leq n^{1.373}$$w$$n^\epsilon \leq k \leq n^{2-\epsilon}$

Ciò equivale a trovare un vettore di bit che è un sottoinsieme del complemento di un altro vettore; cioè i suoi 1 si verificano solo dove si verificano 0 nell'altro.

Se k (o il numero di 1) è piccolo, puoi ottenere il tempo semplicemente generando tutti i sottoinsiemi del complemento di ciascun bitvector e inserendoli in un trie (usando il backtracking). Se nel trie viene trovato un bitvector (possiamo verificarne ciascuno prima dell'inserimento del complemento-sottoinsieme), allora abbiamo una coppia non sovrapposta.$O(n2^k)$

Se il numero di 1 o 0 è limitato a un numero anche inferiore a k, l'esponente può essere sostituito da quello. L'indicizzazione dei sottoinsiemi può essere su ciascun vettore o sul suo complemento, purché il sondaggio usi il contrario.

C'è anche uno schema per la ricerca di superset in un trie che memorizza ogni vettore solo una volta, ma fa saltare i bit durante le sonde per quella che credo sia una complessità aggregata simile; cioè ha inserimento ma o ( 2 k ) ricerche.$o(k)$$o(2^k)$

Rappresentano i vettori di bit come una matrice M . Prendi i e j tra 1 e n .$n\times k$$M$$i$$j$$n$

, il prodotto scalare del I ° e j esimo vettore, è diverso da zero se, e solo se, i vettori i e j condividono un comune 1. Quindi, per trovare una soluzione, calcolare M M T e restituisce la posizione di una voce zero, se tale voce esiste.$(MM^T)_{ij}$$i$$j$$i$$j$$MM^T$

Complessità

Usando la moltiplicazione ingenua, ciò richiede operazioni aritmetiche . Se n = k , prende le operazioni O ( n 2.37 ) usando l'algoritmo Coppersmith-Winograd assolutamente impraticabile, o O ( n 2.8 ) usando l'algoritmo Strassen. Se k = O ( n 0.302 ) , il problema può essere risolto utilizzando le operazioni n 2 + o ( 1 ) .$O(n^2k)$$n=k$$O(n^{2.37})$$O(n^{2.8})$$k=O(n^{0.302})$$n^{2 + o(1)}$