【LeetCode】91. Decode Ways

91. Decode Ways

Description：

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).

 解题思路：

（1）递归解法

题目分析：

如果要用递归解法，就需要先找出递归公式：

numDecodings[102213] = numDecodings[02213] + numDecodings[2213] 

字符串“102213”解码的方式有两种：第一种，先解码子串“1”，再解码子串“02213”。但是以0开始的子串是无法解析的。第二种，先解码子串“10”，再解码子串“2213”。

解码子串“2213”也有两种方式：第一种，先解码子串“2”，再解码子串“213”。第二种，先解码子串“22”，再解码子串“13”。

以此类推。。。

规律显而易见，类似斐波那契数列。不同的是字符串从后往前推出递推公式。

递归公式：

numDecodings[s]= numDecodings[s.substring(1)] + numDecodings[s.substring(2)]

递归结束条件：

1. 当前指针所指字符为0

　　此时此字符无法解码，所以递归公式中的前者就只能为0，后者也为0。

　　例如【023】，substring（1）——【0】|【23】，截掉的【0】不能解析，所以此组合无效。

　　　　　　　　   substring（2）——【02】|【3】，截掉的【02】不能解析，所以此组合无效。

　　所以0数字出现后，解码数的增量为0。

2. 当前字符的值是有效的（大于0），但是当前字符与右边字符组合的数字无效（大于26）。

　　相当于递归公式中的后者为0。

　　例如【3212】，substring（1）——【3】|【212】，截掉的【3】能解析，所以其值为【212】的解码数。

　　　　　　　　     substring（2）——【32】|【12】，截掉的【32】不能解析，所以此组合无效。

递归代码：

不能AC，Time Limit Exceeded。

public class DecodeWays_91 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "102213";
		System.out.println(numDecodings(s));
	}
	
    public static int numDecodings(String s) {
    	if(s.isEmpty())
    		return 1;
    	if(s.charAt(0) == '0')
    		return 0;
    	if(s.length() == 1)
    		return 1;
    	int res = numDecodings(s.substring(1));
    	if(s.charAt(0) == '1' || s.charAt(0) == '2' && s.charAt(0+1) - '0' <= 6 )
    		res += numDecodings(s.substring(2));
    	return res;
    }

}

（2）记忆化递归解法

由于递归解法包含很多重复的计算，我们把重复计算的结果先保存起来，等到用的时候，直接取出来。

已经AC代码：

import java.util.HashMap;

public class DecodeWays_91 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "102213";
		System.out.println(numDecodings1(s));
	}
	
	public static HashMap<String, Integer> memo;
	
	 public static int numDecodings1(String s) {
		memo = new HashMap<>(); 
		memo.put(null, 1);
		return ways(s);
	 }
	 
	 public static int ways(String s) {
		if(memo.containsKey(s))
			return memo.get(s);
		if(s.isEmpty())
    		return 1;
    	if(s.charAt(0) == '0')
    		return 0;
    	if(s.length() == 1)
    		return 1;
    	int res = ways(s.substring(1));
    	if(s.charAt(0) == '1' || s.charAt(0) == '2' && s.charAt(0+1) - '0' <= 6 )
    		res += ways(s.substring(2));
    	
    	memo.put(s, res);
    	return res;
	}

}

（3）动态规划解法

1. 从递归的解法中，我们发现了重叠子问题。根据重叠子问题，我们得到最优子结构。

假设数组dp[i]表示从头到字符串的第i位，一共有多少种解码方法的话。那么如果字符串的第i-1位和第i位能组成一个10到26的数字，说明我们是在第i-2位的解码方法上继续解码，此时dp[i] = dp[i-2]。如果字符串的第i-1位和第i位不能组成有效二位数字，而且第i位不是0的话，说明我们是在第i-1位的解码方法上继续解码，此时dp[i] = dp[i - 1]。所以，如果两个条件都符合，则dp[i] = dp[i - 1] + dp[i - 2]。

 2. 根据最优子结构，写出状态转移方程。

dp[i]的取值有以下四种情况：

1. 如果s[i]和s[i - 1]s[i]都是无效的话，dp[i] = 0;

2. 如果s[i]和s[i - 1]s[i]都是有效的话，dp[i] = dp[i - 1] + dp[i - 2] ;

3. 如果s[i]是有效的，s[i - 1]s[i]是无效的话，dp[i] = dp[i - 1];

4. 如果s[i - 1]s[i]是有效的，s[i]是无效的话，dp[i] = dp[i - 2];

• 如果 s[i] != '0'，则 s[i]是有效的。
• 如果‘10’<= s[i - 1]s[i] <='26'，则s[i-1]s[i]是有效的。

已经AC的代码：

public class DecodeWays_91 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "102213";
		System.out.println(numDecodings(s));
		System.out.println(s.substring(3-2, 3));
	}
	
    public static int numDecodings(String s) {
    	if(s.length() == 0)
    		return s.length();
    	int[] dp = new int[s.length() + 1];
    	//初始化第一种解码方式
    	dp[0] = 1;
    	//如果第一位是0，则无法解码
    	dp[1] = s.charAt(0) == '0' ? 0 : 1;
    	for(int i = 2; i <= s.length(); i++) {
    		// 如果字符串的第i-1位和第i位能组成一个10到26的数字，说明我们可以在第i-2位的解码方法上继续解码
    		if(Integer.parseInt(s.substring(i-2, i)) <= 26 && Integer.parseInt(s.substring(i-2, i)) >= 10) {
    			dp[i] += dp[i - 2];
    		}
    		 // 如果字符串的第i-1位和第i位不能组成有效二位数字，在第i-1位的解码方法上继续解码
            if(Integer.parseInt(s.substring(i-1, i)) != 0){
                dp[i] += dp[i - 1];
            }
    	}
    	 return dp[s.length()];
    }

}

Reference：

【1】LeetCode第[91]题(Java)：Decode Ways（解码方法数）

【2】花花酱 LeetCode 91. Decode Ways

【3】花花酱 LeetCode 91. Decode Ways 视频讲解

【4】[Leetcode] Decode Ways 解码方式