最小化使数组中所有相邻元素不同的成本

📌 相关文章

📜 最小化使数组中所有相邻元素不同的成本

📅 最后修改于: 2021-05-17 16:58:19 🧑 作者: Mango

给定两个大小为N的整数数组arr []和cost [] ，任务是以最小的成本使所有相邻元素互不相同。 cost [i]表示将^第i^个元素增加1的成本。

例子：

Input: arr[] = {2, 2, 3}, cost[] = {4, 1, 5}
Output: 2
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: 0

为什么编程需要懂一点英语

方法：

我们可以观察到，可能需要将元素的最大最大值增加两次。
使用动态编程可以解决此问题。
创建一个DP表dp [] [] ，其中行表示元素，而列表示增量。
dp [i] [j]是使用j增量使^第i^个元素与其相邻元素不同所需的最小成本。
dp [i] [j]的值可以计算为：

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

为什么编程需要懂一点英语

下面是上述方法的实现

C++

// C++ program to find the
// minimum cost required to make
// all adjacent elements disinct
  
#include 
using namespace std;
  
// Function that prints minimum cost required
void minimumCost(int arr[], int cost[], int N)
{
  
    // Dp-table
    vector > dp(N, vector(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 = 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;
        }
    }
  
    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 disinct
    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[0]);
  
    minimumCost(arr, cost, N);
  
    return 0;
}

Java

// Java program to find the minimum 
// cost required to make all 
// adjacent elements disinct
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 disinct
    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 disinct
  
# 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 disinct
    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 disinct
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[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 disinct
    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

输出：

时间复杂度： O(N)
辅助空间： O(N)