第9章动态规划基础

喜欢ヅ旅行 2022-04-11 12:15 154阅读 0赞

## 第9章 动态规划基础 ##

很多同学听到“动态规划”的名称可能会望而生畏，觉得动态规划的问题都很复杂。但其实，动态规划本质依然是递归算法，只不过是满足特定条件的递归算法。在这一章里，我们就来逐步解开动态规划的神秘面纱目录  
9-1 什么是动态规划  
9-2 第一个动态规划问题 Climbing Stairs  
9-3 发现重叠子问题 Integer Break  
9-4 状态的定义和状态转移 House Robber  
9-5 0-1背包问题  
9-6 0-1背包问题的优化和变种  
9-7 面试中的0-1背包问题 Partition Equal Subset Sum  
9-8 LIS问题 Longest Increasing Subsequence  
9-9 LCS，最短路，求动态规划的具体解以及更多

##    9-1 什么是动态规划 ##

记忆化搜索–自上而下的解决问题  
动态规划–自下而上的解决问题  
动态规划：将原问题拆解成若干子问题，同时保存子问题的答案，使得每个子问题只求解一次，最终获得原问题的答案。  
递归问题--------重叠子问题  
记忆化搜索--------自顶向下的解决问题  
动态规划--------自底向上的解决问题  
最优子结构：通过求子问题的最优解，可以获得原问题的最优解。  
递归问题--------重叠子问题 + 最优子结构  
记忆化搜索--------自顶向下的解决问题  
动态规划--------自底向上的解决问题  
题目: 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……  
特别指出：第0项是0，第1项是第一个1。  
这个数列从第三项开始，每一项都等于前两项之和。

// 递归求斐波那契数列
    public class Solution1 {
    
        private int num = 0;
    
        public int fib( int n ){
    
            num ++;
    
            if( n == 0 )
                return 0;
    
            if( n == 1 )
                return 1;
    
            return fib(n-1) + fib(n-2);
        }
    
        public int getNum(){
            return num;
        }
    
        public static void main(String[] args) {
    
            int n = 50;
    
            Solution1 solution = new Solution1();
            long startTime = System.currentTimeMillis();
            int res = solution.fib(n);
            long endTime = System.currentTimeMillis();        System.out.println("fib(" + n + ") = " + res);
            System.out.println("time : " + (endTime - startTime) + " ms");
            System.out.println("run function fib() " + solution.getNum() + " times.");
        }
    }

import java.util.Arrays;
    
    // 记忆化搜索
    public class Solution2 {
    
        private int num = 0;
    
        public int fib(int n){
    
            int[] memo = new int[n + 1];
            Arrays.fill(memo, -1);
            return fib(n, memo);
        }
    
        private int fib(int n, int[] memo){
    
            num ++;
    
            if(n == 0)
                return 0;
    
            if(n == 1)
                return 1;
    
            if(memo[n] == -1)
                memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
    
            return memo[n];
        }
    
        public int getNum(){
            return num;
        }
    
        public static void main(String[] args) {
    
            //int n = 42;
            int n = 42; // 注意: 我们使用n = 1000只是为了测试性能, 实际上会溢出
                          // 斐波那契额数列是以指数速度上涨的
    
            Solution2 solution = new Solution2();
            long startTime = System.currentTimeMillis();
            int res = solution.fib(n);
            long endTime = System.currentTimeMillis();        System.out.println("fib(" + n + ") = " + res);
            System.out.println("time : " + (endTime - startTime) + " ms");
            System.out.println("run function fib() " + solution.getNum() + " times.");
        }
    }

import java.util.Arrays;
    
    // 动态规划
    public class Solution3 {
    
        public int fib(int n){
    
            int[] memo = new int[n + 1];
            Arrays.fill(memo, -1);
    
            memo[0] = 0;
            memo[1] = 1;
            for(int i = 2 ; i <= n ; i ++)
                memo[i] = memo[i - 1] + memo[i - 2];
    
            return memo[n];
        }
    
        public static void main(String[] args) {
    
            //int n = 42;
            int n = 1000; // 注意: 我们使用n = 1000只是为了测试性能, 实际上会溢出
                          // 斐波那契额数列是以指数速度上涨的
    
            Solution3 solution = new Solution3();
            long startTime = System.currentTimeMillis();
            int res = solution.fib(n);
            long endTime = System.currentTimeMillis();
    
            System.out.println("fib(" + n + ") = " + res);
            System.out.println("time : " + (endTime - startTime) + " ms");
        }
    }

9-2 第一个动态规划问题 Climbing Stairs  
题目: LeetCode 70. 爬楼梯  
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2  
输出： 2  
解释： 有两种方法可以爬到楼顶。

1 阶 + 1 阶  
2 阶  
示例 2：  
输入： 3  
输出： 3  
解释： 有三种方法可以爬到楼顶。1 阶 + 1 阶 + 1 阶  
1 阶 + 2 阶  
2 阶 + 1 阶

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70][]

