Leetcode - Meeting Rooms

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 boolean canAttendMeetings(Interval[] intervals) {
        if (intervals == null || intervals.length == 0) {
            return true;
        }

        int max = 0;
        for (int i = 0; i < intervals.length; i++) {
            Interval curr = intervals[i];
            max = Math.max(max, curr.end);
        }

        boolean[] timeline = new boolean[max + 1];
        for (int i = 0; i < intervals.length; i++) {
            Interval curr = intervals[i];
            for (int j = curr.start + 1; j <= curr.end - 1; j++) {
                if (timeline[j]) {
                    return false;
                }
                else {
                    timeline[j] = true;
                }
            }
            timeline[curr.start] = true;
            timeline[curr.end] = true;
        }

        return true;
    }
}

这个是我自己的做法。起源于谷歌的一次面试。才知道这个问题时间复杂度可以夸张的提高到 O(n),付出空间的代价。

我申请一个布尔数组。全是false
然后将interval start - end全部遍历，改成true
如果期间有哪个index已经是true，说明之前已经有人预定过了，那么就直接返回false了，否则继续。
这是大思路。然后细节是。

如果 [ [3, 4], [4, 5], [5, 6] ]

这个也是可以的。
所以首先遍历 [start + 1, end - 1]
然后如果并没有返回false，这个时候，边界的状态，无论是true还是false，都不会影响最后结果，这相邻的几个会议他一定都能参加。所以更新边界的状态，然后继续往后走。

然后网上还有种排序的做法。时间是O(nlogn),空间是O(1)

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 boolean canAttendMeetings(Interval[] intervals) {
        if (intervals == null || intervals.length == 0) {
            return true;
        }
        
        Arrays.sort(intervals, new Comparator() {
            public int compare(Interval o1, Interval o2) {
                return o1.start - o2.start;
            }    
        });
        
        for (int i = 0; i < intervals.length - 1; i++) {
            if (intervals[i].end > intervals[i + 1].start) {
                return false;
            }
        }
        
        return true;
    }
}

也是挺巧的。
原来这道题目我从来没做过。。。。

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