📌  相关文章
📜  最小化成本以清空给定数组,其中删除元素的成本是其与 Time 瞬间的绝对差异

📅  最后修改于: 2021-09-06 06:15:53             🧑  作者: Mango

给定一个由N 个整数组成的数组arr[] ,任务是找到从数组中移除所有元素的最小成本,使得移除任何元素的成本是当前时刻T (最初为 1 )与数组元素arr[i]abs(T – arr[i])其中T

例子:

朴素的方法:想法是使用递归来解决问题。在每个时刻,存在两种可能性,要么删除任何元素,要么不删除。因此,为了最小化成本,请对数组进行排序。然后,从索引0和时间T = 1 开始,使用以下递推关系解决问题:

时间复杂度: O(2 N )
辅助空间: O(1)

高效方法:为了优化上述方法,思想是使用动态规划,因为上述递推关系存在重叠的子问题和重叠的子结构。请按照以下步骤解决问题:

  • 用一些大值初始化一个大小为N*2N的二维数组cost[][] ,其中cost[i][j]表示使用j从给定数组中删除直到第i索引的所有元素的最小成本多少时间。
  • 此外,将cost[0][0]初始化为0和变量, prev0 ,其中prev将存储先前索引的所有先前成本值中的最小值。
  • 使用变量i遍历给定数组arr[] ,然后对于每个i ,使用变量j在范围[1, 2N] 中迭代:
    • 如果(prev + abs(j – arr[i – 1]) 的值小于cost[i][j] ,则将cost[i][j]更新为该值。
    • 如果cost[i – 1][j]小于prev ,则将prev更新为该值。
  • 完成上述步骤后,将最小成本打印为cost[N][j]

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
using namespace std;
#define INF 10000
 
// Function to find the minimum cost
// to delete all array elements
void minCost(int arr[], int n)
{
 
    // Sort the input array
    sort(arr, arr + n);
 
    // Store the maximum time to delete
    // the array in the worst case
    int m = 2 * n;
 
    // Store the result in cost[][] table
    int cost[n + 1][m + 1];
 
    // Initialize the table cost[][]
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            cost[i][j] = INF;
        }
    }
 
    // Base Case
    cost[0][0] = 0;
 
    // Store the minimum of all cost
    // values of the previous index
    int prev = 0;
 
    // Iterate from range [1, n]
    // using variable i
    for (int i = 1; i <= n; i++) {
 
        // Update prev
        prev = cost[i - 1][0];
 
        // Iterate from range [1, m]
        // using variable j
        for (int j = 1; j <= m; j++) {
 
            // Update cost[i][j]
            cost[i][j] = min(cost[i][j],
                             prev
                                 + abs(j - arr[i - 1]));
 
            // Update the prev
            prev = min(prev, cost[i - 1][j]);
        }
    }
 
    // Store the minimum cost to
    // delete all elements
    int minCost = INF;
 
    // Find the minimum of all values
    // of cost[n][j]
    for (int j = 1; j <= m; j++) {
        minCost = min(minCost, cost[n][j]);
    }
 
    // Print minimum cost
    cout << minCost;
}
 
// Driver Code
int main()
{
    int arr[] = { 4, 2, 4, 4, 5, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    minCost(arr, N);
 
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
import java.io.*;
 
class GFG{
     
static int INF = 10000;
  
// Function to find the minimum cost
// to delete all array elements
static void minCost(int arr[], int n)
{
     
    // Sort the input array
    Arrays.sort(arr);
  
    // Store the maximum time to delete
    // the array in the worst case
    int m = 2 * n;
  
    // Store the result in cost[][] table
    int cost[][] = new int[n + 1][m + 1];
  
    // Initialize the table cost[][]
    for(int i = 0; i <= n; i++)
    {
        for(int j = 0; j <= m; j++)
        {
            cost[i][j] = INF;
        }
    }
  
    // Base Case
    cost[0][0] = 0;
  
    // Store the minimum of all cost
    // values of the previous index
    int prev = 0;
  
    // Iterate from range [1, n]
    // using variable i
    for(int i = 1; i <= n; i++)
    {
         
        // Update prev
        prev = cost[i - 1][0];
  
        // Iterate from range [1, m]
        // using variable j
        for(int j = 1; j <= m; j++)
        {
             
            // Update cost[i][j]
            cost[i][j] = Math.min(cost[i][j],
                                  prev + Math.abs(
                                     j - arr[i - 1]));
  
            // Update the prev
            prev = Math.min(prev, cost[i - 1][j]);
        }
    }
  
    // Store the minimum cost to
    // delete all elements
    int minCost = INF;
  
    // Find the minimum of all values
    // of cost[n][j]
    for(int j = 1; j <= m; j++)
    {
        minCost = Math.min(minCost, cost[n][j]);
    }
  
    // Print minimum cost
    System.out.print(minCost);
}
  
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 4, 2, 4, 4, 5, 2 };
    int N = arr.length;
  
    // Function Call
    minCost(arr, N);
}
}
 
