Welcome to Subscribe On Youtube

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

845. Longest Mountain in Array (Medium)

Let's call any (contiguous) subarray B (of A) a mountain if the following properties hold:

  • B.length >= 3
  • There exists some 0 < i < B.length - 1 such that B[0] < B[1] < ... B[i-1] < B[i] > B[i+1] > ... > B[B.length - 1]

(Note that B could be any subarray of A, including the entire array A.)

Given an array A of integers, return the length of the longest mountain

Return 0 if there is no mountain.

Example 1:

Input: [2,1,4,7,3,2,5]
Output: 5
Explanation: The largest mountain is [1,4,7,3,2] which has length 5.

Example 2:

Input: [2,2,2]
Output: 0
Explanation: There is no mountain.

Note:

  1. 0 <= A.length <= 10000
  2. 0 <= A[i] <= 10000

Follow up:

  • Can you solve it using only one pass?
  • Can you solve it in O(1) space?

Related Topics:
Two Pointers

Solution 1.

  • class Solution {
        public int longestMountain(int[] A) {
            int length = A.length;
            int[] ascending = new int[length];
            for (int i = 1; i < length; i++) {
                if (A[i] > A[i - 1])
                    ascending[i] = ascending[i - 1] + 1;
            }
            int[] descending = new int[length];
            for (int i = length - 2; i >= 0; i--) {
                if (A[i] > A[i + 1])
                    descending[i] = descending[i + 1] + 1;
            }
            int longest = 0;
            int start = 1, end = length - 1;
            for (int i = start; i < end; i++) {
                if (ascending[i] > 0 && descending[i] > 0) {
                    int mountainLength = ascending[i] + descending[i] + 1;
                    longest = Math.max(longest, mountainLength);
                }
            }
            return longest;
        }
    }
    
    ############
    
    class Solution {
        public int longestMountain(int[] arr) {
            int left = 0, right = 0;
            int ans = 0;
            int status = -1;
            while (++right < arr.length) {
                if (status == -1 || status == 1) {
                    if (arr[right] == arr[right - 1]) {
                        status = -1;
                    }
                    if (status == -1) {
                        if (arr[right] > arr[right - 1]) {
                            status = 1;
                        } else {
                            left = right;
                        }
                    }
                    if (status == 1 && arr[right] < arr[right - 1]) {
                        status = 2;
                    }
                } else {
                    if (arr[right] > arr[right - 1]) {
                        status = 1;
                        ans = Math.max(right - left, ans);
                        left = right - 1;
                    } else if (arr[right] == arr[right - 1]) {
                        status = -1;
                        ans = Math.max(right - left, ans);
                        left = right;
                    }
                }
            }
            if (status == 2) {
                ans = Math.max(ans, right - left);
            }
            return ans;
        }
    }
    
  • // OJ: https://leetcode.com/problems/longest-mountain-in-array/
    // Time: O(N)
    // Space: O(1)
    class Solution {
    public:
        int longestMountain(vector<int>& A) {
            int dir = 0, N = A.size(), start = -1, ans = 0;
            for (int i = 1; i < N; ++i) {
                int d = A[i] == A[i - 1] ? 0 : (A[i] > A[i - 1] ? 1 : -1); // the new direction
                if (d == dir) continue; // if the direction is the same, skip
                if (dir == -1 && start != -1) ans = max(ans, i - start); // if we have a valid starting point and we are going downwards, we can try to update the answer
                dir = d;
                if (dir == 1) start = i - 1; // if new direction is upwards, set the starting point
                else if (dir == 0) start = -1; // going horizontal will invalidate the starting point.
            }
            if (dir == -1 && start != -1) ans = max(ans, N - start); // handle the case where the downward section reaches the end.
            return ans;
        }
    };
    
  • class Solution:
        def longestMountain(self, arr: List[int]) -> int:
            left, right = 0, 1
            status = -1
            ans = 0
            while right < len(arr):
                if status == -1 or status == 1:
                    if arr[right] == arr[right - 1]:
                        status = -1
                    if status == -1:
                        if arr[right] > arr[right - 1]:
                            status = 1
                        else:
                            left = right
                    if status == 1 and arr[right] < arr[right - 1]:
                        status = 2
                else:
                    if arr[right] == arr[right - 1]:
                        status = -1
                        ans = max(ans, right - left)
                        left = right
                    elif arr[right] > arr[right - 1]:
                        status = 1
                        ans = max(ans, right - left)
                        left = right - 1
                right += 1
            if status == 2:
                ans = max(right - left, ans)
            return ans
    
    ############
    
    class Solution(object):
        def longestMountain(self, A):
            """
            :type A: List[int]
            :rtype: int
            """
            N = len(A)
            inc = [1] * N
            dec = [1] * N
            for i in range(1, N):
                if A[i] - A[i - 1] > 0:
                    inc[i] = inc[i - 1] + 1
            for i in range(N - 2, -1, -1):
                if A[i] - A[i + 1] > 0:
                    dec[i] = dec[i + 1] + 1
            res = 0
            for i in range(1, N - 1):
                if inc[i] != 1 and dec[i] != 1:
                    res = max(res, inc[i] + dec[i] - 1)
            return res
    
  • func longestMountain(arr []int) (ans int) {
    	n := len(arr)
    	for l, r := 0, 0; l+2 < n; l = r {
    		r = l + 1
    		if arr[l] < arr[r] {
    			for r+1 < n && arr[r] < arr[r+1] {
    				r++
    			}
    			if r+1 < n && arr[r] > arr[r+1] {
    				for r+1 < n && arr[r] > arr[r+1] {
    					r++
    				}
    				ans = max(ans, r-l+1)
    			} else {
    				r++
    			}
    		}
    	}
    	return
    }
    
    func max(a, b int) int {
    	if a > b {
    		return a
    	}
    	return b
    }
    

All Problems

All Solutions