Depend operations to type the Array by incrementing every aspect of accelerating subsegment by 1

Given an array arr[] of measurement N, the duty is to make array arr[] sorted in non-decreasing order within the minimal variety of operations the place in a single operation, you’ll be able to select any non-decreasing sub-segment and increment every aspect of sub-segment by 1.

Examples:

Enter: arr[] = {5, 3, 2, 5}
Output: 3
Rationalization: First operation: [5, 3, 2, 5]→[5, 3, 3, 5]
Second operation: [5, 3, 3, 5]→[5, 4, 4, 5]
Third operation: [5, 4, 4, 5]→[5, 5, 5, 5]
Therefore, the minimal operations required shall be 3

Enter: arr[] = {1, 2, 3, 5, 3}
Output: 2
Rationalization: First operation: [1, 2, 3, 5, 3] -> [1, 2, 3, 5, 4]
Second operation: [1, 2, 3, 5, 4] -> [1, 2, 3, 5, 5]
Therefore, the minimal operations required shall be 2

Method: To unravel the issue comply with the under concept:

This drawback might be solved utilizing a grasping strategy.  We all know that an array is sorted in non-decreasing order if arr[i] <= arr[i+1] for all i. So we are able to begin iterating from again and if any aspect is discovered to be larger than the minimal of all its proper components, We should set all the correct components to arr[i] with a view to make it improve. The variety of operations taken would be the absolute distinction between the minimal and the arr[i].

Comply with the under steps to implement the concept:

• Begin iterating from the again and discover the index the place arr[i] > minimal on proper.
• Increment depend by absolutely the distinction of minimal and arr[i] as in a single operation aspect can solely be elevated by 1.
• Maintain observe of the minimal in every step.
• If arr[i] is just not larger than the minimal of all its proper, replace minimal to nums[i].
• Return depend.

Under is the implementation for the above strategy:

// C++ code for the above strategy:
#embrace <bits/stdc++.h>
utilizing namespace std;

// Perform for locating out the minimal
// variety of operations.
int minimumOperations(vector<int>& nums, int n)
{

    // Conserving observe of minimal from proper
    int mini = nums[n - 1];

    // Depend the overall variety of operations
    int cnt = 0;
    for (int i = n - 2; i >= 0; i--) {

        // If any aspect is larger than
        // the minimal of its proper,
        // increment depend
        if (nums[i] > mini) {
            cnt += abs(mini - nums[i]);
            mini = nums[i];
        }
        else {

            // Updating minimal
            mini = nums[i];
        }
    }

    // Returning depend
    return cnt;
}

// Driver code
int most important()
{
    vector<int> arr = { 5, 3, 2, 5 };
    int n = arr.measurement();

    // Perform name
    cout << minimumOperations(arr, n);
    return 0;
}

Time Complexity: O(N) 
Auxiliary House: O(1)