README.md

1574. Shortest Subarray to be Removed to Make Array Sorted

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

Solutions (Rust)

1. Solution

impl Solution {
    pub fn find_length_of_shortest_subarray(arr: Vec<i32>) -> i32 {
        let mut arr = arr;
        let mut i = arr.len();
        let mut ret = arr.len() - 1;

        arr.insert(0, 0);

        while i > 0 && arr[i - 1] <= arr[i] {
            i -= 1;
        }

        if i == 0 {
            return 0;
        }

        for j in 0..arr.len() {
            if j > 0 && arr[j - 1] > arr[j] {
                break;
            }

            while i < arr.len() && arr[i] < arr[j] {
                i += 1;
            }

            ret = ret.min(i - j - 1);
        }

        ret as i32
    }
}