Qual è il modo più efficiente per testare la sovrapposizione di due intervalli interi?

Dati due intervalli interi inclusi [x1: x2] e [y1: y2], dove x1 ≤ x2 e y1 ≤ y2, qual è il modo più efficiente per verificare se vi è una sovrapposizione dei due intervalli?

Una semplice implementazione è la seguente:

bool testOverlap(int x1, int x2, int y1, int y2) {
  return (x1 >= y1 && x1 <= y2) ||
         (x2 >= y1 && x2 <= y2) ||
         (y1 >= x1 && y1 <= x2) ||
         (y2 >= x1 && y2 <= x2);
}

Ma mi aspetto che ci siano modi più efficienti per calcolarlo.

Quale metodo sarebbe il più efficiente in termini di minor numero di operazioni.

Cosa significa che gli intervalli si sovrappongono? Significa che esiste un numero C che è in entrambi gli intervalli, ad es

x1 <= C <= x2

e

y1 <= C <= y2

Ora, se possiamo supporre che gli intervalli siano ben formati (in modo che x1 <= x2 e y1 <= y2), allora è sufficiente testare

x1 <= y2 && y1 <= x2

Dati due intervalli [x1, x2], [y1, y2]

def is_overlapping(x1,x2,y1,y2):
    return max(x1,y1) <= min(x2,y2)

Questo può facilmente deformare un normale cervello umano, quindi ho trovato un approccio visivo più facile da capire:

le Explanation

Se due intervalli sono "troppo grandi" per rientrare in uno slot che è esattamente la somma della larghezza di entrambi, allora si sovrappongono.

Per gli intervalli [a1, a2]e [b1, b2]questo sarebbe:

/**
 * we are testing for:
 *     max point - min point < w1 + w2    
 **/
if max(a2, b2) - min(a1, b1) < (a2 - a1) + (b2 - b1) {
  // too fat -- they overlap!
}

Ottima risposta da parte di Simon , ma per me è stato più facile pensare al caso inverso.

Quando 2 intervalli non si sovrappongono? Non si sovrappongono quando uno di essi inizia dopo che l'altro finisce:

dont_overlap = x2 < y1 || x1 > y2

Ora è facile esprimere quando si sovrappongono:

overlap = !dont_overlap = !(x2 < y1 || x1 > y2) = (x2 >= y1 && x1 <= y2)

Sottraendo il Minimo delle estremità degli intervalli dal Massimo dell'inizio sembra fare il trucco. Se il risultato è minore o uguale a zero, abbiamo una sovrapposizione. Questo lo visualizza bene:

Suppongo che la domanda riguardasse il codice più veloce, non il più breve. La versione più veloce deve evitare i rami, quindi possiamo scrivere qualcosa del genere:

per caso semplice:

static inline bool check_ov1(int x1, int x2, int y1, int y2){
    // insetead of x1 < y2 && y1 < x2
    return (bool)(((unsigned int)((y1-x2)&(x1-y2))) >> (sizeof(int)*8-1));
};

oppure, in questo caso:

static inline bool check_ov2(int x1, int x2, int y1, int y2){
    // insetead of x1 <= y2 && y1 <= x2
    return (bool)((((unsigned int)((x2-y1)|(y2-x1))) >> (sizeof(int)*8-1))^1);
};

Se hai a che fare con, dati due intervalli [x1:x2]e intervalli di ordine [y1:y2]naturale / anti-naturale allo stesso tempo dove:

• ordine naturale: x1 <= x2 && y1 <= y2o
• ordine anti-naturale: x1 >= x2 && y1 >= y2

allora potresti volerlo usare per controllare:

sono sovrapposti <=> (y2 - x1) * (x2 - y1) >= 0

dove sono coinvolte solo quattro operazioni:

• due sottrazioni
• una moltiplicazione
• un confronto

return x2 >= y1 && x1 <= y2;

Se qualcuno sta cercando un one-liner che calcoli l'effettiva sovrapposizione:

