常用算法案例分析(二)

1、动态规划专题

这里特别要注意一点：

在写出状态转移方程方程之后，要循环遍历求解时，要根据实际情况确定是从下往上遍历还是从上往下遍历。

1.1、0-1背包的问题(子集问题)

问题描述：

每篇动态规划文章都得重复一遍套路，步骤为：

• 第一步要明确两点，「状态」和「选择」。先说状态，如何才能描述一个问题局面？只要给定几个可选物品和一个背包的容量限制，就形成了一个背包问题，对不对？所以状态有两个，就是「背包的容量」和「可选择的物品」。
  再说选择，也很容易想到啊，对于每件物品，你能选择什么？选择就是「装进背包」或者「不装进背包」嘛。
  明白了状态和选择，动态规划问题基本上就解决了，只要往这个框架套就完事儿了：

or 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 择优(选择1，选择2...)

• 第二步要明确dp数组的定义。dp数组是什么？其实就是描述问题局面的一个数组。换句话说，我们刚才明确问题有什么「状态」，现在需要用dp数组把状态表示出来。
  首先看看刚才找到的「状态」，有两个，也就是说我们需要一个二维dp数组，一维表示可选择的物品，一维表示背包的容量。
  dp[i][w]的定义如下：对于前i个物品，当前背包的容量为w，这种情况下可以装的最大价值是dp[i][w]。
  比如说，如果 dp[3][5] = 6，其含义为：对于给定的一系列物品中，若只对前 3 个物品进行选择，当背包容量为 5 时，最多可以装下的价值为 6。
• 第三步，根据「选择」，思考状态转移的逻辑(状态转移方程)。

先重申一下刚才我们的dp数组的定义：

dp[i][w]表示：对于前i个物品，当前背包的容量为w时，这种情况下可以装下的最大价值是dp[i][w]。

如果你没有把这第i个物品装入背包，那么很显然，最大价值dp[i][w]应该等于dp[i-1][w]。你不装嘛，那就继承之前的结果。

如果你把这第i个物品装入了背包，那么dp[i][w]应该等于dp[i-1][w-wt[i-1]] + val[i-1]。

首先，由于i是从 1 开始的，所以对val和wt的取值是i-1。

而dp[i-1][w-wt[i-1]]也很好理解：你如果想装第i个物品，你怎么计算这时候的最大价值？换句话说，在装第i个物品的前提下，背包能装的最大价值是多少？

显然，你应该寻求剩余重量w-wt[i-1]限制下能装的最大价值，加上第i个物品的价值val[i-1]，这就是装第i个物品的前提下，背包可以装的最大价值。

综上就是两种选择，我们都已经分析完毕，也就是写出来了状态转移方程，可以进一步细化代码：

for i in [1..N]:
    for w in [1..W]:
        dp[i][w] = max(
            //当前物品的重量可以被装进包中
            dp[i-1][w],
            //不可以被装进包中
            dp[i-1][w - wt[i-1]] + val[i-1]
        )
return dp[N][W]

• 最后一步，求边界的值。

所以，最终的代码为：

int knapsack(int W, int N, vector<int>& wt, vector<int>& val) {
   
    // vector 全填入 0，base case 已初始化
    vector<vector<int>> dp(N + 1, vector<int>(W + 1, 0));
    for (int i = 1; i <= N; i++) {
   
        for (int w = 1; w <= W; w++) {
   
            if (w - wt[i-1] < 0) {
   
                // 当前背包容量装不下，只能选择不装入背包
                dp[i][w] = dp[i - 1][w];
            } else {
   
                // 装入或者不装入背包，择优
                dp[i][w] = max(dp[i - 1][w - wt[i-1]] + val[i-1], 
                               dp[i - 1][w]);
            }
        }
    }

    return dp[N][W];
}

1.2、分割等和子集(背包问题的变体)(子数组问题)

解题思路：我们可以先对集合求和，得出sum，把问题转化为背包问题，给一个可装载重量为sum/2的背包和N个物品，每个物品的重量为nums[i]。现在让你装物品，是否存在一种装法，能够恰好将背包装满？

class Solution {
   
    //动态规划：等价于0-1背包问题
    //dp[i][j]：i为数组元素的个数，j表示目标值
    //dp[4][11]:若为true，则[1, 5, 11, 5]满足条件
    //状态为：数组元素个数和目标值，取值范围分别为：1-4和0-11
    //路径为：选择或者不选择
    public boolean canPartition(int[] nums) {
   
        //长度小于2，直接返回false
        if(nums.length<2){
   
            return false;
        }
        int sum=0;
        //求所有元素的和
        for(int e:nums){
   
            sum+=e;
        }
        //若和为奇数，返回false
        if(sum%2!=0){
   
            return false;
        }
        //dp[4][11];表示元素为4个、目标值为11,时，存在几个元素的和为目标值
        boolean[][] dp=new boolean[nums.length+1][sum/2+1];
        //若目标值为0，则一直为true
        for(int i=0;i<=nums.length;i++){
   
            dp[i][0]=true;
        }
        
        for(int i=1;i<=nums.length;i++){
   
            for(int j=1;j<=sum/2;j++){
   
                //注意：i可以等于nums.length,所以这里是nums[i]
                if(j<nums[i-1]){
   
                    //目标值小于当前的元素值，则如果前i-1个元素满足条件，则等于i时也满足条件
                    dp[i][j]=dp[i-1][j];
                }else{
   
                    //若前i-1个元素满足条件，则dp[i][j]=dp[i-1][j]
                    //若前i-1个元素不满足条件，则dp[i][j]=dp[i-1][j-nums[i-1]];
                    dp[i][j]=dp[i-1][j]||dp[i-1][j-nums[i-1]];
                }
                
            }
        }
        return dp[nums.length][sum/2];
    }
}

1.3、零钱兑换(二)(子数组问题)

解题思路：和上面两道题思路一样。
状态：硬币种类和总金额。
路径：是否选择当前的硬币。

class Solution {
   
    public int change(int amount, int[] coins) {
   
        //若总金额小于1，则直接返回1
        if(amount<1){
   
            return 1;
        }
        //若硬币种类为0，直接返回0
        if(coins.length<1){
   
            return 0;
        }
        //dp[i][j]：i代表硬币的种类，j代表总金额，dp[i][j]的意思是当硬币的种类为i,总金额为j时，的满足条件的总方式数。
        int[][] dp=new int[coins.length+1][amount+1];
        //若金额为0，则dp[i][0]恒等于1
        for(int i=0;i<=coins.length;i++){
   
            dp[i][0]=1;
        }
        for(int i=1;i<=coins.length;i++){
   
            for(int j=1;j<=amount;j++){
   
                //若当前硬币的值大于总金额，则dp[i][j]=dp[i-1][j];
                if(j<coins[i-