import java.util.Arrays;
    
    public class Solution1 {
    
        private int[] memo;
    
        public int climbStairs(int n) {
            memo = new int[n+1];
            Arrays.fill(memo, -1);
            return calcWays(n);
        }
    
        private int calcWays(int n){
    
            if(n == 0 || n == 1)
                return 1;
    
            if(memo[n] == -1)
                memo[n] = calcWays(n - 1) + calcWays(n - 2);
    
            return memo[n];
        }
    
        public static void main(String[] args) {        System.out.println((new Solution1()).climbStairs(10));
        }

/// 70. Climbing Stairs
    /// https://leetcode.com/problems/climbing-stairs/description/
    /// 动态规划
    /// 时间复杂度: O(n)
    /// 空间复杂度: O(n)
    public class Solution2 {
    
        public int climbStairs(int n) {
    
            int[] memo = new int[n + 1];
            memo[0] = 1;
            memo[1] = 1;
            for(int i = 2 ; i <= n ; i ++)
                memo[i] = memo[i - 1] + memo[i - 2];
            return memo[n];
        }
    
        public static void main(String[] args) {
    
            System.out.println((new Solution2()).climbStairs(10));
        }
    }

课后作业: LeetCode 120、64  
9-3 发现重叠子问题 Integer Break  
题目: LeetCode 343. 整数拆分  
给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

示例 1:

输入: 2  
输出: 1  
解释: 2 = 1 + 1, 1 × 1 = 1。  
示例 2:

输入: 10  
输出: 36  
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。  
说明: 你可以假设 n 不小于 2 且不大于 58。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 1][]

/// 343. Integer Break
    /// https://leetcode.com/problems/integer-break/description/
    /// 暴力搜索
    /// 在Leetcode中提交这个版本的代码会超时! (Time Limit Exceeded)
    /// 时间复杂度: O(n^n)
    /// 空间复杂度: O(n)
    public class Solution1 {
    
        public int integerBreak(int n) {
    
            if(n < 1)
                throw new IllegalArgumentException("n should be greater than zero");
    
            return breakInteger(n);
        }
    
        // 将n进行分割(至少分割两部分), 可以获得的最大乘积
        private int breakInteger(int n){
    
            if(n == 1)
                return 1;
    
            int res = -1;
            for(int i = 1 ; i <= n - 1 ; i ++)
                res = max3(res, i * (n - i), i * breakInteger(n - i));
            return res;
        }
    
        private int max3(int a, int b, int c){
            return Math.max(a, Math.max(b, c));
        }
    
        public static void main(String[] args) {        System.out.println((new Solution1()).integerBreak(2));
            System.out.println((new Solution1()).integerBreak(10));
        }
    }

import java.util.Arrays;
    
    /// 343. Integer Break
    /// https://leetcode.com/problems/integer-break/description/
    /// 记忆化搜索
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution2 {
    
        private int[] memo;
    
        public int integerBreak(int n) {
    
            if(n < 1)
                throw new IllegalArgumentException("n should be greater than zero");
    
            memo = new int[n+1];
            Arrays.fill(memo, -1);
    
            return breakInteger(n);
        }
    
        // 将n进行分割(至少分割两部分), 可以获得的最大乘积
        private int breakInteger(int n){
    
            if(n == 1)
                return 1;
    
            if(memo[n] != -1)
                return memo[n];
    
            int res = -1;
            for(int i = 1 ; i <= n - 1 ; i ++)
                res = max3(res, i * (n - i) , i * breakInteger(n - i));
            memo[n] = res;
            return res;
        }
    
        private int max3(int a, int b, int c){
            return Math.max(a, Math.max(b, c));
        }
    
        public static void main(String[] args) {        System.out.println((new Solution2()).integerBreak(2));
            System.out.println((new Solution2()).integerBreak(10));
        }
    }

/// 343. Integer Break
    /// https://leetcode.com/problems/integer-break/description/
    /// 动态规划
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution3 {
    
        public int integerBreak(int n) {
    
            if(n < 1)
                throw new IllegalArgumentException("n should be greater than zero");
    
            int[] memo = new int[n+1];
            memo[1] = 1;
            for(int i = 2 ; i <= n ; i ++)
                // 求解memo[i]
                for(int j = 1 ; j <= i - 1 ; j ++)
                    memo[i] = max3(memo[i], j * (i - j), j * memo[i - j]);
    
            return memo[n];
        }
    
        private int max3(int a, int b, int c){
            return Math.max(a, Math.max(b, c));
        }
    
        public static void main(String[] args) {
    
            System.out.println((new Solution3()).integerBreak(2));
            System.out.println((new Solution3()).integerBreak(10));
        }
    }

课后作业: LeetCode 279、91、62、63  
9-4 状态的定义和状态转移 House Robber  
题目: LeetCode 198. 打家劫舍  
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:

输入: \[1,2,3,1\]  
输出: 4  
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。  
偷窃到的最高金额 = 1 + 3 = 4 。  
示例 2:

输入: \[2,7,9,3,1\]  
输出: 12  
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。  
偷窃到的最高金额 = 2 + 9 + 1 = 12 。其中对“状态”的定义：考虑偷取\[x, n-1\]范围里的房子（函数的定义）。  
根据对状态的定义，决定状态的转移：  
f(0) = max\{v(0) + f(2), v(1) + f(3), v(2) + f(4), …, v(n-3) + f(n-1), v(n-2) , v(n-1) \}  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 2][]

