Leetcode - Merge Intervals?

Paste_Image.png

My code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        ArrayList<Interval> result = new ArrayList<Interval>();
        if (intervals == null || intervals.size() == 0)
            return result;
        if (intervals.size() == 1) {
            result.add(intervals.get(0));
            return result;
        }
        
        int[] begin = new int[intervals.size()];
        HashMap<Integer, Integer> range = new HashMap<Integer, Integer>();
        range.put(intervals.get(0).start, intervals.get(0).end);
        begin[0] = intervals.get(0).start;
        for (int i = 1; i < intervals.size(); i++) {
            begin[i] = intervals.get(i).start;
            if (range.containsKey(intervals.get(i).start) && intervals.get(i).end <= range.get(begin[i]))
                continue;
            else
                range.put(intervals.get(i).start, intervals.get(i).end);
        }
        Arrays.sort(begin);
        Interval interval = new Interval(begin[0], range.get(begin[0]));
        
        for (int i = 1; i <= begin.length; i++) {
            if (i == begin.length)
                result.add(interval);
            else if (begin[i] > interval.end) {
                result.add(interval);
                interval = new Interval(begin[i], range.get(begin[i]));
            }
            else if (begin[i] < interval.start) {
                if (range.get(begin[i]) <= range.get(begin[i - 1]))
                    interval = new Interval(begin[i], range.get(begin[i - 1]));
                else
                    interval = new Interval(begin[i], range.get(begin[i]));
            }
            else if (range.get(begin[i]) > interval.end)
                interval = new Interval(interval.start, range.get(begin[i]));
            else
                continue;
        }
        return result;
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        Interval a0 = new Interval(1, 4);
        Interval a1 = new Interval(1, 4);
        ArrayList<Interval> result = new ArrayList<Interval>();
        result.add(a0);
        result.add(a1);
        System.out.println(test.merge(result));
    }
}

My test result:

Paste_Image.png

這道題目不算很難。一直在思考一個問題，如何保存這種范圍的映射，這種start和end的映射。最后還是決定用HashMap， key -> start, value -> end.
將所有的數(shù)據(jù)保存在哈希表中，
同時，將所有的開頭數(shù)字，保存在begin數(shù)組中。注意保存哈希表的時候，如果當(dāng)前頭在哈希表中已經(jīng)存在的話，需要判斷下其尾是否大于哈希表對應(yīng)的val。如果不是，則跳過，如果是，則更新哈希表。
然后對 begin[] 排序。
然后按照一定的規(guī)則，處理這個數(shù)組，不斷地插入新的interval到結(jié)果中去。
差不多就這樣了。

**
總結(jié)： Array, sort, hash table
今天總算把三道題目的量完成了。中午和初中同學(xué)吃飯。突然明白了那么一句話。
我努力了這么久，就是為了和你喝一杯咖啡。
感覺他們的世界，和我的不同。他們對知識的掌握程度，也遠(yuǎn)高于我。但同樣的，他們也需要考慮汽車在哪里買便宜。租的房子干不干凈。這些他們也不能幸免。
然后，我要潛下心來，默默地，變強(qiáng)。
最后，希望選課順利！
**

Anyway, Good luck, Richardo!

My code:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        if (intervals == null || intervals.size() == 0)
            return intervals;
        Collections.sort(intervals, new Comparator<Interval>() {
            public int compare(Interval o1, Interval o2) {
//                int start1 = o1.start;
//                int start2 = o2.start;
//                int end1 = o1.end;
//                int end2 = o2.end;
//                if (start1 == start2 && end1 == end2)
//                  return 0;
//                else if (start1 <= start2 && end1 <= end2)
//                    return -1;
//                else
//                    return 1;
                return o1.start - o2.start;
            }        
        });
        
        for (int i = 1; i < intervals.size(); i++) {
            int frontStart = intervals.get(i - 1).start;
            int frontEnd = intervals.get(i - 1).end;
            int backStart = intervals.get(i).start;
            int backEnd = intervals.get(i).end;
            if (backStart > frontEnd)
                continue;
            else {
                intervals.get(i - 1).start = Math.min(frontStart, backStart);
                intervals.get(i - 1).end = Math.max(frontEnd, backEnd);
                intervals.remove(i);
                i--;
            }
        }
        return intervals;
    }
    
    public static void main(String[] args) {
        Interval a1 = new Interval(1, 3);
        Interval a2 = new Interval(2, 5);
        Interval a3 = new Interval(6, 7);
        Interval a4 = new Interval(3, 4);
        ArrayList<Interval> intervals = new ArrayList<Interval>();
        intervals.add(a1);
        intervals.add(a2);
        intervals.add(a3);
        intervals.add(a4);
        Solution test = new Solution();
        System.out.println(test.merge(intervals));
    }
}

