剑指 Offer 10- II. 青蛙跳台阶问题（4种解法）

题目链接

tag: 简单动态规划
记作dp[n]表示有n级台阶的跳法，到达第n级台阶可以从第n-2级台阶到达，也可以从第n-1级台阶到达，因此达到第n级台阶的方案树=到达第n-1级台阶的方案数+到达第n-2级台阶的方案数，即dp[n]=dp[n-2]+dp[n-1]

解法1：
使用dp数组

class Solution {
    int mod=(int)(1e9+7);
    public int numWays(int n) {
        if(n<=1){
            return 1;
        }
        int[] dp=new int[n+1];
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-2]+dp[i-1];
            dp[i]%=mod;
        }
        return dp[n];
    }
}
//O(n)
//O(n)

解法2：
使用变量代替dp数组

class Solution {
    int mod=(int)(1e9+7);
    public int numWays(int n) {
        if(n<=1){
            return 1;
        }
        int dp0=1;
        int dp1=1;
        int dp2=-1;
        for(int i=2;i<=n;i++){
            dp2=dp0+dp1;
            dp2%=mod;
            dp0=dp1;
            dp1=dp2;
        }
        return dp2;
    }
}
//O(n)
//O(1)

解法3：

递归+记忆化搜索

class Solution {
    int mod=(int)(1e9+7);
    int[] memo;
    public int numWays(int n) {
        if(memo==null){
            memo=new int[n+1];
        }
        if(n<=1){
            return 1;
        }
        if(memo[n]!=0){
            return memo[n];
        }else{
            memo[n]=numWays(n-2)+numWays(n-1);
            memo[n]%=mod;
            return memo[n];
        }              
    }
}
//O(n)
//O(n)

解法4：

快速幂，参考剑指 Offer 10- I. 斐波那契数列（4种解法）中的第4种解法，只需要修改一下初始的dp[0]值即可，斐波那契数列中dp[0]=0, 这里dp[0]=1

class Solution {
    int mod=(int)(1e9+7);
    public int numWays(int n) {
        if(n<=1){
            return 1;
        }
        long[][] mat={
            {1,1},
            {1,0}
        };
        long[][] ans={
            {1},
            {1}
        };
        int x=n-1;
        //快速幂算法
        while(x!=0){
            if(x%2==1){
                ans=multi(mat,ans);
            }
            mat=multi(mat,mat);
            x/=2;
        }
        return (int)ans[0][0];   
    }
     //矩阵相乘算法
    public long[][] multi(long[][] a,long[][] b){
        //a:p*q   b: q*r
        int p=a.length,q=a[0].length,r=b[0].length;
        long[][] ans=new long[p][r];
        for(int i=0;i<p;i++){
            for(int j=0;j<r;j++){
                for(int k=0;k<q;k++){
                    ans[i][j]+=a[i][k]*b[k][j];
                    ans[i][j]%=mod;
                }
            }
        }
        return ans;
    }
}
//O(logn)
//O(1)