import java.util.Arrays;
    
    /// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 记忆化搜索
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution1 {
    
        // memo[i] 表示考虑抢劫 nums[i...n) 所能获得的最大收益
        private int[] memo;
    
        public int rob(int[] nums) {
            memo = new int[nums.length];
            Arrays.fill(memo, -1);
            return tryRob(nums, 0);
        }
    
        // 考虑抢劫nums[index...nums.size())这个范围的所有房子
        private int tryRob(int[] nums, int index){
    
            if(index >= nums.length)
                return 0;
    
            if(memo[index] != -1)
                return memo[index];
    
            int res = 0;
            for(int i = index ; i < nums.length ; i ++)
                res = Math.max(res, nums[i] + tryRob(nums, i + 2));
            memo[index] = res;
            return res;
        }
    
        public static void main(String[] args) {
    
            int nums[] = {2, 1};
            System.out.println((new Solution1()).rob(nums));
        }

import java.util.Arrays;
    
    /// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 动态规划
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution2 {
    
        public int rob(int[] nums) {
    
            int n = nums.length;
            if(n == 0)
                return 0;
    
            // memo[i] 表示考虑抢劫 nums[i...n) 所能获得的最大收益
            int[] memo = new int[nums.length];
            memo[n - 1] = nums[n - 1];
            for(int i = n - 2 ; i >= 0 ; i --)
                for (int j = i; j < n; j++)
                    memo[i] = Math.max( memo[i],
                                        nums[j] + (j + 2 < n ? memo[j + 2] : 0));
    
            return memo[0];
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution2()).rob(nums));
        }
    }

import java.util.Arrays;
    
    /// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 记忆化搜索, 改变状态定义
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution3 {
    
        // memo[i] 表示考虑抢劫 nums[0...i] 所能获得的最大收益
        private int[] memo;
    
        public int rob(int[] nums) {
            memo = new int[nums.length];
            Arrays.fill(memo, -1);
            return tryRob(nums, nums.length - 1);
        }
    
        // 考虑抢劫nums[0...index]这个范围的所有房子
        private int tryRob(int[] nums, int index){
    
            if(index < 0)
                return 0;
    
            if(memo[index] != -1)
                return memo[index];
    
            int res = 0;
            for(int i = 0 ; i <= index ; i ++)
                res = Math.max(res, nums[i] + tryRob(nums, i - 2));
            memo[index] = res;
            return res;
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution3()).rob(nums));
        }
    }

/// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 动态规划, 改变状态定义
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution4 {
    
        public int rob(int[] nums) {
    
            int n = nums.length;
            if(n == 0)
                return 0;
    
            // memo[i] 表示考虑抢劫 nums[0...i] 所能获得的最大收益
            int[] memo = new int[nums.length];
            memo[0] = nums[0];
            for(int i = 1 ; i < n ; i ++)
                for (int j = i; j >= 0; j--)
                    memo[i] = Math.max(memo[i],
                                       nums[j] + (j - 2 >= 0 ? memo[j - 2] : 0));
    
            return memo[n-1];
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution4()).rob(nums));
        }
    }

import java.util.Arrays;
    
    /// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 记忆化搜索, 优化状态转移
    /// 时间复杂度: O(n)
    /// 空间复杂度: O(n)
    public class Solution5 {
    
        // memo[i] 表示考虑抢劫 nums[i...n) 所能获得的最大收益
        private int[] memo;
    
        public int rob(int[] nums) {
            memo = new int[nums.length];
            Arrays.fill(memo, -1);
            return tryRob(nums, 0);
        }
    
        // 考虑抢劫nums[index...nums.size())这个范围的所有房子
        private int tryRob(int[] nums, int index){
    
            if(index >= nums.length)
                return 0;
    
            if(memo[index] != -1)
                return memo[index];
    
            // 或者当前房子放弃, 从下一个房子开始考虑
            // 或者抢劫当前的房子, 从i+2以后的房子开始考虑
            return memo[index] =
                    Math.max(tryRob(nums, index + 1),
                             nums[index] + tryRob(nums, index + 2));
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution5()).rob(nums));
        }
    }

import java.util.Arrays;
    
    /// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 动态规划, 优化状态转移
    /// 时间复杂度: O(n)
    /// 空间复杂度: O(n)
    public class Solution6 {
    
        public int rob(int[] nums) {
    
            int n = nums.length;
            if(n == 0)
                return 0;
    
            // memo[i] 表示考虑抢劫 nums[i...n) 所能获得的最大收益
            int[] memo = new int[nums.length];
            memo[n - 1] = nums[n - 1];
            for(int i = n - 2 ; i >= 0 ; i --)
                // 或者当前房子放弃, 从下一个房子开始考虑
                // 或者抢劫当前的房子, 从i+2以后的房子开始考虑
                memo[i] = Math.max(memo[i + 1],
                                   nums[i] + (i + 2 < n ? memo[i + 2] : 0));
    
            return memo[0];
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution6()).rob(nums));
        }
    }

