发表于: 更新于: 浏览: 785

题目地址

题目描述

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

示例 1:

输入: 12258
输出: 5
解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"

提示：

0 <= num < 231

解法

JAVA

  String numStr=String.valueOf(num);
        int res = 1, last = 1;
        for(int i = 2; i <= numStr.length(); i++) {
            String tmp = numStr.substring(i - 2, i);
            int i2 = tmp.compareTo("10") >= 0 && tmp.compareTo("25") <= 0 ? res + last : res;
            last = res;
            res = i2;
        }
        return res;

CPP

class Solution {
public:
    static int translateNum(int num) {
        if (num<10) return 1;
        if (num<25) return 2;
        if (num<100) return 1;
        else {
            int ans = 0;
            int a = 1;
            while (num / 10 >= a) a *= 10;
            ans = ans + translateNum(num % a);
            a /= 10;
            if (num / a < 26) {
                ans = ans + translateNum(num % a);
            }
            return ans;
        }
    }
};

解题思路

动态规划

这道题，实际上并不是要真的转换成它要求的字母，只要得出有多少种分割方法就行了。比如12，就有两种分割方法，1和2、12。
我们以12258为例子
下标为0时，此时数字为1，只能拆分为1
下标为1时，此时数字为12，拆分为1,2|12(以|符号标识不同的分割)
下标为2时，此时数字为122，拆分为1,2,2|12,2|1,22(以|符号标识不同的分割)
......
当下标为2时

  1. 先将之前的下标的结果(1，2|12)，添加当前的数字(12,2|12，2)
  2. 继续下标为0时基础上分割，(1,22)

整理出公式 f(i)= f(i-1)+ f(i-2),如果在i-2的基础上，此时分割的字符不在0~25之间，我们则不能进行分割，即使 f(i)= f(i-1)
其实，我们可以看出类似斐波那契数列,F(3)=F(1)+F(2),在这个基础之上加了一个条件的判断

//截取到i-2位置的字符，类似下标为2的时候，22
String tmp = numStr.substring(i - 2, i);
//判断字符是否在0到25之间，是否累计的i-2的值
 int c = tmp.compareTo("10") >= 0 && tmp.compareTo("25") <= 0 ? res + last : res;

我们定义两个变量，一个变量时i-1值，一个记录i-2的值

   int res = 1, last = 1;
        for(int i = 2; i <= numStr.length(); i++) {
          //计算 i的当前值
          //把i-1的值赋给last，下次遍历就是i-2
            last = res;
          //把当前的计算i赋给res ，到下次遍历，变为i-1
            res = c;
        }

递归

递归的方法其实，我还是不太理解，可以参考题解
结束条件

if (num<10) return 1;
if (num<26) return 2;
if (num<100) return 1;

假设当前数字为9，我们只能拆分1个；
假设当前数字为19，我们只能拆分2个；
假设当前数字为198，由于19在之前的遍历中已经计算了，只能计算最后一个数字8；
递归体

  else {
            int ans = 0;
            int a = 1;
             while (num / 10 >= a) {a *= 10};
            //这里从高位开始，逐步开始拆解位置
            ans = ans + translateNum(num % a);
            a /= 10;
            //如果只剩2位数字，且组合起来小于26，只有分开与组合两种翻译方式
           if (num / a < 26) {
                ans = ans + translateNum(num % a);
            }
            return ans;
        }

这个递归的方法还有其他写法，我只参考其中一个比较好理解的一个版本，个人还是喜欢动态规划的写法。