Trovare il massimo XOR di due numeri in un intervallo: possiamo fare meglio del quadratico?

Supponiamo stiamo dato due numeri $l$ e e che vogliamo trovare per l \ le i, \, j \ le r .$r$$\max{(i\oplus j)}$$l\le i,\,j\le r$

L'algoritmo ingenuo controlla semplicemente tutte le coppie possibili; ad esempio in ruby ​​avremmo:

def max_xor(l, r)
  max = 0

  (l..r).each do |i|
    (i..r).each do |j|
      if (i ^ j > max)
        max = i ^ j
      end
    end
  end

  max
end

Ho la sensazione che possiamo fare meglio di secondo grado. Esiste un algoritmo migliore per questo problema?

Possiamo raggiungere runtime lineare nella lunghezza della rappresentazione binaria di e :$n$$l$$r$

Il prefisso nella rappresentazione binaria di e , che è la stessa per entrambi i valori, è anche lo stesso per tutti i valori tra loro. Quindi questi bit saranno sempre .$p$$l$$r$$0$

Poiché , il bit seguente questo prefisso sarà a e in . Inoltre, i numeri e sono entrambi nell'intervallo.$r>l$$1$$r$$0$$l$$p10^{n-|p|-1}$$p01^{n-|p|-1}$

Quindi il massimo che stiamo cercando è .$0^{|p|}1^{n-|p|}$

È possibile farlo in tempo .$\mathcal{O}(\log r)$

Il massimo XOR possibile di due numeri interi qualsiasi da un intervallo può essere determinato da l ⊕ r , assumendo che l , r siano numeri interi. Questo valore è uguale a 2 p - 1 , dove p è il valore più piccolo in modo che 2 p sia maggiore di l ⊕ r . $[l, r]$$l \oplus r$$l, r$$2^p-1$$p$$2^p$$l \oplus r$

Ecco un'implementazione in C ++

int maximumXOR(int l, int r) {
    int q = l ^ r, a = 1;
    while(q){
        q /= 2;
        a <<= 1;
    }
    return --a;
}

Dobbiamo massimizzare lo xor tra "piccolo" e "alto". Facciamo un esempio per capirlo.

5 xo 2 = 101 xo 010 primo caso: il bit MSB non è impostato per entrambi i valori nell'intervallo. Se si desidera massimizzare questo, ciò che dobbiamo fare è mantenere l'MSB di 5 (100) così com'è e pensare massimizzando i bit inferiori rimanenti. Come sappiamo che i bit più bassi saranno tutti uno per il caso in cui tutto è 11, che non è altro che 3, ovvero 2 ^ 2-1. Poiché il problema sta parlando dell'intervallo tra 2 e 5, abbiamo sicuramente 3 nell'intervallo. Quindi tutto ciò che dobbiamo fare è scoprire il set di MSB più alto nel più grande dei 2 valori e aggiungere i rimanenti 1 per i bit inferiori.

secondo caso: per quanto riguarda il caso in cui MSB sia impostato per entrambi i valori nell'intervallo che fa xor avremo sicuramente quei bit impostati come 0 e dobbiamo tornare ai bit più bassi. Anche in questo caso per bit inferiori dobbiamo ripetere la stessa logica del primo caso. esempio: (10, 12) (1010, 1100) Come puoi vedere entrambi hanno MSB impostato su 1, allora dobbiamo tornare ai bit inferiori che sono 010 e 100. Ora questo problema è lo stesso del primo caso.

Esistono diversi modi per codificare questo. Quello che ho fatto è stato fare solo lo xor tra "piccolo" e "alto" e questo rimuoverà il bit MSB se sia "piccolo" che "alto" hanno impostato il bit MSB. In caso contrario, verrà preservato il bit MSB. Dopo quello sto provando a fare tutti i bit più bassi 1 scoprendo la potenza massima di 2 nell'uscita xored e sottraendo da 1.

def range_xor_max(small, high):
  if small == high:
    return 0
  xor = small ^ high
  #how many power of 2 is present
  how_many_power_of_2 = math.log(xor, 2)
  #we need to make all one's below the highest set bit
  return 2**int(math.floor(how_many_power_of_2)+1) - 1

Beh, è possibile utilizzare la XOR di L e r per trovare la risposta.

Supponiamo che l = 4 e r = 6.

l = 100, r = 110 (equivalenti binari di questi numeri)

l⊕r = 0 10

Ciò significa che il valore massimo che stai cercando avrà sicuramente il suo primo bit (MSB) come zero. (Pensaci, è anche possibile che il tuo valore massimo abbia un 1 nel primo bit? Se fosse 01010 e 00101, lo xor sarebbe stato = 01 111, ovvero il valore massimo tra 01010 e 00101 avrà sicuramente un 1 nel loro secondo bit da sinistra, non è possibile ottenere un 1 prima del secondo bit da sinistra, cioè nel primo bit da sinistra)

Quindi, ti rimangono i restanti 2 bit per trovare il massimo. Sappiamo che il valore massimo possibile quando abbiamo n bit con noi è = 2 ⁿ −1, quindi la risposta in questo caso sarà 2 ² -1 = 4-1 = 3.

Dall'esempio sopra, possiamo creare un algoritmo generale per questo.

Passaggio 1. num = numero di bit richiesti per rappresentare max ( l , r )

Passaggio 2. res = l ⊕ r

Passaggio 3. pos = Posizione del primo bit impostato da sinistra in res (indicizzazione basata su 0)

Passaggio 4. n = num - pos

Passaggio 5. ans = 2 ⁿ −1

Complessità temporale = O (n)

Per ogni cifra binaria, ci sono 4 possibilità: 1_e_1, 1_e_0, 0_e_1 o 0_e_0. Le possibili cifre inferiori non fanno alcuna differenza o log-vanishingly piccola per l'output xor di scelta della cifra successiva. Il miglior algoritmo possibile è ignorare tutte le cifre inferiori e considerare solo le successive 2 disponibili, date le precedenti scelte sulle cifre più alte. Se questo è 1_and_1 o 0_and_0, la scelta è chiara, ma se questa cifra è 1_and_0 vs 0_and_1 (che hanno lo stesso valore xor ma diseguale) allora ricorsivamente dovrebbe essere uguale all'algoritmo https://en.wikipedia.org/wiki/Edit_distance , significa peggior caso di log al quadrato.

Per intervalli di 32 bit, ho appena trovato questa O(1)soluzione negli editoriali di Hacker Rank. Non ho idea di come funzioni, ma funziona. (Forse qualcuno può spiegare perché funziona.)

def max_xor(L,R):
  v = L^R
  v |= v >> 1
  v |= v >> 2
  v |= v >> 4
  v |= v >> 8
  v |= v >> 16
  return b

Fonte: https://www.hackerrank.com/challenges/maximizing-xor/editorial