分治法和动态规划法解最大子序列问题 C++

最新推荐文章于 2024-04-06 14:59:07 发布

原创最新推荐文章于 2024-04-06 14:59:07 发布 · 465 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了两种不同的算法实现方式来解决最大子数组求和问题：分治法和动态规划法。分治法通过递归地将问题分解为较小的子问题，并结合子问题的解来解决原始问题；动态规划法则利用数组记录每个状态的最优解，从而避免重复计算。

分治法：

class Solution {
public:
    int maxCross(int A[], int low, int high)
    {
        int mid = (low + high)/2;
        int leftsum = A[mid];
        int sum = 0;
        for (int i = mid; i >= low; i--)
        {
            sum = sum + A[i];
            if (sum > leftsum)
                leftsum = sum;
        }
        int rightsum = A[mid+1];
        sum = 0;
        for (int j = mid+1; j <= high; j++)
        {
            sum = sum + A[j];
            if (sum > rightsum)
                rightsum = sum;
        }
        return (rightsum + leftsum);
             
    }
    int maxFind(int A[], int low, int high)
    {
        int mid;
        if (low == high)
            return A[low];
        else
        {
            mid = (low + high)/2;
            int left,right, cross;
            left = maxFind(A, low, mid);
            right = maxFind(A, mid+1, high);
            cross = maxCross(A, low, high);
            return max(max(left,right), cross);
        }
    }
    int maxSubArray(int A[], int n) {
        int sum;
        sum = maxFind(A, 0, n-1);
        return sum;
    }
};

动态规划法：

class Solution {
public:
    int maxSubArray(int A[], int n) {
        int s[n];
        int sum;
        s[0] = A[0];
        for (int i = 1 ; i < n ; i++)
        {
            s[i] = max(s[i-1] + A[i], A[i]);
        }
        sum = s[0];
        for (int i = 1 ; i < n ; i++)
        {
            if (s[i] > sum)
                sum = s[i];
        }
        return sum;
    }
};