LeetCode第[91]题(Java)：Decode Ways（解码方法数）
题目：解码方法数
难度：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.
翻译：
一个包含A-Z字母的消息被编码成数字，使用以下映射：
“A” - > 1
“B”- > 2
……
“Z”- > 26
给定一个包含数字的非空字符串，确定解码它的总方法数。
我的思路：一开始想用递归但是边界问题太多，就放弃了。
single 从0开始（每个数组单独解码），count从1开始，如果s[i-1]s[i]二者组成的数字在（0，26 ] 范围内，那就count+；
且遇见0的时候，一开始的单独编码就不存在了，且少了一次组合的机会，例如【110】 中【11】和【0】不能组合
所以此时 single = 0；count - 1
我的代码：
1 public int numDecodings(String s) { 2 if (s.isEmpty() || s.charAt(0) == '0') 3 return 0; 4 5 int count = 0; 6 int single = 1; 7 for (int i = 1; i < s.length(); i++) { 8 if (s.charAt(i) == '0'){ 9 count = s.length() > 2 ? count-1 : count; 10 single = 0; 11 } 12 int x = Integer.parseInt(s.substring(i-1, i+1)); 13 if ( x<= 26 && x > 0) { 14 count += 1; 15 } 16 } 17 return (count + single) > 0 ? (count + single) : 0; 18 }
结果：214 / 258 test cases passed.
编码过程中的问题：
1、最初 single 和 count 没有分开计算；
2、第9行，当只有两个的时候，此时count 不需要 -1 ，例如【10】；
3、这个思路还是有问题的，例如【1212】中少计算了【12】【12】这个组合
答案代码：
1 public class Solution { 2 public int numDecodings(String s) { 3 int n = s.length(); 4 if (n == 0) return 0; 5 6 int[] memo = new int[n+1]; 7 memo[n] = 1; 8 memo[n-1] = s.charAt(n-1) != '0' ? 1 : 0; 9 10 for (int i = n - 2; i >= 0; i--) 11 if (s.charAt(i) == '0') continue; 12 else memo[i] = (Integer.parseInt(s.substring(i,i+2))<=26) ? memo[i+1]+memo[i+2] : memo[i+1]; 13 14 return memo[0]; 15 } 16 }
答案思路：
假设所有的数字都有效，且左右两两相邻数之间也有效（1到26）,那么有如下规律
numDecodings(s) = numDecodings(s.substring(1)) + numDecodings(s.substring(2)) --------------------------------------------------式（1）
规律显而易见，斐波那契数列。不过是反过来的（从字符串后面往前）
当然，那只是假设，也要考虑特殊情况：
【使用一个数组（大小为len+1）从后往前记录对应的数字“出现”后解码数的增量】
1、当前指针所指字符为0
此时此字符无法解码，所以式（1）中的前者就只能为0，后者也为0
例如【023】，substring（1）——【0】|【23】，截掉的【0】不能解析，所以此组合无效
substring（2）——【02】|【3】，截掉的【02】不能解析，所以此组合无效
所以0数字出现后，解码数的增量为0。
2、当前字符的值是有效的（大于0），但是当前字符与右边字符组合的数字无效（大于26）
相当于式（1）中的后者=0
例如【3212】，substring（1）——【3】|【212】，截掉的【3】能解析，所以其值为【212】的解码数
substring（2）——【32】|【12】，截掉的【32】不能解析，所以此组合无效\
递归实现：
1 public int numDecodings(String s) { 2 if (s.isEmpty()) { 3 return 1; 4 } 5 6 if (s.charAt(0) == '0') { 7 return 0; 8 } 9 10 if (s.length() == 1) 11 return 1; 12 13 int sub1 = numDecodings(s.substring(1)); 14 int sub2 = 0; 15 16 if (Integer.parseInt(s.substring(0,2)) <= 26) { 17 sub2 = numDecodings(s.substring(2)); 18 } 19 return sub1 + sub2; 20 }
此方法会在最后几个用例（很长）运行超时。
所以答案采用了迭代的方式进行。
优化：既然是斐波纳数列，那么就能使用双值迭代的方式取代用一个数组进行记录。
1 public int numDecodings(String s) { 2 if (s.isEmpty() || s.charAt(0) == '0') { 3 return 0; 4 } 5 int sub1 = 1; 6 int sub2 = 1; 7 for (int i = s.length() - 2; i > -1; i--) { 8 if (s.charAt(i+1) == '0') { 9 sub1 = 0; 10 } 11 if (Integer.parseInt(s.substring(i,i+2)) <= 26) { 12 sub1 = sub1 + sub2; 13 sub2 = sub1 - sub2; 14 } else { 15 sub2 = sub1; 16 } 17 } 18 return sub1; 19 }
第11行其实还可以使用字符进行判断以降低时间和空间复杂度：
s.charAt(i) == '1' || s.charAt(i) == '2' && s.charAt(i+1) - '0' <= 6
