# Find minimum adjustment cost of an array

Given an array of positive integers, replace each element in the array such that the difference between adjacent elements in the array is less than or equal to a given target. We need to minimize the adjustment cost, that is the sum of differences between new and old values. We basically need to minimize ?|A[i] – Anew[i]| where 0 ? i ? n-1, n is size of A[] and Anew[] is the array with adjacent difference less than or equal to the target. Assume all elements of the array is less than constant M = 100.

Examples:

`Input: arr = [1, 3, 0, 3], target = 1Output: Minimum adjustment cost is 3Explanation: One of the possible solutions is [2, 3, 2, 3]Input: arr = [2, 3, 2, 3], target = 1Output: Minimum adjustment cost is 0Explanation:  All adjacent elements in the input array are already less than equal to given targetInput: arr = [55, 77, 52, 61, 39, 6,              25, 60, 49, 47], target = 10Output: Minimum adjustment cost is 75Explanation: One of the possible solutions is [55, 62, 52, 49, 39, 29, 30, 40, 49, 47]`

In order to minimize the adjustment cost ?|A[i] – Anew[i]| for all index i in the array, |A[i] – Anew[i]| should be as close to zero as possible. Also, |A[i] – Anew[i+1] ]| ? Target.
This problem can be solved by dynamic programming.

Let dp[i][j] defines minimal adjustment cost on changing A[i] to j, then the DP relation is defined by –

`dp[i][j] = min{dp[i - 1][k]} + |j - A[i]|           for all k's such that |k - j| ? target`

Here, 0 ? i ? n and 0 ? j ? M where n is the number of elements in the array and M = 100. We have to consider all k such that max(j – target, 0) ? k ? min(M, j + target)
Finally, the minimum adjustment cost of the array will be min{dp[n – 1][j]} for all 0 ? j ? M.

Algorithm:

• Create a 2D array with the initializations dp[n][M+1] to record the least adjustment cost of changing A[i] to j, where n is the array’s length and M is its maximum value.
• Calculate the smallest adjustment cost of changing A to j for the first element of the array, dp[j], using the formula dp[j] = abs (j – A).
• Replace A[i] with j in the remaining array elements, dp[i][j], and use the formula dp[i][j] = min(dp[i-1][k] + abs(A[i] – j)), where k takes all feasible values between max(j-target,0) and min(M,j+target), to get the minimal adjustment cost.
• As the minimum adjustment cost, give the lowest number from the last row of the dp table.

Below is the implementation of the above idea:

