LeetCode 青蛙跳问题

LeetCode 青蛙跳问题

1、问题描述：

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1
来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2、leetcode上提交的执行结果

效果还是可以的，速度应该是最快的了，占用内存应该还可以继续优化，不过最近比较忙，应该没有时间去优化了。。。

image

3、具体代码：

public class Test {
    private static final long mod = 1000000007;

    private static int number = 100;
    /**
     * 存储阶乘 factorial
     */
    private static long[] factorial = new long[number];
    /**
     * 储存阶乘逆元
     */
    private static long[] inverse = new long[number];

    
    public static void main(String[] args) {
        Test test = new Test();

        for (int i = 0; i < 100; i++) {

            System.out.println( test.numWays(i));
        }

        //System.out.println(test.numWays(46));
    }

    public int numWays(int n) {
        initFactorial();
        if (n==0){
            return 1;
        }
        if (n==1){
            return 1;
        }
        // 2出现的最大的个数
        int k = n/2;
        int remainder = n%2;
        // 全为1的场景
        long count = 0;
        for (int i=0;i<=k;i++) {
            if (i==0 || (i==k&&remainder==0)) {
                count++;
                continue;
            }
            // 1的个数
            int j = n-i*2;

            count +=comb(j+i, i);

        }
        return (int)(count%mod);
    }

    /**
     * 初始化阶乘数据
     */
    public void initFactorial(){
        factorial[0] = 1;
        inverse[0] = 1;
        for (int i = 1;i < number;i++){
            factorial[i] = (factorial[i-1] * i)% mod;
            inverse[i] = getInverse(factorial[i])%mod;
        }
    }

    /**
     * 求排列组合数  C（n，m）= n！/（m！*（n-m）！）
     */
    public long comb(int n,int m){
        return factorial[n]*inverse[m]%mod*inverse[n-m]%mod;
    }


    /**
     * 快速幂算法
     * 
     * @param a
     * @param b
     * @return
     */
    public static long fastPower(long a, long b) {
        long result = 1;
        long base = a;

        while (b>0){
            if ((b&1)!=0){
                result = (result*base)%mod;
            }
            base = (base*base)%mod;
            b>>=1;
        }

        return result;
    }

    /**
     * 乘积逆元取模
     * 除法求模不能类似乘法，对于（A/B）mod C，直接（A mod C）/ （B mod C）是错误的；
     * 找到B的逆元b(b=B^-1);求出(A*b)modC即可；
     *
     * a^-1=a^(p-2)
     * p为素数时，a的逆元就是a^(p-2),就直接用快速幂求出a^(p-2)即是a的逆元
     */
    public long getInverse(long a){
        return fastPower(a,mod-2);
    }
  
}

4、解题思路

     本题青蛙只能跳1步或2步，这就举个例子现在如果知道跳1步有几次、跳2步有几次，例如，跳1步的2次，跳2步的1次，那么总共的可能情况就是 (2+1)!/(2!1!) ; 一般的描述就是，跳1步的a次，跳2步的b次，那么排列组合总共的可能情况就是(a+b)!/(a!b!)--式1，因此问题就转化为求1步和2步的次数；
     有2种特殊情况，即全部是1或全部是2(n为偶数刚好可以被2整除)的情况，这种情况下count总计分别都是1次；2最多会出现的次数 即k=n/2，然后1出现最少的次数n-k; 所以2步可能出现的次数就是0~n/2，对应上述numWays方法中的逻辑，然后只需要对2的取值范围进行遍历出现不同次数，对应的组合求解方案就是上式1；
      然后解题的关键就是在对排列组合对应阶乘的计算上了，如果数字较大会导致阶乘的结果值很大，会溢出；参考求排列组合数常见的方法，本题引入费马小定理、逆元的概念，然后使用快速幂计算求出结果^文献[1]；
      (a+b)!/(a!b!)该值可能会很大需要取模计算，即 (a+b)!/(a!b!)/mod ，为简单表述，即可表示为(A/B)%mod，除法取余无法直接进行计算^文献[2]；然后根据费马小定理可以表示为(A/B)%mod=(A*(B^(mod-2)%mod))%mod(注mod为质数)， 其中B^(mod-2)%mod称为B对mod取模条件下的逆元；问题关键就在求取B^(mod-2)%mod 上，这里用到了快速幂求解方案；快速幂，顾名思义就是快速的求次幂，二进制思想，变乘法为多次加法，例如:a^n，普通的算法就是累乘，这样的计算方法的时间复杂度就是O(n),而快速幂的方法使得次幂的计算方法的时间复杂度降低到O(logn)，参考上面的fastPower方法。详细解析参考网上其他资料或demo，例如Java 算法-快速幂^文献[3]

本文参考的资料：

• [1] 除法取余引发的思考
  
• [2] 求组合数（取模）的两种方法
  
• [3] Java 算法-快速幂