Given an integer array arr
, remove a subarray (can be empty) from arr
such that the remaining elements in arr
are non-decreasing.
A subarray is a contiguous subsequence of the array.
Return the length of the shortest subarray to remove.
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.
Example 4:
Input: arr = [1] Output: 0
Constraints:
1 <= arr.length <= 10^5
0 <= arr[i] <= 10^9
Solution: Two Pointers
Find the right most j such that arr[j – 1] > arr[j], if not found which means the entire array is sorted return 0. Then we have a non-descending subarray arr[j~n-1].
We maintain two pointers i, j, such that arr[0~i] is non-descending and arr[i] <= arr[j] which means we can remove arr[i+1~j-1] to get a non-descending array. Number of elements to remove is j – i – 1 .
Time complexity: O(n)
Space complexity: O(1)
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// Author: Huahua class Solution { public: int findLengthOfShortestSubarray(vector<int>& arr) { const int n = arr.size(); int j = n - 1; while (j > 0 && arr[j - 1] <= arr[j]) --j; if (j == 0) return 0; int ans = j; // remove arr[0~j-1] for (int i = 0; i < n; ++i) { if (i > 0 && arr[i - 1] > arr[i]) break; while (j < n && arr[i] > arr[j]) ++j; // arr[i] <= arr[j], remove arr[i + 1 ~ j - 1] ans = min(ans, j - i - 1); } return ans; } }; |