斐波那契数列与n!

斐波那契数列

实现斐波那契数列
0、1、1、2、3、5、8、13、21、34、……
F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）

递归实现：

package org.fan.learn.dp;

/**
 * Created by fan on 2016/9/12.
 */
public class Fibo {

    //注意这里是long型的，斐波那契数列很大
    public static long[] result;
    public static final int MAX = 100000;

    public static long fibo(int idx) {
        if (idx <= 0) {
            return 0;
        }
        if (idx == 1) {
            return 1;
        }

        //记忆化搜索
        if (result[idx] >= 0) {
            return result[idx];
        }

        result[idx] = fibo(idx-1) + fibo(idx-2);
        return result[idx];
    }

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

        result = new long[MAX];
        for (int i = 0; i < MAX; i++) {
            result[i] = -1;
        }
        System.out.println(fibo(50));
        System.out.println("Time:" + (System.currentTimeMillis() - start) + " ms");
        /*
        不记忆化搜索：
        12586269025
        Time:124053 ms
        记忆化搜索：
        12586269025
        Time:3 ms
         */
    }
}

如果不加记忆化搜索，时间复杂度为：n!
加了记忆化搜索，时间复杂度为：n
不加记忆化搜索的时间复杂度怎么计算的？
比如计算f(idx)需要计算f(idx-1),f(idx-2),f(idx-3)…….f(2),f(1)
而计算f(idx-1)时，又要重复计算f(idx-2),f(idx-3)…….f(2),f(1)
计算f(idx-2)时，又要重复计算f(idx-3)…….f(2),f(1)
这样f(1)重复计算了n次，f(2)重复计算了n-1次（因为计算f(1)时无需计算f(2)），以此类推，时间复杂度为O(n!)。
加了记忆化搜索之后，没有了重复计算，因此是O(n)

递推实现：

    //递推实现
    public static long fibo2(int idx) {
        result[0] = 0;
        result[1] = 1;
        for (int i = 2; i <= idx; i++) {
            result[i] = result[i-1] + result[i-2];
        }
        return result[idx];
    }

完整代码：

package org.fan.learn.dp;

/**
 * Created by fan on 2016/9/12.
 */
public class Fibo {

     public static long[] result;
    public static final int MAX = 100000;

    public static long fibo(int idx) {
        if (idx <= 0) {
            return 0;
        }
        if (idx == 1) {
            return 1;
        }

        //记忆化搜索
        if (result[idx] >= 0) {
            return result[idx];
        }

        result[idx] = fibo(idx-1) + fibo(idx-2);
        return result[idx];
    }

    //递推实现
    public static long fibo2(int idx) {
        result[0] = 0;
        result[1] = 1;
        for (int i = 2; i <= idx; i++) {
            result[i] = result[i-1] + result[i-2];
        }
        return result[idx];
    }

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

        result = new long[MAX];
        for (int i = 0; i < MAX; i++) {
            result[i] = -1;
        }
        System.out.println(fibo(50));
        System.out.println("Digui Time:" + (System.currentTimeMillis() - start) + " ms");
        /*
        不记忆化搜索：
        12586269025
        Time:124053 ms
        记忆化搜索：
        12586269025
        Time:3 ms
         */

        long start2 = System.currentTimeMillis();
        for (int i = 0; i < MAX; i++) {
            result[i] = -1;
        }
        System.out.println(fibo2(50));
        System.out.println("Ditui Time:" + (System.currentTimeMillis() - start2) + " ms");
    }
}

执行结果：
12586269025
Digui Time:10 ms
12586269025
Ditui Time:1 ms
可以肯定的是，递推要比递归的时间用的要少，即使递归有记忆化搜索的优化。

一个参考的菲波那切数列数列在线计算器，验证代码的正确性：
http://www.99cankao.com/algebra/fibonacci.php

n!

5!=5*4*3*2*1=120
代码实现：

package org.fan.learn.dp;

/**
 * Created by fan on 2016/9/12.
 */
public class Multiply {
    public static long fDigui(int idx) {
        if (idx == 1) {
            return 1;
        }
        return fDigui(idx-1) * idx;
    }

    public static long fDitui(int idx) {
        if (idx < 1) {
            return 0;
        }
        long result = 1L;
        for (int i = 1; i <= idx; i++) {
            result = result * i;
        }
        return result;
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        System.out.println(fDigui(10));
        System.out.println("Digui Time:" + (System.currentTimeMillis() - start) + " ms");

        long start2 = System.currentTimeMillis();
        System.out.println(fDitui(10));
        System.out.println("Ditui Time:" + (System.currentTimeMillis() - start2) + " ms");
    }
}

注意：
n!这个的递归实现是没有冗余的。
运行结果：
3628800
Digui Time:1 ms
3628800
Ditui Time:0 ms