# Minimize the cost to make all the adjacent elements distinct in an Array

• Difficulty Level : Hard
• Last Updated : 20 Aug, 2021

Given two integer arrays arr[] and cost[] of size N, the task is to make all adjacent elements distinct at minimum cost. cost[i] denotes the cost to increment ith element by 1.
Examples:

Input: arr[] = {2, 2, 3}, cost[] = {4, 1, 5}
Output:
Explanation:
The second element has minimum increment cost. Hence, increase the cost of the second element twice.
Therefore the resultant array: {2, 4, 3}
Input: arr[] = {1, 2, 3}, cost[] = {7, 8, 3}
Output:

Approach:

• We can observe that there an element might need to be increased maximum twice.
• This problem can be solved using Dynamic Programming.
• Create a DP-table dp[][], where rows represent the elements, and columns represent the increment.
• dp[i][j] is the minimum cost required to make ith element distinct from its adjacent elements using j increments.
• The value of dp[i][j] can be calculated as:

dp[i][j] = j * cost[i] + (minimum from previous element if both elements are different)

Below is the implementation of the above approach

## C++

 `// C++ program to find the``// minimum cost required to make``// all adjacent elements distinct` `#include ``using` `namespace` `std;` `// Function that prints minimum cost required``void` `minimumCost(``int` `arr[], ``int` `cost[], ``int` `N)``{` `    ``// Dp-table``    ``vector > dp(N, vector<``int``>(3));` `    ``// Base case``    ``// Not increasing the first element``    ``dp = 0;` `    ``// Increasing the first element by 1``    ``dp = cost;` `    ``// Increasing the first element by 2``    ``dp = cost * 2;` `    ``for` `(``int` `i = 1; i < N; i++) {``        ``for` `(``int` `j = 0; j < 3; j++) {` `            ``int` `minimum = 1e6;` `            ``// Condition if current element``            ``// is not equal to previous``            ``// non-increased element``            ``if` `(j + arr[i] != arr[i - 1])``                ``minimum``                    ``= min(minimum,``                          ``dp[i - 1]);` `            ``// Condition if current element``            ``// is not equal to previous element``            ``// after being increased by 1``            ``if` `(j + arr[i] != arr[i - 1] + 1)``                ``minimum``                    ``= min(minimum,``                          ``dp[i - 1]);` `            ``// Condition if current element``            ``// is not equal to previous element``            ``// after being increased by 2``            ``if` `(j + arr[i] != arr[i - 1] + 2)``                ``minimum``                    ``= min(minimum,``                          ``dp[i - 1]);` `            ``// Take the minimum from all cases``            ``dp[i][j] = j * cost[i] + minimum;``        ``}``    ``}` `    ``int` `ans = 1e6;` `    ``// Finding the minimum cost``    ``for` `(``int` `i = 0; i < 3; i++)``        ``ans = min(ans, dp[N - 1][i]);` `    ``// Printing the minimum cost``    ``// required to make all adjacent``    ``// elements distinct``    ``cout << ans << ``"\n"``;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 1, 2, 2, 3, 4 };``    ``int` `cost[] = { 3, 2, 5, 4, 2, 1 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``minimumCost(arr, cost, N);` `    ``return` `0;``}`

