扫描线算法模板原理其实很容易想明白

如果多架飞机降落和起飞在同一时刻，我们认为降落有优先权。

下面这个是参考答案：

将起飞时间和降落时间放到同一个数组中, 标识出是起飞还是降落时间, 然后对数组排序.

遍历数组即可, 碰到起飞计数器加一, 碰到降落计数器减一. 维护最大值作为答案.

注意降落优先于起飞.——当心！！！

精選裡面的Python解答使用的是cmp這個function，然而這個cmp function在Python 3.x已經不再作為sorted(), list.sort()的參數了下面提供的版本是依照精選Python解答改過來的，適用於Python3.x版

def sorter(x, y):
    if x[0] != y[0]:
        return x[0] - y[0]
    return x[1] - y[1]


from functools import cmp_to_key
class Solution:
    
    def countOfAirplanes(self, airplanes):
        times = []
        for airplane in airplanes:
            times.append((airplane.start, 1))
            times.append((airplane.end, -1))

        times = sorted(times, key = cmp_to_key(sorter))

        count = 0
        max_count = 0
        for time, delta in times:
            count += delta
            max_count = max(max_count, count)
            
        return max_count
我的答案：

"""
Definition of Interval.
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param airplanes: An interval array
    @return: Count of airplanes are in the sky.
    """
    def countOfAirplanes(self, airplanes):
        # write your code here
        lines = []
        START, END = 1, 0
        for p in airplanes:
            lines.append((p.start, START))
            lines.append((p.end, END))
        
        lines.sort()
        
        c = 0
        ans = 0
        for p, flag in lines:
            if flag == START:
                c += 1
            else:
                c -= 1
            ans = max(ans, c)
        assert c == 0
        
        return ans

直接排序就好了，因为python3里tuple的比较就是按照先比较第一个，再比较第二个！！！

>>> (1, 1) > (1, 2)
False
>>> (1, 1) < (1, 2)
True
>>> (2, 1) < (2, 3)
True
>>> (2, 1) > (2, 3)
False
>>> (2, 1) == (2, 1)
True

L = [(‘d’,2),(‘a’,4),(‘b’,3),(‘c’,2)]
L.sort(key=lambda x:(x[1],x[0])) 先按照数字排序，再按照字母排序
L
[(‘c’, 2), (‘d’, 2), (‘b’, 3), (‘a’, 4)]

919. 会议室 II

样例

样例1

输入: intervals = [(0,30),(5,10),(15,20)]
输出: 2
解释:
需要两个会议室
会议室1:(0,30)
会议室2:(5,10),(15,20)

样例2

输入: intervals = [(2,7)]
输出: 1
解释:
只需要1个会议室就够了

"""
Definition of Interval.
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def minMeetingRooms(self, intervals):
        # Write your code here
        lines = []
        S, E = 1, 0
        for i in intervals:
            lines.append((i.start, S))
            lines.append((i.end, E))
        
        lines.sort()
        
        ans = 0
        c = 0
        for t, flag in lines:
            if flag == S:
                c += 1
            else:
                c -= 1
            ans = max(ans, c)
        
        assert c == 0
        return ans

输出两组区间的交集

描述

目前有两个用户的有序在线时间序列，每一个区间记录了该用户的登录时间点x和离线时间点y，请找出这两个用户同时在线的时间段，输出的时间段请从小到大排序。

你需要返回一个intervals的列表

样例

样例 1：

输入：seqA = [(1,2),(5,100)], seqB = [(1,6)]
输出：[(1,2),(5,6)]
解释：在 (1,2), (5,6) 这两个时间段内，两个用户同时在线。

样例 2：

输入：seqA = [(1,2),(10,15)], seqB = [(3,5),(7,9)]
输出：[]
解释：不存在任何时间段，两个用户同时在线。

30行超简单扫描线算法，仍然是遇到start，count++，遇到end，count--，那么intersection就是找出所有时刻(x, x+1)，其中x时刻count=2，x+1时刻的count=1

public class Solution {
    public List<Interval> timeIntersection(List<Interval> seqA, List<Interval> seqB) {
        seqA.addAll(seqB);
        List<Point> points = new ArrayList<>();
        for (Interval interval : seqA) {
            points.add(new Point(interval.start, true));
            points.add(new Point(interval.end, false));
        }

        Collections.sort(points, (p1, p2) -> p1.x - p2.x);

        int count = 0;
        int start = -1;
        List<Interval> res = new ArrayList<>();
        for (Point p : points) {
            if (p.ifStart) count++;
            else count--;

            if (count == 2) start = p.x;
            if (count == 1 && start != -1) {
                res.add(new Interval(start, p.x));
                start = -1;
            }
        }

        return res;
	}

    class Point {
        int x;
        boolean ifStart;
        public Point(int x, boolean ifStart) {
            this.x = x;
            this.ifStart = ifStart;
        }
    }
}

当然，还有双指针解法 ==>以前在没有学sweep line的时候我就是这样做的。。。

可以用二路归并相似的思路，用两个指针来分别记录两个list的当前扫描位置

然后分情况讨论

如果两个区间没有交集， seqAi.start > seqBj.end or seqAi.end < seqBj.start 在这种情况下就将end小的List的指针向前进一
如果两个区间有交集，则统计 start 为两个start中大的那个， end 为两个end 中小的那个，将这个区间放入答案集合，并且前进end小的那个list的指针

因为两个list都是按start sorted并且没有Overlap, 所以结果也一定是按相同顺序排序时间复杂度O(N) N为两个List中相对较短的长度，空间复杂度 O(1）

class Solution:
    """
    @param seqA: the list of intervals
    @param seqB: the list of intervals
    @return: the time periods
    """
    def timeIntersection(self, seqA, seqB):
        # Write your code here
                
        if seqA == None or seqB == None or len(seqA) == None or len(seqB) == None:
            return []
            
        i，j = 0, 0
        ans = []
        while i < len(seqA) and j < len(seqB):
            if seqA[i].start > seqB[j].end:
                j += 1
                continue
            elif seqB[j].start > seqA[i].end:
                i += 1
                continue
            
            if seqA[i].start <= seqB[j].start:
                start = seqB[j].start
            elif seqA[i].start > seqB[j].start:
                start = seqA[i].start
            
            if seqA[i].end <= seqB[j].end:
                end = seqA[i].end
                i += 1
            elif seqA[i].end > seqB[j].end:
                end = seqB[j].end
                j += 1
            ans.append(Interval(start, end))
        return ans

将者，智、信、仁、勇、严也。

Hi，我是李智华，华为-安全AI算法专家，欢迎来到安全攻防对抗的有趣世界。

391. 数飞机

公告

将者，智、信、仁、勇、严也。

Hi，我是李智华，华为-安全AI算法专家，欢迎来到安全攻防对抗的有趣世界。

扫描线算法模板 原理其实很容易想明白

391. 数飞机

样例

注意事项

919. 会议室 II

样例

描述

样例

公告

扫描线算法模板原理其实很容易想明白