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++ program to find minimum adjustment cost of an array #include <bits/stdc++.h> 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[0][j] = 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] = 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[0]);
int target = 10;
cout << "Minimum adjustment cost is "
<< minAdjustmentCost(arr, n, target) << endl;
return 0;
} |
// 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 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# 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[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] = 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. |
<script> // Javascript program to find minimum adjustment cost of an array
let M = 100;
// Function to find minimum adjustment cost of an array
function minAdjustmentCost(A, n, target)
{
// dp[i][j] stores minimal adjustment cost on changing
// A[i] to j
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;
}
}
// handle first element of array separately
for (let j = 0; j <= M; j++)
dp[0][j] = Math.abs(j - A[0]);
// do for rest elements of the array
for (let i = 1; i < n; i++)
{
// replace A[i] to j and calculate minimal adjustment
// cost dp[i][j]
for (let j = 0; j <= M; j++)
{
// initialize minimal adjustment cost to INT_MAX
dp[i][j] = Number.MAX_VALUE;
// consider all k such that k >= max(j - target, 0) and
// k <= min(M, j + target) and take minimum
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));
}
}
// return minimum value from last row of dp table
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));
// This code is contributed by decode2207.
</script> |
<?php // PHP program to find minimum // adjustment cost of an array $M = 100;
// Function to find minimum // adjustment cost of an array function minAdjustmentCost( $A , $n , $target )
{ // dp[i][j] stores minimal
// adjustment cost on changing
// A[i] to j
global $M ;
$dp = array ( array ());
// handle first element
// of array separately
for ( $j = 0; $j <= $M ; $j ++)
$dp [0][ $j ] = abs ( $j - $A [0]);
// do for rest
// elements of the array
for ( $i = 1; $i < $n ; $i ++)
{
// replace A[i] to j and
// calculate minimal adjustment
// cost dp[i][j]
for ( $j = 0; $j <= $M ; $j ++)
{
// initialize minimal adjustment
// cost to INT_MAX
$dp [ $i ][ $j ] = PHP_INT_MAX;
// consider all k such that
// k >= 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. ?> |
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:
#include <bits/stdc++.h> 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[0]); // 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[0]);
int target = 10;
cout << "Minimum adjustment cost is "
<< minAdjustmentCost(arr, n, target) << endl;
return 0;
} |
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));
}
} |
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))
|
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[0]); // 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));
}
} |
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[0]); // 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)