## Java

 `// Java program to find the minimum``// cost required to make all``// adjacent elements distinct``import` `java.util.*;` `class` `GFG{` `// Function that prints minimum cost required``static` `void` `minimumCost(``int` `arr[], ``int` `cost[],``                        ``int` `N)``{` `    ``// Dp-table``    ``int` `[][]dp = ``new` `int``[N][``3``];` `    ``// Base case``    ``// Not increasing the first element``    ``dp[``0``][``0``] = ``0``;` `    ``// Increasing the first element by 1``    ``dp[``0``][``1``] = cost[``0``];` `    ``// Increasing the first element by 2``    ``dp[``0``][``2``] = cost[``0``] * ``2``;` `    ``for``(``int` `i = ``1``; i < N; i++)``    ``{``       ``for``(``int` `j = ``0``; j < ``3``; j++)``       ``{``          ``int` `minimum = (``int``) 1e6;``          ` `          ``// Condition if current element``          ``// is not equal to previous``          ``// non-increased element``          ``if` `(j + arr[i] != arr[i - ``1``])``              ``minimum = Math.min(minimum, dp[i - ``1``][``0``]);``          ` `          ``// Condition if current element``          ``// is not equal to previous element``          ``// after being increased by 1``          ``if` `(j + arr[i] != arr[i - ``1``] + ``1``)``              ``minimum = Math.min(minimum, dp[i - ``1``][``1``]);``          ` `          ``// Condition if current element``          ``// is not equal to previous element``          ``// after being increased by 2``          ``if` `(j + arr[i] != arr[i - ``1``] + ``2``)``              ``minimum = Math.min(minimum, dp[i - ``1``][``2``]);` `          ``// Take the minimum from all cases``          ``dp[i][j] = j * cost[i] + minimum;``       ``}``    ``}``    ``int` `ans = (``int``) 1e6;` `    ``// Finding the minimum cost``    ``for``(``int` `i = ``0``; i < ``3``; i++)``       ``ans = Math.min(ans, dp[N - ``1``][i]);` `    ``// Printing the minimum cost``    ``// required to make all adjacent``    ``// elements distinct``    ``System.out.print(ans + ``"\n"``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``1``, ``2``, ``2``, ``3``, ``4` `};``    ``int` `cost[] = { ``3``, ``2``, ``5``, ``4``, ``2``, ``1` `};``    ``int` `N = arr.length;` `    ``minimumCost(arr, cost, N);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find the``# minimum cost required to make``# all adjacent elements distinct` `# Function that prints minimum cost required``def` `minimumCost(arr, cost, N):` `    ``# Dp-table``    ``dp ``=` `[[``0` `for` `i ``in` `range``(``3``)] ``for` `i ``in` `range``(N)]` `    ``# Base case``    ``# Not increasing the first element``    ``dp[``0``][``0``] ``=` `0` `    ``# Increasing the first element by 1``    ``dp[``0``][``1``] ``=` `cost[``0``]` `    ``# Increasing the first element by 2``    ``dp[``0``][``2``] ``=` `cost[``0``] ``*` `2` `    ``for` `i ``in` `range``(``1``, N):``        ``for` `j ``in` `range``(``3``):` `            ``minimum ``=` `1e6` `            ``# Condition if current element``            ``# is not equal to previous``            ``# non-increased element``            ``if` `(j ``+` `arr[i] !``=` `arr[i ``-` `1``]):``                ``minimum ``=` `min``(minimum, dp[i ``-` `1``][``0``])` `            ``# Condition if current element``            ``# is not equal to previous element``            ``# after being increased by 1``            ``if` `(j ``+` `arr[i] !``=` `arr[i ``-` `1``] ``+` `1``):``                ``minimum ``=` `min``(minimum, dp[i ``-` `1``][``1``])` `            ``# Condition if current element``            ``# is not equal to previous element``            ``# after being increased by 2``            ``if` `(j ``+` `arr[i] !``=` `arr[i ``-` `1``] ``+` `2``):``                ``minimum ``=` `min``(minimum, dp[i ``-` `1``][``2``])` `            ``# Take the minimum from all cases``            ``dp[i][j] ``=` `j ``*` `cost[i] ``+` `minimum``            ` `    ``ans ``=` `1e6` `    ``# Finding the minimum cost``    ``for` `i ``in` `range``(``3``):``        ``ans ``=` `min``(ans, dp[N ``-` `1``][i])` `    ``# Printing the minimum cost``    ``# required to make all adjacent``    ``# elements distinct``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``1``, ``2``, ``2``, ``3``, ``4` `]``    ``cost ``=` `[ ``3``, ``2``, ``5``, ``4``, ``2``, ``1` `]``    ``N ``=` `len``(arr)` `    ``minimumCost(arr, cost, N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to find the minimum``// cost required to make all``// adjacent elements distinct``using` `System;` `class` `GFG{` `// Function that prints minimum cost required``static` `void` `minimumCost(``int` `[]arr, ``int` `[]cost,``                        ``int` `N)``{` `    ``// Dp-table``    ``int` `[,]dp = ``new` `int``[N, 3];` `    ``// Base case``    ``// Not increasing the first element``    ``dp[0, 0] = 0;` `    ``// Increasing the first element by 1``    ``dp[0, 1] = cost;` `    ``// Increasing the first element by 2``    ``dp[0, 2] = cost * 2;` `    ``for``(``int` `i = 1; i < N; i++)``    ``{``       ``for``(``int` `j = 0; j < 3; j++)``       ``{``          ``int` `minimum = (``int``) 1e6;``          ` `          ``// Condition if current element``          ``// is not equal to previous``          ``// non-increased element``          ``if` `(j + arr[i] != arr[i - 1])``              ``minimum = Math.Min(minimum,``                                 ``dp[i - 1, 0]);``          ` `          ``// Condition if current element``          ``// is not equal to previous element``          ``// after being increased by 1``          ``if` `(j + arr[i] != arr[i - 1] + 1)``              ``minimum = Math.Min(minimum,``                                 ``dp[i - 1, 1]);``          ` `          ``// Condition if current element``          ``// is not equal to previous element``          ``// after being increased by 2``          ``if` `(j + arr[i] != arr[i - 1] + 2)``              ``minimum = Math.Min(minimum,``                                 ``dp[i - 1, 2]);``          ` `          ``// Take the minimum from all cases``          ``dp[i, j] = j * cost[i] + minimum;``       ``}``    ``}``    ``int` `ans = (``int``) 1e6;` `    ``// Finding the minimum cost``    ``for``(``int` `i = 0; i < 3; i++)``       ``ans = Math.Min(ans, dp[N - 1, i]);``       ` `    ``// Printing the minimum cost``    ``// required to make all adjacent``    ``// elements distinct``    ``Console.Write(ans + ``"\n"``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 1, 1, 2, 2, 3, 4 };``    ``int` `[]cost = { 3, 2, 5, 4, 2, 1 };``    ``int` `N = arr.Length;` `    ``minimumCost(arr, cost, N);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`7`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up