动态规划

动态规划的本质就是把一个大问题分解为若干个小问题来解决，知道被分解的最小问题是可以被解决的。常见的动态规划解法包括递归或者使用数组来存储中间计算状态然后通过循环解决。

a. 有一个map将ABCDE...Z映射到1234...26. 因此，'26'既可以对应到Z又可以对应到BF，给定一个数字串，找出其map back的字符串总和，比如26可以对应到Z或者BF，所以return 2。 

class Solution {
    //递归解法
    int numDecoding(string s) {
        return helper(s, 0);
    }
    int helper(string& s, int start) {
        if (start >= s.size()) return 0;
        if (s[start] == '0') return 0;
        if (start + 1 == s.size()) return 1;
        if (start + 2 == s.size()) {
            if (s[start+1] == '0')
                return s[start] > '2' ? 0 : 1;
            else 
                return s.substr(start, 2) > "26" ? 1 : 2; 
        }
        int match1 = helper(s, start + 1);
        int match2 = 0;
        if (s.substr(start, 2) < '27') 
            match2 = helper(s, start + 2);
        return match1 + match2;
    }
    //非递归解法
    int numDecoding(string s) {
        if (s.empty()) return 0;
        vector<int> cache(s.length(), 0);
        for(int i = 0; i < s.length(); ++i) {
            if (i == 0) cache[i] = s[0] == '0' ? 0 : 1;
            else if (i == 1) cache[i] = s[0] == '0' ? 0 : (s[1] == '0' ? (s[0] < '3' ? 1 : 0) : (s.substr(0, 2) > '26' ? 1 : 2); 
            else {
                if (s[i] == '0') 
                    cache[i] = (cache[i-1] != '0' && s.substr(i-1, 2) < '27') cache[i-2] : 0; 
                else 
                    cache[i] = cache[i-1] + (cache[i-1] != '0' && s.substr(i-1, 2) < '27' ? cache[i-2] : 0);
            }
    }
}