动态规划(一)
一.初入动态规划
1.什么是动态规划？
- A：求有多少种方式走到右下角
- B：输出所有走到右下角的路径，哪个可以用动态规划？
- 题A是计数问题，属于动态规划题型的一种，而题B则是DFS
2.动态规划特点
A.计数
- 有多少种方式走到右下角
- 有多少种方法选出k个数使得和是sum
B.最大最小值
- 从左上角走到右下角路径的最大数字和
- 最长上升子序列长度
C.求存在性
- 取石子游戏，先手是否必胜(博弈论)
- 能不能选出k个数使得和是sum
3.例1 零钱兑换(leetcode 322)
- 给定不同的硬币，比如分别为2元，5元，7元，每种硬币足够多
- 买一本书需要27元
- 如何用最少的硬币组合正好付清，不需要对方找钱？
重点是最少，明显属于最值问题，那么如何达到最少的目的？
- 试试直觉，最少的硬币组合->用面值大的硬币(算是贪心的思想)，7+7+7=21 21+5=26，还有1块钱凑不出来…
- 改算法，尽量用面值大的硬币，最后如何可以用一种硬币付清就行，7+7+7=21 21+2+2+2=27，6枚
- 然而答案是5枚，7+5+5+5+5=27
动态规划组成部分一：确定状态
- 状态在动态规划中的作用属于定海神针
- 简单的说，解动态规划的时候需要开一个数组，数组的每个元素f[i]或者f[i][j]代表什么(类似解数学题中，x,y,z代表什么)
- 确定状态需要两个意识，最后一步、子问题
最后一步
- 虽然不知最优策略是什么，但是最优策略肯定是K枚硬币a1,a2,…ak面值加起来是27
- 所以一定有一枚最后的硬币：ak
- 除掉这枚硬币，前面硬币面值加起来是27-ak
- 我们不关心前面的k-1枚硬币是怎么拼出27-ak(可能有1种拼法，也可以能有100种)，而且我们现在不知道ak和k，但是我们知道前面的硬币拼出27-ak
- 因为是最优策略，所以拼出27-ak的硬币数一定是最少，否则这就不是最优策略了，就矛盾了
- 如下图
- 所以我们需要知道最少用多少枚硬币可以拼出27-ak，而原问题是最少用多少枚硬币拼出27
- 我们将原问题转化成一个子问题，而且规模更小：27-ak
- 为了简化定义，我们设状态f(x)=最少用多少枚硬币拼出x，而原来要求f(27),现在变成了f(27-k)
- 但是此时我们不知道最后那枚硬币ak是多少，最后那枚硬币ak可能是2,5,7其中之一
- 如果ak是2，f(27)=f(27-2)+1(加上最后这一枚硬币2)
- 如果ak是5，f(27)=f(27-5)+1(加上最后这一枚硬币5)
- 如果ak是7，f(27)=f(27-7)+1(加上最后这一枚硬币7)
- 除此以外，没有其他的可能了
- 需要求最少硬币，所以
- f(27)=min{f(27-2)+1,f(27-5)+1,f(27-7)+1}
- f(27)表示拼出27所需最少的硬币数
- f(27-2)+1拼出25所需最少的硬币数，加上最后一枚硬币2
- f(27-5)+1拼出25所需最少的硬币数，加上最后一枚硬币5
- f(27-7)+1拼出25所需最少的硬币数，加上最后一枚硬币7
和递归有什么关系？
- 用递归解法会有点问题，重复计算了很多次，效率低下，直接用数组在数组中计算不香嘛？
- 如何避免？
- 可以将计算结果保存下俩，并改变计算顺序
动态规划组成部分二：转移方程
- 设状态f[x]=最少用多少枚硬币拼出x
- 对于任意x，f[x]=min{f[x-2]+1,f[x-5]+1,f[x-7]+1}拼出x所需最少的硬币数
- f[x-2]+1表示拼出x-2所需最少的硬币数，加上最少一枚硬币2
- f[x-5]+1表示拼出x-5所需最少的硬币数，加上最少一枚硬币5
- f[x-7]+1表示拼出x-7所需最少的硬币数，加上最少一枚硬币7
动态规划组成部分三：初始条件和边界情况
- 两个问题：
- x-2，x-5或者x-7小于0怎么办
- 什么时候停下来
- 如果不能拼出y，就定义f[y]=正无穷
- 例如f[-1]=f[-2]=正无穷
- 所以f[1]=min{f[-1]+1,f[-4]+1,f[-6]+1}=正无穷，表示拼不出来1
- 初始条件：f[0]=0(初始条件用转移方程算不出来，要根据题目来定义)
动态规划组成部分四：计算顺序
- 拼出X所需要的最少硬币数：f[X]=min{f[x-2]+1,f[x-5]+1,f[x-7]+1}
- 初始条件：f[0]=0
- 然后计算f[1]，f[2]，…f[27]
- 当我们计算到f[x]时，f[x-2]，f[x-5]，f[X-7]都已经得到结果了
- f[x]=非无穷数，表示最少用多少枚硬币拼出X
- f[x]=正无穷，表示无法用硬币拼出X
- 每一步尝试三种硬币，一共27步，与递归算法比，没有任何重复计算
- 算法时间复杂度(需要进行步数)：273(nm)
- 递归时间复杂度：>>27*3
编写代码
public int coinChange(int[] coins, int amount) {
int [] dp = new int[amount+1];
dp[0]=0;
for(int i=1;i<=amount;i++){
dp[i]=Integer.MAX_VALUE;
for(int j=0;j<coins.length;j++){
if(i-coins[j]>=0&&dp[i-coins[j]]!=Integer.MAX_VALUE) {
dp[i] = Math.min(dp[i - coins[j]] + 1, dp[i]);
}
}
}
if(dp[amount]==Integer.MAX_VALUE){
return -1;
}
return dp[amount];
}
4.例2 不同路径(leetcode 62)
- m行n列网格，有一个机器人总左上角触发，每一步只能向下或向右一步，问有多少种方法走到右下角
- 典型的计数型动态规划
动态规划组成部分一：确定状态
- 最后一步，不管何种方式到右下角，总有最后一步挪动，向右或者向下
- 右下角坐标为(m-1,n-1)
- 那么前一步机器人一定是在(m-2,n-1)或者(m-1,n-2)
- 首先，我们需要知道一个概念
- 如果机器人有x种方式从左上角走到(m-2,n-1)，有y种方式从左上角走到(m-1,n-2)，则机器人有x+y种方式走到(m-1,n-1)
- 加法原理，满足两个条件，无重复，无遗漏
- 问题转化为，机器人有多少种方式从左上角走到(m-2,n-1)和(m-1,n-2)，而原题有多少种方式从左上角走到(m-1,n-1)
- 子问题
- 状态：设f[i][j]为机器人有多少种方式从左上角走到(i,j)
动态规划组成部分二：转移方程
- 对于任意一个格子，f[i][j]=f[i-1][j]+f[i][j-1]
动态规划组成部分三：初始条件和边界情况
- 初始条件：f[0][0]=1 因为机器人只有一种方式到左上角
- 边界情况：i=0或j=0，则前一步只能有一个方向过来->f[i][j]=1
动态规划组成部分四：计算顺序
- f[0][0]=1
- 计算第0行，计算第1行…
- 计算第m-1行
- 答案是f[m-1][n-1]
- 时间复杂度(计算步数)：O(MN)，空间复杂度(数组大小)：O(MN)
编写代码
public int uniquePaths(int m, int n) {
int [][] dp = new int [n][m];//表示到(i,j)有dp[i][j]种方式
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(i==0||j==0){
dp[i][j]=1;
}else{
dp[i][j]=dp[i-1][j]+dp[i][j-1];
}
}
}
return dp[n-1][m-1];
}
5.例3 青蛙跳石头(leetcode 403)
- 有n块石头分别在x轴的0,1,…n-1位置，一只青蛙在石头0，想跳到石头n-1，如果青蛙在第i块石头上，它最多可以向右跳距离ai，问青蛙能否跳到石头n-1上
例子：
输入a=[2,3,1,1,4] 输出:true
输入a=[3,2,1,0,4] 输出;false
第一步：确定状态
-
最后一步：如果青蛙能跳到最后一块石头n-1，我们考虑它跳的最后一步
-
这一步是从石头i跳过来，i
-
需要两个条件同时满足
- 青蛙可以跳到石头i
- 最后一步不超过跳跃的最大距离：n-1-j<=ai
-
那么，我们需要知道青蛙能不能跳到石头i(i
-
原来问题青蛙能不能跳到石头n-1
-
子问题
-
状态：设f[j]表示青蛙能不能跳到石头j上
第二步：转移方程
f[j]=OR(0<=i
- f[j]表示青蛙能不能跳到石头j
- 枚举上一个跳到的石头i
- f[i]表示青蛙能不能跳到石头i
- 最后一步的距离不能超过ai
第三步：初始条件和边界情况
- 初始条件：f[0]=True，因为青蛙一开始就在石头0
- 没有边界情况
第四步：计算顺序
- 初始化f[0]=true
- 计算f[1]，f[2]，…,f[n-1]
- 答案是f[n-1]
- 时间复杂度：O(n²)，空间复杂度：O(n)
编写代码
public boolean canJump(int[] nums) {
int n = nums.length;
boolean [] dp = new boolean[n];
dp[0]=true;//dp[i]表示是否可以跳到第i个石头上，初始化青蛙在第0个石头上
for(int i=1;i<n;i++){
dp[i]=false;
for(int j=0;j<i;j++){
if(dp[j]&&j+nums[j]>=i){
dp[i]=true;
break;
}
}
}
return dp[n-1];
}
6.例4 乘积最大子数组(leetcode 152)
- 给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积
例子：
输入： [2,3,-2,4] 输出：2*3=6
输入：[-2,0,-1] 输出：0
第一步：确定状态
- 题目是求连续最大的子数组对应的乘积，要考虑乘积就一定要分为两种情况，两个正数相乘为最大或者是两个负数相乘为最大
- 最后一步：前面相乘的结果为sum，再乘以an，为数组中乘积最大的连续子数组
- 按照乘法性质，如果你想让sum*an最大，无非两种可能性
- an为负数，sum一定是前n-1位乘积最小的数
- an为正数，sum一定是前n-1位乘积最大的数
- 本来求整个数组中乘积最大的连续子数组的乘积(长度n)，现在我们要求数组前(长度n-1)乘积最大和最小的连续数组的乘积
- 子问题
- 设imax[i]为前i位乘积最大的数，imin[i]为前i位乘积最小的数
第二步：转移方程
- 当nums[i]小于0时
imax[i]=Math.max(imin[i-1]*nums[i],nums[i])
imin[i]=Math.min(imax[i-1]*nums[i],nums[i]) - 当nums[i]大于等于0时
imax[i]=Math.max(imax[i-1]*nums[i],nums[i])
imin[i]=Math.min(imin[i-1]*nums[i],nums[i])
第三步：初始条件和边界情况
- 初始条件：imax[0]=nums[0],imax[0]=nums[0]
- 没有边界情况
第四步：计算顺序
- 初始化imax[0]=nums[0],imax[0]=nums[0]
- 计算从1到n-1
- 时间复杂度：O(n)，空间复杂度：O(n)[可以优化成O(2)]
第五步：编写代码
public int maxProduct(int[] nums) {
int n = nums.length;
int result = nums[0];
int [] imax = new int[n];
int [] imin = new int[n];
imax[0]=nums[0];
imin[0]=nums[0];
for(int i=1;i<n;i++){
if(nums[i]<0){
imax[i] = Math.max(imin[i-1]*nums[i],nums[i]);
imin[i] = Math.min(imax[i-1]*nums[i],nums[i]);
}else{
imax[i] = Math.max(imax[i-1]*nums[i],nums[i]);
imin[i] = Math.min(imin[i-1]*nums[i],nums[i]);
}
result = Math.max(imax[i],result);
}
return result;
}
- 优化
- 你会发现它i只会和i-1有关，所以我们可以对这题的空间进行优化
public int maxProduct(int[] nums) {
int n = nums.length;
int result = nums[0];
int imax=nums[0],imin=nums[0];
for(int i=1;i<n;i++){
if(nums[i]<0){
imax = imax^imin;
imin = imax^imin;
imax = imax^imin;
}
imax = Math.max(imax*nums[i],nums[i]);
imin = Math.min(imin*nums[i],nums[i]);
result = Math.max(imax,result);
}
return result;
}
- 常见动态规划类型
- 坐标型
- 序列型
- 划分型
- 区间型
- 背包型
- 最长序列型
- 博弈型
- 综合型