LeetCode-91题：解码方法（原创）

梧桐168

已于 2024-03-08 16:02:02 修改

阅读量1k

点赞数 20

分类专栏： LeetCode题解文章标签： leetcode 算法职场和发展

于 2024-03-07 10:14:40 首次发布

本文链接：https://blog.csdn.net/IT_Fly/article/details/136524075

版权

LeetCode题解专栏收录该内容

25 篇文章 2 订阅

订阅专栏

【题目描述】

一条包含字母 A-Z 的消息通过以下映射进行了编码：

'A' -> "1"
'B' -> "2"
...
'Z' -> "26"
要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：

"AAJF" ，将消息分组为 (1 1 10 6)
"KJF" ，将消息分组为 (11 10 6)
注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。给你一个只含数字的非空字符串 s ，请计算并返回解码方法的总数。

题目数据保证答案肯定是一个 32 位的整数。

【题目链接】. - 力扣（LeetCode）

【解题代码】

package dp;

public class NumDecodings {

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        // String s = "106";
        //String s = "10";
        //String s = "06";
        //String s = "11106";
        String s = "111111111111111111111111111111111111111111111";
        int result = new NumDecodings().numDecodings(s);
        System.out.println("result = " + result);
        System.out.println("函数执行时间:" + (System.currentTimeMillis() - start) + "MS");
    }

    public int numDecodings(String s) {
        // 按照惯例定义一个dp数组
        int[] dp = new int[s.length()];
        char ch1 = s.charAt(0);
        // 设置dp[0]值，如果第一个字符为合法解码，那么设置为1，否则为0
        dp[0] = ch1 > 48 ? 1 : 0;
        // 依次遍历后续字符
        for (int i = 1; i < dp.length; i++) {
            char ch2 = s.charAt(i);
            // 计算当前字符和上一个字符组合解码值:等于((ch1-48)*10+ch2-48)，即(ch1*10 +ch2-528)
            char num = (char) (ch1 * 10 + ch2 - 528);
            // 如果当前字符是合法解码，那么当前字符可以作为一个单独解码加入上一个字符的解码分组里，在这种情况下，解码数就等于上一字符解码数
            if (ch2 > 48) {
                dp[i] = dp[i - 1];
            }
            // 如果上一个字符是合法解码，并且当前字符和上一个字符之和也是合法解码
            if (ch1 > 48 && num < 27) {
                // 如果i值大于1，那么当前字符和上一个字符组合解码加入上上个字符的解码分组里，在这种情况下，解码数要加上于上上个字符解码数
                if (i > 1) {
                    dp[i] += dp[i - 2];
                } else { // 如果i值等于2，那么就多一个当前字符和上一个字符组合解码
                    dp[i] += 1;
                }
            }
            // 更新ch1为ch2值
            ch1 = ch2;
        }
        return dp[s.length() - 1];
    }

    // 递归实现方式，速度慢
    public int numDecodings1(String s) {
        return numDecodings1(s, 0);
    }

    private int numDecodings1(String s, int n) {
        if (n == s.length()) {
            return 1;
        }
        int result = 0;
        char ch1 = s.charAt(n);
        // 当前字符是合法解码，那么将当前字符作为一个解码和之后所有字符放在一个分组
        if (ch1 > 48) {
            // 当前解码数等于之后所有字符解码
            result = numDecodings1(s, n + 1);
            if (n < s.length() - 1) {
                // 计算当前字符和下一个字符组合解码值:等于((ch1-48)*10+ch2-48)，即(ch1*10 +ch2-528)
                char ch2 = (char) (ch1 * 10 + s.charAt(n + 1) - 528);
                // 如果当前字符和下个字符之和也是合法解码，那么解码数再加上去掉这两个字符之后所有字符解码
                if (ch2 < 27) {
                    result += numDecodings1(s, n + 2);
                }
            }
        }
        return result;
    }
}

【解题思路】

分析题目可得知，一个字符要么单独解码，要么和下一个字符进行解码，一开始最简单的思路就是采用递归的方式：从第一个字符开始，首先如果当前字符是合法解码，那么将当前字符作为一个解码和之后所有字符放在一个分组，即当前解码数等于之后所有字符解码数。再次如果当前字符和下个字符之和也是合法解码，那么解码数再加上去掉这两个字符之后所有字符解码。递归这种方式容易思考，但估计速度慢，先写出来试试看，代码如下：