import java.util.Arrays;
    
    /// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 记忆化搜索, 改变状态定义, 优化转移方程
    /// 时间复杂度: O(n)
    /// 空间复杂度: O(n)
    public class Solution7 {
    
        // memo[i] 表示考虑抢劫 nums[0...i] 所能获得的最大收益
        private int[] memo;
    
        public int rob(int[] nums) {
            memo = new int[nums.length];
            Arrays.fill(memo, -1);
            return tryRob(nums, nums.length - 1);
        }
    
        // 考虑抢劫nums[0...index]这个范围的所有房子
        private int tryRob(int[] nums, int index){
    
            if(index < 0)
                return 0;
    
            if(memo[index] != -1)
                return memo[index];
    
            // 或者当前房子放弃, 考虑[0...index-1]的所有房子
            // 或者抢劫当前的房子, 考虑[0...index-2]的所有房子
            return memo[index] =
                    Math.max(tryRob(nums, index - 1),
                             nums[index] + tryRob(nums, index - 2));
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution7()).rob(nums));
        }
    }

/// 198. House Robber
    /// https://leetcode.com/problems/house-robber/description/
    /// 动态规划, 改变状态定义, 优化转移方程
    /// 时间复杂度: O(n)
    /// 空间复杂度: O(n)
    public class Solution8 {
    
        public int rob(int[] nums) {
    
            int n = nums.length;
            if(n == 0)
                return 0;
    
            // memo[i] 表示考虑抢劫 nums[0...i] 所能获得的最大收益
            int[] memo = new int[nums.length];
            memo[0] = nums[0];
            for(int i = 1 ; i < n ; i ++)
                memo[i] = Math.max(memo[i - 1],
                                   nums[i] + (i - 2 >= 0 ? memo[i - 2] : 0));
    
            return memo[n-1];
        }
    
        public static void main(String[] args) {        int nums[] = {2, 1};
            System.out.println((new Solution8()).rob(nums));
        }
    }

课后作业: LeetCode 213、337、309

9-5 0-1背包问题  
题目: 有一个背包，它的容量为c(Capacity)。现在有n种不同的物品，编号为0…,n-1，其中每一件物品的重量为w(i)，价值为v(i)。  
问可以向这个背包中盛放哪些物品，使得在不超过背包容量的基础上，物品的总价值最大。  
其中对“状态”的定义：F(i, c)考虑将n个物品放入容量为c的背包，使得价值最大。  
根据对状态的定义，决定状态的转移：

F(i,c)=F(i-1,c)

=v(i)+F(i-1,c-w(i))

F(i, c) = max\{F(i-1, c), v(i) + F(i-1, c - w(i))\}

测试数据

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 3][]

![20181206193928403.png][]

/// 背包问题
    /// 记忆化搜索
    /// 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
    /// 空间复杂度: O(n * C)
    public class Solution1 {
    
        private int[][] memo;
    
        public int knapsack01(int[] w, int[] v, int C){
    
            if(w == null || v == null || w.length != v.length)
                throw new IllegalArgumentException("Invalid w or v");
    
            if(C < 0)
                throw new IllegalArgumentException("C must be greater or equal to zero.");
    
            int n = w.length;
            if(n == 0 || C == 0)
                return 0;
    
            memo = new int[n][C + 1];
            return bestValue(w, v, n - 1, C);
        }
    
        // 用 [0...index]的物品,填充容积为c的背包的最大价值
        private int bestValue(int[] w, int[] v, int index, int c){
    
            if(c <= 0 || index < 0)
                return 0;
    
            if(memo[index][c] != -1)
                return memo[index][c];
    
            int res = bestValue(w, v, index-1, c);
            if(c >= w[index])
                res = Math.max(res, v[index] + bestValue(w, v, index - 1, c - w[index]));
    
            return memo[index][c] = res;
        }
    
        public static void main(String[] args) {
    
        }
    
    }

/// 背包问题
    /// 动态规划
    /// 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
    /// 空间复杂度: O(n * C)
    public class Solution2 {
    
        public int knapsack01(int[] w, int[] v, int C){
    
            if(w == null || v == null || w.length != v.length)
                throw new IllegalArgumentException("Invalid w or v");
    
            if(C < 0)
                throw new IllegalArgumentException("C must be greater or equal to zero.");
    
            int n = w.length;
            if(n == 0 || C == 0)
                return 0;
    
            int[][] memo = new int[n][C + 1];
    
            for(int j = 0 ; j <= C ; j ++)
                memo[0][j] = (j >= w[0] ? v[0] : 0 );
    
            for(int i = 1 ; i < n ; i ++)
                for(int j = 0 ; j <= C ; j ++){
                    memo[i][j] = memo[i-1][j];
                    if(j >= w[i])
                        memo[i][j] = Math.max(memo[i][j], v[i] + memo[i - 1][j - w[i]]);
                }
    
            return memo[n - 1][C];
        }
    
        public static void main(String[] args) {    }
    }

