Leetcode刷题笔记——动态规划

---

layout: pages
title: Leetcode刷题笔记——动态规划
date: 2021-06-07 09:00:08
categories: LeetCode刷题笔记
tags: 算法

---

1、目标和问题——基本的动态规划

1.1、回溯穷举

因为每一种可能都是会得到我们所需要的结果的，所以自然而然地可以想到使用回溯算法来解决

class Solution {
    int result = 0;

    public int findTargetSumWays(int[] nums, int target) {
        getSum(nums, target, 0, nums.length);
        return result;
    }

    public void getSum(int[] nums, int target, int index, int length) {
        //回溯递归的出口
        if (index == length) {
            if (target == 0)
                result ++;
            return;
        }
        //回溯处理
        getSum(nums, target - nums[index], index + 1, length);
        getSum(nums, target + nums[index], index + 1, length);
    }
}

• 时间复杂度：O(2^n)，其中 n 是数组nums 的长度。回溯需要遍历所有不同的表达式，共有 2^n 种不同的表达式，每种表达式计算结果需要 *O(1)*的时间，因此总时间复杂度是 O(2^n)

• 空间复杂度：O(n)，其中 n是数组 nums 的长度。空间复杂度主要取决于递归调用的栈空间，栈的深度不超过 n

1.2、动态规划

我们还可以把这道题转化为01背包问题使用动态规划的方法进行解决，官方题解写的还是很清楚的，这里直接贴出来

按照nums = [1,1,1,1]，target = 2来描述一下具体的计算过程，首先给出整个表格的样式d[n+1][neg+1]，这里的n指的是数组长度，为4，neg为数组和减去target除以2为1，动态规划表格如下，行表示所选的数字和为0、1、2，列表示从前几个数字中来选取

	neg=0	neg=1
从前0个数字
从前1个数字
从前2个数字
从前3个数字
从前4个数字

首先初始化边界条件，从前0个数字中选取，也就是无数可选的时候，除了目标为0有一种啥也不选的方案之外，其他的均没有可选方案，因此全部置0

	neg=0	neg=1
从前0个数字	1	0
从前1个数字
从前2个数字
从前3个数字
从前4个数字

开始从第0行递推，对于前1个数字，也就是1，令和为0的方案，因为1本身是大于0的，所以肯定不能选1，就把前0个数字的结果继承下来，是1

和为1的方案，1可选可不选，不选的话也是继承前0个数字和为1的结果，是0，选的话是前0个数字和为0（1-1=0）的方案数也就是1，0+1=1，共1种方案

第二行更新后得到以下结果

	neg=0	neg=1
从前0个数字	1	0
从前1个数字	1	1
从前2个数字
从前3个数字
从前4个数字

同样的推导第3行也是一样

对于前2个数字，我们已经有了前1个数字的组合方案，第二个数字还是1

令和为0的方案，因为1本身是大于0的，所以肯定不能选1，就把前0个数字的结果继承下来，是1

和为1的方案，1可选可不选，不选的话也是继承前0个数字和为1的结果，是1，选的话是前1个数字和为0（1-1=0）的方案数也就是1，0+1=1，共2种方案

以此类推最后得到的表格为

	neg=0	neg=1
从前0个数字	1	0
从前1个数字	1	1
从前2个数字	1	2
从前3个数字	1	3
从前4个数字	1	4

所以最后得到的结果就是4，所以状态转移方程就很容易理解了，最后给出目标和问题的动态规划题解代码如下

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        int length = nums.length;

        //求数组和
        for (int num : nums) {
            sum += num;
        }

        //没有结果的特殊情况
        int diff = sum - target;
        if (diff < 0 || diff % 2 != 0)
            return 0;
        
        int neg = diff / 2;

        //创建动态规划数组
        int[][] dp = new int[length + 1][neg + 1];
        //动态规划数组初始化
        dp[0][0] = 1;

        for (int i = 1; i <= length; i++) {
            for (int j = 0; j <=neg; j++) {
                //状态转移方程
                if (nums[i - 1] > j)
                    //nums[i - 1]不可选
                    dp[i][j] = dp[i - 1][j];
                else
                    //nums[i - 1]可选
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i - 1]];
            }
        }

        return dp[length][neg];
    }
}

当然也可以采用滚动数组的方式进行更新，更能节省空间，代码如下，注意滚动数组内层循环一定采用倒序的方式，以保证传递来的是[i-1]的值（重要！！！）

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        int diff = sum - target;
        if (diff < 0 || diff % 2 != 0) {
            return 0;
        }
        int neg = diff / 2;
        int[] dp = new int[neg + 1];
        dp[0] = 1;
        for (int num : nums) {
            for (int j = neg; j >= num; j--) {
                dp[j] += dp[j - num];
            }
        }
        return dp[neg];
    }
}

动态规划耗时2ms，击败100%，空间36.2MB，击败44.88%

回溯耗时600ms，击败31.92%，空间35.8MB，击败85.96%

可以看出动态规划是一种典型的空间换时间的算法，但收益还是挺高的

动态规划的核心就是两个

• 边界条件
• 状态转移方程

