算法学习 —— 动态规划练习（二）

一、不同路径（LeetCode-62）

1.1 题目介绍

62. 不同路径

1.2 解题思路

计数型动态规划

最后一步

最右下角的坐标假设为(m,n)，则假设走到(m,n)所有可能的路径为f[m][n]

子问题

走到(m,n)的前一步有两种可能一种是(m-1,n)，一种是(m,n-1)

状态转移方程

f[m][n] = f[m-1][n] + f[m][n-1]

初始化和边界
因为根据题意，只能向右走，或向下走。从(0,0)到位于(0,n)或(m,0)这点位置，都只有一种走法。
i = 0 或 j = 0 ，则f[i][j] = 0

1.3 解题代码

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] f = new int[m][n];
        //最后一步
        //f[m-1][n-1] = f[m-1][n-2] + f[m-2][n-1]
        //初始条件
        //f[0][j] = 1  f[i][0] = 1 
        int i,j;
        for(i=0;i<m;i++){
            for(j=0;j<n;j++){
                if(i==0||j==0){
                    f[i][j] = 1;
                }else{
                    f[i][j] = f[i-1][j] + f[i][j-1];
                }
                
            }
        }
        return f[m-1][n-1];
    }
}

二、跳跃游戏（LeetCode-55）

2.1 题目介绍

55. 跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。

示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。

示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

2.2 解题思路

存在型动态规划

最后一步
确定状态，最后一步，是f[n]能否走到n的位置

子问题
能否走到f[n],在n之前，如果有i+a[i] >= n 的话，并且f[i]可以到达，则f[n]也可以到达

状态转移方程

f[x] = f[i] & (i + a[i] >=x)

0 < i < x

初始化
f[0] = 0

2.3 解题代码

class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        boolean[] f = new boolean[n];
        int i,j;
        f[0] = true;
        for(i=1;i<n;i++){
            f[i] = false;
            for(j=0;j<i;j++){
                if(f[j] && j+nums[j] >= i){
                    f[i] = true;
                    break;
                }
            }
        }
        return f[n-1];
        
    }
}

三、1155. 掷骰子的N种方法（LeetCode-1155）

3.1 题目介绍

这里有 d 个一样的骰子，每个骰子上都有 f 个面，分别标号为 1, 2, ..., f。

我们约定：掷骰子的得到总点数为各骰子面朝上的数字的总和。

如果需要掷出的总点数为 target，请你计算出有多少种不同的组合情况（所有的组合情况总共有 f^d 种），模 10^9 + 7 后返回。

3.2 解题思路

该题属于计数型动态规划

根据题意，设dp[d][target]是用掷d个骰子，骰子的面数f，得到和为target的方法数。

假设d=3,f=5,target = 19

（1）最后一步：

d[3][19] = d[2][19-1] +  d[2][19-2] +  d[2][19-3] +  d[2][19-4] +  d[2][19-5] 

由于 d[3][19]初始化为0,所以上面的公式可以简化为

for (i = 1;i<5;i++)
    d[3][19] += d[3-1][19 - i]

（2）初始条件

当只有一个骰子时，有f个面，我们知道获得x(1<=x<=f)的方法均为1种。

所以

for(i=1;i<f;i++)
    dp[1][i] = 1 

（3）状态转移方程

for(i = 2;i<=d;i++)
    for(j = 1;j<=target;j++)
        for (k = 1;k<=f;k++)
            // j>=k
            dp[i][j] += d[i-1][j-k] 

（4）边界

循环结束，i = d,j = target，即到达边界点，也就求出解。

3.3 解题代码

public int numRollsToTarget(int d, int f, int target) {

        int[][] dp = new int[31][1001];
        //初始化条件，只有1个骰子的时候，1-f的方法均只有1种
        for (int i = 1; i <= f; i++) {
            dp[1][i] = 1;
        }
        //骰子数
        for (int i = 2; i <= d; i++) {
            //要凑出的面值
            for (int j = 1; j <= target; j++) {
                //骰子面值
                for (int k = 1; k <= f; k++) {
                    if (j >= k) {
                        dp[i][j] += dp[i - 1][j - k];
                        dp[i][j] %= 1000000007;
                    }
                }
            }
        }
        return dp[d][target];

    }

四、单字符重复子串的最大长度（LeetCode-1156）

占坑，待AC。

如果字符串中的所有字符都相同，那么这个字符串是单字符重复的字符串。

给你一个字符串 text，你只能交换其中两个字符一次或者什么都不做，然后得到一些单字符重复的子串。返回其中最长的子串的长度。

输入输出

输入：text = "ababa"
输出：3

输入：text = "aaabaaa"
输出：6


输入：text = "aaabbaaa"
输出：4


输入：text = "aaaaa"
输出：5


输入：text = "abcdef"
输出：1

参考视频

动态规划入门 Introduction to Dynamic Programming