// This code is contributed by sanjoy_62


Python3
# Python3 program for the above approach
 
INF = 10000
 
# Function to find the minimum cost
# to delete all array elements
def minCost(arr, n):
 
    # Sort the input array
    arr = sorted(arr)
 
    # Store the maximum time to delete
    # the array in the worst case
    m = 2 * n
 
    # Store the result in cost[][] table
    cost = [[INF for i in range(m + 1)] for i in range(n + 1)]
 
    # Base Case
    cost[0][0] = 0
 
    # Store the minimum of all cost
    # values of the previous index
    prev = 0
 
    # Iterate from range [1, n]
    # using variable i
    for i in range(1, n + 1):
 
        # Update prev
        prev = cost[i - 1][0]
 
        # Iterate from range [1, m]
        # using variable j
        for j in range(1, m + 1):
 
            # Update cost[i][j]
            cost[i][j] = min(cost[i][j], prev + abs(j - arr[i - 1]))
 
            # Update the prev
            prev = min(prev, cost[i - 1][j])
 
    # Store the minimum cost to
    # delete all elements
    minCost = INF
 
    # Find the minimum of all values
    # of cost[n][j]
    for j in range(1, m + 1):
        minCost = min(minCost, cost[n][j])
 
    # Print minimum cost
    print(minCost)
 
# Driver Code
if __name__ == '__main__':
    arr=[4, 2, 4, 4, 5, 2]
    N = len(arr)
 
    # Function Call
    minCost(arr, N)
 
# This code is contributed by mohit kumar 29


C#
// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
   
static int INF = 10000;
   
// Function to find the minimum cost
// to delete all array elements
static void minCost(int[] arr, int n)
{
     
    // Sort the input array
    Array.Sort(arr);
     
    // Store the maximum time to delete
    // the array in the worst case
    int m = 2 * n;
     
    // Store the result in cost[][] table
    int[,] cost = new int[n + 1, m + 1];
     
    // Initialize the table cost[][]
    for(int i = 0; i <= n; i++)
    {
        for(int j = 0; j <= m; j++)
        {
            cost[i, j] = INF;
        }
    }
   
    // Base Case
    cost[0, 0] = 0;
     
    // Store the minimum of all cost
    // values of the previous index
    int prev = 0;
   
    // Iterate from range [1, n]
    // using variable i
    for(int i = 1; i <= n; i++)
    {
         
        // Update prev
        prev = cost[i - 1, 0];
   
        // Iterate from range [1, m]
        // using variable j
        for(int j = 1; j <= m; j++)
        {
             
            // Update cost[i][j]
            cost[i, j] = Math.Min(cost[i, j],
                                  prev + Math.Abs(
                                     j - arr[i - 1]));
   
            // Update the prev
            prev = Math.Min(prev, cost[i - 1, j]);
        }
    }
   
    // Store the minimum cost to
    // delete all elements
    int minCost = INF;
   
    // Find the minimum of all values
    // of cost[n][j]
    for(int j = 1; j <= m; j++)
    {
        minCost = Math.Min(minCost, cost[n, j]);
    }
   
    // Print minimum cost
    Console.Write(minCost);
}
 
// Driver Code
public static void Main()
{
    int[] arr = { 4, 2, 4, 4, 5, 2 };
    int N = arr.Length;
     
    // Function Call
    minCost(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga


Javascript


输出:
4

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

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live