# Find minimum adjustment cost of an array

• Difficulty Level : Hard
• Last Updated : 17 May, 2021

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 that or equal to target.
Assume all elements of the array is less than constant M = 100.
Examples:

```Input: arr = [1, 3, 0, 3], target = 1
Output: Minimum adjustment cost is 3
Explanation: One of the possible solutions
is [2, 3, 2, 3]

Input: arr = [2, 3, 2, 3], target = 1
Output: Minimum adjustment cost is 0
Explanation:  All adjacent elements in the input
array are already less than equal to given target

Input: arr = [55, 77, 52, 61, 39, 6,
25, 60, 49, 47], target = 10
Output: Minimum adjustment cost is 75
Explanation: 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 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.
Below is the implementation of 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.`

## 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.` `?>`

## Javascript

 ``

Output:

`Minimum adjustment cost is 75`