最大子段和的四种算法_最大子段和的时间复杂度

---

一、例题：

注意: 字段和必须是在数组下标连续的元素之和，数组下标不能跳跃。

二、算法

1.暴力算法(时间复杂度：O(N^3)

思路：从第一个元素开始，到最后元素结束，求出这中间的最大字段和；
从第二个元素开始，到最后元素结束，求出这中间的最大字段和，再与已求的最大字段和比较。
……
从第n个元素开始，到最后元素结束，求出这中间的最大字段和，再与已求的最大字段和比较。
最后得出该数组中的最大字段和。

代码如下（示例）：

#include <iostream>
#include <climits>//取最值头文件
using namespace std;

//求数组a中的n个元素的最大字段和
//注意：两个int型的最大整数相加是会超出int型的，所以要有相加的和应该为long long型
long long MaxSum(int a[],int n);
int main()
{
    int n;
    long long sum;
    cin >> n;//共有n个元素
    int a[n];
    for(int i = 0; i < n; i++)
    {
        cin >> a[i];//将这n个元素放入数组a中
    }
    sum = MaxSum(a,n);//调用函数，求出最大字段和sum
    cout << sum << endl;//输出最大字段和
    return 0;
}

//求数组a中的n个元素的最大字段和
long long MaxSum(int a[],int n)
{
    long long Thissum;
    long long  maxs = LONG_LONG_MIN;//Thissum为当前的字段和，maxs为到目前为止最大的字段和,应初始化为最小值
    for(int i = 0; i < n; i++)
    {
        for(int j = i; j < n; j++)
        {
            Thissum = 0;
            for(int k = i; k <= j; k++)
            {
                Thissum += a[k];
                if(Thissum > maxs)
                    maxs = Thissum;
            }
        }
    }
    return maxs;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2.暴力算法的改进(时间复杂度：O(N^2))

代码如下（示例）：

#include <iostream>
#include <climits>//取最值头文件
using namespace std;

//求数组a中的n个元素的最大字段和
//注意：两个int型的最大整数相加是会超出int型的，所以要有相加的和应该为long long型
long long MaxSum(int a[],int n);
int main()
{
    int n;
    long long sum;
    cin >> n;//共有n个元素
    int a[n];
    for(int i = 0; i < n; i++)
    {
        cin >> a[i];//将这n个元素放入数组a中
    }
    sum = MaxSum(a,n);//调用函数，求出最大字段和sum
    cout << sum << endl;//输出最大字段和
    return 0;
}

//求数组a中的n个元素的最大字段和
long long MaxSum(int a[],int n)
{
    long long Thissum;
    long long  maxs = LONG_LONG_MIN;//Thissum为当前的字段和，maxs为到目前为止最大的字段和,应初始化为最小值
    for(int i = 0; i < n; i++)
    {
        Thissum = 0;
        for(int j = i; j < n; j++)
        {
            Thissum += a[j];
            if(Thissum > maxs)
                maxs = Thissum;
        }
    }
    return maxs;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3.分治算法(时间复杂度：O(nlogn))

思路：从数组的中心开始，求出左半边的最大字段和leftsum；
再求出右半边的最大字段和rightsum；
再求出从中心(从中心开始，包含中心)到起始点的最大字段和S1；
再求出从中心+1(含中心+1)到终点的最大字段和S2；
将sum = s1 + s2;
比较leftsum，rightsum，sum取其三者的最大值。

---

#include <iostream>
#include <climits>//取最值头文件
using namespace std;

//求数组a中的从left到right之间的最大字段和
//注意：两个int型的最大整数相加是会超出int型的，所以要有相加的和应该为long long型
long long MaxSum(int a[],int left,int right);
long long msum;
int main()
{
    int n;
    cin >> n;//共有n个元素
    int a[n];
    for(int i = 0; i < n; i++)
    {
        cin >> a[i];//将这n个元素放入数组a中
    }
    MaxSum(a,0,n-1);//调用函数，求出最大字段和sum
    cout << msum << endl;//输出最大字段和
    return 0;
}

long long maxs = LONG_LONG_MIN;//将maxs初始化为最小值；
long long bordersum  = 0;
//求数组a中的从left到right之间的最大字段和
//注意：两个int型的最大整数相加是会超出int型的，所以要有相加的和应该为long long型
long long MaxSum(int a[],int left,int right)
{
    //如果只有一个元素就返回max{a[left],maxs}
    if(left == right)
    {
        if(a[left] > maxs)
            return a[left];
        else
            return maxs;
    }
    long long leftsum = 0,rightsum = 0;
    int center = (left + right)/2;
    leftsum = MaxSum(a,left,center);//求出左半边的最大字段和
    rightsum = MaxSum(a,center+1,right);//求出右半边的最大字段和
    //跨越左右两边的最大字段和
    //从center向左到left
    long long s1 = 0,inleft = 0;
    for(int i = center; i >= 0; i--)
    {
        inleft += a[i];
        if(inleft > s1)
            s1 = inleft;
    }
    //从center向右到right
    long long s2 = 0,inright = 0;
    for(int i = center+1; i <= right; i++)
    {
        inright += a[i];
        if(inright > s2)
            s2 = inright;
    }
    bordersum = s1 + s2;
    //取三者中的最大值
    msum = max(leftsum,bordersum);
    msum = max(msum, rightsum);
    return msum;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

4.动态规划(时间复杂度：O(n))

思路：从第一个元素开始与它后边的一个元素比较，取max{它之前的最大字段和加上它后边那个元素的值，它本身的值}。从而得到最终的最大字段和。

#include <iostream>
#include <climits>//取最值头文件
using namespace std;

//求数组a中的n个元素的最大字段和
//注意：两个int型的最大整数相加是会超出int型的，所以要有相加的和应该为long long型
long long MaxSum(int a[],int n);
long long dp[100001];//备忘录：同于存放到i号元素的最大字段和
int main()
{
    int n;
    cin >> n;//共有n个元素
    int a[n];
    for(int i = 1; i <= n; i++)
    {
        cin >> a[i];//将这n个元素放入数组a中
    }
    cout << MaxSum(a,n+1) << endl;//调用函数，求出最大字段和sum并输出最大字段和
    return 0;
}

//求数组a中的n个元素的最大字段和
//注意：两个int型的最大整数相加是会超出int型的，所以要有相加的和应该为long long型
long long MaxSum(int a[],int n)
{
    long long maxs = LONG_LONG_MIN;
    for(int i = 1; i < n; i++)
    {
        if(dp[i-1] + a[i] > a[i])
        {
            dp[i] = dp[i-1] + a[i];
        }
        else
            dp[i] = a[i];
    }
    for(int i=1;i<=n;i++)
    {
        maxs=max(maxs,dp[i]);
    }
    return maxs;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41