大家好,我是耀星,欢迎来到动态规划频道,如何你是一枚新手的话,建议大家能够先学习动态规划入门篇
目录
⌛动态规划题目特点
Example1 (换硬币)
Example2 (跳跃游戏)
Example 3 (解密方法)
Example 4(最长升序子串)
Example 5(调手表)
坐标型动态规划总结
1.计数
-有多少种方式走到终点
-有多少种方式选出k个数的和相同
...
2.求最大值最小值
-求路径的最大最小数字和
-最长上升子序列长度
...
3.求存在性
-取石子游戏,先手是否必胜
-能不能选出k个数和是sum
...
你有三种硬币,分别面值2元,5元和7元,每种硬币都有足够多,假设买一本书需要27元,如何用最少的数量的硬币买到这本书,如果给定金额不能够拼出返回-1。
LintCode链接:换硬币
⚖1.确定状态
⏯最后一步:
最后一步我们可能选2元,选择5元,选择7元,如果告诉你拼出25元最少要5枚,拼出22元最少要5枚,拼出20元最少要四枚。那么你最后当然会选择7元作为最后一枚硬币,拼出27元。
子问题:
如果最后一步是选择2元
dp[27] = dp[27-2]+1;//转化为求25元能够用最少硬币拼出
如果最后一步是选择5元
dp[27] = dp[27-5]+1;//转化为求22元能够用最少硬币拼出
如果最后一步是选择7元
dp[27] = dp[20] +1;//转化为求20元能够用最少硬币拼出
我门只是做了假设最后一步应该怎么走,那么具体怎么走才是最优的呢?
dp[27] = min{dp[20],dp[25],dp[22]}+1
⚛2.转移方程
3.初始条件和边界情况
dp[0] = 0;//0元用0枚硬币拼出
如过i-k<0时,则不能够拼出我们想要的数,设不能拼出为+∞。
4.计算顺序
dp[0] dp[1] dp[2] dp[3]....dp[n]
说明:题目中并没有给定确定的硬币面值,但是我们同样可以通过推导得出dp[i]=min{dp[i-k1],dp[i-k2],dp[i-k3]...dp[i-kn]}+1 .
public class Solution {
public int coinChange(int[] coins, int amount) {
int m = coins.length;
if(m == 0 || amount == 0){
return 0;
}
int[] dp = new int[amount+1];
//初始化
dp[0] = 0;
for(int i=1; i<=amount; i++){
dp[i] = Integer.MAX_VALUE;
//有m个不同的硬币
for(int j=0; j= coins[j] && dp[i-coins[j]] != Integer.MAX_VALUE){//处理边界情况
dp[i] = Math.min(dp[i-coins[j]]+1,dp[i]);//转移方程
}
}
}
//拼不出返回-1
if(dp[amount] == Integer.MAX_VALUE){
return -1;
}
return dp[amount];
}
}
小结
↘最值型动态规划
↘动态规划组成部分
-1.确定状态
最后一步(最后一步应该如何选择硬币k)
子问题(选择最少的硬币,子问题dp[i-coins[j]]
2.转移方程
dp[i] = Math.min{dp[i-2],dp[i-5],dp[i-7]}+1;
3.初始条件和边界情况
dp[0] = 0;
不能拼出i,dp[i] = Integer.MAX_VALUE;
给出一个非负整数数组,你最初定位在数组的第一个位置。数组中的每个元素代表你在那个位置可以跳跃的最大长度。判断你是否能到达数组的最后一个位置。
样例
输入:A=[2,3,1,1,4]
输出:true
LintCode链接:跳跃游戏
⚖1.确定状态
设定一个数组dp[i]表示是否能够跳到第i个位置,能够跳到为true,不能够跳到为false.
⏯最后一步:从数组的第一个位置开始跳,最后一步要求跳到第n-1块石头,设最后一步是从第i块石头跳到n-1
子问题:是否能够跳跃到第i个位置
原问题:是否能够跳到第n-1个位置
想要跳到n-1,第i个位置需要满足的条件有:
dp[i] == true
i+A[i] >= n-1//从第i个位置开始跳,i+A[i]能够跳到的最大位置>=n-1,那么就能跳到第n-1个位置
状态:dp[i]表示能否跳到第i个位置
⌛2.转移方程
用变量j向前枚举
☑3.初始条件和边界情况
起始位置为数组的第一个元素,所以第一个位置一定能够跳到
dp[0] = true
4.计算顺序
dp[0] dp[1] dp[2] dp[3]...dp[n-1]
public class Solution {
public boolean canJump(int[] A) {
int n = A.length;
if(n == 0 || A==null){
return false;
}
boolean[] dp = new boolean[n];
dp[0] = true;
for(int i=1; i=0;j--){
if(dp[j] == true && j+A[j] >= i){
dp[i] = true;
break;
}
}
}
return dp[n-1];
}
}
解密方法:有一段数字序列,将该段数字序列解密成字符串,一共有多少种解密方法。
1-A 2-B 3-C... 26-Z
例如:
12:L或AB
LintCode链接:解密方法
⚖1.确定状态
⏯最后一步:最后一个字符可能由两位数组成,也有可能由一位数组成。
例如:128439516
将数字序列划分成若干段数字序列
6为最后一个数字,最后一步可以拼成一个F,16作为最后一个数字也可以可以解密为一个P,如果告诉你N-1个数可以拼出的N1种方案,N-2个数可以拼出N2种方案,那么你一定会计算N个数有多少种解密方法。
子问题:求N-1和N-2个数字序列的解密方法
原问题:求N个数字序列的解密方法
状态:前i个数字序列,有dp[i]种解密方法
⚛2.转移方程
☑3.初始条件和边界情况
初始条件:dp[0] = 1即空串有一种解密方式
边界情况:i == 1,只看最后一个数字
当最后一位是0时,可能由两位数字组成,若两位都为0或两位大于26则不能组成字符串,所以先默认dp[i] = 0,若不满足组成字符条件,则dp[i]就为0。
4.计算顺序
dp[0] dp[1] dp[2] dp[3] ...dp[n]
public class Solution {
=
public int numDecodings(String s) {
char[] ss = s.toCharArray();
int n = ss.length;
if(n == 0){
return 0;
}
int[] dp = new int[n+1];
dp[0] = 1;
for(int i=1; i<=n; i++){
dp[i] = 0;先初始化为0,可能存在不能组成字符串的情况
//用一个字符作为结尾
int t1 = ss[i-1]-'0';
if(t1>0 && t1<=9){//若t == 0,自动选择后两位作为一个字符
dp[i]+=dp[i-1];
}
if(i>=2){
//取出倒数第二位
int t2 = (ss[i-2]-'0')*10+ss[i-1]-'0';
if(t2<=26 && t2>=10){//最后两位小于26并且大于等于10才能组成字符
dp[i]+=dp[i-2];
}
}
}
return dp[n];
}
}
给定一个整数数组(下标从 0 到 n-1, n 表示整个数组的规模),请找出该数组中的最长上升连续子序列。(最长上升连续子序列可以定义为从右到左或从左到右的序列。)
LintCode链接:最长升序子串
输入:[5, 4, 2, 1, 3]
输出:4
解释:
给定 [5, 4, 2, 1, 3],其最长上升连续子序列(LICS)为 [5, 4, 2, 1],返回 4。
⚖1.确定状态
通过最优策略选择出最长升序子串的长度
⏯最后一步 :如果告诉你以A[i-1]为结尾的升序子串长度为为N1,如果A[i]>A[i-1],那么以A[i]为结尾的升序子串长度为N1+1,如果A[i]
子问题:只要知道A[i-1]作为升序子串中最后一个元素的最长升序子串的长度。
原问题:求A[i]前的最长升序子串的长度。
状态:使用dp[i]记录以A[i]元素为为结尾的升序子串中最后一个元素的长度。
例如:
⚛2.转移方程
☑3.初始条件和边界情况
初始条件:
dp[0] = 1
4.计算顺序
dp[0] dp[1] dp[2] dp[3]...dp[n-1]
public class Solution {
//计算最长升序子列
public int MyLongstIncreasingContinuousSubsequence(int[] A){
int n = A.length;
if(n == 0 || A == null){
return 0;
}
int[] dp = new int[n];
//初始化
dp[0] = 1;
int max = 1;//记录最长子串
for(int i=1; iA[i-1]){
dp[i] = Math.max(1, dp[i-1]+1);
max = Math.max(dp[i],max);
}
}
return max;
}
public int longestIncreasingContinuousSubsequence(int[] A) {
int ret1 = MyLongstIncreasingContinuousSubsequence(A);
//倒置字符串,计算最长降序子串
int left = 0;
int right = A.length-1;
while(left < right){
int temp = A[left];
A[left] = A[right];
A[right] = temp;
left++;
right--;
}
int ret2 = MyLongstIncreasingContinuousSubsequence(A);
int result = Math.max(ret1, ret2);
return result;
}
}
小明买了块高端大气上档次的电子手表,他正准备调时间呢。在 M78 星云,时间的计量单位和地球上不同,M78 星云的一个小时有 n分钟。大家都知道,手表只有一个按钮可以把当前的数加一。在调分钟的时候,如果当前显示的数是 0 ,那么按一下按钮就会变成 1,再按一次变成 2 。如果当前的数是 n - 1按一次后会变成 0。作为强迫症患者,小明一定要把手表的时间调对。如果手表上的时间比当前时间多 1,则要按 n - 1 次加一按钮才能调回正确时间。小明想,如果手表可以再添加一个按钮,表示把当前的数加 k 该多好啊......他想知道,如果有了这个+k 按钮,按照最优策略按键,从任意一个分钟数调到另外任意一个分钟数最多要按多少次。
注意,按 +k按钮时,如果加 k 后数字超过 n-1则会对 n 取模。
比如,n=10, k=6 的时候,假设当前时间是 0,连按 2 次 +k+k 按钮,则调为 2。
输入描述
一行两个整数 n, k(0 < k < n <10^5) (0
输出描述
输出一行一个整数,表示按照最优策略按键,从一个时间调到另一个时间最多要按多少次。
OJ链接:调手表
1.确定状态
最后一步:
最后一步要调到n-1的位置,可以从n-1-1 || n-1-k || (j*k)%n的位置调到n-1。
子问题:
如果最优策略是从i-1~i
如果最优策略是从i-k~i
如果最优策略是(j*k)%n~i
转化为求调到时间i-1或i-k或(j*k)%n的最优策略
原问题:求调第到第n-1分钟的最优策略
状态:dp[i]为调第i分钟,按表的最少次数。
✨2.转移方程
3.初始条件及边界情况
初始条件:
dp[0] = 0
4.计算顺序
dp[0] dp[1] dp[2] dp[3]...dp[n-1]
import java.util.Scanner;
import java.util.Arrays;
public class Solution {
public int MinNumberOfTime {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int k = scan.nextInt();
int[] dp = new int[n];
dp[0] = 0;初始化
for(int i=1;i=0 && k>1){
dp[i] = Math.min(dp[i-k]+1,dp[i]);
}
for(int j=2;j
给定输入为序列或者网格
动态规划状态下标为序列下标i或者坐标(i,j)
--dp[i]表示以i个元素结尾的某种性质
--d[i][j]表示以坐标(i,j)为结尾的性质
初始化设置dp[0]或dp[0][0...n]的值
二维空间优化:滚动数组节省空间
水平有限⏰,希望能够对大家有帮助。感谢大家的支持!