// 递归实现方式，速度慢
public int numDecodings1(String s) {
    return numDecodings1(s, 0);
}

private int numDecodings1(String s, int n) {
    if (n == s.length()) {
        return 1;
    }
    int result = 0;
    char ch1 = s.charAt(n);
    // 当前字符是合法解码，那么将当前字符作为一个解码和之后所有字符放在一个分组
    if (ch1 > 48) {
        // 当前解码数等于之后所有字符解码
        result = numDecodings1(s, n + 1);
        if (n < s.length() - 1) {
            // 计算当前字符和下一个字符组合解码值:等于((ch1-48)*10+ch2-48)，即(ch1*10 +ch2-528)
            char ch2 = (char) (ch1 * 10 + s.charAt(n + 1) - 528);
            // 如果当前字符和下个字符之和也是合法解码，那么解码数再加上去掉这两个字符之后所有字符解码
            if (ch2 < 27) {
                result += numDecodings1(s, n + 2);
            }
        }
     }
     return result;
    }

不出所料，提交之后。LeetCode系统报错：超出时间限制：

本地试了一下，运行时长高达13414毫秒，唉，递归方式太不靠谱了，还是回到我们的“动态规划”大法的正途之中去；

按照动态规划的“过把原问题分解为相对简单的子问题的方式求解复杂问题的方法”的模式化套路，反复深度思考，终于得到以下几个要点：

如果当前字符是合法解码，那么当前字符可以作为一个单独解码加入上一个字符的解码分组里，在这种情况下，解码数就等于上一字符解码数；
dp[i] = dp[i - 1];
如果上一个字符是合法解码，并且当前字符和上一个字符之和也是合法解码，那么当前字符和上一个字符组合解码加入上上个字符的解码分组里，在这种情况下，解码数要加上于上上个字符解码数
dp[i] += dp[i - 2];

思路一打开，解题就简单了，且看下面解题步骤

【解题步骤】

按照惯例定义一个dp数组
```
int[] dp = new int[s.length()];
```
设置dp[0]值，如果第一个字符为合法解码，那么设置为1，否则为0
```
char ch1 = s.charAt(0);
dp[0] = ch1 > 48 ? 1 : 0;
```

依次遍历后续所有字符，获取当前字符，以及当前字符和上个字符的组合解码值

 // 依次遍历后续字符
 for (int i = 1; i < dp.length; i++) {
    char ch2 = s.charAt(i);
     // 计算当前字符和上一个字符组合解码值:等于((ch1-48)*10+ch2-48)，即(ch1*10 +ch2-528)
    char num = (char) (ch1 * 10 + ch2 - 528);

如果当前字符是合法解码，那么当前字符可以作为一个单独解码加入上一个字符的解码分组里，在这种情况下，解码数就等于上一字符解码数
```
if (ch2 > 48) {
    dp[i] = dp[i - 1];
}
```
如果上一个字符是合法解码，并且当前字符和上一个字符之和也是合法解码：
1）如果i值大于1，那么当前字符和上一个字符组合解码加入上上个字符的解码分组里，在这种情况下，解码数要加上于上上个字符解码数
2）如果i值等于2，那么就多一个当前字符和上一个字符组合解码
```
if (ch1 > 48 && num < 27) {
    if (i > 1) {
        dp[i] += dp[i - 2];
    } else { // 如果i值等于2，那么就多一个当前字符和上一个字符组合解码
        dp[i] += 1;
    }
}
```
循环尾句，更新上个字符为当前字符
```
ch1 = ch2;
```
循环结束，dp数组最后一个值就是所求答案，最后返回即可
```
return dp[s.length() - 1];
```
最后提交代码，顺利0毫秒通过，本地把刚才超时的例子 "111111111111111111111111111111111111111111111"跑了一下，也是0毫秒，大功告成，顺利收工。

【思考总结】

对于此类问题，“动态规划”是王道，递归方式容易思考，但是存在大量的重复计算，性能远远和动态规划无法相比；
动态规划是优化版的递归，通过储存子问题的解避免重复计算，提高效率，适合解决有重叠子问题和最优子结构的问题。而递归直接通过函数自调用解决问题，简单直观但可能效率低下因为重复计算。动态规划自底向上，递归自顶向下。。
对于王道的动态规划，再复习下其思想精髓
LeetCode解题之前，一定不要看题解，看了就“破功”了！