Description
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?
思路
解法一
由题可知，山型数组的 LIS(LDS) 部分是严格递增（递减）的，所以判断条件只能是 < 或 >，不能是 ≤ 或 ≥ 。
先不考虑什么高级解法，暴力解题。利用一个 for 循环得到每个 increasing sequence 的最后一个元素，称之为 peak，并逐一加入 peak_points 中。随后遍历 peak_points 中的每一个 peak, 继续计算以它为起点的 decreasing sequence 的长度，同时计算出山型数组最长的长度。
时间复杂度：O(n^2)，因为得到了每一个 peak 之后还需要一个循环来处理 decreasing sequence
空间复杂度：O(n)，需要一个 HashMap 存储 peak 的索引和以它为终点的 increasing sequence 的长度
耗时 28 ms, Memory 9.7 MB, ranking 15%
class Solution {
public:
int longestMountain(const vector<int> &nums) {
if (nums.size() < 3) return 0;
// mapping from index of peak element to increasing sequence length
unordered_map<int, int> peak_points;
int incre_seq_length = 1;
for (int i = 1; i < nums.size(); ++i) {
if (nums[i-1] < nums[i]) {
++incre_seq_length;
} else {
// length of increasing part of B should be at least 2
if (incre_seq_length >= 2) {
peak_points[i - 1] = incre_seq_length;
}
incre_seq_length = 1;
}
}
// derive length of decresing sequences following start_point
int max_mountain_length = 0;
for (auto item : peak_points) {
int mountain_length = item.second;
bool has_decre_element = false;
for (int i = item.first + 1; i < nums.size(); ++i) {
if (nums[i-1] > nums[i]) {
if (!has_decre_element) has_decre_element = true;
++mountain_length;
} else {
break;
}
}
if (has_decre_element &&
max_mountain_length < mountain_length) {
max_mountain_length = mountain_length;
}
}
return max_mountain_length;
}
};
解法二
利用 DP 求 LIS 的思想求解，逆向求 LIS（相当于求出了一个山型数组的LDS），然后再正向求 LIS，在正向求解时顺便也计算出 mountain_length 。
利用 up[] 和 down[] 记录了求解 LIS 和 LDS 时每个子序列的长度。up[i] 表示以 nums[i] 为结尾的 increasing sequence 的长度（实际为长度减一，以便计算山型数组的长度），down[i] 表示以 nums[i] 为开头的 decreasing sequence 的长度。
时间复杂度：O(n)，因为求解 LDS 和 LIS 是线性DP
空间复杂度：O(n)，需要用到 up[] 和 down[] 两个记录数组
耗时 20 ms, Memory 9.0 MB, ranking 91.26%
class Solution {
public:
int longestMountain(const vector<int> &nums) {
if (nums.size() < 3) return 0;
int max_mountain_length = 0;
// up[i] represents length - 1 of increasing sequence that end with up[i]
vector<int> up(nums.size());
// down[i] represents length - 1 of decreasing sequence that start with down[i]
vector<int> down(nums.size());
for (int i = nums.size() - 2; i >= 0; --i) {
if (nums[i] > nums[i+1]) {
down[i] = down[i+1] + 1;
}
}
for (int i = 1; i < nums.size(); ++i) {
if (nums[i-1] < nums[i]) {
up[i] = up[i-1] + 1;
if (down[i] > 0) {
int mountain_length = up[i] + down[i] + 1;
if (max_mountain_length < mountain_length) {
max_mountain_length = mountain_length;
}
}
}
}
return max_mountain_length;
}
};
解法三
follow up 中需要将 space 优化成 O(1)，所以不能使用解法二中提到的记录数组 up[] 和 down[]。
因为每次更新状态时，up[] 和 down[] 中的值不能直接被几个变量替代，所以不能直接压缩空间为 O(1)，而是需要重新设计 DP 算法里的状态。
用 up 表示以 nums[i] 为结尾的 increasing sequence 的长度（实际为长度减一，以便计算山型数组的长度），用 down 表示以 nums[i] 为结尾的 decreasing sequence 的长度。这样，山型数组的长度就等价于 up + down + 1。
因为 nums 的第一个元素肯定不是 peak （山型数组至少要三个数据，如果第一个元素是 peak，那就只剩山型数组的右半部了），所以从 i=1 开始遍历 nums，计算 up、down 和山型数组长度，在每一次重新爬坡时把 up 和 down 重置为 0。遍历结束后，我们就得到了山型数组最长的长度。
时间复杂度：O(n)
空间复杂度：O(1)
耗时 20 ms, Memory 7.8 MB, ranking 91.26%
class Solution {
public:
int longestMountain(const vector<int> &nums) {
if (nums.size() < 3) return 0;
int max_mountain_length = 0;
// up represents length - 1 of increasing sequence that end with current idx
int up = 0;
// down represents length - 1 of decreasing sequence that start with current idx
int down = 0;
// nums[0] cannot be a peak element
for (int i = 1; i < nums.size(); ++i) {
if (nums[i-1] == nums[i]) { // go with a new mountain sequence
up = 0;
down = 0;
continue;
}
if (nums[i-1] < nums[i]) {
if (down > 0) { // go with a new mountain sequence
up = 0;
down = 0;
}
++up;
}
if (nums[i-1] > nums[i]) {
++down;
}
if (up > 0 && down > 0) {
int mountain_length = up + down + 1;
if (max_mountain_length < mountain_length) {
max_mountain_length = mountain_length;
}
}
}
return max_mountain_length;
}
};
参考
- 《[LeetCode] 845. Longest Mountain in Array 数组中最长的山》：https://www.cnblogs.com/grandyang/p/10459400.html