Check whether an array can be made strictly increasing by incrementing and decrementing adjacent pairs - GeeksforGeeks

16 Dec, 2021
Given an array arr[] of size N consisting of non-negative integers. In one move ith index element of the array is decreased by 1 and (i+1)th index is increased by 1. The task is to check if there is any possibility to make the given array strictly increasing (containing non-negative integers only) by making any number of moves.
Examples: 
Input: arr[3] = [1, 2, 3]Output: YesExplanation: The array is already sorted in strictly increasing order.
Input: arr[2] = [2, 0]Output: YesExplanation: Consider i = 0 for the 1st move arr[0] = 2-1 = 1, arr[1] = 0 + 1 = 1. Now the array becomes, [1, 1].In 2nd move consider i = 0. So now arr[0] = 1 – 1 = 0, arr[1] = 1 + 1 = 2. The final array becomes, arr[2] = [0, 2] which is strictly increasing.
Input: arr[3] = [0, 1, 0]Output: NoExplanation: This array cannot be made strictly increasing containing only non negative integers by performing any number of moves.
Approach: The problem can be solved using the following mathematical observation. 
Since all the array elements are non-negative, so minimum strictly increasing order of an array of size N can be: 0, 1, 2, 3 . . . (N-1).
So the minimum sum(min_sum) of first i elements (till (i-t)th index) of any such array is min_sum = (i*(i-1))/2.
Therefore, the sum of first i elements of given array(cur_sum) must satisfy the condition cur_sum ≥ min_sum .
If the condition is not satisfied, then it is not possible to make the given array strictly increasing. Consider the following example
Illustration 1:
arr[]           = 4 5  1   2   3min_sum   = 0 1  3   6  10sum(arr)   = 4 9 10 12 15
As this array satisfies the condition for every i, it is possible to convert this array to strictly increasing array
Illustration 2:
arr[]           = 2 3 1 0 2min_sum   = 0 1 3 6 10sum(arr)   = 2 5 6 6 8
Here at index 4 the sum of array does not satisfy the condition of having minimum sum 10. So it is not possible to change the array into a strictly increasing one.
Follow the steps mentioned below to implement the concept:
Traverse from index = 0 to index = N – 1, and for each i check if sum till that is greater than or equal to (i*(i+1))/2.
If the condition is satisfied then the array can be made strictly increasing. Otherwise, it cannot be made strictly increasing.
Follow the below implementation for the above approach:
C++
Java
Python3
C#
Javascript
// C++ code to check if the given array// can be made strictly increasing#include <bits/stdc++.h>using namespace std; // Function to check if// the array can be made strictly increasingvoid CheckStrictlyIncreasing(int arr[],                             int N){    // variable to store sum till current    // index element    int cur_sum = 0;    bool possible = true;    for (int index = 0;         index < N; index++) {        cur_sum += arr[index];         // Sum of 0, 1, ...(i)th element        int req_sum = (index * (index + 1)) / 2;         // Check if valid or not        if (req_sum > cur_sum) {            possible = false;            break;        }    }     // If can be made strictly increasing    if (possible)        cout << "Yes";    else        cout << "No";} // Driver codeint main(){    int arr[3] = { 1, 2, 3 };    int N = 3;     CheckStrictlyIncreasing(arr, N);    return 0;}
// Java code to check if the given array// can be made strictly increasingimport java.util.*; class GFG{ // Function to check if// the array can be made strictly increasingstatic void CheckStrictlyIncreasing(int arr[],                             int N){    // variable to store sum till current    // index element    int cur_sum = 0;    boolean possible = true;    for (int index = 0;         index < N; index++) {        cur_sum += arr[index];         // Sum of 0, 1, ...(i)th element        int req_sum = (index * (index + 1)) / 2;         // Check if valid or not        if (req_sum > cur_sum) {            possible = false;            break;        }    }     // If can be made strictly increasing    if (possible)        System.out.print("Yes");    else        System.out.print("No");} // Driver codepublic static void main(String[] args){    int arr[] = { 1, 2, 3 };    int N = 3;     CheckStrictlyIncreasing(arr, N);}} // This code is contributed by shikhasingrajput
# Python 3 code to check if the given array# can be made strictly increasing # Function to check if# the array can be made strictly increasingdef CheckStrictlyIncreasing(arr,                            N):     # variable to store sum till current    # index element    cur_sum = 0    possible = True    for index in range(N):        cur_sum += arr[index]         # Sum of 0, 1, ...(i)th element        req_sum = (index * (index + 1)) // 2         # Check if valid or not        if (req_sum > cur_sum):            possible = False            break     # If can be made strictly increasing    if (possible):        print("Yes")     else:        print("No") # Driver codeif __name__ == "__main__":     arr = [1, 2, 3]    N = 3     CheckStrictlyIncreasing(arr, N)     # This code is contributed by ukasp.
// C# code to check if the given array// can be made strictly increasingusing System; class GFG{ // Function to check if the array can// be made strictly increasingstatic void CheckStrictlyIncreasing(int []arr,                                    int N){         // Variable to store sum till current    // index element    int cur_sum = 0;    bool possible = true;    for(int index = 0;            index < N; index++)    {        cur_sum += arr[index];         // Sum of 0, 1, ...(i)th element        int req_sum = (index * (index + 1)) / 2;         // Check if valid or not        if (req_sum > cur_sum)        {            possible = false;            break;        }    }     // If can be made strictly increasing    if (possible)        Console.Write("Yes");    else        Console.Write("No");} // Driver codepublic static void Main(String[] args){    int []arr = { 1, 2, 3 };    int N = 3;     CheckStrictlyIncreasing(arr, N);}} // This code is contributed by shikhasingrajput
<script>       // JavaScript code for the above approach        // Function to check if       // the array can be made strictly increasing       function CheckStrictlyIncreasing(arr, N)       {                       // variable to store sum till current           // index element           let cur_sum = 0;           let possible = true;           for (let index = 0;               index < N; index++) {               cur_sum += arr[index];                // Sum of 0, 1, ...(i)th element               let req_sum = (index * (index + 1)) / 2;                // Check if valid or not               if (req_sum > cur_sum) {                   possible = false;                   break;               }           }            // If can be made strictly increasing           if (possible)               document.write("Yes");           else               document.write("No");       }        // Driver code       let arr = [1, 2, 3];       let N = 3;        CheckStrictlyIncreasing(arr, N);  // This code is contributed by Potta Lokesh   </script>
Yes
Time Complexity: O(N)Space Complexity: O(1)
lokeshpotta20
shikhasingrajput
ukasp
sagartomar9927
Sequence and Series
Arrays
Mathematical
Pattern Searching
Arrays
Mathematical
Pattern Searching
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Next Greater Element
Window Sliding Technique
Count pairs with given sum
Program to find sum of elements in a given array
Reversal algorithm for array rotation
Program for Fibonacci numbers
Write a program to print all permutations of a given string
C++ Data Types
Set in C++ Standard Template Library (STL)
Coin Change | DP-7