数据集转字符集 -- 动态规划

问题描述

题目链接：解码方法
一条包含字母 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 位 的整数。

解题思路

同样考虑从暴力递归到动态规划的两种思路，动态规划考虑从左到右和从右到左的两种实现，详细见如下代码：

class NumDecodings:
    """
    https://leetcode.cn/problems/decode-ways/
    解码方法
    """
    def solution1(self, s: str) -> int:
        if not s:
            return 0
        return self.process1(s, 0)

    def process1(self, s: str, index: int) -> int:
        """
        s[0...index] 已转化完，不用关心
        s[index...]去转化，返回有多少种方法
        :param s:
        :param index:
        :return:
        """
        if index == len(s):
            return 1
        # i没到最后，说明有字符
        if str[index] == '0':  # 之前的决定有问题
            return 0
        # index 单独转
        ways = self.process1(s, index+1)
        if index+1 < len(s) and ((ord(s[index])-ord('0'))*10 + ord(s[index+1])-ord('0')<27):
            ways += self.process1(s, index+2)
        return ways

    def solution2(self, s: str) -> int:
        """
        记忆式搜索
        从右往左，动态规划
        dp[i]表示：str[i...]有多少种转化方式
        :param s:
        :return:
        """
        if not s:
            return 0

        n = len(s)
        dp = [0]*(n+1)
        dp[n] = 1
        for index in range(n-1, -1, -1):
            if s[index] != '0':
                ways = dp[index+1]
                if index + 1 < len(s) and ((ord(s[index]) - ord('0')) * 10 + ord(s[index + 1]) - ord('0') < 27):
                    ways += dp[index+2]

                dp[index] = ways

        return dp[0]

    def solution3(self, s: str) -> int:
        """
        从左往右，动态规划
        dp[i]表示：str[0...i]有多少种转化方式
        :param s:
        :return:
        """
        if not s or s[0] == '0':
            return 0

        n = len(s)
        dp = [0]*n
        dp[0] = 1

        for i in range(1, n):
            if s[i] == '0':
                """
                如果此时str[i]=='0'，那么他是一定要拉前一个字符(i-1的字符)一起拼的，
				那么就要求前一个字符，不能也是‘0’，否则拼不了。
				前一个字符不是‘0’就够了嘛？不够，还得要求拼完了要么是10，要么是20，如果更大的话，拼不了。
				这就够了嘛？还不够，你们拼完了，还得要求str[0...i-2]真的可以被分解！
				如果str[0...i-2]都不存在分解方案，那i和i-1拼成了也不行，因为之前的搞定不了。
                """
                if s[i-1] == '0' or s[i-1] > '2' or (i-2>=0 and dp[i-2]==0):
                    return 0
                else:
                    dp[i] = dp[i-2] if i-2 >= 0 else 1

            else:
                dp[i] = dp[i-1]
                if s[i-1] != '0' and ((ord(s[i-1]) - ord('0')) * 10 + ord(s[i]) - ord('0') < 27):
                    dp[i] += dp[i-2] if i-2 >= 0 else 1

        return dp[n-1]