貪心算法之無重疊區間

一個容易出錯的題

貪心算法（英語：greedy algorithm），又稱貪婪算法，是一種在每一步選擇中都採起在當前狀態下最好或最優（即最有利）的選擇，從而但願致使結果是最好或最優的算法。 好比在旅行推銷員問題中，若是旅行員每次都選擇最近的城市，那這就是一種貪心算法。

描述

給定一個區間的集合，找到須要移除區間的最小數量，使剩餘區間互不重疊。

注意:

1. 能夠認爲區間的終點老是大於它的起點。
2. 區間 [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更容易與後面的元素重疊。

編碼

1. 首先排序。

// 對數組排序，從小到大排序，首先比較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;
            }
        });

複製代碼

2. 考慮各類狀況，與元素的處理。這一步的狀況處理，與上面分析的一致，只須要看明白上面的解題思路便可

// 當前須要被比較的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;

        }
複製代碼

3. 代碼彙總

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. 執行結果

額外

還有一種用貪心算法，只比較不重複元素的數量，剩下的都是要刪除的，只比較了第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;

    }
複製代碼

其實和上一步是同樣的了。

最後

思路清晰才能寫出優雅的代碼

參考

• 435. 無重疊區間