9-6 0-1背包问题的优化和变种  
优化：跟进分析会发现，第i行元素只依赖于第i-1行元素，理论上，只需要保持两行元素。

/// 背包问题
    /// 动态规划改进: 滚动数组
    /// 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
    /// 空间复杂度: O(C), 实际使用了2*C的额外空间
    public class Solution1 {
    
        public int knapsack01(int[] w, int[] v, int C){
    
            if(w == null || v == null || w.length != v.length)
                throw new IllegalArgumentException("Invalid w or v");
    
            if(C < 0)
                throw new IllegalArgumentException("C must be greater or equal to zero.");
    
            int n = w.length;
            if(n == 0 || C == 0)
                return 0;
    
            int[][] memo = new int[2][C + 1];
    
            for(int j = 0 ; j <= C ; j ++)
                memo[0][j] = (j >= w[0] ? v[0] : 0);
    
            for(int i = 1 ; i < n ; i ++)
                for(int j = 0 ; j <= C ; j ++){
                    memo[i % 2][j] = memo[(i-1) % 2][j];
                    if(j >= w[i])
                        memo[i % 2][j] = Math.max(memo[i % 2][j], v[i] + memo[(i-1) % 2][j - w[i]]);
                }
    
            return memo[(n-1) % 2][C];
        }
    
        public static void main(String[] args) {    }
    }

/// 背包问题
    /// 动态规划改进
    /// 时间复杂度: O(n * C) 其中n为物品个数; C为背包容积
    /// 空间复杂度: O(C), 只使用了C的额外空间
    public class Solution2 {
    
        public int knapsack01(int[] w, int[] v, int C){
    
            if(w == null || v == null || w.length != v.length)
                throw new IllegalArgumentException("Invalid w or v");
    
            if(C < 0)
                throw new IllegalArgumentException("C must be greater or equal to zero.");
    
            int n = w.length;
            if(n == 0 || C == 0)
                return 0;
    
            int[] memo = new int[C+1];
    
            for(int j = 0 ; j <= C ; j ++)
                memo[j] = (j >= w[0] ? v[0] : 0);
    
            for(int i = 1 ; i < n ; i ++)
                for(int j = C ; j >= w[i] ; j --)
                    memo[j] = Math.max(memo[j], v[i] + memo[j - w[i]]);
    
            return memo[C];
        }
    
        public static void main(String[] args) {
    
        }
    }

0-1背包问题更多变种  
完全背包问题：每个物品可以无限使用  
多重背包问题：每个物品不止1个，有num\[i\]个  
多维费用背包问题：要考虑物品的体积和重量两个维度  
物品间加入更多约束：物品间可以互相排斥、也可以相互依赖

9-7 面试中的0-1背包问题 Partition Equal Subset Sum  
题目: LeetCode 416. 分割等和子集  
给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

注意:

每个数组中的元素不会超过 100  
数组的大小不会超过 200  
示例 1:

输入: \[1, 5, 11, 5\]

输出: true

解释: 数组可以分割成 \[1, 5, 5\] 和 \[11\].

示例 2:

输入: \[1, 2, 3, 5\]

输出: false

解释: 数组不能分割成两个元素和相等的子集.典型的背包问题，在n个物品中选出一定物品，填满sum/2的背包。  
其中对“状态”的定义：F(n, c)考虑将n个物品填满容量为c的背包。  
根据对状态的定义，决定状态的转移：  
F(i, c) = F(i - 1, c) || F(i-1, c - w(i))

import java.util.Arrays;
    
    /// 416. Partition Equal Subset Sum
    /// https://leetcode.com/problems/partition-equal-subset-sum/description/
    /// 记忆化搜索
    /// 时间复杂度: O(len(nums) * O(sum(nums)))
    /// 空间复杂度: O(len(nums) * O(sum(nums)))
    public class Solution1 {
    
        // memo[i][c] 表示使用索引为[0...i]的这些元素,是否可以完全填充一个容量为c的背包
        // -1 表示为未计算; 0 表示不可以填充; 1 表示可以填充
        private int[][] memo;
    
        public boolean canPartition(int[] nums) {
    
            int sum = 0;
            for(int i = 0 ; i < nums.length ; i ++){
                if(nums[i] <= 0)
                    throw new IllegalArgumentException("numbers in nums must be greater than zero.");
                sum += nums[i];
            }
    
            if(sum % 2 == 1)
                return false;
    
            memo = new int[nums.length][sum / 2 + 1];
            for(int i = 0 ; i < nums.length ; i ++)
                Arrays.fill(memo[i], -1);
            return tryPartition(nums, nums.length - 1, sum / 2);
        }
    
        // 使用nums[0...index], 是否可以完全填充一个容量为sum的背包
        private boolean tryPartition(int[] nums, int index, int sum){
    
            if(sum == 0)
                return true;
    
            if(sum < 0 || index < 0)
                return false;
    
            if(memo[index][sum] != -1)
                return memo[index][sum] == 1;
    
            memo[index][sum] = (tryPartition(nums, index - 1, sum) ||
                    tryPartition(nums, index - 1, sum - nums[index])) ? 1 : 0;
    
            return memo[index][sum] == 1;
        }
    
        private static void printBool(boolean res){
            System.out.println(res ? "True" : "False");
        }
    
        public static void main(String[] args) {
    
            int[] nums1 = {1, 5, 11, 5};
            printBool((new Solution1()).canPartition(nums1));        int[] nums2 = {1, 2, 3, 5};
            printBool((new Solution1()).canPartition(nums2));
        }
    }

