g0901_1000.s0986_interval_list_intersections.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0901_1000.s0986_interval_list_intersections;

// #Medium #Array #Two_Pointers #Algorithm_II_Day_4_Two_Pointers
// #2022_03_31_Time_2_ms_(99.95%)_Space_43.1_MB_(85.56%)

import java.util.ArrayList;

/**
 * 986 - Interval List Intersections\.
 *
 * Medium
 *
 * You are given two lists of closed intervals, `firstList` and `secondList`, where firstList[i] = [start_i, end_i] and secondList[j] = [start_j, end_j]. Each list of intervals is pairwise **disjoint** and in **sorted order**.
 *
 * Return _the intersection of these two interval lists_.
 *
 * A **closed interval** `[a, b]` (with `a <= b`) denotes the set of real numbers `x` with `a <= x <= b`.
 *
 * The **intersection** of two closed intervals is a set of real numbers that are either empty or represented as a closed interval. For example, the intersection of `[1, 3]` and `[2, 4]` is `[2, 3]`.
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2019/01/30/interval1.png)
 *
 * **Input:** firstList = \[\[0,2],[5,10],[13,23],[24,25]], secondList = \[\[1,5],[8,12],[15,24],[25,26]]
 *
 * **Output:** [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
 *
 * **Example 2:**
 *
 * **Input:** firstList = \[\[1,3],[5,9]], secondList = []
 *
 * **Output:** []
 *
 * **Constraints:**
 *
 * *   `0 <= firstList.length, secondList.length <= 1000`
 * *   `firstList.length + secondList.length >= 1`
 * *   0 <= start_i < end_i <= 10⁹
 * *   end_i < start_i+1
 * *   0 <= start_j < end_j <= 10⁹
 * *   end_j < start_j+1
**/
public class Solution {
    public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
        ArrayList list = new ArrayList<>();
        int i = 0;
        int j = 0;
        while (i < firstList.length && j < secondList.length) {
            int start = Math.max(firstList[i][0], secondList[j][0]);
            int end = Math.min(firstList[i][1], secondList[j][1]);
            if (start <= end) {
                list.add(new int[] {start, end});
            }
            if (firstList[i][1] > end) {
                j++;
            } else {
                i++;
            }
        }
        return list.toArray(new int[0][]);
    }
}