Fibonacci数列从暴力递归到动态规划处理步骤

import java.util.Scanner;

public class Fibonacci {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(process(n));
    }

    private static int process(int n) {
        if(n==1||n==2){
            return 1;
        }

       return process(n - 1) + process(n - 2);
        
    }
}

第一步：直接暴力递归求解，虽然想法很简单，但是当n的数值足够大时会导致堆栈内存溢出

所以可以将公共解提取出来保存到一个数组中，

 以n=7为例子，

此时当计算n=4时，会出现重复解，可以将n=4,这个解放到数组中，即arr[4],只需要计算一次即可得出答案，

public class Fibonacci {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n + 1];
        //初始化数组
        for(int i=0;i<=arr.length;i++){
            a[i]=0;
        }
        arr[1] = 1;
        arr[2] = 1;
        System.out.println(process(n, arr));
    }

    private static int process(int n, int[] arr) {
         int ans = 0;
         if (arr[n] != 0) {
              return  arr[n];
          }
          ans = process(n - 1, arr) + process(n - 2, arr);
          arr[n]=ans;
          return ans;

    }

}

这时就有了动态规划基本模型的雏版了，我们会发现数组中似乎有着关联，可以在初始化中就可以把值算出来

import java.util.Scanner;

public class Fibonacci {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n + 1];
        arr[0]=0;
        arr[1] = 1;
        arr[2] = 1;
        for (int i = 3; i < arr.length; i++) {
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println(a[n]);
    }

}