记忆化递归问题

记忆化递归的原理和思路

为什么要用记忆化递归？

回答：因为普通的递归可能会重复求解某一值，类似斐波那契数列。同样的子问题可能会被求解多次，这样就会很慢很慢很慢。

解决方法：我们把历史求解（子问题）记录下来，如果下次需要求解子问题，那么直接取出就好。其时间复杂度为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;
    }
}

总结：

记忆化递归方法能够记录递归产生的有效的中间值，降低程序计算的时间。这是一种挺重要的思想，空间换时间。等我学会动态规划之后再用动态规划解这道题，先挖个坑。