import java.util.Arrays;
    
    /// 416. Partition Equal Subset Sum
    /// https://leetcode.com/problems/partition-equal-subset-sum/description/
    /// 动态规划
    /// 时间复杂度: O(len(nums) * O(sum(nums)))
    /// 空间复杂度: O(len(nums) * O(sum(nums)))
    public class Solution2 {
    
        public boolean canPartition(int[] nums) {
    
            int sum = 0;
            for(int i = 0 ; i < nums.length ; i ++){
                if(nums[i] <= 0)
                    throw new IllegalArgumentException("numbers in nums must be greater than zero.");
                sum += nums[i];
            }
    
            if(sum % 2 == 1)
                return false;
    
            int n = nums.length;
            int C = sum / 2;
    
            boolean[] memo = new boolean[C + 1];
            for(int i = 0 ; i <= C ; i ++)
                memo[i] = (nums[0] == i);
    
            for(int i = 1 ; i < n ; i ++)
                for(int j = C; j >= nums[i] ; j --)
                    memo[j] = memo[j] || memo[j - nums[i]];
    
            return memo[C];
        }
    
        private static void printBool(boolean res){
            System.out.println(res ? "True" : "False");
        }
    
        public static void main(String[] args) {
    
            int[] nums1 = {1, 5, 11, 5};
            printBool((new Solution2()).canPartition(nums1));
    
            int[] nums2 = {1, 2, 3, 5};
            printBool((new Solution2()).canPartition(nums2));
        }
    }

课后作业: LeetCode 322、377、474、139、494

9-8 LIS问题 Longest Increasing Subsequence  
题目: LeetCode 300. 最长上升子序列  
给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: \[10,9,2,5,3,7,101,18\]  
输出: 4  
解释: 最长的上升子序列是 \[2,3,7,101\]，它的长度是 4。  
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。  
你算法的时间复杂度应该为 O(n2) 。  
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?暴力解法：选择所有的子序列进行判断。  
动态规划：  
其中对“状态”的定义：LIS(i)表示以第i个数字为结尾的最长上升子序列的长度。即LIS(i)表示\[0,…,i\]的范围内，选择数字nums\[i\]可以获得的最长上升子序列的长度。  
根据对状态的定义，决定状态的转移：  
LIS(i) = 当(j < i)时，max\{1 + LIS(j) if nums\[i\] > nums\[j\]\}

import java.util.Arrays;
    
    /// 300. Longest Increasing Subsequence
    /// https://leetcode.com/problems/longest-increasing-subsequence/description/
    /// 记忆化搜索
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution1 {
    
        private int[] memo;
    
        public int lengthOfLIS(int[] nums) {
    
            if(nums.length == 0)
                return 0;
    
            memo = new int[nums.length];
            Arrays.fill(memo, -1);
            int res = 1;
            for(int i = 0 ; i < nums.length ; i ++)
                res = Math.max(res, getMaxLength(nums, i));
    
            return res;
        }
    
        // 以 nums[index] 为结尾的最长上升子序列的长度
        private int getMaxLength(int[] nums, int index){
    
            if(memo[index] != -1)
                return memo[index];
    
            int res = 1;
            for(int i = 0 ; i <= index-1 ; i ++)
                if(nums[index] > nums[i])
                    res = Math.max(res, 1 + getMaxLength(nums, i));
    
            return memo[index] = res;
        }
    
        public static void main(String[] args) {
    
            int nums1[] = {10, 9, 2, 5, 3, 7, 101, 18};
            System.out.println((new Solution1()).lengthOfLIS(nums1));
            // 4
    
            // ---
    
            int nums2[] = {4, 10, 4, 3, 8, 9};
            System.out.println((new Solution1()).lengthOfLIS(nums2));
            // 3
    
            // ---
    
            int nums3[] = {2, 2};
            System.out.println((new Solution1()).lengthOfLIS(nums3));
            // 1
    
            // ---        int nums4[] = {1, 3, 6, 7, 9, 4, 10, 5, 6};
            System.out.println((new Solution1()).lengthOfLIS(nums4));
            // 6
        }
    }