## C++

 `// C++ program to find minimum adjustment cost of an array` `#include ` `using` `namespace` `std;`   `#define M 100`   `// Function to find minimum adjustment cost of an array` `int` `minAdjustmentCost(``int` `A[], ``int` `n, ``int` `target)` `{` `    ``// dp[i][j] stores minimal adjustment cost on changing` `    ``// A[i] to j` `    ``int` `dp[n][M + 1];`   `    ``// handle first element of array separately` `    ``for` `(``int` `j = 0; j <= M; j++)` `        ``dp[j] = ``abs``(j - A);`   `    ``// do for rest elements of the array` `    ``for` `(``int` `i = 1; i < n; i++)` `    ``{` `        ``// replace A[i] to j and calculate minimal adjustment` `        ``// cost dp[i][j]` `        ``for` `(``int` `j = 0; j <= M; j++)` `        ``{` `          ``// initialize minimal adjustment cost to INT_MAX` `          ``dp[i][j] = INT_MAX;`   `          ``// consider all k such that k >= max(j - target, 0) and` `          ``// k <= min(M, j + target) and take minimum` `          ``for` `(``int` `k = max(j-target,0); k <= min(M,j+target); k++)` `             ``dp[i][j] = min(dp[i][j], dp[i - 1][k] + ``abs``(A[i] - j));` `        ``}` `    ``}    `   `    ``// return minimum value from last row of dp table` `    ``int` `res = INT_MAX; ` `    ``for` `(``int` `j = 0; j <= M; j++)` `        ``res = min(res, dp[n - 1][j]);`   `    ``return` `res;` `}`   `// Driver Program to test above functions` `int` `main()` `{` `    ``int` `arr[] = {55, 77, 52, 61, 39, 6, 25, 60, 49, 47};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `target = 10;`   `    ``cout << ``"Minimum adjustment cost is "` `         ``<< minAdjustmentCost(arr, n, target) << endl;`   `    ``return` `0;` `}`

## Java

 `// Java program to find minimum adjustment cost of an array` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG ` `{` `    ``public` `static` `int` `M = ``100``;` `    `  `    ``// Function to find minimum adjustment cost of an array` `    ``static` `int` `minAdjustmentCost(``int` `A[], ``int` `n, ``int` `target)` `    ``{` `        ``// dp[i][j] stores minimal adjustment cost on changing` `        ``// A[i] to j` `        ``int``[][] dp = ``new` `int``[n][M + ``1``];` ` `  `        ``// handle first element of array separately` `        ``for` `(``int` `j = ``0``; j <= M; j++)` `            ``dp[``0``][j] = Math.abs(j - A[``0``]);` ` `  `        ``// do for rest elements of the array` `        ``for` `(``int` `i = ``1``; i < n; i++)` `        ``{` `            ``// replace A[i] to j and calculate minimal adjustment` `            ``// cost dp[i][j]` `            ``for` `(``int` `j = ``0``; j <= M; j++)` `            ``{` `                ``// initialize minimal adjustment cost to INT_MAX` `                ``dp[i][j] = Integer.MAX_VALUE;` ` `  `                ``// consider all k such that k >= max(j - target, 0) and` `                ``// k <= min(M, j + target) and take minimum` `                ``int` `k = Math.max(j-target,``0``);` `                ``for` `( ; k <= Math.min(M,j+target); k++)` `                    ``dp[i][j] = Math.min(dp[i][j], dp[i - ``1``][k] +  ` `                                                ``Math.abs(A[i] - j));` `            ``}` `        ``}    ` ` `  `        ``// return minimum value from last row of dp table` `        ``int` `res = Integer.MAX_VALUE; ` `        ``for` `(``int` `j = ``0``; j <= M; j++)` `            ``res = Math.min(res, dp[n - ``1``][j]);` ` `  `        ``return` `res;` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``int` `arr[] = {``55``, ``77``, ``52``, ``61``, ``39``, ``6``, ``25``, ``60``, ``49``, ``47``};` `        ``int` `n = arr.length;` `        ``int` `target = ``10``;` ` `  `        ``System.out.println(``"Minimum adjustment cost is "` `                    ``+minAdjustmentCost(arr, n, target));` `    ``}` `}`   `// This code is contributed by Pramod Kumar`

## Python3

 `# Python3 program to find minimum` `# adjustment cost of an array ` `M ``=` `100`   `# Function to find minimum` `# adjustment cost of an array` `def` `minAdjustmentCost(A, n, target):` `    `  `    ``# dp[i][j] stores minimal adjustment ` `    ``# cost on changing A[i] to j ` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(M ``+` `1``)] ` `             ``for` `i ``in` `range``(n)]` `             `  `    ``# handle first element` `    ``# of array separately` `    ``for` `j ``in` `range``(M ``+` `1``):` `        ``dp[``0``][j] ``=` `abs``(j ``-` `A[``0``])`   `    ``# do for rest elements ` `    ``# of the array ` `    ``for` `i ``in` `range``(``1``, n):` `        `  `        ``# replace A[i] to j and ` `        ``# calculate minimal adjustment` `        ``# cost dp[i][j] ` `        ``for` `j ``in` `range``(M ``+` `1``):` `            `  `            ``# initialize minimal adjustment` `            ``# cost to INT_MAX` `            ``dp[i][j] ``=` `100000000` `            `  `            ``# consider all k such that` `            ``# k >= max(j - target, 0) and` `            ``# k <= min(M, j + target) and ` `            ``# take minimum` `            ``for` `k ``in` `range``(``max``(j ``-` `target, ``0``), ` `                           ``min``(M, j ``+` `target) ``+` `1``):` `                ``dp[i][j] ``=` `min``(dp[i][j], dp[i ``-` `1``][k] ``+` `                                        ``abs``(A[i] ``-` `j))` `                                        `  `    ``# return minimum value from ` `    ``# last row of dp table` `    ``res ``=` `10000000` `    ``for` `j ``in` `range``(M ``+` `1``):` `        ``res ``=` `min``(res, dp[n ``-` `1``][j])` `    ``return` `res`   `# Driver Code ` `arr``=` `[``55``, ``77``, ``52``, ``61``, ``39``, ` `       ``6``, ``25``, ``60``, ``49``, ``47``]` `n ``=` `len``(arr)` `target ``=` `10` `print``(``"Minimum adjustment cost is"``, ` `       ``minAdjustmentCost(arr, n, target), ` `                              ``sep ``=` `' '``)`   `# This code is contributed ` `# by sahilshelangia`

