70.Climbing Stairs

题目链接：https://leetcode.com/problems/climbing-stairs/description/

题目大意：爬楼梯问题，一共花费n步爬到楼顶，一次可以爬一个台阶或两个台阶，求出一共有多少种方法可以爬到楼顶。

此题其实是裴波那挈数列问题。

法一：动规公式：fib[n] = fib[n - 1] + fib[n - 2]。用for循环数组来求fib[n]，将其返回既是结果。代码如下（耗时0ms）：

    public int climbStairs(int n) {
        int[] fib = new int[1000];
        fib[0] = 1;
        fib[1] = 1;
        fib[2] = 2;
        for(int i = 3; i <= n; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        return fib[n];
    }

法二（超时）：直接递归，超时了，而且递归栈的深度也是一个问题。代码如下：

public int climbStairs(int n) {
        if(n == 0 || n == 1) {
            return 1;
        }
        else if(n == 2) {
            return 2;
        }
        return climbStairs(n - 1) + climbStairs(n - 2);
    }

法三（借鉴）：其实是法二的改进版，记忆性递归，用数组记录已经计算过的fib[i]，如果已经计算过则直接返回不用再继续递归。代码如下（耗时0ms）：

public int climbStairs(int n) {
        int[] fib = new int[1000];
        for(int i = 0; i <= n; i++) {
            fib[i] = 0;
        }
        return fib(fib, n);
    }
    
    public int fib(int[] fib, int n) {
        if(n == 0 || n == 1) {
            return 1;
        }
        else if(n == 2) {
            return 2;
        }
        if(fib[n] != 0) {
            return fib[n];
        }
        else {
            fib[n] = fib(fib, n - 1) + fib(fib, n - 2);
            return fib[n];
        }
    }

快速幂知识点：

快速幂：http://www.cnblogs.com/CXCXCXC/p/4641812.html

快速幂取模：http://www.cnblogs.com/lj-1568/p/4754336.html

 借鉴：   http://blog.csdn.net/hanleijun/article/details/24550065

https://leetcode.com/problems/climbing-stairs/solution/

package problem_70;

public class MatrixTest {

    static int[][] matrix;
    
    public static void main(String[] args) {
        init(2);  
        matrix[0][0] = 1;  
        matrix[0][1] = 1;  
        matrix[1][0] = 1;  
        matrix[1][1] = 0;  
        int[][] temp = new int[matrix.length][matrix.length];  
        temp = pow(4);  
        for (int[] a : temp) {  
            for (int b : a) {  
                System.out.print(b + " ");  
            }  
            System.out.println();  
        }  
        System.out.println("斐波那契数列的fn值为：" + temp[0][1]);  
    }
    
    //初始化矩阵
    public static void init(int n) {  
        matrix = new int[n][n];  
    }  
  
    //矩阵相乘
    public static int[][] matrixMulti(int[][] m, int[][] n) {  
        int[][] temp = new int[matrix.length][matrix.length];  
        for (int k = 0; k < matrix.length; k++) {  
            for (int i = 0; i < matrix.length; i++) {  
                for (int j = 0; j < matrix.length; j++) {  
                    temp[k][i] += m[k][j] * n[j][i];  
                }  
            }  
        }  
        return temp;  
    }  
  
    //矩阵快速幂
    public static int[][] pow(int n) {  
        int[][] temp = new int[matrix.length][matrix.length];  
        if (n == 1) {  
            return matrix;  
        } else {  
            if (n % 2 != 0) {  //奇数
                temp = pow((n - 1) / 2);  
                temp = matrixMulti(temp, temp);  
                return matrixMulti(temp, matrix);  
            } else {  //偶数
                temp = pow(n / 2);  
                temp = matrixMulti(temp, temp);  
                return temp;  
            }  
        }  
    }  
}

法四（借鉴）：数学方法

public class Solution {
    public int climbStairs(int n) {
        double sqrt5=Math.sqrt(5);
        double fibn=Math.pow((1+sqrt5)/2,n+1)-Math.pow((1-sqrt5)/2,n+1);
        return (int)(fibn/sqrt5);
    }
}