面试题46：把数字翻译成字符串-动态规划

题目描述

面试题46：给定一个数字，按照如下规则翻译成字符串：0翻译成“a”，1翻译成“b”…25翻译成“z”。一个数字有多种翻译可能，例如12258一共有5种，分别是bccfi，bwfi，bczi，mcfi，mzi。实现一个函数，用来计算一个数字有多少种不同的翻译方法。

题目分析

方法一：动态规划

见到题目第一反应是递归，然而…写了半天也没写出来。剑指offer的思路也是递归，但是用循环实现。其实本质上来说，这是一道考察动态规划的题目。假设dp[i]表示位置i - 1结尾处总共有多少种翻译方法，则状态方程如下：

注意申请dp的时候，多申请一个数。
dp数组的最开始的数相等于一个““辅助”数，其值为1，此时dp[i]表示位置i - 1结尾处总共有多少种翻译方法.注意边界情况

class Solution {
public:
    int translateNum(int num) {
        string  s = to_string(num);
        int len = s.size();
        vector<int> dp(len + 1, 0);

        dp[0] = 1; //辅助元素
        dp[1] = 1; //s[0]结尾的组合数

        for (int i = 2; i <= len; ++i) {
            if (s[i - 2] == '0' || s.substr(i - 2, 2) > "25") //字符以及字符串比较
                dp[i] = dp[i -1];
            else 
                dp[i] = dp[i-1] + dp[i-2];
        }

        return dp[len]; //s[len-1] 结尾的元素的组合总个数
    }
};

作者：huwt
链接：https://leetcode-cn.com/problems/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-lcof/solution/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-hui-su-dong-tai/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

不用辅助数，dp[i]表示位置i结尾处总共有多少种翻译方法，此时需要单独处理数字个数为2时的情况，即边界情况.

class Solution {
public:
    int translateNum(int num) {
        string s = to_string(num);
        int len = s.size();
        
        vector<int> dp(len,0);

        dp[0] = 1;
        if (len > 1) { //单独处理dp[1]
             if ( s[0] == '0' || s.substr(0, 2) > "25" )
                dp[1] = 1;
            else
                dp[1] = 2;
        }
       
        for (int i = 2; i < len; ++i) {
            if ( s[i - 1] == '0' || s.substr(i - 1, 2) > "25")
                dp[i] = dp[i-1];
            else 
                dp[i] = dp[i-1] + dp[i-2] ;
        }
        return dp[len -1];
    }
};

方法二：回溯法

class Solution {
public:
    int backtrace(string& str, int pos) {
        int n = str.size();
        if (pos == n) {
            return 1;
        }
        if (pos == n-1 || str[pos] == '0' || str.substr(pos, 2) > "25") {
            return backtrace(str, pos+1);
        }
        return backtrace(str, pos+1) + backtrace(str, pos+2);
    }
    int translateNum(int num) {
        string str = to_string(num);
        return backtrace(str, 0);
    }
};

c++中str.substr的用法

substr有2种用法：
假设：string s = “0123456789”;

string sub1 = s.substr(5); //只有一个数字5表示从下标为5开始一直到结尾：sub1 = “56789”

string sub2 = s.substr(5, 3); //从下标为5开始截取长度为3位：sub2 = “567”

20211001

使用stringstream转换字符串

class Solution {
public:
    int translateNum(int num) {
        stringstream ss;
        ss << num; // 将num放入输入流中
        string s;
        ss >> s; // 从输入流中提取字符串
        string::size_type len = s.size();
        vector<int> dp(len, 0); // dp[i]：以i结尾位置处总共有多少种翻译方法
        dp[0] = 1; // 初始条件
        if (len > 1) { // 不加这个会报堆缓冲区发生了溢出
            if (s[0] == '0' || s.substr(0, 2) > "25") { // 不能合并
                dp[1] = 1;
            } else {
                dp[1] = 2;
            }
        }
     
        for (string::size_type i = 2; i < len; i++) {
            if (s[i - 1] == '0' || s.substr(i - 1, 2) > "25") { // 不能合并
                dp[i] = dp[i -1];
            } else {
                dp[i] = dp[i-1] + dp[i-2];
            }
        }

        return dp[len - 1]; //s[len-1] 结尾的元素的组合总个数
    }
};

进一步优化：

class Solution {
public:
    int translateNum(int num) {
        stringstream ss;
        ss << num; // 将num放入输入流中
        string s;
        ss >> s; // 从输入流中提取字符串
        string::size_type len = s.size();
        vector<int> dp(len + 1, 0); // 申请一个复制字段

        dp[0] = 1; // 辅助字段
        dp[1] = 1; // 初始值,即s[0]结尾处对应的翻译方法数量

        for (string::size_type i = 2; i <= len; i++) { // 从s[1]开始在循环中获得
            if (s[i - 2] == '0' || s.substr(i - 2, 2) > "25") { // s[i-1]不能与前者合并时
                dp[i] = dp[i -1];
            } else { // s[i-1]可以和前者合并时
                dp[i] = dp[i-1] + dp[i-2];
            }
        }

        return dp[len]; //s[len-1] 结尾的元素的组合总个数
    }
};