Given an integer array arr
, remove a subarray (can be empty) from arr
such that the remaining elements in arr
are non-decreasing.
Return the length of the shortest subarray to remove.
A subarray is a contiguous subsequence of the array.
Example 1:
Input: arr = [1,2,3,10,4,2,3,5] Output: 3 Explanation: The shortest subarray we can remove is [10,4,2] of length 3. The remaining elements after that will be [1,2,3,3,5] which are sorted. Another correct solution is to remove the subarray [3,10,4].
Example 2:
Input: arr = [5,4,3,2,1] Output: 4 Explanation: Since the array is strictly decreasing, we can only keep a single element. Therefore we need to remove a subarray of length 4, either [5,4,3,2] or [4,3,2,1].
Example 3:
Input: arr = [1,2,3] Output: 0 Explanation: The array is already non-decreasing. We do not need to remove any elements.
Constraints:
1 <= arr.length <= 105
0 <= arr[i] <= 109
思路:我可以找到左边递增的最后一个位置,右边递增的最前面的一个位置,
part1 removepart part2
.....left XXXXXXX right.....
i j
那么 中间的X位置,是必须肯定要remove掉的,至少肯定结果是Math.min(part1 + removepart, removepart + part2),还能不能更小呢?那么问题就出现在前面和后面的段能否连起来,如果能够连起来,那么removepart 可以加上一小段,remove掉就可以让整个arr连成一大段递增了。
那么如何判断前后能否连接起来呢?双指针,arr[i] < arr[j], i ++ , update res,注意这里是j - i -1,因为i, j都不进去length;arr[i] > arr[j], j ++;
class Solution {
public int findLengthOfShortestSubarray(int[] arr) {
int n = arr.length;
int left = 0;
while(left + 1 < n && arr[left] <= arr[left + 1]) {
left++;
}
if(left == n - 1) {
return 0;
}
int right = n - 1;
while(left <= right && arr[right - 1] <= arr[right]) {
right--;
}
int res = Math.min(n - left - 1, right);
int i = 0;
int j = right;
while(i <= left && j < n) {
if(arr[i] <= arr[j]) {
res = Math.min(res, j - i - 1);
i++;
} else {
j++;
}
}
return res;
}
}