LeetCode Top Interview Questions 91. Decode Ways (Java版； Medium)

welcome to my blog

LeetCode Top Interview Questions 91. Decode Ways (Java版; Medium)

题目描述

A message containing letters from A-Z is being encoded to numbers using the following mapping:

'A' -> 1
'B' -> 2
...
'Z' -> 26
Given a non-empty string containing only digits, determine the total number of ways to decode it.

Example 1:

Input: "12"
Output: 2
Explanation: It could be decoded as "AB" (1 2) or "L" (12).
Example 2:

Input: "226"
Output: 3
Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).

//状态压缩
class Solution {
    public int numDecodings(String s) {
        int n = s.length();
        if(n==0){
            return 0;
        }
        //小心初始化
        int a=0,b=1,c=1;
        for(int i=1; i<=n; i++){
            if(s.charAt(i-1)!='0'){
                a = b;
            }else{
                a = 0;
            }
            if(i-2>=0){
                int cur = Integer.valueOf(s.substring(i-2,i));
                if(cur>=10 && cur<=26){
                    a = a + c;
                }
            }
            //
            c = b;
            b = a;
        }
        return a;
    }
}

class Solution {
    public int numDecodings(String s) {
        int n = s.length();
        if(n==0){
            return 0;
        }
        //dp[i]表示前i个字符的解码种数
        int[] dp = new int[n+1];
        dp[0] = 1;
        for(int i=1; i<=n; i++){
            if(s.charAt(i-1)!='0'){
                dp[i] = dp[i-1];
            }
            if(i-2>=0){
                int a = Integer.valueOf(s.substring(i-2,i));
                if(a>=10 && a<=26){
                    dp[i] = dp[i] + dp[i-2];
                }
            }
        }
        return dp[n];
    }
}

第一次做; 空间压缩的动态规划, 不再需要O(n)的数组; 核心: 思想和普通dp一样, 要找好a,b,c和dp[i-2],dp[i-1],dp[i]的对应关系; 如何对a,b,c进行赋值更新; 这个方法容易写错, 先把普通的递归掌握好

class Solution {
    public int numDecodings(String s) {
        int n = s.length();
        if(n==1)
            return s.charAt(0)=='0'? 0:1;
        //初始化非常关键, 找好a,b,c和dp[i-2], dp[i-1], dp[i]的关系
        int a=1; //dp[i-2]
        int b=s.charAt(0)=='0'? 0:1; //dp[i-1]
        int c=0;
        for(int i=2; i<=n; i++){
            int one = Integer.parseInt(s.substring(i-1, i));
            int two = Integer.parseInt(s.substring(i-2,i));
            if(one==0)
                c = 0;
            else
                c = b;   
            if(two>=10 && two<=26)
                c = c + a;
            //update
            a = b;
            b = c;
        }
        return c;
    }
}

第一次做; 改进了代码, 思想没变; 核心:dp[i]表示前i个字符所有组合的数量; dp[0]初始化为1

class Solution {
    public int numDecodings(String s) {
        int n = s.length();
        int[] dp = new int[n+1];
        //初始化
        dp[0] = 1;
        //顺便也初始化dp[1], 这样就不用在dp主体中检查i-2是否越界了, dp主体中i从2开始, 所以i-2不会越界
        dp[1] = s.charAt(0)=='0'? 0:1;
        //dp主体
        for(int i=2; i<=n; i++){
            //Integer.parseInt()只能接收String, 不能接收char
            int one = Integer.parseInt(s.substring(i-1,i)); 
            int two = Integer.parseInt(s.substring(i-2,i));
            if(one!=0)
                dp[i] = dp[i-1];
            if(two>=10 && two<=26)
                dp[i] = dp[i] + dp[i-2];
        }
        return dp[n];
    }
}

第一次做; 根据暴力递归改成动态规划; 核心:dp[i]表示前i个字符所有组合的数量; dp[0]必须初始化为1; 需要改进的地方:考虑两个字符时,不用检查靠前的字符是否为’0’, 直接检查这两个字符组成的数字是否大于等于10同时小于等于26

/*
暴力递归改成动态规划, dp[i]表示前i个字符组合的所有可能
核心:dp[0]要初始化为0, 案例解释:"12"; dp主体处理逻辑参考暴力递归即可
*/

