算法思想-動態規劃

通過把原問題分解成相對簡單的子問題的方式求解複雜問題的方法
性質：
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;
    }
};