Leetcode16.17 连续数列

　　暴力求解时找到正确的遍历解空间的方式很重要。有的遍历方式本身具有递归结构，同时存在重复子问题，可以方便的做优化。

　　寻找函数的定义取决于我们看问题的角度，这与生活中解决问题的思路是相通的。

　　在剖析问题时，应该从多种角度去观察问题：

　　从整体到局部、局部到整体的视角转化；关键逻辑的取逆，比如极大化极小、极小化极大，选择变不选择、不选择变选择等；问题的拆分，一个问题分解为多个不同的问题逐个击破；无序转有序等等等等，视角决定结果。从错误或者复杂的视角出发，后续的所有努力都将是错误和复杂的。

int an = Integer.MIN_VALUE;

    /**
     * @Author Niuxy
     * @Date 2020/7/1
     * @Description 遍历以每个元素开头的所有可能长度的连续子数组的和
     */
    public int maxSubArray0(int[] nums) {
        int[][] cache = new int[nums.length][nums.length];
        for (int begin = 0; begin < nums.length; begin++) {
            for (int length = 1; length <= nums.length - begin; length++) {
                maxSubArrayDP(nums, begin, length, cache);
            }
        }
        return an;
    }

    /**
     * @Author Niuxy
     * @Date 2020/7/1
     * @Description 具有递归结构的问题定义，求以 begin 开头，长度为 length 的子数组的和
     */
    public int maxSubArrayDP(int[] nums, int begin, int length, int[][] cache) {
        if (length == 1) {
            an = an > nums[begin] ? an : nums[begin];
            return nums[begin];
        }
        if (cache[begin][length] != 0) {
            return cache[begin][length];
        }
        int re = maxSubArrayDP(nums, begin + 1, length - 1, cache) + nums[begin];
        cache[begin][length] = re;
        an = an > re ? an : re;
        return re;
    }

　　转为递推：

/**
     * @Author Niuxy
     * @Date 2020/7/1
     * @Description 转为 递推，DP 解法
     */
    public final int maxSubArray(int[] nums) {
        int an = nums[0];
        int[][] cache = new int[nums.length][nums.length + 1];
        for (int i = 1; i < nums.length; i++) {
            cache[i][1] = nums[i];
            an = an > cache[i][1] ? an : cache[i][1];
        }
        for (int i = nums.length - 1; i >= 0; i--) {
            for (int j = 2; j <= nums.length - i; j++) {
                cache[i][j] = cache[i + 1][j - 1] + nums[i];
                an = an > cache[i][j] ? an : cache[i][j];
            }
        }
        return an;
    }

　　优化空间复杂度：

    /**
     * @Author Niuxy
     * @Date 2020/7/1
     * @Description dp 优化空间复杂度
     */
    public final int maxSubArray2(int[] nums) {
        int an = nums[0];
        int[] thisLevel = new int[nums.length + 1];
        int[] beforeLevel = new int[nums.length + 1];
        for (int i = 1; i < nums.length; i++) {
            an = an > nums[i] ? an : nums[i];
        }
        beforeLevel[1] = nums[nums.length - 1];
        for (int i = nums.length - 1; i >= 0; i--) {
            for (int j = 2; j <= nums.length - i; j++) {
                thisLevel[j] = beforeLevel[j - 1] + nums[i];
                an = an > thisLevel[j] ? an : thisLevel[j];
            }
            //缓存换位,beforeLevel 复用
            int[] temp = beforeLevel;
            beforeLevel = thisLevel;
            thisLevel = beforeLevel;
            beforeLevel[1] = nums[i];
        }
        return an;
    }

　　无效计算、重复计算、多余的空间都被优化掉了，但结果并不能令人满意：

 

　　因为问题的最优解法不是 DP，而是贪心：

    public int maxSubArray(int[] nums) {
     int res=nums[0];
     for(int i=1;i<nums.length;i++){
       nums[i]=Math.max(nums[i-1]+nums[i],nums[i]);
       res=Math.max(res,nums[i]);
     }
     return res;
    }