class Solution {
    public int numDecodings(String s) {
        //dp[i]表示: 前i个字符所有组合的数量? 或是 [0,i]所有组合的数量?
        int n = s.length();
        int[] dp = new int[n+1];
        //initialize; 不能初始化为0, 案例解释:"12"
        dp[0] = 1;
        //dp主体
        String cur;
        int tmp;
        for(int i=1; i<=n; i++){
            //以s.charAt(i-1)为开头, 那么s.charAt(i-1)不能为'0'
            if(s.charAt(i-1)=='0')
                dp[i] = 0;
            else
                dp[i] = dp[i-1];
            //以s.charAt(i-1)为结尾,那么在i-2不越界的情况下, s.charAt(i-2)不能为'0'
            if(i-2>=0 && s.charAt(i-2)!='0'){
                //左闭右开
                cur = s.substring(i-2, i);
                tmp = Integer.parseInt(cur);
                if(tmp>=10 && tmp<=26)
                    dp[i] = dp[i] + dp[i-2];
            }
        }
        return dp[n];
    }
}

第一次做; 暴力递归超时, 然后接着改成了memo数组优化的暴力递归, 避免了重复计算相同的子问题; 核心: 字符串中的’0’只能作为结尾, 不能作为开头; memo[i]的含义:[i,end]上所有组合的数量; 递归函数逻辑: [index,end]上所有组合的数量; 具体处理时, 分成以s[index]开头, 和以s[index,index+1]开头这两种情况进行讨论

/*
暴力递归, 以i开头或者以[i,i+1]开头; 这个可以用memo数组优化
核心: 相乘还是相加, 感觉是相加; 字符串中的'0'只能作为结尾, 不能作为开头
细节: 字符串索引越界检查
*/
import java.util.Arrays;


class Solution {
    public int numDecodings(String s) {
        //memo[i]表示[i,end]上所有组合的数量; 并不是以s.charAt(i)开头的数量
        int[] memo = new int[s.length()];
        Arrays.fill(memo, -1);
        return core(memo, s, 0);
    }
    //递归函数逻辑: [index,end]上所有组合的数量; 具体处理时, 分成以s[index]开头, 和以s[index,index+1]开头这两种情况进行讨论
    public int core(int[] memo, String s, int index){
        //base case
        if(index==s.length())
            return 1;
        if(memo[index]!=-1)
            return memo[index];
        //
        int res1=0, res2=0;
        String cur;
        int tmp;
        //以i开头
        cur = s.substring(index,index+1);
        tmp = Integer.parseInt(cur);
        //字符串中的'0'只能作为结尾, 不能作为开头, 所以开头是'0'的时候直接返回0
        if(tmp==0)
            return 0;
        
        //开头不为'0'
        res1 = core(memo, s, index+1);
        //以[i,i+1]开头; 越界检查
        if(index+1<s.length()){
            cur = s.substring(index, index+2);
            tmp = Integer.parseInt(cur);
            if(tmp>=1 && tmp<=26){
                res2 = core(memo, s, index+2);
            }
        }
        memo[index] = res1 + res2;
        return memo[index];
    }
}

LeetCode最优解, 我的思路和他一样, 但是写得没他简洁

和本题相似的问题:
62. Unique Paths
70. Climbing Stairs
509. Fibonacci Number

I used a dp array of size n + 1 to save subproblem solutions. dp[0] means an empty string will have one way to decode, dp[1] means the way to decode 
a string of size 1. I then check one digit and two digit combination and save the results along the way. In the end, dp[n] will be the end result.

public class Solution {
    public int numDecodings(String s) {
        if(s == null || s.length() == 0) {
            return 0;
        }
        int n = s.length();
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = s.charAt(0) != '0' ? 1 : 0;
        for(int i = 2; i <= n; i++) {
            int first = Integer.valueOf(s.substring(i-1, i));
            int second = Integer.valueOf(s.substring(i-2, i));
            if(first >= 1 && first <= 9) {
               dp[i] += dp[i-1];  
            }
            if(second >= 10 && second <= 26) {
                dp[i] += dp[i-2];
            }
        }
        return dp[n];
    }
}