2、一和零问题——高维动态规划数组

题目描述如下

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

• 输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
• 输出：4
• 解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。
  其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

• 输入：strs = [“10”, “0”, “1”], m = 1, n = 1
• 输出：2
• 解释：最大的子集是 {“0”, “1”} ，所以答案是 2 。

提示：

• 1 <= strs.length <= 600
• 1 <= strs[i].length <= 100
• strs[i] 仅由 ‘0’ 和 ‘1’ 组成
• 1 <= m, n <= 100

2.1、三维动态数组

这道题不仅有0的限制而且有1的限制，因此要采用三维的动态规划数组来解决，给出代码如下

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int length = strs.length;

        //三维动态规划数组
        int[][][]dp = new int[length + 1][m + 1][n + 1];

        for (int i = 1; i <= length; i++) {
            int[] count = zerosOnes(strs[i - 1]);
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    //当前字符串能被添加进子集
                    if (count[0] <= j && count[1] <= k)
                        dp[i][j][k] = Math.max(dp[i - 1][j][k], 1 + dp[i - 1][j - count[0]][k - count[1]]);
                    //当前字符串不能被添加进子集
                    else 
                        dp[i][j][k] = dp[i - 1][j][k];
                }
            }
        }

        return dp[length][m][n];
    }

    //统计01数量的方法，返回值为数组，result[0]为0的个数，result[1]为1的个数
    public int[] zerosOnes(String str) {
        char[] arr = str.toCharArray();
        int[] result = new int[2];

        for (char c : arr) {
            if (c == '0')
                result[0] ++;
            else 
                result[1] ++;
        }   

        return result;
    }
}

2.2、滚动数组降维

同样的动态规划数组下一行的数值只与上一行有关，因此可以采用滚动数组的方式，去除一个维度的值，代码如下

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        
        int length = strs.length;

        //三维动态规划数组
        int[][]dp = new int[m + 1][n + 1];

        for (int i = 1; i <= length; i++) {
            int[] count = zerosOnes(strs[i - 1]);
            for (int j = m; j >=count[0]; j--) {
                for (int k = n; k >= count[1]; k--) {
                    dp[j][k] = Math.max(dp[j][k], 1 + dp[j - count[0]][k - count[1]]);
                }
            }
        }

        return dp[m][n];
    }

    //统计01数量的方法，返回值为数组，result[0]为0的个数，result[1]为1的个数
    public int[] zerosOnes(String str) {
        char[] arr = str.toCharArray();
        int[] result = new int[2];

        for (char c : arr) {
            if (c == '0')
                result[0] ++;
            else 
                result[1] ++;
        }   

        return result;
    }
}

• 时间复杂度：O(lmn+L)，其中 l是数组strs 的长度，m 和 n 分别是 0 和 1 的容量，L 是数组 strs 中的所有字符串的长度之和。
  动态规划需要计算的状态总数是 O(lmn)，每个状态的值需要 O(1)的时间计算。
  对于数组strs 中的每个字符串，都要遍历字符串得到其中的 0 和 1 的数量，因此需要 O(L) 的时间遍历所有的字符串。
  总时间复杂度是 O(lmn + L)。

• 空间复杂度：O(mn)，其中 m 和 n 分别是 0 和 1 的容量。使用空间优化的实现，需要创建 m+1行 n+1列的二维数组dp。

3、最后一块石头的重量

动态规划问题的核心在于两点

• 将问题转化为求和问题（无论是方案和还是值的和）
• 明确动态规划数组行的意义，即确定一个由上一行推导出下一行的形式
  题解写的还是很清楚的，这里贴出来
  
  给出代码如下

class Solution {
    public int lastStoneWeightII(int[] stones) {
        //求和
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }

        int m = sum / 2;
        int n = stones.length;

        //滚动数组降维
        boolean[] dp = new boolean[m + 1];
        dp[0] = true;

        for (int i = 1; i <= n; i++) {
            int stone = stones[i - 1];
            //倒序遍历保证每个传来的都是i - 1情况下的值 
            for (int j = m; j >= stone; j--) {
                dp[j] = dp[j] || dp[j - stone];
            }
        }

        for (int j = m; j >= 0; j--) {
            if (dp[j] == true)
                return sum - 2 * j;
        } 

        return 0;
    }
}

同样可以采用滚动数组降维，别忘了倒序

class Solution {
   public int lastStoneWeightII(int[] stones) {
       //求和
       int sum = 0;
       for (int stone : stones) {
           sum += stone;
       }

       int m = sum / 2;
       int n = stones.length;

       //二维动态规划数组
       boolean [][] dp = new boolean[n + 1][m + 1];

       dp[0][0] = true;

       for (int i = 1; i <= n; i++) {
           for (int j = 0; j <= m; j++) {
               if (stones[i - 1] > j)
                   dp[i][j] = dp[i - 1][j];
               else 
                   dp[i][j] = dp[i - 1][j] || dp[i - 1][j - stones[i - 1]];
           }
       }

       for (int j = m; j >= 0; j--) {
           if (dp[n][j] == true)
               return sum - 2 * j;
       }

       return 0;

   }
}