记忆化递归的原理和思路
为什么要用记忆化递归?
回答:因为普通的递归可能会重复求解某一值,类似斐波那契数列。同样的子问题可能会被求解多次,这样就会很慢很慢很慢。
解决方法:我们把历史求解(子问题)记录下来,如果下次需要求解子问题,那么直接取出就好。其时间复杂度为O(1)。
举个例子:斐波拉契数列求解。
递归解法:
def f(n):
if n <= 1:
return n
return f(n-1) + f(n-2)
记忆化递归解法:
m = [0] * max_size # 开辟一个数组来存储,或者使用字典
def f(n):
if n <= 1:
return n
if not m[n]:
m[n] = f(n - 1) + f(n -2)
return m[n]
区别在哪呢?
如果要计算f(100),在递归方法中,计算f(100)=f(99)+f(98)。即在计算f(99)时就已经计算过了f(98),但是由于这个数没有存下来,导致一直需要重复计算,记忆化递归就是把递归过程中产生的有效值存下来,用的时候直接用就好了,不需要重复计算。
详细介绍看链接文章。
记忆化递归相比动态规划的优势在哪儿?
动态规划是有先后顺序的,子问题求解后才能求解父问题。因此你要小心确保问题求解的顺序,从而避免bug。
但是记忆化递归,当你的子问题没有求解时,程序会自动去求解。而不需要小心翼翼的去确保顺序,减轻我们的工作量。
记录一下刷过的LeetCode题。
LeetCode 91.解码方法:
一条包含字母 A-Z 的消息通过以下映射进行了 编码 :
'A' -> 1
'B' -> 2
...
'Z' -> 26
要 解码 已编码的消息,所有数字必须基于上述映射的方法,反向映射回字母(可能有多种方法)。例如,“11106” 可以映射为:
"AAJF"
,将消息分组为 (1 1 10 6)"KJF"
,将消息分组为 (11 10 6)
注意,消息不能分组为 (1 11 06) ,因为 “06” 不能映射为 “F” ,这是由于 “6” 和 “06” 在映射中并不等价。
给你一个只含数字的 非空 字符串 s ,请计算并返回 解码 方法的 总数 。
题目数据保证答案肯定是一个 32 位 的整数。
示例 1:
输入:s = "12"
输出:2
解释:它可以解码为 "AB"(1 2)或者 "L"(12)。
提示:
1 <= s.length <= 100
s 只包含数字,并且可能包含前导零。
思路:
首先想到的是,怎么遍历出所有的结果。
直接想到的是,一个个来解码呗。按照正常的解码思路。
给一个字符串,解码只能选前1位或者前2位(最大值为26),所以相当于一个二叉树,就可以用迭代的思想来做了。
但是呢,写出来缺发现运行测试例子超时了。确实容易超时哈,直接递归。
"111111111111111111111111111111111111111111"
直接贴使用记忆化递归的代码吧
class Solution {
public int numDecodings(String s) {
char[] numChar = s.toCharArray();
int[] f = new int[101];
for(int i=0;i<f.length;i++){
f[i]=-1;
}
return getNum(numChar,0,f);
}
public int getNum(char[] s,int start, int[] f){
if(start==s.length){
return 1;
}
if(f[start]!=-1){
return f[start];
}
int left=0; int right=0;
int one = s[start] - '0';
//判断是不是为0,如果是,直接返回0
if(one==0){
return 0;
}
else{
left = getNum(s, start+1, f);
}
//判断往后走两位
if(start<s.length-1){
int two = one*10 + s[start+1] - '0';
if(two>26){
right = 0;
}
else{
right = getNum(s, start+2,f);
}
}
return f[start]=left+right;
}
}
总结:
记忆化递归方法能够记录递归产生的有效的中间值,降低程序计算的时间。这是一种挺重要的思想,空间换时间。等我学会动态规划之后再用动态规划解这道题,先挖个坑。