剑指 Offer 46. 把数字翻译成字符串

[剑指 Offer 46. 把数字翻译成字符串]

难度 中等

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

示例 1:

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

提示：

• 0 <= num < 231

解法一：递归

class Solution {
    public int translateNum(int num) {
    	String nums = String.valueOf(num);
    	return dfs(nums, 0);
    }
    
    private int dfs(String nums, int index) {
    	if(index >= nums.length() - 1) {
    		return 1;
    	}
    	String temp = nums.substring(index, index + 1);	//判断该位置与下一位置的数字是否能够组合为一个字符
		if(temp.compareTo("25") <= 0 && temp.compareTo("10") >= 0) {
			return dfs(nums, index + 1) + dfs(nums, index + 2);
	    }else {		
	    	return dfs(nums, index + 1);
	    }
    }
}

解法二：递归 + 备忘录

解法一中有些子结构会重复计算，这里我们采用数组 meo 来记录已经处理过的子结构，当再次需要的时候就可以直接从备忘录中取出，从而避免重复计算。

meo 中对应的索引是字符串指针的位置，值为从该位置开始对应子树的返回值。

class Solution {
    public int translateNum(int num) {
    	String nums = String.valueOf(num);
    	int[] meo = new int[nums.length()];
    	Arrays.fill(meo, -1);
    	return dfs(nums, 0, meo);
    }
    
    private int dfs(String nums, int index, int[] meo) {
     	if(index >= nums.length() - 1) {
    		return 1;
    	}       
    	if(meo[index] != -1){
    		return meo[index];
    	}
    	String temp = nums.substring(index, index + 2);	//判断该位置与下一位置的数字是否能够组合为一个字符
		if(temp.compareTo("25") <= 0 && temp.compareTo("10") >= 0) {
			meo[index] = dfs(nums, index + 1, meo) + dfs(nums, index + 2, meo);
	    }else {		
	    	meo[index] = dfs(nums, index + 1, meo);
	    }
		return meo[index];
    }
}

解法三：动态规划

翻译第 i 位置的字符串时的翻译规则：

• 该位置可以单独作为一位来翻译
• 如果第 i - 1 位和第 i 位组成的数字在 10 到 25 之间，可以把这两位连起来翻译

class Solution {
    public int translateNum(int num) {
    	char[] nums = String.valueOf(num).toCharArray();
    	int len = nums.length;
    	if(len == 1) {
    		return 1;
    	}
    	int[] dp = new int[len + 1];
    	dp[0] = 1; 
    	dp[1] = 1;
    	// dp[i] 表示以第 i 位结尾的前缀串翻译的方案数
    	for(int i = 2; i <= len; i++) {
    		//第 i 个数单独翻译为一个字符，此时翻译方法数为翻译到第 i - 1 个数的翻译方法数
    		dp[i] = dp[i - 1];
    		// 判断第 i 个数与第 i - 1个数的组合是否能够翻译为字符
    		if(valid(nums[i - 2], nums[i - 1])) {
    			//如果能够翻译，则加上翻译到第 i - 2 个字符的翻译方法数
    			dp[i] += dp[i - 2];
    		}
    	}
    	return dp[len];
    }
    
    //判断第 i 个数与第 i - 1个数的组合是否能够翻译为字符
    private boolean valid(char x, char y) {
    	if(x != '1' & x != '2') {
    		return false;
    	}
    	if(x == '2' && y > '5') {
    		return false;
    	}
    	return true;
    }
}

解法四：动态规划 + 滚动数组

class Solution {
    public int translateNum(int num) {
        String nums = String.valueOf(num);
        int p = 0, q = 0, r = 1;
        for (int i = 0; i < nums.length(); ++i) {
            p = q; 
            q = r; 
            r = 0;
            r += q;
            if (i == 0) {
                continue;
            }
            String temp = nums.substring(i - 1, i + 1);
            if (temp.compareTo("25") <= 0 && temp.compareTo("10") >= 0) {
                r += p;
            }
        }
        return r;
    }
}