动态规划总结

1、背包问题

N个物品，每个物品重量为weight[i]，价值为value[i]，背包最大容量为max

基本公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]) 容量为j的背包能获得的最大价值

题型转换：

将一个数组分成两堆相同大小的子集

leetcode416

public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }

        if (sum % 2 != 0) {
            return false;
        }

        int target = sum / 2;
        int[] dp = new int[target + 1];
        for (int i = 0; i < nums.length; i++) {
            for (int j = target; j >= nums[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
                System.out.println("i = " + i);
                System.out.println("j = " + j);
                System.out.println(dp[j]);
            }
            System.out.println("\n");
        }
        return dp[target] == target;
    }

leetcode96  二叉树组合

public int numTrees(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                dp[i] += dp[j] * dp[i - 1 - j];
            }
        }
        return dp[n];
    }

2.完全背包求排列/组合

a.求组合的情况

for (int i = 0; i < coins.size(); i++) { // 遍历物品
    for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
        dp[j] += dp[j - coins[i]];
    }
}

这里比如 amount = 5，coins[0] = 2 , coins[1] = 3,   遍历第0个物品时，dp[5] += dp[5-2] = 0,并没有记录2，3的情况，遍历完才给dp中的一些元素赋值，

遍历第1个物品时，这时候dp[5] += dp[5-3] = 1，也就是2,3情况 

     0  1  2  3  4  5

2   1  0  1  0  1  0  

3   1  0  0  1  0  1

b.求排列的情况

for (int j = 0; j <= amount; j++) { // 遍历背包容量
    for (int i = 0; i < coins.size(); i++) { // 遍历物品
        if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
    }
}

同样 amount = 5，coins[0] = 2 , coins[1] = 3

    0    1     2    3    4    5

2  1    0     1    0    1    1    

3  1    0     1    1    0    2

应该按容量看每一列，遍历完容量容量为2的背包时dp[2] = dp[2-2]  = 1，遍历完容量为3的背包

dp[3] = dp[3-3] = 1，

遍历完容量为5的背包，coins[0],coins[1]都符合条件,dp[5] += dp[5-2] + dp[5-3] = 2，其实也就是包含了{2,3}和{3,2}

c.dp[0]的初始化

dp[0] = 0的情况：求能组成target的最小个数

dp[0] = 1的情况：求能组合/排列的个数

3.多重背包

多加了一个每个物品的个数，在遍历每个物品时在遍历一下个数即可

    for(int i = 0; i < weight.length; i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            // 以上为01背包，然后加一个遍历个数
            for (int k = 1; k <= nums[i] && (j - k * weight[i]) >= 0; k++) { // 遍历个数
                dp[j] = Math.max(dp[j], dp[j - k * weight[i]] + k * value[i]);
            }
        }
    }

4.股票买入问题

leetcode.188

最多可以买入K，所以有2K个状态，需要注意的是奇数时买入股票，偶数时卖出股票即可

每一个状态都有两种情况，操作/不操作，即拿原状态的值和操作后的值取大。初始化和leetcode123类似，把买入操作初始化为prices[0]

class Solution {
    public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        if (k == 0 || len == 0) {
            return 0;
        }

        int[] dp = new int[2*k];
        for (int i = 0; i < dp.length; i++) {
            if (i % 2 == 0) {
                dp[i] = -prices[0];
            }
        }

        for (int i = 1; i < prices.length; i++) {
            dp[0] = Math.max(dp[0], -prices[i]);
            for (int j = 1; j < 2*k; j++) {
                if (j % 2 != 0) {
                    dp[j] = Math.max(dp[j - 1] + prices[i], dp[j]);
                } else {
                    dp[j] = Math.max(dp[j], dp[j - 1] - prices[i]);
                }
            }
        }

        return dp[2*k - 1];
    }
}

股票买入最佳时机含冷冻期

卖出后有一天的冷冻期，所以在分成持有股票和未持有股票两种状态时有一些变化

持有股票只能从延续前一个持有状态或者在从冷冻期前的值来得到

解法一：两种状态

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len == 1) {
            return 0;
        }        
        int[][] dp = new int[len][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        dp[1][0] = Math.max(dp[0][0], -prices[1]);
        dp[1][1] = Math.max(dp[0][1], dp[0][0] + prices[1]);
        for (int i = 2; i < len; i++) {
            dp[i][0] = Math.max(dp[i - 2][1] - prices[i],dp[i - 1][0]);
            dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
        }
        return dp[len - 1][1];
    }
}

 解法二：三种状态

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        //由于可以无限次交易，所以只定义两个维度，第一个维度是天数，第二个维度表示是否持有股票，0表示不持有，1表示持有，2表示过渡期
        int[][] dp = new int[prices.length][3];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        for (int i = 1; i < prices.length; i++) {
            //第i天不持有股票的情况有两种
            //a.第i-1天也不持有股票
            //b.第i-1天是过渡期
            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][2]);
            //第i天持有股票有两种情况
            //a.第i-1天也持有股票，第i天不操作，
            //b.第i-1天不持有股票，在第i天买入
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i]);
            //第i天是冷冻期只有一种情况，第i-1天持有股票且卖出
            dp[i][2] = dp[i-1][1] + prices[i];
        }
        //最后最大利润为最后一天，不持有股票或者进入冷冻期的情况
        return Math.max(dp[prices.length-1][0], dp[prices.length-1][2]);
    }
}

5.最長遞增子序列