一、题目
一条包含字母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位的整数。
二、求解思路
在这个问题中，每个非零的数字都代表一个字符，而当数字为两位数时，只有小于或等于26的组合（且不能包含前导0）才能对应一个字符。基于这个规则，我们可以构建出解题的基本思路：将给定的字符串不断地拆分为单个数字或两个数字的组合。这种不断拆分的过程，自然而然地让人联想到二叉树的遍历。下面先尝试用递归的方式解决。
#include <iostream>
#include <vector>
#include <string>
class Solution {
public:
int numDecodings(const std::string& s) {
return binaryTreeTraversal(s, 0);
}
private:
int binaryTreeTraversal(const std::string& s, int index) {
int length = s.length();
// 递归终止条件：到达字符串末尾
if (index >= length) return 1;
// 单个0不能解码
if (s[index] == '0') return 0;
// 遍历左分支（单个字符）
int res = binaryTreeTraversal(s, index + 1);
// 遍历右分支（两个字符），确保不越界并且数值不大于26
if (index < length - 1 && (s[index] == '1' || (s[index] == '2' && s[index + 1] <= '6'))) {
res += binaryTreeTraversal(s, index + 2);
}
return res;
}
};
int main() {
Solution solution;
std::string s = "11106";
std::cout << "The total number of ways to decode the message '" << s << "' is: " << solution.numDecodings(s) << std::endl;
return 0;
}
运行上面代码的时候我们发现当数据量比较大的时候直接超时，这是因为上面代码中包含了大量的重复计算，如下图所示，比如两个红色框内都只剩下205。
#include <iostream>
#include <vector>
#include <string>
#include <cstring> // 用于 memset
int binaryTreeTraversal(const char* chars, int length, std::vector<int>& map, int index) {
// 递归终止条件：到达字符串末尾
if (index >= length) return 1;
// 如果计算过了，直接从 map 中取
if (map[index] != -1) return map[index];
// 单个0不能解码
if (chars[index] == '0') return 0;
// 遍历左分支（单个字符）
int res = binaryTreeTraversal(chars, length, map, index + 1);
// 遍历右分支（两个字符），确保不越界并且数值不大于26
if (index < length - 1 && (chars[index] == '1' || (chars[index] == '2' && chars[index + 1] <= '6'))) {
res += binaryTreeTraversal(chars, length, map, index + 2);
}
// 把计算的结果存储到 map 中
map[index] = res;
return res;
}
int numDecodings(const std::string& s) {
std::vector<int> map(s.length(), -1);
return binaryTreeTraversal(s.c_str(), s.length(), map, 0);
}
int main() {
std::string s = "11106";
std::cout << "The total number of ways to decode the message '" << s << "' is: " << numDecodings(s) << std::endl;
return 0;
}
动态规划方式解决
递归是从下到上开始计算，他是一直蒙着头往下走，当走到叶子节点的时候在回去。实际上我们还可以从上到下来计算，也就是这里讲的动态规划。
定义dp[i]表示前i个字符的解码数。
如果要求前i个字符的解码数，我们可以先求前i -1个字符的解码数，但前提条件是当前字符也可以解码（一个字符的话，只要不是0，都可以）。
还可以求前i -2个字符的解码数，但前提条件是当前字符和前一个字符构成的两个数字是有效的，也就是小于等于26。
每次截取一个或者每次截取两个，看到这里大家应该已经明白了，如果没有条件限制的话，这题解法和青蛙跳台阶相关问题完全一样，每次跳一个台阶或者每次跳两个台阶，递归公式其实就是个斐波那契数列。
dp[i]=dp[i -1]+dp[i -2]
只不过这里的斐波那契数列是有条件限制的，需要根据条件判断哪一项该加，哪一项不该加，但原理都差不多，来看下代码
#include <iostream>
#include <string>
#include <vector>
int numDecodings(const std::string& s) {
int length = s.length();
std::vector<int> dp(length + 1);
dp[0] = 1; // 空字符串有一种解码方式
for (int i = 1; i <= length; i++) {
// 判断截取一个字符是否符合（只要不是 '0'，都符合）
if (s[i - 1] != '0') {
dp[i] += dp[i - 1];
}
// 判断截取两个字符是否符合
if (i >= 2 && (s[i - 2] == '1' || (s[i - 2] == '2' && s[i - 1] <= '6'))) {
dp[i] += dp[i - 2];
}
}
return dp[length];
}
int main() {
std::string s = "11106";
std::cout << "The total number of ways to decode the message '" << s << "' is: " << numDecodings(s) << std::endl;
return 0;
}
三、代码实现
#include <iostream>
#include <string>
int numDecodings(const std::string& s) {
int length = s.length();
int lastLast = 0; // 上上个解码方法的数量
int last = 1; // 上一个解码方法的数量
int cur = 0; // 当前解码方法的数量
for (int i = 0; i < length; i++) {
cur = 0; // 每次循环开始时重置当前解码方法数量
// 判断截取一个字符是否符合（只要不是 '0'，都符合）
if (s[i] != '0') {
cur = last;
}
// 判断截取两个字符是否符合
if (i >= 1 && (s[i - 1] == '1' || (s[i - 1] == '2' && s[i] <= '6'))) {
cur += lastLast;
}
// 更新 lastLast 和 last 为下一次循环准备
lastLast = last;
last = cur;
}
// 最后返回的是 last，即最后一个解码方法的数量
return last;
}
int main() {
std::string s = "11106";
std::cout << "The total number of ways to decode the message '" << s << "' is: " << numDecodings(s) << std::endl;
return 0;
}
