Depend operations to kind the Array by incrementing every component of accelerating subsegment by 1

Given an array arr[] of dimension 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 may select any non-decreasing sub-segment and increment every component 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 might 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 might be 2

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

This drawback might be solved utilizing a grasping method.  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 component is discovered to be higher than the minimal of all its proper parts, We should set all the proper parts to arr[i] with the intention 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 rely by absolutely the distinction of minimal and arr[i] as in a single operation component can solely be elevated by 1.
• Hold observe of the minimal in every step.
• If arr[i] just isn’t higher than the minimal of all its proper, replace minimal to nums[i].
• Return rely.

Under is the implementation for the above method:

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

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

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

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

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

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

    // Returning rely
    return cnt;
}

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

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

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