LeetCode 2345. Finding the Number of Visible Mountains

原题链接在这里：https://leetcode.com/problems/finding-the-number-of-visible-mountains/description/

题目：

You are given a 0-indexed 2D integer array peaks where peaks[i] = [xi, yi] states that mountain i has a peak at coordinates (xi, yi). A mountain can be described as a right-angled isosceles triangle, with its base along the x-axis and a right angle at its peak. More formally, the gradients of ascending and descending the mountain are 1 and -1 respectively.

A mountain is considered visible if its peak does not lie within another mountain (including the border of other mountains).

Return the number of visible mountains.

Example 1:

Input: peaks = [[2,2],[6,3],[5,4]]
Output: 2
Explanation: The diagram above shows the mountains.
- Mountain 0 is visible since its peak does not lie within another mountain or its sides.
- Mountain 1 is not visible since its peak lies within the side of mountain 2.
- Mountain 2 is visible since its peak does not lie within another mountain or its sides.
There are 2 mountains that are visible.

Example 2:

Input: peaks = [[1,3],[1,3]]
Output: 0
Explanation: The diagram above shows the mountains (they completely overlap).
Both mountains are not visible since their peaks lie within each other.

Constraints:

• 1 <= peaks.length <= 105
• peaks[i].length == 2
• 1 <= xi, yi <= 105

题解：

Write some examples and we can find the pattern that if we sort the peaks, first ascending based on its left start point, then descending on its right end point.

When iterate from left to right, whenever we encounter a bigger right end point, we find a visible mountain.

Note there could be duplicate, thus check if the current and the next peak are the same, if yes, continue.

Time Complexity: O(nlogn). n = peask.length.

Space: O(n). sort worst case uses O(n) space.

AC Java:

class Solution {
    public int visibleMountains(int[][] peaks) {
        if(peaks == null || peaks.length == 0){
            return 0;
        }

        int n = peaks.length;
        Arrays.sort(peaks, (a, b) -> {
            if(a[0] - a[1] == b[0] - b[1]){
                return b[0] + b[1] - a[0] - a[1];
            }

            return a[0] - a[1] - (b[0] - b[1]);
        });

        int res = 0;
        int maxEnd = Integer.MIN_VALUE;
        for(int i = 0; i < n; i++){
            int x = peaks[i][0];
            int y = peaks[i][1];
            if(x + y > maxEnd){
                maxEnd = x + y;
                if(i < n - 1 && Arrays.equals(peaks[i], peaks[i + 1])){
                    continue;
                }

                res++;
            }
        }

        return res;
    }
}

AC Python:

class Solution:
    def visibleMountains(self, peaks: List[List[int]]) -> int:
        n = len(peaks)

        peaks.sort(key = lambda x: (x[0] - x[1], -(x[0] + x[1])))

        res = 0
        maxEnd = -inf

        for i, (x, y) in enumerate(peaks):
            if x + y > maxEnd:
                maxEnd = x + y

                if i < n - 1 and peaks[i] == peaks[i+1]:
                    continue
                
                res += 1
        
        return res

类似Buildings With an Ocean View.