Cách hiệu quả nhất để kiểm tra hai phạm vi số nguyên cho sự chồng chéo là gì?

Cho hai phạm vi số nguyên bao gồm [x1: x2] và [y1: y2], trong đó x1 ≤ x2 và y1 y2, cách hiệu quả nhất để kiểm tra xem có sự chồng chéo nào của hai phạm vi không?

Một cách thực hiện đơn giản như sau:

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

Nhưng tôi hy vọng có nhiều cách hiệu quả hơn để tính toán điều này.

Phương pháp nào sẽ hiệu quả nhất về các hoạt động ít nhất.

Nó có nghĩa gì cho các phạm vi chồng chéo? Nó có nghĩa là tồn tại một số số C trong cả hai phạm vi, nghĩa là

x1 <= C <= x2

và

y1 <= C <= y2

Bây giờ, nếu chúng ta được phép giả định rằng các phạm vi được hình thành tốt (sao cho x1 <= x2 và y1 <= y2) thì đủ để kiểm tra

x1 <= y2 && y1 <= x2

Cho hai phạm vi [x1, x2], [y1, y2]

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

Điều này có thể dễ dàng làm cong vênh bộ não người bình thường, vì vậy tôi đã tìm thấy một cách tiếp cận trực quan để dễ hiểu hơn:

giải thích

Nếu hai phạm vi "quá béo" để khớp với một vị trí chính xác bằng tổng chiều rộng của cả hai, thì chúng trùng nhau.

Đối với phạm vi [a1, a2]và [b1, b2]điều này sẽ là:

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

Câu trả lời tuyệt vời từ Simon , nhưng đối với tôi thì dễ dàng hơn khi nghĩ về trường hợp ngược lại.

Khi nào 2 phạm vi không trùng nhau? Chúng không trùng nhau khi một trong số chúng bắt đầu sau khi một cái khác kết thúc:

dont_overlap = x2 < y1 || x1 > y2

Bây giờ thật dễ dàng để thể hiện khi họ làm chồng chéo:

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

Trừ tối thiểu các đầu của các phạm vi từ Tối đa của đầu bắt đầu dường như thực hiện thủ thuật. Nếu kết quả nhỏ hơn hoặc bằng 0, chúng ta có sự trùng lặp. Điều này hình dung nó tốt:

Tôi cho rằng câu hỏi là về mã nhanh nhất chứ không phải mã ngắn nhất. Phiên bản nhanh nhất phải tránh các nhánh, vì vậy chúng ta có thể viết một cái gì đó như thế này:

cho trường hợp đơn giản:

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

hoặc, đối với trường hợp này:

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;

Nếu bạn đang giao dịch, đưa ra hai phạm vi [x1:x2]và [y1:y2], phạm vi trật tự tự nhiên / chống tự nhiên cùng một lúc trong đó:

• trật tự tự nhiên: x1 <= x2 && y1 <= y2hoặc
• trật tự chống tự nhiên: x1 >= x2 && y1 >= y2

sau đó bạn có thể muốn sử dụng điều này để kiểm tra:

chúng bị chồng chéo <=> (y2 - x1) * (x2 - y1) >= 0

nơi chỉ có bốn hoạt động được tham gia:

• hai phép trừ
• một phép nhân
• một so sánh

Nếu ai đó đang tìm kiếm một lớp lót tính toán sự chồng chéo thực tế:

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

Nếu bạn muốn một vài thao tác ít hơn, nhưng một vài biến số hơn:

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

Suy nghĩ theo cách ngược lại : làm thế nào để 2 phạm vi không trùng nhau ? Cho [x1, x2], sau đó [y1, y2]nên ở bên ngoài [x1, x2] , tức là, y1 < y2 < x1 or x2 < y1 < y2tương đương với y2 < x1 or x2 < y1.

Do đó, điều kiện để làm cho 2 phạm vi trùng nhau : not(y2 < x1 or x2 < y1), tương đương với y2 >= x1 and x2 >= y1(cùng với câu trả lời được chấp nhận bởi Simon).

Bạn đã có đại diện hiệu quả nhất - đó là mức tối thiểu cần kiểm tra trừ khi bạn biết chắc rằng x1 <x2, v.v., sau đó sử dụng các giải pháp mà người khác đã cung cấp.

Bạn có thể nên lưu ý rằng một số trình biên dịch sẽ thực sự tối ưu hóa điều này cho bạn - bằng cách quay lại ngay khi bất kỳ 4 biểu thức nào trở về đúng. Nếu một trả về đúng, kết quả cuối cùng cũng vậy - vì vậy các kiểm tra khác có thể được bỏ qua.

Trường hợp của tôi thì khác. tôi muốn kiểm tra hai phạm vi thời gian chồng chéo. không nên có một đơn vị thời gian chồng chéo. Đây là thực hiện Go.

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

Các trường hợp thử nghiệm

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

bạn có thể thấy có mẫu XOR trong so sánh ranh giới

Đây là phiên bản của tôi:

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;

Trừ khi bạn đang chạy một số trình kiểm tra phạm vi hiệu suất cao trên hàng tỷ số nguyên có khoảng cách rộng rãi, các phiên bản của chúng tôi sẽ hoạt động tương tự. Quan điểm của tôi là, đây là tối ưu hóa vi mô.