這是我自己寫的，直接在里面改元素。
但是速度較慢。
為什么呢？
因為我有一個刪除操作。鏈表的刪除操作復(fù)雜度是O(n),所以如果測試案例的重合元素很多，我的速度會很慢很慢。
于是有了一個改進(jìn)方法，就是新建一個ArrayList<...> ret,
然后把需要塞進(jìn)去的，已經(jīng)更新好了的interval放進(jìn)去，這樣就不會再有刪除操作了。同樣也是遍歷整個鏈表。鏈表的.add()并不是很消耗時間的操作。我就懶得寫了，但是速度應(yīng)該會更快。
然后就出現(xiàn)了一個問題，以前從來沒有碰到過：

Line 19: java.lang.IllegalArgumentException: Comparison method violates its general contract!

我查了下，大概是，
如果 A = B, 那么 B = A, 而我的comparator方法寫得可能違背了這一點(diǎn)。

Collections.sort(intervals, new Comparator() {
            public int compare(Object o1, Object o2) {
                int start1 = ((Interval) o1).start;
                int start2 = ((Interval) o2).start;
                if (start1 <= start2)
                    return -1;
                else
                    return 1;
            }        
        });

這是那段錯誤的代碼。我改了下，

Collections.sort(intervals, new Comparator<Interval>() {
            public int compare(Interval o1, Interval o2) {
//                int start1 = o1.start;
//                int start2 = o2.start;
//                int end1 = o1.end;
//                int end2 = o2.end;
//                if (start1 == start2 && end1 == end2)
//                  return 0;
//                else if (start1 <= start2 && end1 <= end2)
//                    return -1;
//                else
//                    return 1;
                return o1.start - o2.start;
            }        
        });

如果直接用注釋的部分，是對的。用當(dāng)前部分也是對的。
我還是不能很好地理解這個錯誤。等回了學(xué)校再仔細(xì)研究下。

然后我看了以前的做法，竟然可以用HashMap來做，也果真是巧妙！
我又自己重寫了下，錯了好幾次才AC。思路和代碼比之前要簡潔很多。
但其實和我上面的版本差不多的。就是一個排序。一個用Comparator實現(xiàn)，一個用HashMap實現(xiàn)。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        ArrayList<Interval> result = new ArrayList<Interval>();
        if (intervals == null || intervals.size() == 0)
            return result;
            
        int[] begin = new int[intervals.size()];
        HashMap<Integer, Integer> range = new HashMap<Integer, Integer>();
        for (int i = 0; i < intervals.size(); i++) {
            int start = intervals.get(i).start;
            int end = intervals.get(i).end;
            begin[i] = start;
            if (range.containsKey(start) && range.get(start) >= end)
                continue;
            else
                range.put(start, end);
        }
        Arrays.sort(begin);
        result.add(new Interval(begin[0], range.get(begin[0])));
        for (int i = 1; i < begin.length; i++) {
            if (begin[i] == begin[i - 1])
                continue;
            else {
                if (begin[i] > result.get(result.size() - 1).end)
                    result.add(new Interval(begin[i], range.get(begin[i])));
                else
                    result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end, range.get(begin[i]));
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Solution test = new Solution();
        Interval a0 = new Interval(2, 3);
        Interval a1 = new Interval(4, 5);
        Interval a2 = new Interval(6, 7);
        Interval a3 = new Interval(8, 9);
        Interval a4 = new Interval(1, 10);
        ArrayList<Interval> result = new ArrayList<Interval>();
        result.add(a0);
        result.add(a1);
        result.add(a2);
        result.add(a3);
        result.add(a4);
        System.out.println(test.merge(result));
    }
}

