[Leetcode] 21 & 23 & 56 & 57: Intervals

Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Example:

Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

题目理解：把两个排好序的linkedlist merge起来，然后返回merge好的linkedlist的头节点。
关于linkedlist的题目一般都要准备好双指针，然后通过双指针的“速度”“方向”“遍历”来完成.这道题也是需要使用双指针：
题目给了一个很关键的提示：两个linkedlist都是排好序的，那么我们可以得到以下的结论：
1. let s1 = head of list 1, s2 = head of list 2
2. if s1 < s2 and s1 -> next < s2, then there does not exist any element e such that s1 < e < s2.
因为我们只有两个linkedlist，所以这个结论我们可以很容易通过contradiction来证明。
在实施起来也非常容易. 这里需要使用一个dummy 和curr节点分别在每次遍历的时候更新和用作返回值。

解法1:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        ListNode *dummy = new ListNode(-1), *curr = dummy;
        while (l1 && l2) {
            if (l1->val < l2->val) {
                dummy->next = l1;
                l1 = l1->next;
            } else { // if l1 and l2 are equal, then choose l2 (you can also choose l1)
                dummy->next = l2;
                l2 = l2->next;
            }
            dummy = dummy->next;
        }
        if (l1)
            dummy->next = l1;
        else if (l2)
            dummy->next = l2;
        return curr->next;
    }
};

Merge K sorted Lists

 

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6
题目理解：与上一道题不同的是这次是k个linkedlist，所以最简单能想到的方法便是继续套用两个的做法：

1. merge list i with j, where j != i and j is in the range of k - i
2. when finish list i, merge i + 1 until i == k

这个做法其实就是把每两个都merge一遍，这样的复杂度便是：
1. assume the average length of each list is m
2. to merge i = 1 with all the valid j: it will require (k + k) + (2k + k) + (3k + k) ... + ((m - 1)k + k) = 2k + 3k + 4k + ... + mk = O(m2 * k)

这样做的复杂度会比较高，我们可以通过一些别的方法来降低复杂度.这个算法实际上并没有充分利用排好序的特征，只是在merge的时候保证是可以通过线性扫描来完成。
一般对于排好序的数组一般还是应该先想到二分法和快速/归并排序。首先最直观的方法便是使用一个priority queue来实现：假如不是一个linkedlist，那么我们实际上
只需要每次都把所有的数字push进我们的heap其实就可以了，这样时间复杂度便是：
1. first list will require m insertions, for each insertion the complexity will be log m (worst case), so total will be m log m
2. second list require 2m log 2m
3. total will be m log m + 2m log 2m + 3m log 3m + ... + km log km = O(m * k2)
这里其实可以看到这个算法并没有提高太多，如果我们的k远大于averge length m，那么实际上这个算法并没有提升多少。假如我们不用每次都把所有之前的数字都遍历一遍，或者通过某种方式降低每次
push进去的node的数量其实就可以有效的降低我们的复杂度。那么就可以每次都放k个节点进到我们的priority queue中，我们每次保证这个queue只有k个元素，这样时间复杂度就会大量的降低：
1. push all the first nodes into priority queue (pq).
2. pop the first node by from pq, so that we get the smallest node among the k head nodes
3. append the pop node to our return list, and push the next node from the node we just pop
4. going back to 2 until there is no more nodes left from pq
这个方法可以保证每次push进去的复杂度永远是log k，一共有m * k 个节点，所以总的时间复杂度是O(m * k * log k)，这也是这道题的最终结果：

解法1：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](const ListNode* left, const ListNode* right) {
            return (left -> val) > (right -> val);
        };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq(cmp);
        ListNode* dummy = new ListNode(-1);
        ListNode* curr = dummy;
        for (auto node : lists)
            if (node)
                pq.push(node);
        
        while (!pq.empty()) {
            auto t = pq.top();
            pq.pop();
            curr -> next = t;
            curr = curr -> next;
            if (t && t -> next)
                pq.push(t -> next);
        }
        return dummy -> next;
    }
};

 

Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

Example 1:

Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

Example 2:

Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considered overlapping.

题目理解：给一个没有顺序的interval数组，现在要把所有有交错的interval都merge一起，返回最终的结果。
第一步是先按照每一个interval的起始位置排序，然后遍历一遍把所有 current end <= next start 的两个interal都merge一次，这样最后的list就是已经merge好的了

解法1：

#define vvi vector<vector<int>>
#define vi vector<int>
#define pb push_back
class Solution {
public:
    vi mergeTwo(vi& l, vi& r) {
        return {min(l[0], r[0]), max(l[1], r[1])};
    }
    vvi merge(vvi& in) {
        vvi res;
        sort(in.begin(), in.end());
        for (int i = 0; i < in.size(); ++i) {
            if (res.empty() || res.back()[1] < in[i][0])
                res.pb(in[i]);
            else
            {
                vi merged = mergeTwo(res.back(), in[i]);
                res.pop_back();
                res.pb(merged);
            }
                
        }
        return res;
    }
};

Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:

Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]

Example 2:

Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].

题目理解：给一个数组，每个element都是[start, end]，代表一个interval。现在要插入一个新的interval：[new start, new end],返回最终数组。如果新的interval与之前的任意的interval有交错的话：new start < start or new end > end，则需要把这种的interval merge一起。我们可以先看几个test：1. [[1, 3], [10, 13]] - insert [5, 7] -> [[1, 3], [5, 7], [10, 13]] (no intersection)2. [[1, 3], [5, 10]] - insert [3, 5] -> [[1, 3], [3, 5], [5, 10]] -> [[1, 5], [5, 10]] -> [[1, 10]] (multiple intersections)如果只有两个interval的话，这个问题便很好解决：1. old interval list = [[start, end]]2. insert new interval [new start, new end]3. new interal list = [[min(start, new start), max(new end, end)]]实际上我们需要merge的只有交错的interval，所以如果能把所有会交错的数组通过某种方式都拿出来，那么我们只要把所有的这些交错的数组种取最小的start和最大的end便可以组成我们新的数组：1. create a list that holds all the intervals that have end < new start; create another list that holds all the intervals that have new end < start2. so the rest of the intervals are all going to intersect with new interval, we keep updating our new start and new end once we get a new one that will intersect with new interval.3. concatenate the two list, and insert the new interval at the middle. (O(n))

这样的算法时间复杂度是O( n) 因为我们在遍历前首先要排序，之后要再次遍历整个数组。

解法1：

class Solution {
    public:
        vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
            vector<vector<int>> left, right;
            int s = newInterval[0], e = newInterval[1];
            for (auto& i : intervals) {
                if (i[1] < s) { // all less than newInterval
                    left.push_back(i);
                } else if (i[0] > e) { // all greater than newInterval
                    right.push_back(i);
                } else {
                    s = min(s, i[0]); // the one needs to be merged
                    e = max(e, i[1]);
                }
            }
            left.push_back({s, e});
            // O(n)
            left.insert(left.end(), right.begin(), right.end());
            return left;
        }
};