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:

0 <= A.length <= 10000
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.

// 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;
    }
};

Java

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;
    }
}

// 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(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

845 - Longest Mountain in Array

845. Longest Mountain in Array (Medium)

Solution 1.

All Problems

All Solutions