【1.3】动态规划-解码方法

一、题目

一条包含字母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;
}