**
記住了，鏈表的remove操作很費(fèi)時間，決定性浪費(fèi)時間！
能不用就不用把！
還有一個comparator 問題沒有搞清楚！
**

Anyway, Good luck, Richardo!

More efficient solution:
My code:

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        ArrayList<Interval> ret = new ArrayList<Interval>();
        if (intervals == null || intervals.size() == 0)
            return ret;
        Collections.sort(intervals, new Comparator<Interval>() {
                public int compare(Interval o1, Interval o2) {
                    return o1.start - o2.start;
                }            
        });    
        Interval preInterval = intervals.get(0);
        for (int i = 1; i < intervals.size(); i++) {
            Interval curr = intervals.get(i);
            if (curr.start > preInterval.end) {
                ret.add(preInterval);
                preInterval = curr;
            }
            else {
                Interval merge = new Interval(preInterval.start, Math.max(preInterval.end, curr.end));
                preInterval = merge;
            }
        }
        ret.add(preInterval);
        return ret;
    }
}

Anyway, Good luck, Richardo!

My code:

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        List<Interval> ret = new ArrayList<Interval>();
        if (intervals == null || intervals.size() == 0) {
            return ret;
        }
        
        ret.add(intervals.get(0));
        
        for (int i = 1; i < intervals.size(); i++) {
            Interval curr = intervals.get(i);
            int j = ret.size() - 1;
            for (; j >= 0; j--) {
                Interval cmp = ret.get(j);
                if (cmp.end < curr.start) {
                    ret.add(j + 1, curr);
                    break;
                }
                else if (cmp.start <= curr.start) {
                    cmp.end = Math.max(cmp.end, curr.end);
                    break;
                }
                else if (cmp.start <= curr.end) {
                    cmp.start = curr.start;
                    cmp.end = Math.max(cmp.end, curr.end);
                    curr = cmp;
                    ret.remove(j);
                }
                else {
                    continue;
                }
            }
            if (j < 0) {
                ret.add(0, curr);
            }
        }
        
        return ret;
    }
}

自己寫了出來。應(yīng)該是 Insert sort 的一種變形。
注意地方是，如果在向左遍歷途中，更新了一個Interval導(dǎo)致他的start變小了，那么很有可能這個interval會覆蓋他前面一個interval。這個時候就要把當(dāng)前Interval從鏈表里面刪除掉。然后更新curr指針。讓他和下一個interval再次進(jìn)行比較。

list remove 操作。一般情況下，時間復(fù)雜度是O(n)
如果刪的是頭部或者尾部，時間復(fù)雜度是O(1)

以前的那個用HashMap實現(xiàn)sort的方法也是很有意思的。

Anyway, Good luck, Richardo! -- 09/02/2016

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容

  • 背景 一年多以前我在知乎上答了有關(guān)LeetCode的問題, 分享了一些自己做題目的經(jīng)驗。 張土汪：刷leetcod...
    土汪閱讀 12,776評論 0贊 33
  • My code: My test result: 首先說下測試結(jié)果為什么這么慢。我的理解是，這道題目是8.9才改題...
    Richardo92閱讀 1,254評論 1贊 1
  • My code: My test result: 這個做法不是我一開始的做法。但是這個做法速度更快更高效。我也是看...
    Richardo92閱讀 250評論 0贊 1
  • My code: 這道題目還是挺有意思的。一開始寫出來超出時間了，沒有怎么仔細(xì)分析。兩個操作，get,set,最理...
    Richardo92閱讀 410評論 0贊 0
  • My code: 最近比較忙。之前寫的題目一直沒有更新。現(xiàn)在正好有點(diǎn)時間，更新一下。這道題木之前聽學(xué)長說過，他在面...
    Richardo92閱讀 299評論 0贊 0