青蛙跳台阶问题

青蛙跳台阶问题

问题描述：
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n (1<=n<=100)级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

input

2
7
0

output

2
21
1

可能是最近递归做多了，把最简单的迭代忘记了。

错误的递归想法：（我现在的水平还太低，普通的递归过不了）

class Solution {
public:
    int numWays(int n) {
        if(n==1){return 1;}
        else if(n==0){return 1;}
        else if(n==2){return 2;}
        return (numWays(n-1)+numWays(n-2))%1000000007;
    }
};

为何会超时呢？因为中间存在很多次计算，比如fib（3）,他需要fib(2)和fib(1)，fib(4)需要fib(3)和fib(2)，因而在计算过程中，每一次fib(2),fib(3)都需要重复不断的计算，浪费了大量的时间。

网上ac的一种递归过法：

class Solution {
public:
    unordered_map<int,int> mp;
    int dfs(int n){
        //边界条件
        if(n==0)
            return 1;
        else if(n==1)
            return 1;
        //先检查下，这个n是不是之前就算过，如果算过直接返回
        else if(mp.count(n))
            return mp[n];
        //哈希表中没有，先算出来，再存在哈希表中，下次用到就不用重复计算
        int a=dfs(n-1)%1000000007;
        mp[n-1]=a;
        int b=dfs(n-2)%1000000007;
        mp[n-2]=b;
        mp[n]=(a+b)%1000000007;
        return mp[n];
    }
    int numWays(int n) {
        return dfs(n);
    }
};

利用一个哈希表，把计算过的fib(n)的值存在哈希表中，这样就可以减少大量运算

普通迭代方法：

class Solution {
public:
    int numWays(int n) {
        int a[101];
        for(int i=0;i<=n;++i){
            //确定初始条件
            if(i==0)
                a[i]=1;
            else if(i==1)
                a[i]=1;
            //动态规划方程
            else
                a[i] = (a[i-1]+a[i-2])%1000000007;
        }
        return a[n];  
    }
};

因为dp还没学，还在练分治和递归，明天就把dp学了，发现这类的题目都是用动态规划做的，递归的做法很少，应该和递归效率太过低下有关。

我是打算还是先把递归和分治练透了，一步一个脚印，所以比较拖沓。