Formatted question description: https://leetcode.ca/all/757.html

757. Set Intersection Size At Least Two (Hard)

An integer interval [a, b] (for integers a < b) is a set of all consecutive integers from a to b, including a and b.

Find the minimum size of a set S such that for every integer interval A in intervals, the intersection of S with A has a size of at least two.

 

Example 1:

Input: intervals = [[1,3],[1,4],[2,5],[3,5]]
Output: 3
Explanation: Consider the set S = {2, 3, 4}.  For each interval, there are at least 2 elements from S in the interval.
Also, there isn't a smaller size set that fulfills the above condition.
Thus, we output the size of this set, which is 3.

Example 2:

Input: intervals = [[1,2],[2,3],[2,4],[4,5]]
Output: 5
Explanation: An example of a minimum sized set is {1, 2, 3, 4, 5}.

 

Constraints:

  • 1 <= intervals.length <= 3000
  • intervals[i].length == 2
  • 0 <= ai < bi <= 108

Related Topics:
Greedy

Solution 1. Greedy

Keep track of the two intersection points.

// OJ: https://leetcode.com/problems/set-intersection-size-at-least-two/

// Time: O(NlogN)
// Space: O(1)
class Solution {
public:
    int intersectionSizeTwo(vector<vector<int>>& A) {
        sort(begin(A), end(A), [](auto &a, auto &b) { return a[1] < b[1]; });
        int ans = 0, a = INT_MIN, b = INT_MIN;
        for (auto &v : A) {
            if (v[0] > b) {
                b = v[1];
                a = v[1] - 1;
                ans += 2;
            } else if (v[0] > a) {
                a = v[1];
                if (a == b) --a;
                else if (a > b) swap(a, b);
                ans++;
            }
        }
        return ans;
    }
};

Java

class Solution {
    public int intersectionSizeTwo(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                if (interval1[0] != interval2[0])
                    return interval1[0] - interval2[0];
                else
                    return interval2[1] - interval1[1];
            }
        });
        int length = intervals.length;
        int[] remains = new int[length];
        Arrays.fill(remains, 2);
        int size = 0;
        for (int i = length - 1; i >= 0; i--) {
            int[] interval = intervals[i];
            int start = interval[0], end = interval[1];
            int remain = remains[i];
            int intersectionStart = start, intersectionEnd = start + remain;
            for (int j = intersectionStart; j < intersectionEnd; j++) {
                for (int k = 0; k <= i; k++) {
                    if (remains[k] > 0 && j <= intervals[k][1])
                        remains[k]--;
                }
                size++;
            }
        }
        return size;
    }
}

All Problems

All Solutions