int overlap = ( x2 > y1 || y2 < x1 ) ? 0 : (y2 >= y1 && x2 <= y1 ? y1 : y2) - ( x2 <= x1 && y2 >= x1 ? x1 : x2) + 1; //max 11 operations

Se vuoi un paio di operazioni in meno, ma un paio di variabili in più:

bool b1 = x2 <= y1;
bool b2 = y2 >= x1;
int overlap = ( !b1 || !b2 ) ? 0 : (y2 >= y1 && b1 ? y1 : y2) - ( x2 <= x1 && b2 ? x1 : x2) + 1; // max 9 operations

Pensa in modo inverso : come fare in modo che i 2 intervalli non si sovrappongano ? Dato [x1, x2], quindi [y1, y2]dovrebbe essere esterno [x1, x2] , vale a dire, y1 < y2 < x1 or x2 < y1 < y2che è equivalente a y2 < x1 or x2 < y1.

Pertanto, la condizione per sovrapporre i 2 intervalli:, not(y2 < x1 or x2 < y1)che è equivalente a y2 >= x1 and x2 >= y1(lo stesso con la risposta accettata da Simon).

Hai già la rappresentazione più efficiente: è il minimo indispensabile che deve essere controllato a meno che tu non sappia per certo che x1 <x2 ecc., Quindi usa le soluzioni fornite da altri.

Probabilmente dovresti notare che alcuni compilatori lo ottimizzeranno effettivamente per te, tornando non appena una di queste 4 espressioni restituirà true. Se uno restituisce vero, così sarà il risultato finale, quindi gli altri controlli possono essere semplicemente saltati.

Il mio caso è diverso. Voglio controllare che due intervalli di tempo si sovrappongano. non dovrebbe esserci una sovrapposizione di tempo unitario. ecco l'implementazione di Go.

    func CheckRange(as, ae, bs, be int) bool {
    return (as >= be) != (ae > bs)
    }

Casi test

if CheckRange(2, 8, 2, 4) != true {
        t.Error("Expected 2,8,2,4 to equal TRUE")
    }

    if CheckRange(2, 8, 2, 4) != true {
        t.Error("Expected 2,8,2,4 to equal TRUE")
    }

    if CheckRange(2, 8, 6, 9) != true {
        t.Error("Expected 2,8,6,9 to equal TRUE")
    }

    if CheckRange(2, 8, 8, 9) != false {
        t.Error("Expected 2,8,8,9 to equal FALSE")
    }

    if CheckRange(2, 8, 4, 6) != true {
        t.Error("Expected 2,8,4,6 to equal TRUE")
    }

    if CheckRange(2, 8, 1, 9) != true {
        t.Error("Expected 2,8,1,9 to equal TRUE")
    }

    if CheckRange(4, 8, 1, 3) != false {
        t.Error("Expected 4,8,1,3 to equal FALSE")
    }

    if CheckRange(4, 8, 1, 4) != false {
        t.Error("Expected 4,8,1,4 to equal FALSE")
    }

    if CheckRange(2, 5, 6, 9) != false {
        t.Error("Expected 2,5,6,9 to equal FALSE")
    }

    if CheckRange(2, 5, 5, 9) != false {
        t.Error("Expected 2,5,5,9 to equal FALSE")
    }

puoi vedere che c'è un modello XOR nel confronto dei confini

Dato: [x1,x2] [y1,y2] allora x1 <= y2 || x2 >= y1funzionerebbe sempre. come

      x1 ... x2
y1 .... y2

se x1 > y2poi non si sovrappongono o

x1 ... x2
    y1 ... y2

se x2 < y1non si sovrappongono.

Ecco la mia versione:

int xmin = min(x1,x2)
  , xmax = max(x1,x2)
  , ymin = min(y1,y2)
  , ymax = max(y1,y2);

for (int i = xmin; i < xmax; ++i)
    if (ymin <= i && i <= ymax)
        return true;

return false;

A meno che tu non stia eseguendo un controllo di gamma ad alte prestazioni su miliardi di interi molto distanziati, le nostre versioni dovrebbero funzionare in modo simile. Il punto è che questa è micro-ottimizzazione.