The Indian Engineer

Problem 1574 Shortest Subarray to be Removed to Make Array Sorted

Posted on 4 mins

Array Two-Pointers Binary-Search Stack Monotonic-Stack

Problem Statement

Link - Problem 1574

Question

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:

Solution

class Solution {
public:
    int findLengthOfShortestSubarray(vector<int>& arr) {

        int n = arr.size();
        int left = 0, right = n - 1;
        while(right > 0 && arr[right - 1] <= arr[right])
        {
            right--;
        }
        int ans = right;
        while(left < right && (left == 0 || arr[left - 1] <= arr[left]))
        {
            while(right < n && arr[left] > arr[right])
            {
                right++;
            }
            ans = min(ans, right - left - 1);
            left++;
        }
        return ans;
    }
};

Complexity Analysis

| Algorithm | Time Complexity | Space Complexity |
| --------- | --------------- | ---------------- |
| Greedy    | O(n)            | O(1)             |

Explanation

1. Intuition

2. Implementation


Complexity Analysis

Time Complexity:

Space Complexity:


Footnote

This question is rated as Medium difficulty.

Hints

The key is to find the longest non-decreasing subarray starting with the first element or ending with the last element, respectively.

After removing some subarray, the result is the concatenation of a sorted prefix and a sorted suffix, where the last element of the prefix is smaller than the first element of the suffix.


Similar Questions:

Title URL Difficulty
Count the Number of Incremovable Subarrays II https://leetcode.com/problems/count-the-number-of-incremovable-subarrays-ii Hard
Count the Number of Incremovable Subarrays I https://leetcode.com/problems/count-the-number-of-incremovable-subarrays-i Easy