算法设计与分析（七）：Graph And Tree

Non-overlapping Intervals

Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
Note:
You may assume the interval’s end point is always bigger than its start point.
Intervals like [1,2] and [2,3] have borders “touching” but they don’t overlap each other.

Example 1:

Input: [ [1,2], [2,3], [3,4], [1,3] ]

Output: 1

Explanation: [1,3] can be removed and the rest of intervals are non-overlapping.

Example 2:

Input: [ [1,2], [1,2], [1,2] ]

Output: 2

Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.

Example 3:

Input: [ [1,2], [2,3] ]

Output: 0

Explanation: You don't need to remove any of the intervals since they're already non-overlapping.

本题要将一堆区间中的某些区间去掉，使得剩下的区间中没有重叠的部分。而且要求找到最优的筛选法，使得需要删除的次数最少。
如何使得删除的次数最少呢？我们可以稍稍“贪婪”一点地想。如果每次我们都将与剩下区间中重叠的区间数最多的那个区间去掉，是不是就是我们这次删选的最优选择呢？
很难从数学上证明这种思路是否正确，不过直观上觉得这是最好的删选方式。既然有了这种想法，试试就知道是否正确。

联想数据结构中的邻接矩阵，我们可以将有重叠的区间视为“相邻”的，以此可以构造出一个区间们的“邻接矩阵”，0代表两个区间不相邻，1代表相邻：

int len = intervals.size();
if(len == 0) return 0;
vector<vector<int>> overlapping(len,vector<int>(len,0));

将每个区间的相邻区间数存储起来：

//vector<int> nums(len,0);

显然，当nums中仍有元素大于0时，说明区间中仍有重叠。

如何判断两个区间是否有重叠呢？情况比较多。这时我们可以反过来思考：如何判断两个区间没有重叠呢？这就简单了。只要某个区间的大端小于另一个区间的小端。不符合这种的就是有重叠的:

for(int i = 0;i < len;i ++) {
            int count = 0;
            for(int j = 0;j < len;j ++) {
                if(i != j) {
                    if( !(intervals[i].end <= intervals[j].start || intervals[j].end <= intervals[i].start)) {
                        overlapping[i][j] = 1;
                        count ++;
                    }
                }
            }
            nums[i] = count;
            //overlapping[i][i] = count;
        }

现在开始循环验证：找到nums中最大的元素，如果该元素不为0，将该元素对应的区间删除，nums置零，并且搜索邻接矩阵中该区间的那一行，将其中值为1的对应区间的nums值减一，因为他的一个响铃区间被删掉了。
重复该操作，直到nums中没有大于0的元素为止：

int max = -1;
        while(true) {
            int pos = 0;
            int max = overlapping[0][0];
            for(int i = 1;i < len;i ++) {
                if(overlapping[i][i] > max) {
                    max = overlapping[i][i];
                    pos = i;
                }
            }
            if(max == 0) break;
            overlapping[pos][pos] = 0;
            for(int i = 0;i < len;i ++) {
                if(overlapping[pos][i] == 1) {
                    overlapping[i][i] --;
                }
            }
            ans ++;
        }

做完之后验证，发现结果是不对的。问题在那里呢？
我们没有考虑一种特殊的情况：队列中的相同区间（例如【1,2】、【1,2】）。我们将这种区间简单地视为普通的重叠区间而已。这种思考有问题。显然，这种相同区间是一定要删除的，而且应该尽早删除，因为其他区间只要与这种区间相邻，就会增加一大堆的相邻数。这是一种删除优先级比相邻数更高的区间，所以我们要提前考虑，删除它们：

for(int i = 0;i < len;i ++) {
        for(int j = i+1;j < len;j ++) {
        	if(intervals[i].start == intervals[j].start && intervals[i].end == intervals[j].end) {
			 for(int k = 0;k < len;k ++) {
                	  if(overlapping[i][k] == 1) {
                    		overlapping[k][i] = 0;
                    		overlapping[i][k] = 0;
                    		overlapping[k][k] --;
                	  }
            	  }
				ans ++;
        		overlapping[i][i] = 0;
                break;
				}
		}
}

这种方式的时间复杂度和空间复杂度都很高，其时间复杂度需要删除的区间数和相同区间数影响，而且代码复杂冗长。
我在讨论中找到了一种更好的方法。

直接将区间数组按照区间起点从小到大排序，从第一个区间开始遍历，如果前一个区间的结尾大于下一个区间的开始，说明两个区间中有一个区间要删除；删除哪一个呢？删除结尾较大的那个，这样剩下的那个区间与其他区间重叠的机会更小。
如何验证这种方式是最优的呢？其实不好验证，这是一种经验性的总结。如果有读者，想要证明的可以自己尝试挑战一下。

附上两种方式的完整代码;

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    int eraseOverlapIntervals(vector<Interval>& intervals) {
        int ans = 0;
        
        int len = intervals.size();
        if(len == 0) return 0;
        vector<vector<int>> overlapping(len,vector<int>(len,0));
        //vector<int> nums(len,0);
        
        for(int i = 0;i < len;i ++) {
            int count = 0;
            for(int j = 0;j < len;j ++) {
                if(i != j) {
                    if( !(intervals[i].end <= intervals[j].start || intervals[j].end <= intervals[i].start)) {
                        overlapping[i][j] = 1;
                        count ++;
                    }
                }
            }
            //nums[i] = count;
            overlapping[i][i] = count;
        }
        
        for(int i = 0;i < len;i ++) {
        		for(int j = i+1;j < len;j ++) {
        			if(intervals[i].start == intervals[j].start && intervals[i].end == intervals[j].end) {
						for(int k = 0;k < len;k ++) {
                			if(overlapping[i][k] == 1) {
                    		overlapping[k][i] = 0;
                    		overlapping[i][k] = 0;
                    		overlapping[k][k] --;
                		}
            		}
						ans ++;
        				overlapping[i][i] = 0;
                        break;
					}
				}
			}
        
        
        int max = -1;
        while(true) {
            int pos = 0;
            int max = overlapping[0][0];
            for(int i = 1;i < len;i ++) {
                if(overlapping[i][i] > max) {
                    max = overlapping[i][i];
                    pos = i;
                }
            }
            if(max == 0) break;
            overlapping[pos][pos] = 0;
            for(int i = 0;i < len;i ++) {
                if(overlapping[pos][i] == 1) {
                    overlapping[i][i] --;
                }
            }
            ans ++;
        }
        
        return ans;
    }
};

class Solution {
public:
    int eraseOverlapIntervals(vector<Interval>& intervals) {
        auto comp = [](const Interval& i1, const Interval& i2){ return i1.start < i2.start; };
        sort(intervals.begin(), intervals.end(), comp);
        int res = 0, pre = 0;
        for (int i = 1; i < intervals.size(); i++) {
            if (intervals[i].start < intervals[pre].end) {
                res++;
                if (intervals[i].end < intervals[pre].end) pre = i;
            }
            else pre = i;
        }
        return res;
    }
};

附上LeetCode链接：https://leetcode.com/problems/non-overlapping-intervals/description/