马上面临秋招，笔者也刷过不少题了，但是动态规划一直是笔者心中的痛点，大厂的笔试中动态规划已成标配，为了圆大厂梦，笔者决定沉下心，认真研究一下动态规划问题，近日看到leetcode一位大佬将动态规划问题划分为五类，私以为很受用，加上一些个人见解，将其写成博客，如有什么错误还请各位看官指正。
前面介绍了动态规划【一】到达目标的最大/最小路径，今天我们来介绍动态规划的第二种题型：到达目标的不同方式总数
1、到达目标的不同方式总数
1.1 问题描述
通常这类问题都具有如下的描述：
给定一个目标，求到达目标的所有不同路径/组合/方式
1.2 解题方法
以路径问题为例，通常在所有可能的路径中，不同的路径数都由前不同的路径加上当前的路径数来得出，我们可以列出状态转移方程：
routes[i] = route[i-1],routes[i-2],routes[i-3]...routes[i-k]
通常，解决这类问题的代码都是如下形式：
for(int i=1;i<=target;i++){
for(int j=0;j<ways.size(),j++){
dp[i]=min(dp[i],dp[i-ways[j]])+cost[i];
}
}
通常，解决这类问题的代码都是如下形式：
for(int i=1;i<=target;i++){
for(int j=0;j<ways.size(),j++){
if(ways[j]<=i){
dp[i]+=dp[i-ways[j]];
}
}
}
1.3 leetcode原题解析
以下是笔者搜集的leetcode此类问题，附上笔者的代码，在这里不讨论代码的优化问题。
62. Unique Paths (Medium)
/**
*对于网格中的点，每一个点的路径总数都由前一个状态的路径总数来决定
*当m或n为0时，每个点前面都只有一种状态，所以只有一条路径
*/
class Solution {
public int uniquePaths(int m, int n) {
int [][] dp = new int[m+1][n+1];
dp[0][0]=0;
if (m==0 || n==0){
return 1;
}
for (int i=0;i<=m;i++){
dp[i][0]=1;
}
for (int i=0;i<=n;i++){
dp[0][i]=1;
}
for (int i =1;i<m;i++){
for (int j=1;j<n;j++){
dp[i][j]=dp[i-1][j]+dp[i][j-1];
}
}
return dp[m-1][n-1];
}
}
63. Unique Paths II (Medium)
/**
*这题与leetcode62类似，只是需要判断障碍物
*如果某个点[i][j]的值为1，说明是障碍物，那么dp[i][j]的值为0
*/
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
if (obstacleGrid[0][0]==1){
return 0;
}
int[][] dp = new int[m][n];
dp[0][0] = 1;
for (int i = 0;i<m;i++){
for (int j = 0;j<n;j++){
if (obstacleGrid[i][j]==1){
dp[i][j]=0;
}
else{
dp[i][j] += i>0? dp[i-1][j]:0;
dp[i][j] +=j>0? dp[i][j-1]:0;
}
}
}
return dp[m-1][n-1];
}
}
70. Climbing Stairs (easy)
/**
*就是爬楼梯换了一种提问方式，由最少步数变成多少种不同的方式
*/
class Solution {
public int climbStairs(int n) {
int[] dp = new int[n+1];
dp[0] = 0;
dp[1] = 1;
if(n<=1){
return n;
}
dp[2] = 2;
for (int i=3;i<=n;i++){
for (int j=1;j<=2;j++){
dp[i]+=dp[i-j];
}
}
return dp[n];
}
}
377. Combination Sum IV (Medium)
/*
*这是很典型的组合问题，只是将爬楼梯问题的两步换成了给定的数组
*/
class Solution {
public int combinationSum4(int[] nums, int target) {
if (target<=0 || nums.length==0){
return 0;
}
int [] dp = new int[target+1];
dp[0] = 1;
for (int i = 1;i<=target;i++){
for (int num:nums){
if(i>=num){
dp[i]+=dp[i-num];
}
}
}
return dp[target];
}
}
416. Partition Equal Subset Sum (Medium)
/**
*这个问题本质上仍是0-1背包问题，只是条件变得严格了，只要在最后加一个判断
*如果sum-2*dp(maxsize)==0，那么说明它们可以等分为2部分
*/
class Solution {
public boolean canPartition(int[] nums) {
int sum = 0;
for (int num:nums){
sum+=num;
}
int maxsize = sum/2;
if (maxsize*2!=sum || nums.length==0){
return false;
}
int [] dp = new int[maxsize+1];
for (int num:nums){
for (int j = maxsize;j>=num;j--){
dp[j]=Math.max(dp[j],dp[j-num]+num);
}
}
return (sum-2*dp[maxsize])==0;
}
}
494. Target Sum (Medium)
/**
*这个问题可以转化为0-1背包问题，要达到目标，那么只要sum(nums)-target平分为2部分就行了
*/
class Solution {
public int findTargetSumWays(int[] nums, int S) {
int sum = 0;
for (int num:nums){
sum+=num;
}
int target = (sum-S)/2;
if (target*2!=sum-S || S>sum){
return 0;
}
int [] dp= new int [target+1];
dp[0] = 1;
for (int num:nums){
for (int j = target;j>=num;j--){
dp[j]+=dp[j-num];
}
}
return dp[target];
}
}
576. Out of Boundary Paths (Medium)
/**
*球每次运动都有4种可能，所以dp[i][j]肯定是由前4种状态决定的
*当球到达边界时，它只有一种方式出去，所以临界值需要单独判断
*/
class Solution {
public int findPaths(int m, int n, int N, int i, int j) {
int [][][] dp = new int[N+1][m+1][n+1];
int [][] directions = {{1,0},{-1,0},{0,1},{0,-1}};
int mod = 1000000007;
for (int a = 1;a<=N;a++){
for (int b = 0;b<m;b++){
for (int c = 0;c<n;c++){
for (int d = 0;d<4;d++){
int x = b+directions[d][0];
int y = c+directions[d][1];
if (x<0 || x>=m || y<0 || y>=n){
dp[a][b][c] +=1;
dp[a][b][c]%=mod;
}
else{
dp[a][b][c] +=(dp[a-1][x][y])%mod;
dp[a][b][c] %=mod;
}
}
}
}
}
return dp[N][i][j];
}
}
688. Knight Probability in Chessboard (Medium)
/**
*这题与leetcode576类似，但是它算的是概率
*一旦棋子跳出棋盘，就不需要计算它在棋盘中的概率，直接进入下一次循环
*/
class Solution {
public double knightProbability(int N, int K, int r, int c) {
double [][][] dp = new double[K+1][N+1][N+1];
if ( r>=N ||c>=N ||r<0 || c<0){
return 0.0;
}
if(K==0){
return 1.0;
}
int [][] directions = {{-1,-2},{-2,-1},{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2}};
for(int i =0;i<N;i++){
for(int j=0;j<N;j++){
dp[0][i][j]=1.0;
}
}
for(int num = 1;num<=K;num++){
for (int i =0;i<N;i++){
for (int j=0;j<N;j++){
double tmp = 0.0;
for (int k = 0;k<8;k++){
int x = i+directions[k][0];
int y = j+directions[k][1];
if(x>=N || y>=N ||x<0 ||y<0){
continue;
}
tmp+=(0.125*dp[num-1][x][y]);
}
dp[num][i][j]=tmp;
}
}
}
return dp[K][r][c];
}
}
790. Domino and Tromino Tiling (Medium)
/**
*老实说我没明白这道题的公式是怎么推出来的，但是推出公式后发现还是一个组合数问题
*这里我附上一个公式推导的博文，感兴趣的读者可以看看：https://blog.csdn.net/u010829672/article/details/79810697
*/
class Solution {
public int numTilings(int N) {
int [] dp = new int[N+1];
int mod = 1000000007;
if(N<=2){
return N;
}
dp [0] = 1;
dp[1] = 1;
dp [2] = 2;
for (int i =3;i<=N;i++){
dp[i] = (2*dp[i-1]%mod+dp[i-3]%mod)%mod;
}
return dp[N];
}
}
801. Minimum Swaps To Make Sequences Increasing (Medium)
/**
*为了保持两个数组有序，那么既可以交换，也可以保持，用2个list来保存使其有序的最小代价
*附上一篇博文，里面详细讲解了解题过程：https://blog.csdn.net/weixin_37373020/article/details/81561750
*/
class Solution {
public int minSwap(int[] A, int[] B) {
int[] swap = new int[A.length];
int[] keep = new int[A.length];
Arrays.fill(swap,0);
Arrays.fill(keep,0);
swap[0]=1;
for (int i= 1;i<A.length;i++){
swap[i] = keep[i] = 1000000;
if((A[i]>A[i-1]) && (B[i]>B[i-1])){
keep[i] = keep[i-1];
swap[i] = swap[i-1]+1;
}
if((A[i]>B[i-1]) && (B[i]>A[i-1])){
keep[i]=Math.min(keep[i],swap[i-1]);
swap[i]=Math.min(swap[i],keep[i-1]+1);
}
}
return Math.min(keep[A.length-1],swap[A.length-1]);
}
}
808. Soup Servings (Medium)
/**
*这题与leetcode688类似，每个状态都由前面的四种状态决定
*如果A或B<=0，就直接置为0
*/
public class Solution {
double [][] dp;
public double soupServings(int N) {
if(N>4800){ //为什么是4800？至今未搞明白
return 1.0;
}
N = (N+24)/25;
int [][]directions = {{4,0},{3,1},{2,2},{1,3}};
dp = new double[N+1][N+1];
for (int i = 0;i<N+1;i++){
dp[0][i]=1.0;
}
dp[0][0] = 0.5;
for (int i = 1;i<=N;i++)
{
for(int j = 1;j<=N;j++)
{
for (int k = 0;k<4;k++){
int x = i-directions[k][0];
int y = j-directions[k][1];
if (x<0){
x = 0;
}
if(y<0){
y=0;
}
dp[i][j]+=(0.25*dp[x][y]);
}
}
}
return dp[N][N];
}
}
1155. Number of Dice Rolls With Target Sum (Medium)
/**
*不知道咋分析(笑哭)，看解析吧：https://blog.csdn.net/u010946478/article/details/103417906
*/
class Solution {
public int numRollsToTarget(int d, int f, int target) {
int mod = 1000000007;
int [][] dp = new int[d+1][target+1];
dp[0][0] = 1;
for (int i = 1;i<=d;i++){
for (int j = 1;j<=f;j++){
for (int k=0;k<=target-j;k++){
dp[i][k+j]+=dp[i-1][k];
dp[i][k+j]%=mod;
}
}
}
return dp[d][target];
}
}
1.4 挑战极限
以下两个题为hard难度，笔者看到难度就已经放弃了(笑哭)，但是为了内容的完整性和为大佬铺路，这里还是列出来，感兴趣的同学可以挑战一下。
1218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
