斐波那契数列相关问题总结

最新推荐文章于 2019-11-03 21:09:20 发布

Wayne566

最新推荐文章于 2019-11-03 21:09:20 发布

阅读量1k

点赞数

分类专栏： Java学习笔记

本文链接：https://blog.csdn.net/wayne566/article/details/78151769

版权

Java学习笔记专栏收录该内容

23 篇文章 2 订阅

订阅专栏

一. 原问题

在数学上，斐波纳契数列以如下被以递归的方法定义：F(0)=0，F(1)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*），即从第三项开始，每一项等于前两项之和。

输入格式：输入包括一行，包括一个整数N (0≤N≤50)。

输出格式：输出包括一行，包括一个整数，为斐波那契数列的第 N 项的值。

递归方法
时间复杂度为O(2^n)。

import java.util.Scanner;

public class Fibonacci_1 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        long f = fib(n);
        System.out.println(f);
    }

    public static long fib(int n) {
        if(n == 0){
            return 0;
        }else if (n == 1){
            return 1;
        }else {
            return fib(n - 1) + fib(n - 2);
        }
    }
}

数组存储，动态规划

当一个问题可以分解成若干重复的子问题时，运用动态规划的思想：只需要将子问题求解一次，以后再遇到，直接调用，所以新建一个数组用于存储子问题的结果。（以空间换时间）

import java.util.Scanner;

public class Fibonacci_2 {

    static Scanner input = new Scanner(System.in);
    static int n = input.nextInt();
    static long[] result = new long[n + 1];

    public static void main(String[] args) {
        long f = fib(n);
        System.out.println(f);
    }

    public static long fib(int n) {
        long f = 0;
        if(n == 0){
            f = 0;
        }else if (n == 1){
            f = 1;
        }else if (result[n] > 0){
            return result[n];
        }else {
            f = fib(n - 1) + fib(n - 2);
        }
        result[n] = f;
        return f;
    }
}

递推方法
时间复杂度为O(n)

import java.util.Scanner;

public class Fibonacci_3 {
    public static void main(String[] args) {
        long f0 = 0;
        long f1 = 1;
        long f = 0;
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();

        if(n == 0){
            f = 0;
        }else if(n == 1){
            f = 1;
        }else {
            for(int i = 2; i <= n; i++){
                f = f0 + f1;
                f0 = f1;
                f1 = f;
            }
        }

        System.out.println(f);
    }
}

矩阵相乘算法

推导过程：
Fibonacci_1
Fibonacci_2
由此演变成了求 Fibonacci_3 此矩阵的(n - 1)次方的过程。

import java.util.Scanner;

public class Fibonacci_4{

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        long f = fib(n);
        System.out.println(f);
    }

    public static long[][] baseMartrixMulti(int n) {
        long[][] result = {{1, 0}, {0, 1}};//单位阵
        long[][] base = {{1, 1}, {1, 0}};
        long[][] temp = {{1, 0}, {0, 1}};
        for (int i = 0; i < n; i++){
            result[0][0] = temp[0][0] * base[0][0] + temp[0][1] * base[1][0];
            result[0][1] = temp[0][0] * base[0][1] + temp[0][1] * base[1][1];
            result[1][0] = temp[1][0] * base[0][0] + temp[1][1] * base[1][0];
            result[1][1] = temp[1][0] * base[0][1] + temp[1][1] * base[1][1];
            temp[0][0] = result[0][0];//特别注意，数组赋值赋的是引用，不能直接temp = result;
            temp[0][1] = result[0][1];
            temp[1][0] = result[1][0];
            temp[1][1] = result[1][1];
        }
        return result;
    }

    public static long fib(int n) {
        long f = 0;
        if(n != 0){
            long[][] trans = baseMartrixMulti(n - 1);
            f = trans[0][0];//意义为下两条注释的语句
            //long[][] bas = {{1}, {0}};
            //f = trans[0][0] * bas[0][0] + trans[0][1] * bas[1][0];
        }
        return f;
    }
}

矩阵相乘和乘方可以单独抽象出来函数，此处只是为了解决固定矩阵的乘方问题，没有给出普适代码，若有需要参考矩阵乘法求斐波那契数列。

此过程中发现乘方优化算法，参考乘方的优化算法，可结合到矩阵乘方，待研究后贴出代码。

公式法

Fibonacci_4

万能的数学家得出斐波那契数列通项公式如上，推导过程略（其实是因为看不懂，有兴趣自行百度 orz）。又称为“比内公式”，是用无理数表示有理数的一个范例。

代码实现如下：

import java.util.Scanner;

public class Fibonacci_5 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        long f = (long)((Math.pow((1 + Math.sqrt(5)) / 2, n) - Math.pow((1 - Math.sqrt(5)) / 2, n)) / Math.sqrt(5));
        System.out.println(f);
    }
}

二. 引申问题

爬楼梯问题

假设你现在正在爬楼梯，楼梯有 n 级。每次你只能爬 1 级或者 2 级，那么你有多少种方法爬到楼梯的顶部？

输入格式：第一行输入一个整数 n(1≤n≤50)，代表楼梯的级数。

输出格式：输出爬到楼梯顶部的方法总数。

其实相当于斐波那契问题，只是初始条件改变。f(1) = 1, f(2) = 2, n > 2时，f(n) = f(n - 1) + f(n - 2) 。（若用矩阵运算可以将base矩阵减少一阶，也可以虚拟假设 f(0) = 1）

任选一种以上方法给出代码：

import java.util.Scanner;

public class Climb {
    public static void main(String[] args) {
        long f0 = 1;
        long f1 = 1;
        long f = 0;
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        if(n == 1){
            f = 1;
        }else{
            for(int i = 2; i <= n; i++){
                f = f0 + f1;
                f0 = f1;
                f1 = f;
            }
        }
        System.out.println(f);
    }
}

疯狂跳台阶
（题目来源于http://blog.csdn.net/xingyanxiao/article/details/47055973）

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
因此，。f(1)=1，f(2)=2。

代码略。
兔子问题

已知第一个月有一对刚出生的兔子，从出生第三个月起，一对兔子每个月可以生一对小兔子。假如没有发生死亡，则第一个月开始，第N个月后会有多少对？

这里以对为单位，从第一个月开始，每个月总共的兔子数量就是1, 1, 2, 3, 5, 8, 13……可以看出前两个月为1，从第三个月开始，当月的数量为前两个月数量之和，所以 f(n) = f(n - 1) + f(n - 2)(n > 2)。同时f(1) = 1, f(2) = 1。

代码实现同标准数学问题。