【LeetCode】解码方法 II [H]（记忆化搜索）

639. 解码方法 II - 力扣（LeetCode）

一、题目

一条包含字母 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" 不同。

除了 上面描述的数字字母映射方案，编码消息中可能包含 '*' 字符，可以表示从 '1' 到 '9' 的任一数字（不包括 '0'）。例如，编码字符串 "1*" 可以表示 "11"、"12"、"13"、"14"、"15"、"16"、"17"、"18" 或 "19" 中的任意一条消息。对 "1*" 进行解码，相当于解码该字符串可以表示的任何编码消息。

给你一个字符串 s ，由数字和 '*' 字符组成，返回 解码 该字符串的方法 数目 。

由于答案数目可能非常大，返回 109 + 7 的 模 。

示例 1：
输入：s = "*"
输出：9
解释：这一条编码消息可以表示 "1"、"2"、"3"、"4"、"5"、"6"、"7"、"8" 或 "9" 中的任意一条。
可以分别解码成字符串 "A"、"B"、"C"、"D"、"E"、"F"、"G"、"H" 和 "I" 。
因此，"*" 总共有 9 种解码方法。

示例 2：
输入：s = "1*"
输出：18
解释：这一条编码消息可以表示 "11"、"12"、"13"、"14"、"15"、"16"、"17"、"18" 或 "19" 中的任意一条。
每种消息都可以由 2 种方法解码（例如，"11" 可以解码成 "AA" 或 "K"）。
因此，"1*" 共有 9 * 2 = 18 种解码方法。

示例 3：
输入：s = "2*"
输出：15
解释：这一条编码消息可以表示 "21"、"22"、"23"、"24"、"25"、"26"、"27"、"28" 或 "29" 中的任意一条。
"21"、"22"、"23"、"24"、"25" 和 "26" 由 2 种解码方法，但 "27"、"28" 和 "29" 仅有 1 种解码方法。
因此，"2*" 共有 (6 * 2) + (3 * 1) = 12 + 3 = 15 种解码方法。

提示：

• 1 <= s.length <= 105
• s[i] 是 0 - 9 中的一位数字或字符 '*'

二、代码

class Solution {
    public static long MOD = 1000000007;

    public int numDecodings(String str) {
        if (str == null || str.length() == 0) {
            return 0;
        }

        long[] dp = new long[str.length()];
        return (int) process2(str.toCharArray(), 0, dp);
    }

    public long process2(char[] s, int i, long[] dp) {
        if (i == s.length) {
            return 1;
        }

        if (s[i] == '0') {
            return 0;
        }

        if (dp[i] != 0) {
            return dp[i];
        }

        // 当前位置的字符不是*
        if (s[i] != '*') {
            // 情况1：当前位置的数字单独转换
            long p1 = 1 * process2(s, i + 1, dp);
            if (i + 1 == s.length) {
                dp[i] = p1 % MOD;
                return dp[i];
            }

            // 情况2：当前位置的数字和下一个位置的数字合并在一起进行转换
            long p2 = 0;
            // 下一个位置是*
            if (s[i + 1] != '*') {
                int num = (s[i] - '0') * 10 + (s[i + 1] - '0');
                if (num < 27) {
                    p2 = 1 * process2(s, i + 2, dp);
                }
            // 下一个位置不是*
            } else {
                if (s[i] < '3') {
                    p2 = (s[i] == '1' ? 9 : 6) * process2(s, i + 2, dp);
                }
            }

            dp[i] = (p1 + p2) % MOD;
            return dp[i];
        // 当前位置的字符是*
        } else {
            // 情况1：当前位置的数字单独转换
            // i 单转 9种
            long p1 = 9 * process2(s, i + 1, dp);
            if (i + 1 == s.length) {
                dp[i] = p1 % MOD;
                return dp[i];
            }

            // 情况2：当前位置的数字和下一个位置的数字合并在一起进行转换
            long p2 = 0;
            if (s[i + 1] != '*') {
                // * 0 10 20
                // * 1 11 21
                // * 2 12 22
                // * 3 13 23
                // * 6 16 26
                // * 7 17
                // * 8 18
                // * 9 19
                p2 = (s[i + 1] < '7' ? 2 : 1) * process2(s, i + 2, dp);
            } else {
                // **
                // 11~19 9
                // 21 ~26 6
                // 15
                p2 = 15 * process2(s, i + 2, dp);
            }

            dp[i] = (p1 + p2) % MOD;
            return dp[i];
        }
    }
}

三、解题思路

*：可以变1~9。注意*不能变为0，只能变为1~9。

这是一个从左往右尝试的模型，也就是从给定字符串的左边开始分情况讨论，将所有的情况都列出来。