## C#

 `// C# program to find minimum adjustment` `// cost of an array` `using` `System;`   `class` `GFG {` `    `  `    ``public` `static` `int` `M = 100;` `    `  `    ``// Function to find minimum adjustment` `    ``// cost of an array` `    ``static` `int` `minAdjustmentCost(``int` `[]A, ``int` `n,` `                                     ``int` `target)` `    ``{` `        `  `        ``// dp[i][j] stores minimal adjustment` `        ``// cost on changing A[i] to j` `        ``int``[,] dp = ``new` `int``[n,M + 1];`   `        ``// handle first element of array` `        ``// separately` `        ``for` `(``int` `j = 0; j <= M; j++)` `            ``dp[0,j] = Math.Abs(j - A);`   `        ``// do for rest elements of the array` `        ``for` `(``int` `i = 1; i < n; i++)` `        ``{` `            ``// replace A[i] to j and calculate` `            ``// minimal adjustment cost dp[i][j]` `            ``for` `(``int` `j = 0; j <= M; j++)` `            ``{` `                ``// initialize minimal adjustment` `                ``// cost to INT_MAX` `                ``dp[i,j] = ``int``.MaxValue;`   `                ``// consider all k such that ` `                ``// k >= max(j - target, 0) and` `                ``// k <= min(M, j + target) and` `                ``// take minimum` `                ``int` `k = Math.Max(j - target, 0);` `                `  `                ``for` `( ; k <= Math.Min(M, j +` `                                   ``target); k++)` `                    ``dp[i,j] = Math.Min(dp[i,j],` `                                   ``dp[i - 1,k]` `                         ``+ Math.Abs(A[i] - j));` `            ``}` `        ``} `   `        ``// return minimum value from last` `        ``// row of dp table` `        ``int` `res = ``int``.MaxValue; ` `        ``for` `(``int` `j = 0; j <= M; j++)` `            ``res = Math.Min(res, dp[n - 1,j]);`   `        ``return` `res;` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `Main () ` `    ``{` `        ``int` `[]arr = {55, 77, 52, 61, 39,` `                        ``6, 25, 60, 49, 47};` `        ``int` `n = arr.Length;` `        ``int` `target = 10;`   `        ``Console.WriteLine(``"Minimum adjustment"` `                                 ``+ ``" cost is "` `         ``+ minAdjustmentCost(arr, n, target));` `    ``}` `}`   `// This code is contributed by Sam007.`

## Javascript

 ``

## PHP

 `= max(j - target, 0) and` `            ``// k <= min(M, j + target) and` `            ``// take minimum` `            ``for``(``\$k` `= max(``\$j` `- ``\$target``, 0);` `                ``\$k` `<= min(``\$M``, ``\$j` `+ ``\$target``);` `                                       ``\$k``++)` `                ``\$dp``[``\$i``][``\$j``] = min(``\$dp``[``\$i``][``\$j``], ` `                              ``\$dp``[``\$i` `- 1][``\$k``] + ` `                              ``abs``(``\$A``[``\$i``] - ``\$j``));` `        ``}` `    ``} `   `    ``// return minimum value ` `    ``// from last row of dp table` `    ``\$res` `= PHP_INT_MAX; ` `    ``for``(``\$j` `= 0; ``\$j` `<= ``\$M``; ``\$j``++)` `        ``\$res` `= min(``\$res``, ``\$dp``[``\$n` `- 1][``\$j``]);`   `    ``return` `\$res``;` `}`   `    ``// Driver Code` `    ``\$arr` `= ``array``(55, 77, 52, 61, 39, ` `                 ``6, 25, 60, 49, 47);` `    ``\$n` `= ``count``(``\$arr``);` `    ``\$target` `= 10;`   `    ``echo` `"Minimum adjustment cost is "` `        ``, minAdjustmentCost(``\$arr``, ``\$n``, ``\$target``);`   `// This code is contributed by anuj_67.` `?>`

Output

```Minimum adjustment cost is 75

```

Time Complexity: O(n*m2)
Auxiliary Space: O(n *m)

Efficient approach : Space optimization

In previous approach the current value dp[i][j] is only depend upon the current and previous row values of DP. So to optimize the space complexity we use a single 1D array to store the computations.

Implementation steps:

• Create a 1D vector dp of size m+1.
• Set a base case by initializing the values of DP.
• Now iterate over subproblems by the help of nested loop and get the current value from previous computations.
• Now Create a temporary 1d vector prev_dp used to store the current values from previous computations.
• After every iteration assign the value of prev_dp to dp for further iteration.
• Initialize a variable res to store the final answer and update it by iterating through the Dp.
• At last return and print the final answer stored in res.

Implementation:

