区间调度之区间交集问题

区间调度之区间交集问题

区间调度问题共写了3片博客，前两篇重叠区间和区间合并分别讲了区间的最大不相交子集和重叠区间的合并，今天再写一个算法，可以快速找出两组区间的交集。

一、解题思路

解决区间问题的思路一般是先排序，以便操作，不过题目说已经排好序了，那么可以用两个索引指针在 A 和 B 中游走，把交集找出来，代码大概是这样的：

# A, B 形如 [[0,2],[5,10]...]
def intervalIntersection(A, B):
    i, j = 0, 0
    res = []
    while i < len(A) and j < len(B):
        # ...
        j += 1
        i += 1
    return res

不难，我们先老老实实分析一下各种情况。

首先，对于两个区间，我们用 [a1,a2] 和 [b1,b2] 表示在 A 和 B 中的两个区间，那么什么情况下这两个区间没有交集呢：

只有这两种情况，写成代码的条件判断就是这样：

if b2 < a1 or a2 < b1:
    [a1,a2] 和 [b1,b2] 无交集

那么，什么情况下，两个区间存在交集呢？根据命题的否定，上面逻辑的否命题就是存在交集的条件：

# 不等号取反，or 也要变成 and
if b2 >= a1 and a2 >= b1:
    [a1,a2] 和 [b1,b2] 存在交集

接下来，两个区间存在交集的情况有哪些呢？穷举出来：

这很简单吧，就这四种情况而已。那么接下来思考，这几种情况下，交集是否有什么共同点呢？

我们惊奇地发现，交集区间是有规律的！如果交集区间是 [c1,c2]，那么 c1=max(a1,b1)，c2=min(a2,b2)！这一点就是寻找交集的核心，我们把代码更进一步：

while i < len(A) and j < len(B):
    a1, a2 = A[i][0], A[i][1]
    b1, b2 = B[j][0], B[j][1]
    if b2 >= a1 and a2 >= b1:
        res.append([max(a1, b1), min(a2, b2)])
    # ...

最后一步，我们的指针 i 和 j 肯定要前进（递增）的，什么时候应该前进呢？

是否前进，只取决于 a2 和 b2 的大小关系。代码：

while i < len(A) and j < len(B):
    # ...
    if b2 < a2:
        j += 1
    else:
        i += 1

完整代码：

# A, B 形如 [[0,2],[5,10]...]
def intervalIntersection(A, B):
    i, j = 0, 0 # 双指针
    res = []
    while i < len(A) and j < len(B):
        a1, a2 = A[i][0], A[i][1]
        b1, b2 = B[j][0], B[j][1]
        # 两个区间存在交集
        if b2 >= a1 and a2 >= b1:
            # 计算出交集，加入 res
            res.append([max(a1, b1), min(a2, b2)])
        # 指针前进
        if b2 < a2: j += 1
        else:       i += 1
    return res

C++代码：

class Solution {
public:
    vector<vector<int>> intervalIntersection(vector<vector<int>>& A, vector<vector<int>>& B) {
        //保存结果
        vector<vector<int>> ret;
        if(A.empty() || B.empty())
        {
            return ret;
        }

        //i和j两个下标索引
        int i = 0;
        int j = 0;
        while(i < A.size() && j < B.size())
        {
            //下面四个变量的含义相见博客
            int a1 = A[i][0];
            int a2 = A[i][1];
            int b1 = B[j][0];
            int b2 = B[j][1];

            //代表区间有交集，自己画个图就OK
            if(b2 >= a1 && a2 >= b1)
            {
                //max(a1,b1),min(a2,b2)两个区间的交集部分
                ret.push_back({max(a1,b1),min(a2,b2)});
            }

            //更新i和j下标索引，b2 < a2 就代表i所在的区间大于j所在的区间，更新j
            //是因为i区间长于j区间的部分还可能和j的下一个区间继续重叠，还需要继续判断
            //所以更新j而不是更新i
            if(b2 < a2)
            {
                j++;
            }
            else//反之同理
            {
                i++;
            }
        }   
        return ret;
    }
};

总结一下，区间类问题看起来都比较复杂，情况很多难以处理，但实际上通过观察各种不同情况之间的共性可以发现规律，用简洁的代码就能处理。