斐波那契数列面试题解法（java）

斐波那契数列经常出现在程序员面试的题目中，本文总结一下斐波那契数列的解法
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：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*）

题目1：给定整数N,代表台阶数，小明一次可以上一个台阶或一次上两个台阶（因为怕扯着蛋，一次最多上两个台阶），问上N节台阶总共有多少种方法？
问题分析：记f(n)表示上n节台阶的所有方法总数。小明初始站在第0级台阶上，f(0)=1；上第一节台阶，只能一次上去，f(1) = 1；小明上楼梯时要么经过第一级台阶，要么越过第一级台阶（越过第一级台阶只能站第二级台阶上），所以经过一步之后问题变成f(n) = f(n-1) + f(n-2)。f(n-1)表示站在第一级台阶上还剩多少种走法，f(n-2)表示站在第二级台阶上还是多少种走法。

题目2：假设农场中成熟的母牛每年只会生1头小母牛，并且永远不会死。第一年农场有1只成熟的母牛，从第二年开始，母牛开始生小母牛。给定整数N，求出N年后牛的数量。

题目3：我们有一个2xN的长条形棋盘，然后用1x2的骨牌去覆盖整个棋盘。对于这个棋盘，一共有多少种不同的覆盖方法呢？
详见http://hihocoder.com/problemset/problem/1143

计算结果一般很大，有时面试时需要使用BigInteger来表示。有时也会让结果mod一个数输出，这里假设mod19999997作为结果输出。

首先根据定义轻松写出暴力递归的代码

import java.util.Scanner;

class Fibonacci{
    //int能表示的最大值的一半，两个小于halfMax的值相加结果不会越界
    private static int halfMax = Integer.MAX_VALUE>>1;
    //求斐波那契数列第n项，结果对m求余
    public static int fibonacci(int n,int m)
    {
        if(n<1)
            return 0;
        if(n==1 || n==2)
            return 1;
        if(m<=halfMax){
            int result = fibonacci(n-1,m) + fibonacci(n-2,m);
            //return result%m;
            //本来应该进行求余操作，由于result不会大于2m，这里用减法速度回更快
            return result>=m?result-m:result;
        }
        else{
            long result = (long)fibonacci(n-1,m) + fibonacci(n-2,m);
            return (int) (result>=m?result-m:result);
        }           
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(Fibonacci.fibonacci(n, 19999997));
    }
}

面试的时候写成这样肯定是不合格的，这样写的时间复杂度为2的n次方，计算30以内的还可以，更大的数就需要等待了。通过分析可以发现计算中有大量重复的计算，比如f(n-2)，计算f(n)的时候计算一次，计算f(n-1)的时候又计算一次。可以通过建立缓存来解决重复计算问题。代码如下

import java.util.Scanner;

class Fibonacci{
    //int能表示的最大值的一半，两个小于halfMax的值相加结果不会越界
    private static int halfMax = Integer.MAX_VALUE>>1;
    //保存求解中的值
    private static int value[];
    //value中的值是否被计算
    private static boolean used[];
    //求斐波那契数列第n项，结果对m求余
    private static int getFibonacci(int n,int m)
    {
        if(used[n])
            return value[n];
        if(m<=halfMax){
            int result = getFibonacci(n-1,m) + getFibonacci(n-2,m);
            //return result%m;
            //本来应该进行求余操作，由于result不会大于2m，这里用减法速度回更快
            result = result>=m?result-m:result;
            value[n] = result;
            used[n] = true;
            return result;
        }
        else{
            long result = (long)getFibonacci(n-1,m) + getFibonacci(n-2,m);
            result = result>=m?result-m:result;
            value[n] = (int)result;
            used[n] = true;
            return value[n];
        }           
    }
    public static int fibonacci(int n,int m)
    {
        if(n<1)
            return 0;
        if(n==1 || n==2)
            return 1;
        value = new int[n+1];
        value[0] = 0;
        value[1] = 1;
        value[2] = 1;
        used = new boolean[n+1];
        used[0] = true;
        used[1] = true;
        used[2] = true;
        return getFibonacci(n,m);
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(Fibonacci.fibonacci(n, 19999997));
    }
}

斐波那契数列每一项等于前两项的和，我们可以从前往后来计算，使用循环就可以解决了。

import java.util.Scanner;

