Problem link  Remove Subarrays in
Problem Statement:
You are given an array arr of length N. The task is to determine how many contiguous subarrays can be removed so that the remaining elements of the array are in strictly increasing order. An empty subarray is considered strictly increasing.
Approach:
The key idea is to check for every possible subarray in the array arr and determine whether removing that subarray makes the rest of the array strictly increasing. To achieve this, the solution uses nested loops to consider all subarrays and checks whether the rest of the array remains strictly increasing after removing each subarray.
StepbyStep Explanation:

Initialize Variable:
 The variable count is used to keep track of the number of removable subarrays.

Iterate Over All Subarrays:
 Two nested loops are used to iterate over all possible subarrays of the array:
 The outer loop with i iterates over the starting indices of the subarrays.
 The inner loop with j iterates over the ending indices of the subarrays.

Check for Strictly Increasing Condition:
 For each subarray starting at index i and ending at index j, the code checks if the remaining elements of the array (excluding the subarray) are in strictly increasing order.

Iterate Over the Remaining Parts:
 The code first checks the part of the array before the subarray (from index 0 to i1). It uses a variable last to track the last valid element of the increasing sequence. If any element is smaller than or equal to last, the array is not strictly increasing.
 If the part before the subarray is strictly increasing, the code then checks the part of the array after the subarray (from index j+1 to n1). Again, if any element is smaller than or equal to last, the array is not strictly increasing.

Increment the Count:
 If both the part before and the part after the subarray are strictly increasing, the subarray can be removed. In this case, the variable count is incremented.

Return the Result:
 After checking all possible subarrays, the total number of removable subarrays is stored in count and returned as the result.
Time Complexity:
The approach involves checking all subarrays of the array, resulting in a time complexity of O(N^3), where N is the length of the array. This is because there are O(N^2) possible subarrays, and for each subarray, checking the remaining parts of the array takes O(N) time.
Space Complexity:
The space complexity is O(1) since the solution only uses a few variables, such as count, last, and increasing, and does not require any extra space that grows with the size of the input.