Minimum increment operations to make the array in increasing order
Given an array of size N and X. Find minimum moves required to make the array in increasing order. In each move one can add X to any element in the array.
Examples:
Input : a = { 1, 3, 3, 2 }, X = 2
Output : 3
Explanation : Modified array is { 1, 3, 5, 6 }
Input : a = { 3, 5, 6 }, X = 5
Output : 0
Observation :
Let’s take two numbers a and b. a >= b and convert this into a < b by adding some number X.
so, a < b + k*X
( a – b ) / x < kso, the minimum possible value of k is ( a – b ) / x + 1.
Approach :
Iterate over the given array and take two numbers when a[i] >= a[i-1] and apply above observation.
Below is the implementation of the above approach:
C++
// CPP program to find minimum moves required // to make the array in increasing order #include <bits/stdc++.h> using namespace std; // function to find minimum moves required // to make the array in increasing order int MinimumMoves(int a[], int n, int x) { // to store answer int ans = 0; // iterate over an array for (int i = 1; i < n; i++) { // non- increasing order if (a[i] <= a[i - 1]) { int p = (a[i - 1] - a[i]) / x + 1; // add moves to answer ans += p; // increase the element a[i] += p * x; } } // return required answer return ans; } // Driver code int main() { int arr[] = { 1, 3, 3, 2 }; int x = 2; int n = sizeof(arr) / sizeof(arr[0]); cout << MinimumMoves(arr, n, x); return 0; } |
chevron_right
filter_none
Java
// Java program to find minimum moves required // to make the array in increasing order import java.util.*; import java.lang.*; import java.io.*; class GFG{ // function to find minimum moves required // to make the array in increasing order static int MinimumMoves(int a[], int n, int x) { // to store answer int ans = 0; // iterate over an array for (int i = 1; i < n; i++) { // non- increasing order if (a[i] <= a[i - 1]) { int p = (a[i - 1] - a[i]) / x + 1; // add moves to answer ans += p; // increase the element a[i] += p * x; } } // return required answer return ans; } // Driver code public static void main(String args[]) { int arr[] = { 1, 3, 3, 2 }; int x = 2; int n = arr.length; System.out.println(MinimumMoves(arr, n, x)); } } |
chevron_right
filter_none
Python 3
# Python3 program to find minimum # moves required to make the array # in increasing order # function to find minimum moves required # to make the array in increasing order def MinimumMoves(a, n, x) : # to store answer ans = 0 # iterate over an array for i in range(1, n) : # non- increasing order if a[i] <= a[i - 1] : p = (a[i - 1] - a[i]) // x + 1 # add moves to answer ans += p # increase the element a[i] += p * x # return required answer return ans # Driver code if __name__ == "__main__" : arr = [1, 3, 3, 2] x = 2 n = len(arr) print(MinimumMoves(arr, n, x)) # This code is contributed by ANKITRAI1 |
chevron_right
filter_none
C#
// C# program to find minimum moves required // to make the array in increasing order using System; class GFG { // function to find minimum moves required // to make the array in increasing order static int MinimumMoves(int[] a, int n, int x) { // to store answer int ans = 0; // iterate over an array for (int i = 1; i < n; i++) { // non- increasing order if (a[i] <= a[i - 1]) { int p = (a[i - 1] - a[i]) / x + 1; // add moves to answer ans += p; // increase the element a[i] += p * x; } } // return required answer return ans; } // Driver code public static void Main() { int[] arr = {1, 3, 3, 2}; int x = 2; int n = arr.Length; Console.Write(MinimumMoves(arr, n, x)); } } // This code is contributed by ChitraNayal |
chevron_right
filter_none
PHP
<?php // PHP program to find minimum // moves required to make the // array in increasing order // function to find minimum // moves required to make the // array in increasing order function MinimumMoves(&$a, $n, $x) { // to store answer $ans = 0; // iterate over an array for ($i = 1; $i < $n; $i++) { // non- increasing order if ($a[$i] <= $a[$i - 1]) { $p = ($a[$i - 1] - $a[$i]) / $x + 1; // add moves to answer $ans += $p; // increase the element $a[$i] += $p * $x; } } // return required answer return $ans; } // Driver code $arr = array(1, 3, 3, 2 ); $x = 2; $n = sizeof($arr); echo ((int)MinimumMoves($arr, $n, $x)); // This code is contributed // by Shivi_Aggarwal ?> |
chevron_right
filter_none
Output:
3
Recommended Posts:
- Minimum Increment operations to make Array unique
- Minimum number of increment-other operations to make all array elements equal.
- Minimum increment or decrement operations required to make the array sorted
- Minimum increment by k operations to make all elements equal
- Minimum range increment operations to Sort an array
- Arrange the array such that upon performing given operations an increasing order is obtained
- Minimum number of increment/decrement operations such that array contains all elements from 1 to N
- Minimum Increment / decrement to make array elements equal
- Minimum value of X to make all array elements equal by either decreasing or increasing by X
- Minimum operations to make XOR of array zero
- Minimum operations to make GCD of array a multiple of k
- Minimum gcd operations to make all array elements one
- Minimum operations to make counts of remainders same in an array
- Minimum no. of operations required to make all Array Elements Zero
- Minimum delete operations to make all elements of array same
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
- Kth most frequent Character in a given String
- Number of ways to obtain each numbers in range [1, b+c] by adding any two numbers in range [a, b] and [b, c]
- Queries for elements having values within the range A to B in the given index range using Segment Tree
- Count of triplets of numbers 1 to N such that middle element is always largest
- Count of subarrays of size K which is a permutation of numbers from 1 to K