//斐波那契數列
/*
* 取第N位的值(0開始,8是第6位)，0,1,1,2,3,5,8....
* */
public class P12 {
    public static void main(String[] args) {
        System.out.println(calculate(7));
        System.out.println(calculate2(7));
        System.out.println(iterate(7));
    }

    //1、最常見的是暴力遞迴
    public static int calculate(int num){
        
 
if(num == 0){
            return 0;
        }
        if(num == 1){
            return 1;
        }

        return calculate(num-1) + calculate(num-2);
    }

    //2、去重遞迴，時間、空間都是 O(n)
    // 上面的方法要計算calculate(num-1) 和 calculate(num-2)
    // 出現重複計算的問題，例如calculate(9) + calculate(8)，8會在9的分支上計算，所有右側分支根本沒必要計算
 

    public static int calculate2(int num){
        int[] arr = new int[num+1];
        return recurse(arr, num);
    }
    private static int recurse(int[] arr, int num){
        if(num == 0){
            return 0;
        }
        if(num == 1){
            return 1;
        }

        //num剛好可以作為陣列下標
 

        if(arr[num] != 0){      //代表該下標已經有值，
            return arr[num];    //不需要再遞迴了
        }
        arr[num] = recurse(arr, num-1) + recurse(arr, num-2);
        return arr[num];
    }

    //3、雙指標演算法
    // 上方的方法是用陣列存起每個值，但這些值用完之後就沒用的了
    // 只需要3個空間，兩個指標+一個sum，每次計算完都賦值為下一個數
    /*
    * 0 1 1 2 3 5 8
    * ↑ ↑ s
    *   ↑ ↑ s
    * */
    private static int iterate(int num){
        if(num == 0){
            return 0;
        }
        if(num == 1){
            return 1;
        }

        int low = 0;
        int high = 1;
        for(int i=2; i<=num; i++){
            int sum = low+high;
            low = high;
            high = sum;
        }

        return high;
    }
}