LeetCode算法练习——动态规划提高（三）

最新推荐文章于 2023-04-18 15:53:51 发布

alpaca_ll

最新推荐文章于 2023-04-18 15:53:51 发布

阅读量277

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode刷题笔记文章标签： leetcode 动态规划算法

本文链接：https://blog.youkuaiyun.com/alpaca_ll/article/details/106945849

Leetcode刷题笔记专栏收录该内容

18 篇文章

订阅专栏

本文探讨使用动态规划解决LeetCode上的经典问题，包括数字翻译成字符串的不同方法、n个骰子点数的概率分布及最长有效括号的子串长度。通过详细解析算法思路，帮助读者理解并掌握动态规划在不同场景下的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LeetCode剑指 Offer 46. 把数字翻译成字符串

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

示例 1:

输入: 12258
输出: 5
解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"

此题最关键的是将数值转换成字符串，然后判定连续两个字符串的范围是不是在“00”~“25”之间。

基本情况下：dp[i] += dp[i - 1]；因为每个字符都可以表示一个字母，这是基本情况。

接下来我们对连续两个字符的进行判断：

如果高位为“1”也不为“2”则跳过情况，因为此时不会出现其他翻译方法；
如果高位为“2”且低位大于“5”则跳过情况，因为此时不会出现其他翻译方法；
当连续两个字符串的范围在“00”~“25”之间，dp[i] += dp[i - 2]。

class Solution {
public:
    int translateNum(int num) {
        string value = to_string(num);
        vector<int> dp(value.size() + 1, 0);
        dp[0] = 1; dp[1] = 1;
        for(int i = 2; i < dp.size(); i++){
            dp[i] += dp[i - 1];
            if(value[i - 2] != '1' && value[i - 2] != '2')  
                continue;               //高位不是1,2，此时不会出现其他翻译方法
            if(value[i - 2] == '2' && value[i - 1] > '5')   
                continue;               //连续的两位数值大于25，此时不会出现其他翻译方法
            dp[i] += dp[i - 2];
        }
        return dp[value.size()];
    }
};

类似的题目还有LeetCode91. 解码方法，不同的是本题字符编码是从1开始的，需要考虑字符为0的特殊情况，思想类似。

class Solution {
public:
    int numDecodings(string s) {
        if(s.size() == 0)   return 0;
        if(s[0] == '0') return 0;
        vector<int> dp(s.size() + 1, 1);
        for(int i = 1; i < s.size(); i++){
            if(s[i] == '0'){
                if(s[i - 1] == '1' || s[i - 1] == '2')          //10或20的情况
                    dp[i + 1] = dp[i - 1];
                else    return 0;
            }
            else{
                if((s[i - 1] == '1' || (s[i - 1] == '2' && s[i] >= '1' && s[i] <= '6')))
                    dp[i + 1] = dp[i - 1] + dp[i];
                else    dp[i + 1] = dp[i];
            }
        }
        return dp[s.size()];
    }
};

LeetCode剑指 Offer 60. n个骰子的点数

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

示例 1:

输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]

示例 2:

输入: 2
输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]

表示状态

分析问题的状态时，不要分析整体，只分析最后一个阶段即可！因为动态规划问题都是划分为多个阶段的，各个阶段的状态表示都是一样，而我们的最终答案在就是在最后一个阶段。对于这道题，最后一个阶段是什么呢？通过题目我们知道一共投掷 n 枚骰子，那最后一个阶段很显然就是：当投掷完 n 枚骰子后，各个点数出现的次数。

注意，这里的点数指的是前 n 枚骰子的点数和，而不是第 n 枚骰子的点数。

找出了最后一个阶段，那状态表示就简单了。

首先用数组的第一维来表示阶段，也就是投掷完了几枚骰子。
然后用第二维来表示投掷完这些骰子后，可能出现的点数。
数组的值就表示，该阶段各个点数出现的次数。

所以状态表示就是这样的：dp[i][j]，表示投掷完 i 枚骰子后，点数 j 的出现次数。

找出状态转移方程

找状态转移方程也就是找各个阶段之间的转化关系，同样我们还是只需分析最后一个阶段，分析它的状态是如何得到的。最后一个阶段也就是投掷完 n 枚骰子后的这个阶段，我们用 dp[n][j] 来表示最后一个阶段点数 j 出现的次数。

单单看第 n 枚骰子，它的点数可能为 1,2,3,...,6，因此投掷完 n 枚骰子后点数 j 出现的次数，可以由投掷完 n−1 枚骰子后，对应点数 j−1,j−2,j−3,...,j−6出现的次数之和转化过来。写成数学公式是这样的：

