「线性DP」购物

购物

https://ac.nowcoder.com/acm/contest/24213/1015

题目描述

这家糖果店将会在每天出售一些糖果,它每天都会生产出m个糖果,第i天的第j个糖果价格为 C [ i ] [ j ] C[i][j] C[i][j] 元。

现在的你想要在接下来的n天去糖果店进行选购,你每天可以买多个糖果,也可以选择不买糖果,但是最多买m个。(因为最多只生产m个)买来糖果以后,你可以选择吃掉糖果或者留着之后再吃。糖果不会过期,你需要保证这n天中每天你都能吃到至少一个糖果。

这家店的老板看你经常去光顾这家店,感到非常生气。(因为他不能好好睡觉了)于是他会额外的要求你支付点钱。具体来说,你在某一天购买了 k 个糖果,那么你在这一天需要额外支付 k2 的费用。

那么问题来了,你最少需要多少钱才能达成自己的目的呢?

输入描述

第一行两个正整数n和m,分别表示天数以及糖果店每天生产的糖果数量。
接下来n行(第2行到第n+1行),每行m个正整数,第x+1行的第y个正整数表示第x天的第y个糖果的费用。

输出描述

输出只有一个正整数,表示你需要支付的最小费用。

样例

#1

3 2 
1 1
100 100 
10000 10000
107

#2

5 5
1 2 3 4 5
2 3 4 5 1 
3 4 5 1 2 
4 5 1 2 3 
5 1 2 3 4
10

提示

  • 对于100%的数据,1 ≤ n, m ≤ 300 , 所有输入的数均 ≤ 106。

解析

题目大意:求购买 n 颗糖果,保证每天必须吃一颗的前提下,所需要花至少多少钱购买这 n 可糖果。

题目虽然每天都可以生产很多糖果,但题目要求每天只需要吃一颗糖果,所以第 i 天总共所需要购买的糖果只需要 i 颗即可。

还要注意,题目说了每天必须吃一颗,因此第 1 天必须买糖果。

因为每天都可以生产很多糖果,购买的数量也不一定,例如第一天买2个,第二天不买,或者第一天买1个,第二天买1个。因此需要一个分割点 k k k 来进行划分,来进行划分不同的购买情况。

而所求是价格最小,那么我们可以将糖果按价格从小到大排序。还可以对齐进行求前缀和。

DP 信息:

  • 原问题:求购买 n 颗糖果,保证每天必须吃一颗的前提下,所需要花至少多少钱购买这 n 可糖果。
  • 子问题:求某一天购买的糖果至少需要多少钱
  • DP 定义: d p [ i ] [ j ] dp[i][j] dp[i][j] 表示第 i 天总共买了 j 颗糖果(j 是前些天累加的,而不是当天一次性买 j 个)
  • DP 方程: d p [ i ] [ j ] = m i n ( d p [ i ] [ j ] , d p [ i − 1 ] [ k ] + a r r [ i ] [ j − k ] + ( j − k ) ∗ ( j − k ) ) dp[i][j] = min(dp[i][j], dp[i-1][k] + arr[i][j-k] + (j - k) * (j - k)) dp[i][j]=min(dp[i][j],dp[i1][k]+arr[i][jk]+(jk)(jk))
  • DP 初始化: d p [ i ] [ j ] = I N F dp[i][j] = INF dp[i][j]=INF d p [ 0 ] [ 0 ] = 0 dp[0][0] = 0 dp[0][0]=0

AC Code

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt();
        final int MAX = 305;
        int[][] arr = new int[MAX][MAX];
        int[][] dp = new int[MAX][MAX];
        
        for(int i = 0; i <= n; i++) Arrays.fill(dp[i], 1<<30);
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) arr[i][j] = sc.nextInt();
            Arrays.sort(arr[i], 1, m+1); // 价格从小到大排序
            for(int j = 1; j <= m; j++) arr[i][j] += arr[i][j-1]; // 求前缀和
        }
        
        dp[0][0]=0;
        
        for(int i = 1; i <= n; i++) { // 天数
            // 总共买的数量刚好等于 n 即可(详细看解析)
            // i*m 是为了保证第一天的购买不会溢出 1*2=2 小于 n=3 √
            // n=3,m=2, 第一天若直接用 3,会导致生产不足,无法满足需求
            for(int j = i; j <= Math.min(n, i * m); j++) { // 总共需要购买的糖果数量
                for(int k = i - 1; k <= j; k++) { // 划分不同的购买情况
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][k] + arr[i][j-k] + (j-k) * (j-k));
                }
            }
        }
        
        System.out.println(dp[n][n]);
    }
}
i = 1, j = 1;
  k = 0, dp[1][1] = dp[0][0] + arr[1][1] + 1^2; // 0+1+1
  k = 1, dp[1][1] = dp[0][1] + arr[1][0] + 0^2; // INF+0+0
i = 1, j = 2;
  k = 0, dp[1][2] = dp[0][0] + arr[1][2] + 2^2; // 0+2+4
  k = 1, dp[1][2] = dp[0][1] + arr[1][1] + 1^2; // INF+2+2
  k = 2, dp[1][2] = dp[0][2] + arr[1][0] + 0^2; // INF+0+0
i = 2, j = 2;
  // ...
// 以此类推...

i = 1, j = 1
  k = 0  dp[1][1] = dp[0][0] + M[1][1] + 1 * 1
  k = 1  dp[1][1] = dp[0][1] + M[1][0] + 0 * 0
i = 1, j = 2
  k = 0  dp[1][2] = dp[0][0] + M[1][2] + 2 * 2
  k = 1  dp[1][2] = dp[0][1] + M[1][1] + 1 * 1
  k = 2  dp[1][2] = dp[0][2] + M[1][0] + 0 * 0
i = 2, j = 2
  k = 1  dp[2][2] = dp[1][1] + M[2][1] + 1 * 1
  k = 2  dp[2][2] = dp[1][2] + M[2][0] + 0 * 0
i = 2, j = 3
  k = 1  dp[2][3] = dp[1][1] + M[2][2] + 2 * 2
  k = 2  dp[2][3] = dp[1][2] + M[2][1] + 1 * 1
  k = 3  dp[2][3] = dp[1][3] + M[2][0] + 0 * 0
i = 3, j = 3
  k = 2  dp[3][3] = dp[2][2] + M[3][1] + 1 * 1
  k = 3  dp[3][3] = dp[2][3] + M[3][0] + 0 * 0

在上面的过程中,解释一下 k k k

d p [ 1 ] [ 2 ] dp[1][2] dp[1][2] 第 1 天购买 2 个糖果:

第 0 天购买 0 个糖果,第 1 天购买 2 个糖果(第 1 天全买)

第 0 天购买 1 个糖果,第 1 天购买 1 个糖果(平分)

第 0 天购买 2 个糖果,第 1 天购买 0 个糖果(第 0 天全买)

你可能感兴趣的:(#,动态规划,算法,java,动态规划,线性DP)