g0201_0300.s0218_the_skyline_problem.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 g0201_0300.s0218_the_skyline_problem;

// #Hard #Top_Interview_Questions #Array #Heap_Priority_Queue #Ordered_Set #Divide_and_Conquer
// #Segment_Tree #Binary_Indexed_Tree #Line_Sweep
// #2022_07_02_Time_22_ms_(76.93%)_Space_52.3_MB_(45.14%)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.TreeMap;

/**
 * 218 - The Skyline Problem\.
 *
 * Hard
 *
 * A city's **skyline** is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Given the locations and heights of all the buildings, return _the **skyline** formed by these buildings collectively_.
 *
 * The geometric information of each building is given in the array `buildings` where buildings[i] = [left_i, right_i, height_i]:
 *
 * *   left_i is the x coordinate of the left edge of the i^th building.
 * *   right_i is the x coordinate of the right edge of the i^th building.
 * *   height_i is the height of the i^th building.
 *
 * You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height `0`.
 *
 * The **skyline** should be represented as a list of "key points" **sorted by their x-coordinate** in the form [[x₁,y₁],[x₂,y₂],...]. Each key point is the left endpoint of some horizontal segment in the skyline except the last point in the list, which always has a y-coordinate `0` and is used to mark the skyline's termination where the rightmost building ends. Any ground between the leftmost and rightmost buildings should be part of the skyline's contour.
 *
 * **Note:** There must be no consecutive horizontal lines of equal height in the output skyline. For instance, `[...,[2 3],[4 5],[7 5],[11 5],[12 7],...]` is not acceptable; the three lines of height 5 should be merged into one in the final output as such: `[...,[2 3],[4 5],[12 7],...]`
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2020/12/01/merged.jpg)
 *
 * **Input:** buildings = \[\[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
 *
 * **Output:** [[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
 *
 * **Explanation:**
 *
 *     Figure A shows the buildings of the input.
 *     Figure B shows the skyline formed by those buildings.
 *     The red points in figure B represent the key points in the output list. 
 *
 * **Example 2:**
 *
 * **Input:** buildings = \[\[0,2,3],[2,5,3]]
 *
 * **Output:** [[0,3],[5,0]] 
 *
 * **Constraints:**
 *
 * *   1 <= buildings.length <= 10⁴
 * *   0 <= left_i < right_i <= 2³¹ - 1
 * *   1 <= height_i <= 2³¹ - 1
 * *   `buildings` is sorted by left_i in non-decreasing order.
**/
public class Solution {
    public List> getSkyline(int[][] buildings) {
        List> list = new ArrayList<>();
        List lines = new ArrayList<>();
        for (int[] building : buildings) {
            lines.add(new int[] {building[0], building[2]});
            lines.add(new int[] {building[1], -building[2]});
        }
        lines.sort((a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
        TreeMap map = new TreeMap<>();
        map.put(0, 1);
        int prev = 0;
        for (int[] line : lines) {
            if (line[1] > 0) {
                map.put(line[1], map.getOrDefault(line[1], 0) + 1);
            } else {
                int f = map.get(-line[1]);
                if (f == 1) {
                    map.remove(-line[1]);
                } else {
                    map.put(-line[1], f - 1);
                }
            }
            int curr = map.lastKey();
            if (curr != prev) {
                list.add(Arrays.asList(line[0], curr));
                prev = curr;
            }
        }
        return list;
    }
}