一個容易出錯的題
貪心演算法（英語：greedy algorithm），又稱貪婪演算法，是一種在每一步選擇中都採取在當前狀態下最好或最優（即最有利）的選擇，從而希望導致結果是最好或最優的演算法。 比如在旅行推銷員問題中，如果旅行員每次都選擇最近的城市，那這就是一種貪心演算法。
描述
給定一個區間的集合，找到需要移除區間的最小數量，使剩餘區間互不重疊。
注意:
- 可以認為區間的終點總是大於它的起點。
- 區間 [1,2] 和 [2,3] 的邊界相互“接觸”，但沒有相互重疊。
示例 1:
輸入: [ [1,2], [2,3], [3,4], [1,3] ]
輸出: 1
解釋: 移除 [1,3] 後，剩下的區間沒有重疊。
複製程式碼輸入: [ [1,2], [1,2], [1,2] ]
輸出: 2
解釋: 你需要移除兩個 [1,2] 來使剩下的區間沒有重疊。
複製程式碼輸入: [ [1,2], [2,3] ]
輸出: 0
解釋: 你不需要移除任何區間，因為它們已經是無重疊的了。
複製程式碼解題
首先進行排序，排序後的資料更容易比較，不然再無序狀態下需要頻繁的遍歷陣列。
- 排序，首先根據起始點排序，起始位置相同的情況下比較結束位置。
- 排序之後，可能會出現多種情況。如圖下5種情況。
- 情況1，重疊 A1.start < A2.start && A1.end < A2.end
- 情況2，重疊 A1.strat < A2.start && A1.end > A2.end
- 情況3，重疊 A1.strat < A2.start && A1.end = A2.end
- 情況4，不重疊 A2.start >= A1.end
- 情況5，重疊 A1.start=A2.start && A1.end < A2.end，因為已經排好序了，所以不會出現A1.end > A2.end的情況
- 除了要判斷是否重疊，還有一個要考慮的因素。找到需要移除區間的最小數量，那麼在上面的5種情況中，要移除哪一個比較合適呢？移除A1，還是A2
- 情況1，移除A2，因為A2更可能與後面的元素重疊
- 情況2，移除A1，因為A1佔的空間更大，與A1重疊的可能性大於A2
- 情況3，移除A1，原因同上
- 情況4，不重疊，無需處理
- 情況5，移除A2，A2更容易與後面的元素重疊。
編碼
- 首先排序。
// 對陣列排序，從小到大排序，首先比較start，再比較end
// 排序前 [ [1,2], [2,3], [3,4], [1,3] ]
// 排序後 [ [1,2], [1,3]，[2,3], [3,4] ]
Arrays.sort(intervals, new Comparator<Interval>() {
@Override
public int compare(Interval o1, Interval o2) {
if (o1.start == o2.start) {
return o1.end - o2.end;
}
return o1.start - o2.start;
}
});
複製程式碼- 考慮各種情況，與元素的處理。這一步的情況處理，與上面分析的一致，只需要看明白上面的解題思路即可
// 當前需要被比較的Interval座標
int currentIndex = 0;
// 重複區間的個數
int count = 0;
for (int i = 1; i < intervals.length; i++) {
// 情況1
// currentIndex [=====]
// intervals[i] [=====]
boolean overLapFlag = false;
if (intervals[currentIndex].end <= intervals[i].end && intervals[i].start < intervals[currentIndex].end) {
count++;
overLapFlag = true;
}
// 情況2 && 情況3
// currentIndex [=====]
// intervals[i] [==]
else if (intervals[currentIndex].end >= intervals[i].end) {
count++;
overLapFlag = true;
}
// 情況 5 ，因為已經排好序了，所以後續元素肯定大於前一個
// currentIndex [====]
// intervals[i] [======]
else if (intervals[currentIndex].start == intervals[i].start) {
count++;
overLapFlag = true;
}
// 當某個元素佔的空間太大的時候，考慮換一下位置
// 判斷條件同條件2
if (overLapFlag){
if (intervals[currentIndex].end >= intervals[i].end)
{
System.out.println("替換元素：currentIndex" + intervals[currentIndex] + "~" + intervals[i]);
currentIndex = i;
}
continue;
}
// 最後一種
// currentIndex [====]
// intervals[i] [===]
currentIndex = i;
}
複製程式碼- 程式碼彙總
public static int eraseOverlapIntervals(Interval[] intervals) {
if (intervals.length == 0 || intervals.length == 1) {
return 0;
}
// 對陣列排序，從小到大排序，首先比較start，再比較end
// 排序前 [ [1,2], [2,3], [3,4], [1,3] ]
// 排序後 [ [1,2], [1,3]，[2,3], [3,4] ]
Arrays.sort(intervals, new Comparator<Interval>() {
@Override
public int compare(Interval o1, Interval o2) {
if (o1.start == o2.start) {
return o1.end - o2.end;
}
return o1.start - o2.start;
}
});
// 當前需要被比較的Interval座標
int currentIndex = 0;
// 重複區間的個數
int count = 0;
// for (int i = 0; i < intervals.length; i++) {
// System.out.println("[" + intervals[i].start + "," + intervals[i].end + "]");
// }
for (int i = 1; i < intervals.length; i++) {
// 情況1
// currentIndex [=====]
// intervals[i] [=====]
boolean overLapFlag = false;
if (intervals[currentIndex].end <= intervals[i].end && intervals[i].start < intervals[currentIndex].end) {
count++;
overLapFlag = true;
}
// 情況2 && 情況3
// currentIndex [=====]
// intervals[i] [==]
else if (intervals[currentIndex].end >= intervals[i].end) {
count++;
overLapFlag = true;
}
// 情況 5 ，因為已經排好序了，所以後續元素肯定大於前一個
// currentIndex [====]
// intervals[i] [======]
else if (intervals[currentIndex].start == intervals[i].start) {
count++;
overLapFlag = true;
}
// 當某個元素佔的空間太大的時候，考慮換一下位置
// 判斷條件同條件2
if (overLapFlag){
if (intervals[currentIndex].end >= intervals[i].end)
{
System.out.println("替換元素：currentIndex" + intervals[currentIndex] + "~" + intervals[i]);
currentIndex = i;
}
continue;
}
// 最後一種
// currentIndex [====]
// intervals[i] [===]
currentIndex = i;
}
return count;
}
複製程式碼- 執行結果
額外
還有一種用貪心演算法，只比較不重複元素的數量，剩下的都是要刪除的，只比較了第4種情況
如圖：
- 如果，A1的start很小，但是end很長，那麼會錯過很多元素。
所以，也要進行判斷當前的元素是不是過於長。包含了前一個元素
思路如下：
public static int eraseOverlapIntervalsV2(Interval[] intervals) {
if (intervals.length == 0 || intervals.length == 1) {
return 0;
}
// 對陣列排序，從小到大排序，首先比較start，再比較end
// 排序前 [ [1,2], [2,3], [3,4], [1,3] ]
// 排序後 [ [1,2], [1,3]，[2,3], [3,4] ]
Arrays.sort(intervals, new Comparator<Interval>() {
@Override
public int compare(Interval o1, Interval o2) {
if (o1.start == o2.start) {
return o1.end - o2.end;
}
return o1.start - o2.start;
}
});
// 當前需要被比較的Interval座標
int currentIndex = 0;
// 重複區間的個數
int count = 1;
for (int i = 1; i < intervals.length; i++) {
// 最後一種
// currentIndex [====]
// intervals[i] [===]
if (intervals[i].start >= intervals[currentIndex].end){
count++;
currentIndex = i;
}
else {
if (intervals[i].end <= intervals[currentIndex].end){
currentIndex=i;
}
}
}
return intervals.length - count;
}
複製程式碼其實和上一步是一樣的了。
最後
思路清晰才能寫出優雅的程式碼