斐波那契数列入门动态规划

一、斐波那契数列经典解法：

 public int fibonacci(int n) {

        if (n == 0){
            return 0;
        }
        if (n == 1){
            return 1;
        }

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

这样写结果是对的，但是里面包含了大量重复子问题的计算，这样会导致时间复杂度在n增大时大幅度上升,大概是2^n。

二、记忆化搜索

为了减少子问题的重复计算次数，显然我们可以将子问题的计算结果保存下来，下次需要子问题的结果直接从数组中去取。

 /**记忆化搜索实现*/
    public static int fibonacci2(int n) {

        if (n == 0){
            return 0;
        }
        if (n == 1){
            return 1;
        }
        //创建数组，并将初始值赋为-1
        int[] res = new int[n + 1];
        Arrays.fill(res,-1);
        
        //从n=2开始，将结果记录到res数组中，下次求解fib(n)时不会进入递归
        if (res[n] == -1) {
            res[n] = fibonacci2(n-1) + fibonacci2(n-2);
        }
        return res[n];
    }

记忆化搜索利用了子问题的结果，保证了不在重复进入递归，节省了时间。

三、动态规划

记忆化搜索终究还是自上向下的解决问题的方法，有更符合客观规律的自下向上的解决办法呢！动态规范正是这种思想

用循环的方式求解子问题，并记录子问题，最终由子问题得到原问题的答案

 /*动态规划解法*/
    public static int fibonacci3(int n) {
        //数组中访问的下标小于0会越界
        if(n < 2) return n;

        int[] res = new int[n + 1];
        Arrays.fill(res,-1);

        res[0] = 0;
        res[1] = 1;

        for (int i = 2; i <= n; i++) {
            res[i] = res[i - 1] + res[i - 2];
        }
        return res[n];
    }

这种正向循环的解法，时间效率高。但从头到尾的递推难度较大，比较好的思考方式是找到递归表达式，再用实例来验证递归表达式的正确性。然后从简单实例中总结递推规律，写出正向的动态规划解法。

四、数组中的DP

package 连续子数组的最大和;

public class Main {
    /**
     * 数组中有正数有负数，求子数组的最大值
     *
     * */
    public static int subArraySum(int[] arr){

        //最大的子数组和
        int maxSum = arr[0];
        //累加子数组和
        int curSum = arr[0];
        for (int i = 0; i < arr.length; i++) {
            //累加数组为负数时丢弃
            if (curSum < 0){
                curSum = arr[i];
            }
            else {
                curSum = curSum + arr[i];
            }
            //累加数组过大，就更新
            if (curSum>maxSum){
                maxSum =curSum;
            }
        }
        return maxSum;
    }
}