leetcode 数字翻译字符串 多方法解析

很明显可以看出来，解空间为一个多叉树，我们先画一下状态树，辅助理解：

从这个状态树中，我们就很容易看出来这其实就是 多叉树的回溯搜索，如果当前节点>=10 <=25,则继续向下搜索，否则回溯到上一个节点；

大于10是因为 可能存在0元素，如506, 只能是 5-->06 而不能组成 5->0->6

DFS

class Solution {
public:
    void backtrack(vector<int> arr,int index,int& res){
        if(index == arr.size()){
            res+=1;
            return ;
        }
        int tmp = 0;
        for(int i=index;i<arr.size();i++){
            tmp = tmp*10 + arr[i];
            if(tmp>=10 && tmp<=25){
                backtrack(arr,i+1,res);
            }
        }
    }
    int translateNum(int num) {
        vector<int> arr;
        while(num){
            arr.push_back(num%10);
            num /= 10;
        }
        reverse(arr.begin(),arr.end());

        int res=0;
        backtrack(arr,0,res);
        return res;
    }
};

我们首先定义状态变量，这种一维的问题，很容易直接定义dp[i]表示前i个数字可以组成的字符串，然后求dp[i+1]可以表示的字符串

状态转移方程：
我们首先分析一下，dp[i] 和几个状态有关

• 它可能自己单独翻译，因此12218的翻译次数和1221的翻译次数一样，因为1221加上8仍算同一种翻译。
• 它也可以和前面一位1一起组合翻译18， 这个时候要判断这个组合翻译是否在我们规定的范围内：10~25，如果可以合并则相当于dp[1221] + dp[122],即当成整体和单独翻译两个情况
  所以dp[i] = dp[i-1] + dp[i-2],如果满足合并翻译的话
  否则 dp[i] = dp[i-1]

相当于跳台阶，加了一个限制

动规

class Solution {
public:
    int translateNum(int num) {
        vector<int> arr;
        if(num == 0) return 1;

        while(num){
            arr.push_back(num%10);
            num /= 10;
        }
        reverse(arr.begin(),arr.end());
        vector<int> dp(arr.size()+1,0);

        dp[0] = 1,dp[1] = 1;
        for(int i=2;i<=arr.size();i++){
            dp[i] = dp[i-1];
            int tmp = arr[i-2]*10 + arr[i-1];
            if(tmp>=10&&tmp<=25){
                dp[i] += dp[i-2];
            }
        }
        return dp[arr.size()];
    }
};