## C++

 `#include ` `using` `namespace` `std;`   `#define M 100`   `// Function to find minimum adjustment cost of an array` `int` `minAdjustmentCost(``int` `A[], ``int` `n, ``int` `target)` `{` `    ``int` `dp[M + 1]; ``// Array to store the minimum adjustment costs for each value`   `    ``for` `(``int` `j = 0; j <= M; j++)` `        ``dp[j] = ``abs``(j - A); ``// Initialize the first row with the absolute differences`   `    ``for` `(``int` `i = 1; i < n; i++) ``// Iterate over the array elements` `    ``{` `        ``int` `prev_dp[M + 1];` `        ``memcpy``(prev_dp, dp, ``sizeof``(dp)); ``// Store the previous row's minimum costs`   `        ``for` `(``int` `j = 0; j <= M; j++) ``// Iterate over the possible values` `        ``{` `            ``dp[j] = INT_MAX; ``// Initialize the current value with maximum cost`   `            ``// Find the minimum cost by considering the range of previous values` `            ``for` `(``int` `k = max(j - target, 0); k <= min(M, j + target); k++)` `                ``dp[j] = min(dp[j], prev_dp[k] + ``abs``(A[i] - j));` `        ``}` `    ``}`   `    ``int` `res = INT_MAX;` `    ``for` `(``int` `j = 0; j <= M; j++)` `        ``res = min(res, dp[j]); ``// Find the minimum cost in the last row`   `    ``return` `res; ``// Return the minimum adjustment cost` `}`   `int` `main()` `{` `    ``int` `arr[] = {55, 77, 52, 61, 39, 6, 25, 60, 49, 47};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `target = 10;`   `    ``cout << ``"Minimum adjustment cost is "` `         ``<< minAdjustmentCost(arr, n, target) << endl;`   `    ``return` `0;` `}`

## Java

 `import` `java.util.Arrays;`   `public` `class` `MinimumAdjustmentCost {` `    ``static` `final` `int` `M = ``100``;`   `    ``// Function to find the minimum adjustment cost of an array` `    ``static` `int` `minAdjustmentCost(``int``[] A, ``int` `n, ``int` `target) {` `        ``int``[] dp = ``new` `int``[M + ``1``];`   `        ``// Initialize the first row with absolute differences` `        ``for` `(``int` `j = ``0``; j <= M; j++) {` `            ``dp[j] = Math.abs(j - A[``0``]);` `        ``}`   `        ``// Iterate over the array elements` `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``int``[] prev_dp = Arrays.copyOf(dp, dp.length); ``// Store the previous row's minimum costs`   `            ``// Iterate over the possible values` `            ``for` `(``int` `j = ``0``; j <= M; j++) {` `                ``dp[j] = Integer.MAX_VALUE; ``// Initialize the current value with maximum cost`   `                ``// Find the minimum cost by considering the range of previous values` `                ``for` `(``int` `k = Math.max(j - target, ``0``); k <= Math.min(M, j + target); k++) {` `                    ``dp[j] = Math.min(dp[j], prev_dp[k] + Math.abs(A[i] - j));` `                ``}` `            ``}` `        ``}`   `        ``int` `res = Integer.MAX_VALUE;` `        ``for` `(``int` `j = ``0``; j <= M; j++) {` `            ``res = Math.min(res, dp[j]); ``// Find the minimum cost in the last row` `        ``}`   `        ``return` `res; ``// Return the minimum adjustment cost` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = { ``55``, ``77``, ``52``, ``61``, ``39``, ``6``, ``25``, ``60``, ``49``, ``47` `};` `        ``int` `n = arr.length;` `        ``int` `target = ``10``;`   `        ``System.out.println(``"Minimum adjustment cost is "` `+ minAdjustmentCost(arr, n, target));` `    ``}` `}`

## Python3

 `def` `min_adjustment_cost(A, n, target):` `    ``M ``=` `100` `    ``dp ``=` `[``0``] ``*` `(M ``+` `1``)`   `    ``# Initialize the first row of dp with absolute differences` `    ``for` `j ``in` `range``(M ``+` `1``):` `        ``dp[j] ``=` `abs``(j ``-` `A[``0``])`   `    ``# Iterate over the array elements` `    ``for` `i ``in` `range``(``1``, n):` `        ``prev_dp ``=` `dp[:]  ``# Store the previous row's minimum costs` `        ``for` `j ``in` `range``(M ``+` `1``):` `            ``dp[j] ``=` `float``(``'inf'``)  ``# Initialize the current value with maximum cost`   `            ``# Find the minimum cost by considering the range of previous values` `            ``for` `k ``in` `range``(``max``(j ``-` `target, ``0``), ``min``(M, j ``+` `target) ``+` `1``):` `                ``dp[j] ``=` `min``(dp[j], prev_dp[k] ``+` `abs``(A[i] ``-` `j))`   `    ``res ``=` `float``(``'inf'``)` `    ``for` `j ``in` `range``(M ``+` `1``):` `        ``res ``=` `min``(res, dp[j])  ``# Find the minimum cost in the last row`   `    ``return` `res`   `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``55``, ``77``, ``52``, ``61``, ``39``, ``6``, ``25``, ``60``, ``49``, ``47``]` `    ``n ``=` `len``(arr)` `    ``target ``=` `10`   `    ``print``(``"Minimum adjustment cost is"``, min_adjustment_cost(arr, n, target))`

## C#

 `using` `System;`   `class` `Program` `{` `    ``const` `int` `M = 100;`   `    ``// Function to find minimum adjustment cost of an array` `    ``static` `int` `MinAdjustmentCost(``int``[] A, ``int` `n, ``int` `target)` `    ``{` `        ``int``[] dp = ``new` `int``[M + 1]; ``// Array to store the minimum adjustment costs for each value`   `        ``for` `(``int` `j = 0; j <= M; j++)` `        ``{` `            ``dp[j] = Math.Abs(j - A); ``// Initialize the first row with the absolute differences` `        ``}`   `        ``for` `(``int` `i = 1; i < n; i++) ``// Iterate over the array elements` `        ``{` `            ``int``[] prevDp = (``int``[])dp.Clone(); ``// Store the previous row's minimum costs`   `            ``for` `(``int` `j = 0; j <= M; j++) ``// Iterate over the possible values` `            ``{` `                ``dp[j] = ``int``.MaxValue; ``// Initialize the current value with maximum cost`   `                ``// Find the minimum cost by considering the range of previous values` `                ``for` `(``int` `k = Math.Max(j - target, 0); k <= Math.Min(M, j + target); k++)` `                ``{` `                    ``dp[j] = Math.Min(dp[j], prevDp[k] + Math.Abs(A[i] - j));` `                ``}` `            ``}` `        ``}`   `        ``int` `res = ``int``.MaxValue;` `        ``for` `(``int` `j = 0; j <= M; j++)` `        ``{` `            ``res = Math.Min(res, dp[j]); ``// Find the minimum cost in the last row` `        ``}`   `        ``return` `res; ``// Return the minimum adjustment cost` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int``[] arr = { 55, 77, 52, 61, 39, 6, 25, 60, 49, 47 };` `        ``int` `n = arr.Length;` `        ``int` `target = 10;`   `        ``Console.WriteLine(``"Minimum adjustment cost is "` `+ MinAdjustmentCost(arr, n, target));` `    ``}` `}`

## Javascript

 `const M = 100;`   `// Function to find minimum adjustment cost of an array` `function` `minAdjustmentCost(A, n, target) {` `    ``let dp = ``new` `Array(M + 1); ``// Array to store the minimum adjustment costs for each value`   `    ``for` `(let j = 0; j <= M; j++)` `        ``dp[j] = Math.abs(j - A); ``// Initialize the first row with the absolute differences`   `    ``for` `(let i = 1; i < n; i++) ``// Iterate over the array elements` `    ``{` `        ``let prev_dp = [...dp]; ``// Store the previous row's minimum costs`   `        ``for` `(let j = 0; j <= M; j++) ``// Iterate over the possible values` `        ``{` `            ``dp[j] = Number.MAX_VALUE; ``// Initialize the current value with maximum cost`   `            ``// Find the minimum cost by considering the range of previous values` `            ``for` `(let k = Math.max(j - target, 0); k <= Math.min(M, j + target); k++)` `                ``dp[j] = Math.min(dp[j], prev_dp[k] + Math.abs(A[i] - j));` `        ``}` `    ``}`   `    ``let res = Number.MAX_VALUE;` `    ``for` `(let j = 0; j <= M; j++)` `        ``res = Math.min(res, dp[j]); ``// Find the minimum cost in the last row`   `    ``return` `res; ``// Return the minimum adjustment cost` `}`   `let arr = [55, 77, 52, 61, 39, 6, 25, 60, 49, 47];` `let n = arr.length;` `let target = 10;`   `console.log(``"Minimum adjustment cost is "` `+ minAdjustmentCost(arr, n, target));` `// This code is contributed by Kanchan Agarwal`

Output

`Minimum adjustment cost is 75`

Time Complexity: O(n*m2)
Auxiliary Space: O(m)

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next