算法：数字转变为字符串结果数

题目描述

规定1和A对应、2和B对应、3和C对应…26和Z对应
那么一个数字字符串比如"111”就可以转化为: “AAA”、“KA"和"AK”

给定一个只有数字字符组成的字符串str，返回有多少种转化结果

题目解析

其实这题就是一道青蛙跳台阶，只不过在一次性跳两阶时，要判断条件，不符合就不准跳两阶

递归

定义一个签名：当前要翻译的字符串是str，当前已经翻译到了index处，请返回还剩下多少种翻译方法

int process(str, index);

base case：

• 当index == str时，到达了字符串的尾部，此时返回数字1，表示找到了一种转换结果

普通情况：

• 当index遇到的字符为0，因为没有以0开头的数字串对应的字母，则说明之前的选择是错误的，直接返回0
• 当index遇到的字符是3~9，直接读取一位
• 当index遇到的字符是1~2，可以选一位，也可以选择两位，选择两位的时候要判断是否在10到26之间

class Solution {
	// 从0开始翻译
    int process(string& s, int idx){
        int n = s.size();

		// 如果翻译完毕，那么返回1
        if(idx == n) {
            return 1;
        }

		// 还有字符可以选择
		// 判断能不能选择
        if(s[idx] == '0'){
            return 0;
        }
		//可以选择一位
        int p1 = process(s, idx + 1);
        if(idx + 1 < n && s.substr(idx, 2) < "27"){
            p1 += process(s, idx + 2);  //可以选择两位
        }
        return p1;
    }

public:
    int translateNum(int num) {
        std::string str = std::to_string(num);
        return process(str, 0);
    }
};

暴力递归改动态规划

（1）先举个例子，看暴力递归有没有重复调用，有，所以可以改成递归

（2）准备一个表。重点关注可变参数的范围

 int process(std::string &str, int index)

• index：是索引------0 ~ N

上面只有一个变化维度，所以准备一个一维数组

      std::vector<int> dp(N + 1);

（3）返回值，关注主函数是怎么调用的

        return process(str, 0);

所以直接返回dp[0]

（4）接下来该填表了，对于111

• 先看base case

  		if(idx == n) {
            return 1;
        }

• 标记target

• 看依赖：普遍依赖情况是依赖下一个位置或下两个位置的和。
  
• 所以填表，应该从右到左

class Solution {

public:
    int translateNum(int num) {
        std::string str = std::to_string(num);
        int N = str.size();
        std::vector<int> dp(N + 1, 0);
        dp[N] = 1;
        for (int i = N - 1; i >= 0; --i) {
            if(dp[i] != '0'){
                dp[i] = dp[i + 1];
                if(i + 1 < N && str.substr(i, 2) < "27"){
                    dp[i] += dp[i + 2];
                }
            }
        }
        return dp[0];
    }
};