Was ist der effizienteste Weg, um zwei ganzzahlige Bereiche auf Überlappung zu testen?

Was ist bei zwei inklusive ganzzahligen Bereichen [x1: x2] und [y1: y2], wobei x1 ≤ x2 und y1 ≤ y2, der effizienteste Weg, um zu testen, ob es eine Überlappung der beiden Bereiche gibt?

Eine einfache Implementierung lautet wie folgt:

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);
}

Ich gehe jedoch davon aus, dass es effizientere Möglichkeiten gibt, dies zu berechnen.

Welche Methode wäre im Hinblick auf die wenigsten Operationen am effizientesten?

Was bedeutet es, wenn sich die Bereiche überschneiden? Dies bedeutet, dass es eine Zahl C gibt, die in beiden Bereichen liegt, d. H.

x1 <= C <= x2

und

y1 <= C <= y2

Wenn wir nun annehmen dürfen, dass die Bereiche gut geformt sind (so dass x1 <= x2 und y1 <= y2), reicht es aus, zu testen

x1 <= y2 && y1 <= x2

Bei zwei Bereichen [x1, x2], [y1, y2]

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

Dies kann ein normales menschliches Gehirn leicht verzerren, daher habe ich einen visuellen Ansatz gefunden, der leichter zu verstehen ist:

le Erklärung

Wenn zwei Bereiche "zu fett" sind , um in einen Schlitz zu passen, der genau die Summe der Breite beider ist, überlappen sie sich.

Für Bereiche [a1, a2]und [b1, b2]dies wäre:

/**
 * 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!
}

Tolle Antwort von Simon , aber für mich war es einfacher, über den umgekehrten Fall nachzudenken.

Wann überlappen sich 2 Bereiche nicht? Sie überlappen sich nicht, wenn einer von ihnen beginnt, nachdem der andere endet:

dont_overlap = x2 < y1 || x1 > y2

Jetzt ist es einfach auszudrücken, wenn sie sich überschneiden:

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

Das Subtrahieren des Minimums der Enden der Bereiche vom Maximum des Anfangs scheint den Trick zu tun. Wenn das Ergebnis kleiner oder gleich Null ist, haben wir eine Überlappung. Dies macht es gut sichtbar:

Ich nehme an, die Frage betraf den schnellsten und nicht den kürzesten Code. Die schnellste Version muss Verzweigungen vermeiden, damit wir so etwas schreiben können:

für einen einfachen Fall:

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));
};

oder für diesen Fall:

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);
};

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

Wenn Sie sich mit zwei Bereichen [x1:x2]und [y1:y2]natürlichen / anti-natürlichen Ordnungsbereichen gleichzeitig befasst haben, in denen:

• natürliche Ordnung: x1 <= x2 && y1 <= y2oder
• anti-natürliche Ordnung: x1 >= x2 && y1 >= y2

Dann möchten Sie vielleicht Folgendes verwenden, um Folgendes zu überprüfen:

Sie überlappen sich <=> (y2 - x1) * (x2 - y1) >= 0

wo nur vier Operationen beteiligt sind:

• zwei Subtraktionen
• eine Multiplikation
• ein Vergleich

Wenn jemand nach einem Einzeiler sucht, der die tatsächliche Überlappung berechnet:

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

Wenn Sie ein paar weniger Operationen, aber ein paar mehr Variablen wollen:

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

Denken Sie umgekehrt : Wie lassen sich die beiden Bereiche nicht überlappen ? Gegeben [x1, x2], dann [y1, y2]sollte außerhalb sein [x1, x2] , dh y1 < y2 < x1 or x2 < y1 < y2was äquivalent zu ist y2 < x1 or x2 < y1.

Daher überlappt sich die Bedingung, dass sich die beiden Bereiche überschneiden: not(y2 < x1 or x2 < y1)(entspricht y2 >= x1 and x2 >= y1der akzeptierten Antwort von Simon).

Sie haben bereits die effizienteste Darstellung - es ist das absolute Minimum, das überprüft werden muss, es sei denn, Sie wissen sicher, dass x1 <x2 usw. ist, und verwenden Sie dann die von anderen bereitgestellten Lösungen.

Sie sollten wahrscheinlich beachten, dass einige Compiler dies tatsächlich für Sie optimieren - indem sie zurückkehren, sobald einer dieser 4 Ausdrücke true zurückgibt. Wenn einer true zurückgibt, wird auch das Endergebnis angezeigt, sodass die anderen Überprüfungen einfach übersprungen werden können.

Mein Fall ist anders. Ich möchte überprüfen, ob sich zwei Zeitbereiche überschneiden. Es sollte keine zeitliche Überlappung geben. Hier ist die Go-Implementierung.

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

Testfälle

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")
    }

Sie können sehen, dass es im Grenzvergleich ein XOR-Muster gibt

Hier ist meine Version:

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;

Sofern Sie keinen Hochleistungs-Bereichsprüfer für Milliarden von weit auseinander liegenden Ganzzahlen ausführen, sollten unsere Versionen eine ähnliche Leistung erbringen. Mein Punkt ist, das ist Mikrooptimierung.