【最长连续子序列和】三种复杂度的算法
题目：
★实验任务：为了打破进了实验室就嫁不出去的诅咒，六一儿童节这天集训队特地举办了一场相亲大会，来自各个学院的n个姑娘在实验室内站成一排。每个姑娘有自己的颜值ai。单身狗们决定邀请颜值之和最高的k个（k要大于0）位置相邻的姑娘一起晚上的狼人杀。
★数据输入：输入第一行为一个数n（1<=n<=100000）表示姑娘个数。接下来一行有n个整数ai（-1000<=ai<=1000）表示第i个姑娘的颜值。
★数据输出：输出一行为最大连续子串和。
输入示例：5 6 -1 5 4 -7
输出示例：14
输入示例：7 0 6 -1 1 -6 7 -5
输出示例：7
三种做法：
1.O(n^2)
//
// main.cpp
// MaxSubSequence
//
// Created by wasdns on 16/8/31.
// Copyright © 2016年 wasdns. All rights reserved.
//
#include <iostream>
#include <cstdio>
#include <string.h>
#include <string>
#include <algorithm>
using namespace std;
int number[1000005];
int MaxSubSequence(int n) //复杂度为O(n^2)
{
int MaxSum = 0;
for(int i = 0; i < n; i++)
{
int Cal = 0;
for(int j = i; j < n; j++)
{
Cal += number[j];
if(Cal > MaxSum) //利用先前计算的结果进行比较
{
MaxSum = Cal;
}
}
}
return MaxSum;
};
int main()
{
int n, i;
cin >> n;
for(i = 0; i < n; i++)
{
cin >> number[i];
}
int MaxSum = MaxSubSequence(n);
cout << MaxSum << endl;
return 0;
}
2.O(nlogn)
//
// main.cpp
// MaxSubSequence_2
//
// Created by wasdns on 16/8/31.
// Copyright © 2016年 wasdns. All rights reserved.
//
#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <algorithm>
using namespace std;
int number[1000005];
int MaxCalculator(int left, int right);
int MaxSubSequence(int left, int right)
{
return MaxCalculator(left, right);
}
int CalMax(int a, int b, int c)
{
if(a > b)
{
if(a > c) return a;
else return c;
}
else
{
if(b > c)return b;
else return c;
}
}
int MaxCalculator(int left, int right)
{
if(left == right)
{
if(number[left] > 0) return number[left];
else return 0;
}
int MaxLeftSum = 0;
int MaxRightSum = 0;
int middle;
//cout << left << " " << right << endl;
middle = (left + right)/2;
//cout << middle << endl;
MaxLeftSum = MaxCalculator(left, middle);
MaxRightSum = MaxCalculator(middle + 1, right); //没有+1：导致 0 1 循环
int MLASum = 0; //MaxLeftAreaSum
int MRASum = 0; //MaxRightAreaSum
int MSum = 0;
for(int i = middle; i >= left; i--)
{
MSum += number[i];
if(MSum > MLASum) MLASum = MSum;
}
MSum = 0;
for(int i = middle + 1; i <= right; i++)
{
MSum += number[i];
if(MSum > MRASum) MRASum = MSum;
}
return CalMax(MaxLeftSum, MaxRightSum, MLASum + MRASum);
}
int main()
{
int n, i;
cin >> n;
for(i = 0; i < n; i++)
{
cin >> number[i];
}
cout << MaxSubSequence(0, n-1) << endl;
return 0;
}
3.O(nlogn)：常用的动态规划
//
// main.cpp
// MaxSubSequence_3
//
// Created by wasdns on 16/8/31.
// Copyright © 2016年 wasdns. All rights reserved.
//
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <string.h>
using namespace std;
int Number[100005];
int b[100005]; //含当前位置元素的最大子序列和 不断的更新
int MSS(int n) //状态转移方程：b[i] = MAX{b[i-1] + a[i], a[i]};
{
memset(b, 0, sizeof(b));
int i;
int sum = Number[0]; //sum 初始化为 Number[0]
b[0] = Number[0];
for(i = 1; i < n; i++)
{
if(b[i-1] + Number[i] > Number[i])
{
b[i] = b[i-1] + Number[i];
}
else b[i] = Number[i];
//cout << "b[i] = " << b[i] << endl;
if(sum < b[i]) sum = b[i];
//cout << "sum = " << sum << endl;
}
return sum;
}
int main()
{
int n;
cin >> n;
for(int i = 0; i < n; i++)
{
cin >> Number[i];
}
int MaxSequenceSum = MSS(n);
cout << MaxSequenceSum << endl;
return 0;
}
小结
给出的第一种解决代码，首先复杂度相比使用三个for循环的O(N^3)下降了很多，但是仍然达不到要求。利用的是 之前计算的结果，从当前位置一个一个加过去。
实现算法：
int MaxSubSequence(int n) //复杂度为O(n^2)
{
int MaxSum = 0;
for(int i = 0; i < n; i++)
{
int Cal = 0;
for(int j = i; j < n; j++)
{
Cal += number[j];
if(Cal > MaxSum) //利用先前计算的结果进行比较
{
MaxSum = Cal;
}
}
}
return MaxSum;
};
第一种易于理解，但是算法复杂度过高。因此为了适应题目的要求，提到了第二种的解决方法。
算法实现：最大子序列和，要么出现在 1)left 和 middle 之间，要么出现2)在 middle 和 right 之间，还有 3)middle在这个子序列中。一共三种情况，分别计算出三种情况的最大子序列的大小，取最大值。
前面两种方法，可以使用 递归分治 的思想：更新middle -> 计算上面三种情况的子序列大小 -> 利用递归 -> 更新middle ···
当最后 left 和 middle 重合的时候(或者 middle 和 right 重合的时候)，判断 number[left] 是否大于0，大于0返回number[left]，小于0返回0。
当利用递归 计算完成1)和2）的值之后，转而计算3)的值：左边从middle开始遍历，找到left；右边从middle+1开始遍历，找到right；两边的值相加即可求得3)。
实现代码：
int CalMax(int a, int b, int c)
{
if(a > b)
{
if(a > c) return a;
else return c;
}
else
{
if(b > c)return b;
else return c;
}
}
int MaxCalculator(int left, int right)
{
if(left == right) //递归终止的条件
{
if(number[left] > 0) return number[left];
else return 0;
}
int MaxLeftSum = 0;
int MaxRightSum = 0;
int middle;
//cout << left << " " << right << endl;
middle = (left + right)/2;
//cout << middle << endl;
MaxLeftSum = MaxCalculator(left, middle);
MaxRightSum = MaxCalculator(middle + 1, right); //注意！没有+1：导致 0 1 循环
int MLASum = 0; //MaxLeftAreaSum
int MRASum = 0; //MaxRightAreaSum
int MSum = 0;
for(int i = middle; i >= left; i--) //从middle左边开始遍历
{
MSum += number[i];
if(MSum > MLASum) MLASum = MSum;
}
MSum = 0;
for(int i = middle + 1; i <= right; i++) //从middle+1右边开始遍历
{
MSum += number[i];
if(MSum > MRASum) MRASum = MSum;
}
return CalMax(MaxLeftSum, MaxRightSum, MLASum + MRASum); //取三种情况的最大值
}
第三种，即最常见的动态规划问题了。动态规划是一种利用之前计算结果的算法，我们这里使用了b[i]数组来存储：b[i]代表的意思是，经过number[i]的最大子序列。
如果b[i-1]+number[i]大于number[i]，那么加到此处的最大子序列b[i]更新为b[i-1]+number[i]；否则，将b[i]更新为number[i]重新开始。记录整个过程中的最大子序列和sum。状态转移方程：b[i] = MAX{b[i-1]+number[i], number[i]}
注意：sum需要初始化为Number[0]。
实现代码：
int MSS(int n) //状态转移方程：b[i] = MAX{b[i-1] + a[i], a[i]};
{
memset(b, 0, sizeof(b));
int i;
int sum = Number[0]; //sum 初始化为 Number[0]
b[0] = Number[0];
for(i = 1; i < n; i++)
{
if(b[i-1] + Number[i] > Number[i])
{
b[i] = b[i-1] + Number[i];
}
else b[i] = Number[i];
//cout << "b[i] = " << b[i] << endl;
if(sum < b[i]) sum = b[i];
//cout << "sum = " << sum << endl;
}
return sum;
}
2016/8/31
To improve is to change, to be perfect is to change often.
