动态规划-完全背包系列

完全背包与01背包的区别在于，01背包中所有物品要么选要不不选，完全背包是所有物品可以选任意次。完全背包与01背包很相似，可以将完全背包转换成01背包，也可以找到其状态转移方程。

1.完全背包
2.完全背包变形题-最小乘车费用
3.完全背包变形题-货币系统

---

1.完全背包

问题描述：有n件物品和一个容量为m的背包，每件物品都有无限件可用，第i件物品的体积为w[i]，价值是v[i]，求解将哪些物品放入背包可使这些物品的价值总和最大并且不超过背包容量。

说明：完全背包问题和01背包问题相似，可以将其改造成01背包问题。
方法一：改造状态转移方程：f(n,m) = max{k*v[i]+f(i-1,j-k*w[i])}，其中k=0….j/w[i]
这样需要使用三层for循环，时间复杂度高，不推荐。

**方法二：**f(n,m) = max{f(n-1,m),f(n,m-w[n])+v[n]}

package com.zd.dp.complete;

import java.util.ArrayList;

/**
 * 完全背包问题
 * 有n个物品和容量为m的背包，每件物品有无限件，求最价值最大
 *
 */
public class Main{
    public static void main(String[] args){
        int n = 4;
        int[] weight = {2,3,4,7};
        int[] value = {1,3,5,9};
        int m = 10;
        int res = getMaxValue(n,weight,value,m);
        System.out.println(res);

        int res_01 = getMaxValue_01(n,weight,value,m);
        System.out.println(res_01);

        int res_01_new = getMaxValue_01_new(n,weight,value,m);
        System.out.println(res_01_new);
    }

    /**
     * 方法一：改造状态转移方程
     * @param n
     * @param weight
     * @param value
     * @param m
     * @return
     */
    private static int getMaxValue_01_new(int n, int[] weight, int[] value, int m) {
        if (n == 0 || m == 0)
            return 0;
        int[][] dp = new int[n][m+1];
        for (int i = 0; i < m+1; i++){
            dp[0][i] = (i/weight[0])*value[0];
        }
        for (int i = 0; i < n; i++)
            dp[i][0] = 0;
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < m + 1; j++) {
                int a = dp[i-1][j];
                int b = j-weight[i]
                        < 0 ? 0 : dp[i][j-weight[i]]+value[i];
                dp[i][j] = Math.max(a,b);
            }
        }
        return dp[n-1][m];
    }


    /**
     * 方法二：获取最大价值
     * @param n
     * @param weight
     * @param value
     * @param m
     * @return
     */
    private static int getMaxValue(int n, int[] weight, int[] value, int m) {
        if (n == 0 || m == 0)
            return 0;

        int[][] dp = new int[n][m+1];

        //填充数组第一行
        for (int i = 0; i < m+1; i++){
            dp[0][i] = (i/weight[0])*value[0];
        }
        //填充数组第一列
        for (int i = 1; i < n; i++){
            dp[i][0] = 0;
        }

        //从左到右，从上到下，填充数组其他部分
        for (int i = 1; i < n; i++){
            for (int j = 1; j < m+1; j++){
                int k = j/weight[i];
                for (int l = 0; l <= k; l++){
                    int temp = dp[i-1][j-l*weight[i]]+l*value[i];
                    dp[i][j] = dp[i][j] > temp ? dp[i][j] : temp;
                }
            }
        }
        return dp[n-1][m];
    }
}

2.完全背包变形题-最小乘车费用

问题描述：某条街上每一公里就有一汽车站，乘车费用如下所示：
公里数 1 2 3 4 5 6 7 8 9 10
费用 12 21 31 40 49 58 69 79 90 101
而一辆汽车从不行驶超过10公里，某人想行驶n公里，假设他可以任意次换车，请你帮他找到一种乘车方案使费用最小。

分析：此题为完全背包的应用，人可以选择在任意处下车换乘。

/**
 * 最小搭车费用
 */
public class MinCarFee {
    public static void main(String[] args){
        int[] a = {12,21,31,40,49,58,69,79,90,101};
        int n = 13;
        int res = getMinFee(a,n);
        System.out.println(res);
    }

    /**
     * 最少乘车费用
     * @param a
     * @param n
     * @return
     */
    private static int getMinFee(int[] a, int n) {
        if (a == null || n == 0)
            return 0;
        int length = a.length;
        int[][] dp = new int[length][n+1];
        //填充第一行
        for (int i = 0; i < n+1; i++){
            dp[0][i] = i*a[0];
        }
        //填充第一列
        for (int i = 0; i < length; i++){
            dp[i][0] = 0;
        }
        //填充二维数组中剩余部分
        for (int i = 1; i < length; i++){
            for (int j = 1; j < n+1; j++){
                int A = dp[i-1][j];
                int B = j-i-1 >= 0 ? dp[i][j-i-1]+a[i]:Integer.MAX_VALUE;
                dp[i][j] = Math.min(A,B);
            }
        }
        return dp[length-1][n];
    }
}

3.完全背包变形题-货币系统

问题描述：使用一个货币系统{1，2，5，10，20}产生某一指定货币面值的可能方法有多少种？

分析：f(i,j) = f(i-1,j)+f(i,j-a[i])

/**
 * 货币系统，给定一个确定面额，统计有多少种组法
 */
public class CountsMoney {
    public static void main(String[] args){
        int[] money = {1,2,5,10,20};
        int n = 7;
        int res = getCounts(money,n);
        System.out.println(res);
    }

    /**
     * 统计货币种类数
     * @param money
     * @param n
     * @return
     */
    private static int getCounts(int[] money, int n) {
        if (money == null || n == 0)
            return 0;
        int length = money.length;
        int[][] dp = new int[length][n+1];
        //填充第一行
        for (int i = 0; i < n+1; i++)
            dp[0][i] = 1;

        //填充第一列
        for (int i = 0; i < length; i++)
            dp[i][0] = 0;

        //填充剩余部分
        for (int i = 1; i < length; i++)
            for (int j = 1; j < n+1; j++){
                int A = dp[i-1][j];
                int B = j - money[i] >= 0 ? (dp[i][j-money[i]]==0?1:dp[i][j-money[i]]) : 0;
                dp[i][j] = A + B;
            }
        return dp[length-1][n];
    }
}

总结：当你无法确定状态转移方程时，不妨先画出二维数组，通过填充数组找到规律。上述代码空间复杂度较高，优化方式可以将二维数组转换成一维数组。