动态规划问题

1.什么是动态规划？

• 动态规划（Dynamic Programming）是运筹学的一个分支，是求解决策过程最优化的过程。

• 动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。

• 动态规划常常适用于有重叠子问题和最优子结构性质的问题。

上述概念源自百度百科

2.动态规划核心思想

• 拆分子问题

• 备忘录，减少重复计算

下面以一个具体案例来理解动态规划的核心思想：

3.爬楼梯问题

题目描述：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例2：

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

3.1划分子问题

解题思想：

本问题其实常规解法可以分成多个子问题，爬第n阶楼梯的方法数量，等于 2 部分之和
爬上 n-1n−1 阶楼梯的方法数量。因为再爬1阶就能到第n阶
爬上 n-2n−2 阶楼梯的方法数量，因为再爬2阶就能到第n阶
于是可以得到以下公式：
f（10） = f（9）+f(8) f (9) = f(8) + f(7) f (8) = f(7) + f(6) ... f(3) = f(2) + f(1) 即通用公式为: f(n) = f(n-1) + f(n-2)

但是此时如果直接使用for循环去求解的话，你会发现超出时间限制

你会发现：

• 要计算原问题 f(10)，就需要先计算出子问题 f(9) 和 f(8)

• 然后要计算 f(9)，又要先算出子问题 f(8) 和 f(7)，以此类推。

• 一直到 f(2) 和 f(1），递归树才终止。

递归时间复杂度 = 解决一个子问题时间*子问题个数

• 一个子问题时间 = f（n-1）+f（n-2），也就是一个加法的操作，所以复杂度是 O(1)；

• 问题个数 = 递归树节点的总数，递归树的总节点 = 2^n-1，所以是复杂度O(2^n)。

因此，我们要考虑如何把已经计算过的值存储到备忘录中，以降低时间复杂度

代码来喽：

class Solution {public int climbStairs(int n) {if(n<=2){return n;}int i1 = 1;int i2 = 2;for(int i=3;i<=n;i++){int temp = i1+i2;i1 = i2;i2 = temp;}return i2;}
}

3.2自底向上的动态规划

动态规划跟带备忘录的递归解法基本思想是一致的，都是减少重复计算，时间复杂度相差不大：

典型特征：

• 最优子结构

动态规划问题，其实就是一个递推问题。假设当前决策结果是f(n),则最优子结构就是要让 f(n-k) 最优,最优子结构性质就是能让转移到n的状态是最优的,并且与后面的决策没有关系,即让后面的决策安心地使用前面的局部最优解的一种性质.

• 状态转移方程

• 边界

• 重叠子问题

爬楼梯问题中：

• f(n-1)和f(n-2) 称为 f(n) 的最优子结构

• f(n)= f（n-1）+f（n-2）就称为状态转移方程

• f(1) = 1, f(2) = 2 就是边界啦

• 比如f(10)= f(9)+f(8),f(9) = f(8) + f(7) ,f(8)就是重叠子问题

我们来看下自底向上的解法，从f(1)往f(10）方向，可以看出一个for循环就可以搞定

4.动态规划解题思路

4.1应用场景

如果一个问题，可以把所有可能的答案穷举出来，并且穷举出来后，发现存在重叠子问题，就可以考虑使用动态规划。

适用例题：最长递增子序列、最小编辑距离、背包问题，爬楼梯问题等等

4.2解题思路

• 自底向上思想

• 拆分子问题，记住过往，减少重复计算

大致思路：

穷举分析
确定边界
找出规律，确定最优子结构
写出状态转移方程

穷举分析

列举出尽可能多的方法比如：
阶数是1：f(1) = 1
阶数是2：f(2) = 2
阶数是3：f(3) = f(2) + f(1) =3
阶数是4：f(4) = f(3) + f(2) =5
........
阶数是n:f(n) = f(n-1) + f(n-2)

确定边界

通过穷举发现，阶数为1或2的时候，可以知道明确的跳法，当n>=3时，找到了类似于斐波那契数列公式的规律......

找规律，确定最优子结构

f(n) = f(n-1) + f(n-2)

写出状态转移方程

借助前面三步骤，可以写出此问题的状态转移方程：

1 n=1
f(n) = 2 n=2
f(n-1) + f(n-2) n>3

四步走完成以后：

• 所以我们得到公式 dp[n] = dp[n-1] + dp[n-2]

• 同时需要初始化 dp[0]=1dp[0]=1 和 dp[1]=1dp[1]=1

• 时间复杂度：O(n)

代码来喽：

class Solution {public int climbStairs(int n) {int[] dp = new int[n + 1];dp[0] = 1;dp[1] = 1;for(int i = 2; i <= n; i++) {dp[i] = dp[i - 1] + dp[i - 2];}return dp[n];}
}

代码源自LeetCode优秀题解，博主也写出来了，不过还是想把最优解呈现给大家啦！！！

5. LeetCode例题分析

题目描述：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

下面按照动态规划的解题思路来走这个问题：

1. 穷举分析

拿[10,9,2,5,3,7,101,18]举例来说：

• 当nums只有一个元素10时，最长递增子序列是[10],长度是1.

• 当nums需要加入一个元素9时，最长递增子序列是[10]或者[9],长度是1。

• 当nums再加入一个元素2时，最长递增子序列是[10]或者[9]或者[2],长度是1。

• 当nums再加入一个元素5时，最长递增子序列是[2,5],长度是2。

• 当nums再加入一个元素3时，最长递增子序列是[2,5]或者[2,3],长度是2。

• 当nums再加入一个元素7时，,最长递增子序列是[2,5,7]或者[2,3,7],长度是3。

..........

分析子问题示例，需找规律

原问题数组nums[i]的最长递增子序列 = 子问题数组nums[i-1]的最长递增子序列/nums[i]结尾的最长递增子序列

1. 最简单边界情况

当nums数组只有一个元素时，最长递增子序列的长度dp(1)=1,当nums数组有两个元素时，dp(2) =2或者1， 因此边界就是dp(1)=1。

1. 确定最优子结构

dp(i) =max(dp(j))+1，存在j属于区间[0，i-1],并且num[i]>num[j]。

1. 状态转移方程

                1                (i=1)dp(i)=    max(dp(j))+1       (  0<=j<i且num[j]<num[i] )

代码来喽：

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

心路历程：这类型的题目不止可以利用动态规划的思想来解决，只是博主刚好想回顾一下动态规划所以翻阅了资料总结整理了这篇文章，希望可以帮助到浏览的每一位童鞋！！！

部分 思路and 图源自：微信公众号 - JAVA烂猪皮（gp1106701116）