[LeetCode] Maximum Subarray

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [−2,1,−3,4,−1,2,1,−5,4],
the contiguous subarray [4,−1,2,1] has the largest sum = 6.

click to show more practice.

More practice:

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

 解题思路：

1. 首先是简单的dp。

2. 对于分治，考虑将数组分为左右两段，则最大连续子序列和可能在左半段，也可能在右半段，还可能跨界。三种情况求最大就可以了。

class Solution {

public:

    int dpSolution(int *a, int n)

    {

        if(n == 0) return 0;

        int *dp = new int[n + 1];

        dp[0] = a[0];

        int m = dp[0];

        for(int i = 1;i < n;i++)

        {

            if(dp[i - 1] > 0) dp[i] = dp[i - 1] + a[i];

            else dp[i] = a[i];

            m = max(dp[i], m);

        }

        return m;

    }

    

    int *data;

    int divideConquerSolution(int *a, int n)

    {

        if(n == 0)

            return 0;

        data = a;

        return dcs(0, n);

    }

    

    int dcs(int a, int b)

    {

        if(b - a == 1)

            return data[a];

    

        int mid = (a + b) / 2;

        int left = dcs(a, mid), right = dcs(mid, b);

        int rightSum = 0, leftSum = 0, rightMax = -(1 << 30), leftMax = -(1 << 30);

        for(int i = mid; i < b;i++)

        {

            rightSum += data[i];

            rightMax = max(rightSum, rightMax);

        }

        for(int i = mid - 1; i >= a;i--)

        {

            leftSum += data[i];

            leftMax = max(leftSum, leftMax);

        }

        return max(max(left, right), leftMax + rightMax);

    }

    

    int maxSubArray(int A[], int n) {

        // IMPORTANT: Please reset any member data you declared, as

        // the same Solution instance will be reused for each test case.

       // return dpSolution(A, n);

       return divideConquerSolution(A, n);

    }

};