算法思想-动态规划

通过把原问题分解成相对简单的子问题的方式求解复杂问题的方法
性质：
1、最优子结构：如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构的性质（既满足最优化原理）。最优子结构性质为动态规划算法解决问题提供了重要线索
2、重叠子问题：动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只计算一次，然后将其计算结果保存在一个表格中，当再次需要计算已经计算过的子问题时，只是在表格中简单的查看一下结果，从而获得较高的效率。
状态转移方程：
dp[i] = max(nums[i],nums[i]+dp[i-1])
解释：
i代表数组中第i个元素的位置
dp[i]代表从0到闭区间内，所有包含第i个元素的连续子数组中，总和最大的值

nums = [-2,1,-3,4,-1,2,1,-5,4]
dp = [-2,1,-2,4,3,5,6,1,5]
可以用来解最大子序和：
Python

class Solution:
    def maxSubArray(self, nums):
        if(len(nums) ==0):
            return 0
        dp = [None] * len(nums)
        dp[0] = nums[0]
        max = dp[0]
        for i in range(1,len(nums)):
            if(nums[i] > nums[i] + dp[i-1]):
                dp[i] = nums[i]
            else:
                dp[i] = nums[i] + dp[i-1]
            if(max < dp[i]) :
                max = dp[i]
        return max

Java

package com.Leetcode;

public class MaxChildADD {
    static int maxSubArray(int[] arr){
        if(arr.length == 0) return 0;
        int[] dp = new int[arr.length];
        dp[0] = arr[0];
        int max = dp[0];
        for(int i=1;i<arr.length;i++){
            dp[i] = arr[i] > dp[i-1] ? arr[i] : arr[i] + dp[i-1];
            if(max < dp[i]) max = dp[i];
        }
        return max;
    }
    public static void main(String[] args) {
        int [] array = new int[] {-2,1,-3,4,-1,2,1,-5,4};
        int [] testarray = new int[] {1,2};
        System.out.println(maxSubArray(testarray));

    }
}

C++

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        vector<int> dp(nums.size(),0);
        dp[0] = nums[0];
        int max = dp[0];
        //loop
        for(int i=1;i<nums.size();++i){
            dp[i] = nums[i] >nums[i]+dp[i-1] ? nums[i] : nums[i] + dp[i-1];
            if(max < dp[i]) max = dp[i];
        }
        return max;
    }
};