Find minimum adjustment cost of an array
Last Updated :
14 Oct, 2023
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 = 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 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[0] to j for the first element of the array, dp[0][j], using the formula dp[0][j] = abs (j – A[0]).
- 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++
#include <bits/stdc++.h>
using namespace std;
#define M 100
int minAdjustmentCost( int A[], int n, int target)
{
int dp[n][M + 1];
for ( int j = 0; j <= M; j++)
dp[0][j] = abs (j - A[0]);
for ( int i = 1; i < n; i++)
{
for ( int j = 0; j <= M; j++)
{
dp[i][j] = INT_MAX;
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));
}
}
int res = INT_MAX;
for ( int j = 0; j <= M; j++)
res = min(res, dp[n - 1][j]);
return res;
}
int main()
{
int arr[] = {55, 77, 52, 61, 39, 6, 25, 60, 49, 47};
int n = sizeof (arr) / sizeof (arr[0]);
int target = 10;
cout << "Minimum adjustment cost is "
<< minAdjustmentCost(arr, n, target) << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG
{
public static int M = 100 ;
static int minAdjustmentCost( int A[], int n, int target)
{
int [][] dp = new int [n][M + 1 ];
for ( int j = 0 ; j <= M; j++)
dp[ 0 ][j] = Math.abs(j - A[ 0 ]);
for ( int i = 1 ; i < n; i++)
{
for ( int j = 0 ; j <= M; j++)
{
dp[i][j] = Integer.MAX_VALUE;
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));
}
}
int res = Integer.MAX_VALUE;
for ( int j = 0 ; j <= M; j++)
res = Math.min(res, dp[n - 1 ][j]);
return res;
}
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
M = 100
def minAdjustmentCost(A, n, target):
dp = [[ 0 for i in range (M + 1 )]
for i in range (n)]
for j in range (M + 1 ):
dp[ 0 ][j] = abs (j - A[ 0 ])
for i in range ( 1 , n):
for j in range (M + 1 ):
dp[i][j] = 100000000
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))
res = 10000000
for j in range (M + 1 ):
res = min (res, dp[n - 1 ][j])
return res
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 = ' ' )
|
C#
using System;
class GFG {
public static int M = 100;
static int minAdjustmentCost( int []A, int n,
int target)
{
int [,] dp = new int [n,M + 1];
for ( int j = 0; j <= M; j++)
dp[0,j] = Math.Abs(j - A[0]);
for ( int i = 1; i < n; i++)
{
for ( int j = 0; j <= M; j++)
{
dp[i,j] = int .MaxValue;
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));
}
}
int res = int .MaxValue;
for ( int j = 0; j <= M; j++)
res = Math.Min(res, dp[n - 1,j]);
return res;
}
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));
}
}
|
Javascript
<script>
let M = 100;
function minAdjustmentCost(A, n, target)
{
let dp = new Array(n);
for (let i = 0; i < n; i++)
{
dp[i] = new Array(n);
for (let j = 0; j <= M; j++)
{
dp[i][j] = 0;
}
}
for (let j = 0; j <= M; j++)
dp[0][j] = Math.abs(j - A[0]);
for (let i = 1; i < n; i++)
{
for (let j = 0; j <= M; j++)
{
dp[i][j] = Number.MAX_VALUE;
let 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));
}
}
let res = Number.MAX_VALUE;
for (let j = 0; j <= M; j++)
res = Math.min(res, dp[n - 1][j]);
return res;
}
let arr = [55, 77, 52, 61, 39, 6, 25, 60, 49, 47];
let n = arr.length;
let target = 10;
document.write( "Minimum adjustment cost is "
+minAdjustmentCost(arr, n, target));
</script>
|
PHP
<?php
$M = 100;
function minAdjustmentCost( $A , $n , $target )
{
global $M ;
$dp = array ( array ());
for ( $j = 0; $j <= $M ; $j ++)
$dp [0][ $j ] = abs ( $j - $A [0]);
for ( $i = 1; $i < $n ; $i ++)
{
for ( $j = 0; $j <= $M ; $j ++)
{
$dp [ $i ][ $j ] = PHP_INT_MAX;
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 ));
}
}
$res = PHP_INT_MAX;
for ( $j = 0; $j <= $M ; $j ++)
$res = min( $res , $dp [ $n - 1][ $j ]);
return $res ;
}
$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 );
?>
|
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 <bits/stdc++.h>
using namespace std;
#define M 100
int minAdjustmentCost( int A[], int n, int target)
{
int dp[M + 1];
for ( int j = 0; j <= M; j++)
dp[j] = abs (j - A[0]);
for ( int i = 1; i < n; i++)
{
int prev_dp[M + 1];
memcpy (prev_dp, dp, sizeof (dp));
for ( int j = 0; j <= M; j++)
{
dp[j] = INT_MAX;
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]);
return res;
}
int main()
{
int arr[] = {55, 77, 52, 61, 39, 6, 25, 60, 49, 47};
int n = sizeof (arr) / sizeof (arr[0]);
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 ;
static int minAdjustmentCost( int [] A, int n, int target) {
int [] dp = new int [M + 1 ];
for ( int j = 0 ; j <= M; j++) {
dp[j] = Math.abs(j - A[ 0 ]);
}
for ( int i = 1 ; i < n; i++) {
int [] prev_dp = Arrays.copyOf(dp, dp.length);
for ( int j = 0 ; j <= M; j++) {
dp[j] = Integer.MAX_VALUE;
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]);
}
return res;
}
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 )
for j in range (M + 1 ):
dp[j] = abs (j - A[ 0 ])
for i in range ( 1 , n):
prev_dp = dp[:]
for j in range (M + 1 ):
dp[j] = float ( 'inf' )
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])
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;
static int MinAdjustmentCost( int [] A, int n, int target)
{
int [] dp = new int [M + 1];
for ( int j = 0; j <= M; j++)
{
dp[j] = Math.Abs(j - A[0]);
}
for ( int i = 1; i < n; i++)
{
int [] prevDp = ( int [])dp.Clone();
for ( int j = 0; j <= M; j++)
{
dp[j] = int .MaxValue;
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]);
}
return res;
}
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 minAdjustmentCost(A, n, target) {
let dp = new Array(M + 1);
for (let j = 0; j <= M; j++)
dp[j] = Math.abs(j - A[0]);
for (let i = 1; i < n; i++)
{
let prev_dp = [...dp];
for (let j = 0; j <= M; j++)
{
dp[j] = Number.MAX_VALUE;
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]);
return res;
}
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));
|
Output
Minimum adjustment cost is 75
Time Complexity: O(n*m2)
Auxiliary Space: O(m)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...