import java.util.Arrays;
    
    /// 300. Longest Increasing Subsequence
    /// https://leetcode.com/problems/longest-increasing-subsequence/description/
    /// 记忆化搜索
    /// 时间复杂度: O(n^2)
    /// 空间复杂度: O(n)
    public class Solution2 {
    
        public int lengthOfLIS(int[] nums) {
    
            if(nums.length == 0)
                return 0;
    
            // memo[i] 表示以 nums[i] 为结尾的最长上升子序列的长度
            int memo[] = new int[nums.length];
            Arrays.fill(memo, 1);
            for(int i = 1 ; i < nums.length ; i ++)
                for(int j = 0 ; j < i ; j ++)
                    if(nums[i] > nums[j])
                        memo[i] = Math.max(memo[i], 1 + memo[j]);
    
            int res = memo[0];
            for(int i = 1 ; i < nums.length ; i ++)
                res = Math.max(res, memo[i]);
    
            return res;
        }
    
        public static void main(String[] args) {
    
            int nums1[] = {10, 9, 2, 5, 3, 7, 101, 18};
            System.out.println((new Solution2()).lengthOfLIS(nums1));
            // 4
    
            // ---
    
            int nums2[] = {4, 10, 4, 3, 8, 9};
            System.out.println((new Solution2()).lengthOfLIS(nums2));
            // 3
    
            // ---
    
            int nums3[] = {2, 2};
            System.out.println((new Solution2()).lengthOfLIS(nums3));
            // 1
    
            // ---
    
            int nums4[] = {1, 3, 6, 7, 9, 4, 10, 5, 6};
            System.out.println((new Solution2()).lengthOfLIS(nums4));
            // 6
        }
    }

课后作业: LeetCode 376  
9-9 LCS，最短路，求动态规划的具体解以及更多  
题目: LCS （最长公共子序列）。LCS是Longest Common Subsequence的缩写，即最长公共子序列。一个序列，如果是两个或多个已知序列的子序列，且是所有子序列中最长的，则为最长公共子序列。  
比如，对于char x\[\]=“aabcd”;有顺序且相互相邻的aabc是其子序列，有顺序但是不相邻的abc也是其公共子序列。即，只要得出序列中各个元素属于所给出的数列，就是子序列。  
再加上char y\[\]=“12abcabcd”;对比出才可以得出最长公共子序列abcd。  
动态规划：  
其中对“状态”的定义：LCS(m, n)表示s1\[0,…,m\]和s2\[0,…,n\]的最长公共子序列的长度。  
根据对状态的定义，决定状态的转移：  
s1\[m\] == s2\[n\]: LCS(m, n) = 1 + LCS(m - 1, n - 1)  
s1\[m\] != s2\[n\]: LCS(m, n) = max\{LCS(m - 1, n), LCS(m, n - 1)\}  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 4][]

import java.util.Arrays;
    
    /// LCS问题
    /// 动态规划
    /// 时间复杂度: O(len(s1)*len(s2))
    /// 空间复杂度: O(len(s1)*len(s2))
    public class LCS1 {
    
        private int[][] memo;
    
        public String lcs(String s1, String s2){
    
            if(s1 == null || s2 == null)
                throw new IllegalArgumentException("s1 and s2 can not be null.");
    
            if(s1.length() == 0 || s2.length() == 0)
                return "";
    
            memo = new int[s1.length()][s2.length()];
            for(int i = 0 ; i < s1.length() ; i ++)
                Arrays.fill(memo[i], -1);
    
            lcs(s1, s2, s1.length() - 1, s2.length() - 1);
            return getLCS(s1, s2);
        }
    
        // 求s1[0...m]和s2[0...n]的最长公共子序列的长度值
        private int lcs(String s1, String s2, int m, int n){
    
            if(m < 0 || n < 0)
                return 0;
    
            if(memo[m][n] != -1)
                return memo[m][n];
    
            int res = 0;
            if(s1.charAt(m) == s2.charAt(n))
                res = 1 + lcs(s1, s2, m - 1, n - 1);
            else
                res = Math.max(lcs(s1, s2, m - 1, n),
                               lcs(s1, s2, m, n - 1));
    
            memo[m][n] = res;
            return res;
        }
    
        // 通过memo反向求解s1和s2的最长公共子序列
        private String getLCS(String s1, String s2){
    
            int m = s1.length() - 1;
            int n = s2.length() - 1;
    
            StringBuilder res = new StringBuilder("");
            while(m >= 0 && n >= 0)
                if(s1.charAt(m) == s2.charAt(n)){
                    res = res.insert(0, s1.charAt(m));
                    m --;
                    n --;
                }
                else if(m == 0)
                    n --;
                else if(n == 0)
                    m --;
                else{
                    if(memo[m-1][n] > memo[m][n-1])
                        m --;
                    else
                        n --;
                }
    
            return res.toString();
        }
    
        public static void main(String[] args) {
    
            String s1 = "ABCDGH";
            String s2 = "AEDFHR";
            System.out.println((new LCS1()).lcs(s1, s2));        s1 = "AAACCGTGAGTTATTCGTTCTAGAA";
            s2 = "CACCCCTAAGGTACCTTTGGTTC";
            System.out.println((new LCS1()).lcs(s1, s2));
        }
    }

