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

【题目描述】

一条包含字母 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，否则为0dp[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解题之前，一定不要看题解，看了就“破功”了！