Leetcode 解码方法

解码方法

题目描述：

一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

'A' -> 1

'B' -> 2

...

'Z' -> 26

要 解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"111" 可以将 "1" 中的每个 "1" 映射为 "A" ，从而得到 "AAA" ，或者可以将 "11" 和 "1"（分别为 "K" 和 "A" ）映射为 "KA" 。注意，"06" 不能映射为 "F" ，因为 "6" 和 "06" 不同。

给你一个只含数字的 非空字符串 num ，请计算并返回 解码方法的 总数。

题目数据保证答案肯定是一个 32 位的整数。

题目链接

class Solution {
    private final Map<Integer,Character> map = new HashMap<>();
    private String s;
    private int result;
    private int len;
    public int numDecodings(String s) {
        // 初始化
        this.s = s;
        this.len = s.length();
        for(int i = 1 ; i<=26 ; i++){
            map.put(i,(char)('A'-1+i));
        }
        Solution solution = new Solution();
        recursion(0);
        return this.result;
    }
    private void recursion(int begin){
        if(begin == this.len){
            this.result++;
            return;
        }
        int temp1 = this.s.charAt(begin)-'0';
        int temp2 = temp1;
        if(begin+1<len){
            if(temp1 == 0) return;
            temp2 = this.s.charAt(begin+1)-'0' + temp2*10;
            if(map.containsKey(temp1)){
                recursion(begin+1);
            }
            if(map.containsKey(temp2)){
                recursion(begin+2);
            }
        }else{
            if(temp1 == 0) return;
            if(map.containsKey(temp1)){
                recursion(begin+1);
            }
        }
    }
}

超时，继续优化…

class Solution {
    public int numDecodings(String s) {
        // 初始化
        int len = s.length();
        int[] dp = new int[len];
        if(s.charAt(0) == '0') return 0;
        dp[0] = 1;
        // 动态规划过程
        for(int i = 1 ; i<len ; i++){
            if(s.charAt(i) == '0'){
                if(s.charAt(i-1) != '1' && s.charAt(i-1) != '2') return 0;
                else dp[i] = ((i-2<0)?1:dp[i-2]);
            }else if(s.charAt(i-1) == '1'){
                dp[i] = dp[i-1] + ((i-2<0)?1:dp[i-2]); // 该条件下和爬楼梯的题目类似
            }else if(s.charAt(i-1) == '2'){
                if(s.charAt(i)>='1' && s.charAt(i)<='6'){
                    dp[i] = dp[i-1] + ((i-2<0)?1:dp[i-2]);
                }else{
                    dp[i] = dp[i-1];
                }
            }else{
                dp[i] = dp[i-1];
            }
        }
        return dp[len-1];
    }
}

利用动态规划的思想，定义存储数组dp[i]为字符串s前i+1个字符所有的解码方法个数。
然后可以得出转移方程：

• 当前的位置的字符为'0'，则取决于前一个字符，若为'1'或者'2'，则dp[i] = dp[i-2]('一次两步到达')
• 考虑大于10的情况：前一个位置的字符为'1',则dp[i] = dp[i-1]('一次一步到达')+dp[i-2]('一次两步到达')
• 考虑大于20的情况：前一个位置的字符为'2',如果s[i]的值不在'1'到'6'之间,则dp[i] = dp[i-1],否则dp[i] = dp[i-1]('一次一步到达')+dp[i-2]('一次两次到达')
• 考虑单个普通字符(排除以上所有情况下),dp[i] = dp[i-1]('一步一次到达')

详细请看代码，有疑问欢迎留言。