蓝桥杯Java---斐波那契数列

方法一：赋值法(基本取模)

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        if(n>=1&&n<=1000000){
            int fn1=1;
            int fn2=1;
            int fn=fn1+fn2;
            if(n<2){
                System.out.println(fn1);
            }else {
                for(int i=2;i<n;i++){
                    fn1=fn;
                    fn=(fn1+fn2)%10007;
                    fn2=fn1;
                }
                System.out.println(fn2);
            }
        }
    }
}

 不取模硬算（大数计算）

public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n= sc.nextInt();
        BigDecimal F1=new BigDecimal(1);
        BigDecimal F2=new BigDecimal(1);
        BigDecimal Fn=F1.add(F2);
        if(n<=2){
            System.out.println(F1);
        }else{
            for (int i = 3; i < n; i++) {
                F1=Fn;
                Fn=F1.add(F2);
                F2=F1;
            }
            System.out.println(Fn);
            System.out.println(Fn.divideAndRemainder(BigDecimal.valueOf(10007))[1]);
        }
    }

方法二：数组法

import java.util.Scanner;
	public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        if(n>=1&&n<=1000000){
            int[] Fn=new int[n+2];
            Fn[1]=1;
            Fn[2]=1;
            for(int i=3;i<=n;i++){
                Fn[i]=(Fn[i-1]+Fn[i-2])%10007;
            }
            System.out.println(Fn[n]);
        }
    }
}

方法三：递归法（位数大超时）

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(F(n) % 10007);
    }

    public static int F(int x) {
        if (x == 1 || x == 2) {
            return 1;
        } else {
            return F(x - 1) + F(x - 2);
        }
    }
}

思考：

        如果只按照数列的思路来做，在int范围之内，数据都是正确的，但是输入的数据过大时，就会出现精度缺失问题，所以取模的位置很重要。因为结果只要余数，所以可以把数列中的每一个数看成多少倍的10007加上余数。比如：

F（21）=10946 =939  + 1*10007；

F（22）=17711 =7704 +1*10007；

F（23）= F(21) + F(22) = 28657 = 8643 + 2*10007；

        可见每个数取模后，再求余数，不影响结果，所以实际上前后相加也是各自的余数相加，这样就可以避免求出F(n)最后的结果再除10007了。