$dp[n][j] = \sum_{i = 1}^{6}dp[n-1][j-i]$

n 表示阶段，j 表示投掷完 n 枚骰子后的点数和，i 表示第 n 枚骰子会出现的六个点数。

边界处理

这里的边界处理很简单，只要我们把可以直接知道的状态初始化就好了。我们可以直接知道的状态是啥，就是第一阶段的状态：投掷完 1 枚骰子后，它的可能点数分别为 1,2,3,...,6，并且每个点数出现的次数都是 1。

class Solution {
public:
    vector<double> twoSum(int n) {
        //点数和共有6*n种情况，可能性数组长度为6*n - n + 1 = 5*n + 1
        vector<vector<double>> dp(n + 1, vector<double>(6*n + 1, 0));
        vector<double> res;
        if(n == 0)  res.push_back(0);
        for(int i = 1; i <= n; i++){
            for(int j = i; j <= 6*i; j++){
                if(i == 1){     //投掷一次时，出现的次数均为1,即初始化
                    dp[i][j] = 1;
                    continue;
                }
                for(int k = 1; k <= 6; k++){
                    //投掷完 i 枚骰子后点数 j 出现的次数，可以由投掷完 i−1 枚骰子后，
                    //对应点数 j−1, j−2, j−3,..., j−6出现的次数之和转化过来，其和不小于i-1
                    if(j - k >= i - 1)    dp[i][j] = dp[i][j] + dp[i - 1][j - k];
                }
            }
        }
        for(int i = n; i <= 6*n; i++)
            res.push_back(dp[n][i] / pow(6, n));
        return res;
    }
};

LeetCode32. 最长有效括号

给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: "(()"
输出: 2
解释: 最长有效括号子串为 "()"

示例 2:

输入: ")()())"
输出: 4
解释: 最长有效括号子串为 "()()"

此题如果用暴力法做，利用栈来实现括号匹配问题最后几个用例会出现超时，可以改用动态规划解决该类问题。我们定义一个 dp 数组，其中第 i 个元素表示以下标为 i 的字符结尾的最长有效子字符串的长度。这里需要考虑两种情况，非嵌套匹配“()()”和嵌套匹配“(())”

非嵌套匹配“()()”：当s[i] = ')'时，如果s[i - 1] = '('则匹配，此时dp[i] = dp[i - 2] + 2；

嵌套匹配“(())”：我们一般针对这种格式的第二个 ')'，即满足条件(i - dp[i - 1] - 1 >= 0) && s[i - dp[i - 1] - 1] == '(' ，这里的i - dp[i - 1] - 1 >= 0 确保能够进行该格式的匹配判断：

如果嵌套括号前有括号“()(())”，我们则需要计算上嵌套括号匹配前的括号匹配数量，即加上dp[i - dp[i - 1] - 2]，此时状态转移方程为：dp[i] = dp[i - dp[i - 1] - 2] + dp[i - 1] + 2；
没有的话：dp[i] = dp[i - 1] + 2。

class Solution {
public:
    //暴力法超时
    /*bool isValid(string str){
        stack<char> s;
        for(int i = 0; i < str.size(); i++){
            if(str[i] == '(')   s.push(str[i]);
            else if(!s.empty() && s.top() == '(')   s.pop();
            else    return false;
        }
        return s.empty();
    }

    int longestValidParentheses(string s) {
        int maxlen = 0;
        for(int i = 0; i < s.size(); i++){
            for(int j = 2; j + i <= s.size(); j += 2){
                if(isValid(s.substr(i, j))){
                    if(maxlen < j)  maxlen = j;
                }
            }
        }
        return maxlen;
    }*/
    int longestValidParentheses(string s) {
        int maxlen = 0;
        vector<int> dp(s.size(), 0);            //到第 i 个格子为止，匹配的子串长度
        for(int i = 1; i < s.size(); i++){
            if(s[i] == ')'){
                if(s[i - 1] == '('){
                    if(i - 2 >= 0)  dp[i] = dp[i - 2] + 2;
                    else dp[i] = 2;
                }
                //嵌套括号的情况:(())
                else if((i - dp[i - 1] - 1 >= 0) && s[i - dp[i - 1] - 1] == '('){
                    //嵌套括号前是否有括号:()(())
                    if(i - dp[i - 1] - 2 >= 0)  dp[i] = dp[i - dp[i - 1] - 2] + dp[i - 1] + 2;
                    else    dp[i] = dp[i - 1] + 2;
                }
            }
            maxlen = max(maxlen, dp[i]);
        }
        return maxlen;
    }
};