class Fibonacci{
    //求斐波那契数列第n项，结果对m求余
    public static int fibonacci(int n,int m)
    {
        if(n<1)
            return 0;
        if(n==1 || n==2)
            return 1;
        int value[] = new int[n+1];
        value[1] = 1;
        value[2] = 1;
        //后一项等于前两项的和
        for(int i=3;i<=n;i++){
            long result = (long)value[i-1]+value[i-2];
            value[i] = (int) (result>m?result-m:result);
        }
        return value[n];
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(Fibonacci.fibonacci(n, 19999997));
    }
}

上面的方法计算的时候开辟的大块空间存储中间计算结果。如果需要经常求不大的数的斐波那契数列，我们可以把一定范围内的结果保存起来，每次需要的时候拿出来就可以了。如果只让我们求一次斐波那契数列的第n项，或者n比较大，上面的方法就不好使了。观察发现我们只需要3个数的空间就够了，每次计算f(n)时f(n-3)就没用了，可以把存放f(n-3)的空间用来存放f(n)。使用循环数组可以实现，这里为了不计算mod3，把数组长度设置为了4。

import java.util.Scanner;

class Fibonacci{
    //求斐波那契数列第n项，结果对m求余
    public static int fibonacci(int n,int m)
    {
        if(n<1)
            return 0;
        if(n==1 || n==2)
            return 1;
        //循环队列用来存放计算结果,这里用4不用3为了计算方便
        int value[] = new int[4];
        value[1] = 1;
        value[2] = 1;
        //后一项等于前两项的和
        for(int i=3;i<=n;i++){
            long result = (long)value[(i-1)&3]+value[(i-2)&3];
            value[i&3] = (int) (result>m?result-m:result);
        }
        return value[n&3];
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(Fibonacci.fibonacci(n, 19999997));
    }
}

如果一般小公司面试写成这样就可以了，如果面试大公司需要写出log(n)时间复杂度的算法才行。对于像类似
f(n) = a*f(n-1)+b*f(n-2)+c*f(n-3)…这样的公式的求值可以用矩阵乘法来完成。由于矩阵乘法有结合律，A的n次方可以用A的n/2次方来求，时间复杂度可以降到log（n）的级别。
斐波那契数列的矩阵计算公式如下所示：

继续进行递推可得下面公式：

这样就可以写一个矩阵计算的类来求斐波那契数列了

import java.util.Scanner;
//方形矩阵
class Matrix{
    private long arr[][];
    Matrix(int size){
        arr = new long[size][size];
    }
    Matrix(){
        arr = new long[2][2];
    }
    //往矩阵的n行m列赋值
    public void setValue(int n,int m,int value){
        arr[n][m] = value;
    }
    public long getValue(int n,int m){
        return arr[n][m];
    }
    public int size(){return arr.length;}
    //该矩阵乘matrix
    public Matrix muliMatrix(Matrix matrix,int m){
        if(this.size() != matrix.size())
            return null;
        Matrix result = new Matrix(this.size());
        for(int i=0;i<this.size();i++)
            for(int j=0;jfor(int k=0;k<this.size();k++){
                    result.arr[i][j] += this.arr[i][k]*matrix.arr[k][j];
                    //中间结果对m求余
                    result.arr[i][j] %= m;
                }
        return result;
    }
    //矩阵幂运算,n表示幂，m用来求余
    public Matrix matirxPower(int n , int m){
        if(n==1)
            return this;
        Matrix result = new Matrix(this.size());
        result = matirxPower(n>>1 , m);
        result = result.muliMatrix(result , m);
        if((n&1) == 1){
            result = result.muliMatrix(this, m);
        }
        return result;
    }

}
class Fibonacci{
    public static int fibonacci(int n,int m){
        if(n<1)
            return 0;
        if(n==1 || n==2)
            return 1;
        Matrix factor = new Matrix(2);
        factor.setValue(0, 0, 1);
        factor.setValue(0, 1, 1);
        factor.setValue(1, 0, 1);
        factor = factor.matirxPower(n-2, m);
        Matrix init = new Matrix(2);
        init.setValue(0, 0, 1);
        init.setValue(1, 0, 1);
        Matrix result = factor.muliMatrix(init, m);
        return (int) result.getValue(0, 0);
    }
}


public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(Fibonacci.fibonacci(n+1, 19999997));
    }
}