/// LCS问题
    /// 动态规划
    /// 时间复杂度: O(len(s1)*len(s2))
    /// 空间复杂度: O(len(s1)*len(s2))
    public class LCS2 {
    
        public String lcs(String s1, String s2){
    
            int m = s1.length();
            int n = s2.length();
    
            // 对memo的第0行和第0列进行初始化
            int[][] memo = new int[m][n];
            for(int j = 0 ; j < n ; j ++)
                if(s1.charAt(0) == s2.charAt(j)){
                    for(int k = j ; k < n ; k ++)
                        memo[0][k] = 1;
                    break;
                }
    
            for(int i = 0 ; i < m ; i ++)
                if(s1.charAt(i) == s2.charAt(0)) {
                    for(int k = i ; k < m ; k ++)
                        memo[k][0] = 1;
                    break;
                }
    
            // 动态规划的过程
            for(int i = 1 ; i < m ; i ++)
                for(int j = 1 ; j < n ; j ++)
                    if(s1.charAt(i) == s2.charAt(j))
                        memo[i][j] = 1 + memo[i-1][j-1];
                    else
                        memo[i][j] = Math.max(memo[i-1][j], memo[i][j-1]);
    
            // 通过memo反向求解s1和s2的最长公共子序列
            m = s1.length() - 1;
            n = s2.length() - 1;
            StringBuilder res = new StringBuilder("");
            while(m >= 0 && n >= 0)
                if(s1.charAt(m) == s2.charAt(n)){
                    res.insert(0, s1.charAt(m));
                    m --;
                    n --;
                }
                else if(m == 0)
                    n --;
                else if(n == 0)
                    m --;
                else{
                    if(memo[m-1][n] > memo[m][n-1])
                        m --;
                    else
                        n --;
                }
    
            return res.toString();
        }
    
        public static void main(String[] args) {
    
            String s1 = "ABCDGH";
            String s2 = "AEDFHR";
            System.out.println((new LCS2()).lcs(s1, s2));
    
            s1 = "AAACCGTGAGTTATTCGTTCTAGAA";
            s2 = "CACCCCTAAGGTACCTTTGGTTC";
            System.out.println((new LCS2()).lcs(s1, s2));
        }
    }

/// LCS问题
    /// 动态规划, 躲避边界条件
    /// 时间复杂度: O(len(s1)*len(s2))
    /// 空间复杂度: O(len(s1)*len(s2))
    public class LCS3 {
    
        public String lcs(String s1, String s2){
    
            int m = s1.length();
            int n = s2.length();
    
            // memo 是 (m + 1) * (n + 1) 的动态规划表格
            // memo[i][j] 表示s1的前i个字符和s2前j个字符的最长公共子序列的长度
            // 其中memo[0][j] 表示s1取空字符串时, 和s2的前j个字符作比较
            // memo[i][0] 表示s2取空字符串时, 和s1的前i个字符作比较
            // 所以, memo[0][j] 和 memo[i][0] 均取0
            // 我们不需要对memo进行单独的边界条件处理 :-)
            int[][] memo = new int[m + 1][n + 1];
    
            // 动态规划的过程
            // 注意, 由于动态规划状态的转变, 下面的i和j可以取到m和n
            for(int i = 1 ; i <= m ; i ++)
                for(int j = 1 ; j <= n ; j ++)
                    if(s1.charAt(i - 1) == s2.charAt(j - 1))
                        memo[i][j] = 1 + memo[i - 1][j - 1];
                    else
                        memo[i][j] = Math.max(memo[i - 1][j], memo[i][j - 1]);
    
            // 通过memo反向求解s1和s2的最长公共子序列
            m = s1.length();
            n = s2.length();
            StringBuilder res = new StringBuilder("");
            while(m > 0 && n > 0)
                if(s1.charAt(m - 1) == s2.charAt(n - 1)){
                    res.insert(0, s1.charAt(m - 1));
                    m --;
                    n --;
                }
                else if(memo[m - 1][n] > memo[m][n - 1])
                    m --;
                else
                    n --;
    
            return res.toString();
        }
    
        public static void main(String[] args) {
    
            String s1 = "ABCDGH";
            String s2 = "AEDFHR";
            System.out.println((new LCS3()).lcs(s1, s2));
    
            s1 = "AAACCGTGAGTTATTCGTTCTAGAA";
            s2 = "CACCCCTAAGGTACCTTTGGTTC";
            System.out.println((new LCS3()).lcs(s1, s2));
        }
    }

dijkstra单源最短路径算法也是动态规划问题：  
其中对“状态”的定义：shortestPath(i)表示从start到i的最短路径长度。  
根据对状态的定义，决定状态的转移：  
shortestPath(x) = min\{shortestPath(a) + w(a -> x)\}  
动态规划问题的具体解  
LeetCode 300. Longest Increasing Subsequence的具体解  
0-1背包问题的具体解

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70]: /images/20220411/7fe06c2338cd4a06bbc1d24c8d7df68d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 1]: /images/20220411/4ba003eb3b494df4b0853e993fa210a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 2]: /images/20220411/16babf5cb42c4c5d8374819a6e7b35e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 3]: /images/20220411/988f8aa753964577bb96291c80333fbd.png
[20181206193928403.png]: /images/20220411/30633dc6c885442d998c14d41c728663.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzk0ODkx_size_16_color_FFFFFF_t_70 4]: /images/20220411/3eaa19d65ac94f7e9940dded9cb938e8.png