容器实现的查找最大序列

#include<iostream>
#include<vector>
#include<assert.h>
#include<algorithm>
using namespace std;
int m;
vector<int>n;
int sum;
int main(){
while (cin>>m)
{
n.push_back(m);


}
int maxfar = 0;//存储最大值
for (auto i = n.begin(); i != n.end();++i)//i为最内层循环开始时的左边界，因为要计算所有的序列，所以每一位都要做一次左边界，所以i遍取x中所有的值
{
for (auto j = i; j != n.end(); ++j)//j为最内层开始时的右边界，由于要计算所有的序列，所以也要遍取所有的值，但是这里由于i已经有了定义，当j<i时是无意义的，所以j从i开始取，而不是从x的首位开始取
{
sum = 0;//计算和
for (auto k = i; k <= j; ++k)
{
cout << *k << " ";
sum = sum + *k;//开始求和
maxfar = max(sum, maxfar);//求的和与max比较，max取2者中比较大的那个
//cout << maxfar << endl;
}
cout << endl;
cout << maxfar << endl;
}

}
// cout << maxfar;

cin >> sum;

}

上述代码由于重复计算了所有的sum，所以所耗费的时间较多

下述代码则利用了之前计算的i相同的序列，使得不需要重复计算所有的sum，所以时间复杂度得到了降低

#include<iostream>
#include<vector>
#include<assert.h>
#include<algorithm>
using namespace std;

vector<int>x{ 1, 2, 3, 0, -5, -6, 10, 11 };
vector<int>::iterator beg= x.begin();
vector<int>::iterator end1 = x.end();
int m;
vector<int>n;
int sum;
int main(){
	while (cin>>m)
	{
		n.push_back(m);

	}
	int maxfar = 0;//存储最大值
	for (auto i = n.begin(); i != n.end(); ++i)
	{
		sum = 0;
		for (auto j = i; j !=n.end(); ++j)
		{
			sum = sum + *j;
			maxfar = max(maxfar, sum);
		}
	}//上一种写法是重复计算了sum,而这种写法则是利用了开始序列i相同而j增长的做法，不需要每次都要叠加所有的序列
	cout << maxfar;
	
	cin >> sum;
}

还有更快速的方法如下：

<pre name="code" class="cpp">#include<iostream>
#include<vector>
#include<assert.h>
#include<algorithm>
using namespace std;

vector<int>x{ 1, 2, 3, 0, -5, -6, 10, 11 };
vector<int>::iterator beg= x.begin();
vector<int>::iterator end1 = x.end();
int m;
vector<int>n;
int sum = 0;
int f(vector<int>::iterator l, vector<int>::iterator u){
	int lsum = 0;
	
	if (l > u)return 0;
	if (l == u)return max(0, *l);
	vector<int>::iterator mid = l+(u-l) / 2;
	int lmax = 0, rmax = 0;
	
	for (auto i = mid; i > l; --i){
		lsum = lsum + *i;
		lmax = max(lmax, lsum);
	}//这里不能写成i>=l,否则由于for循环最后一次执行的时候--i会导致容器越界而报错，开头的l必须要使用下面的语句进行迭代
	lsum = lsum + *l;
	lmax = max(lmax, lsum);

	int rsum = 0;
	for (auto i = mid + 1; i <=u; ++i){
		rsum = rsum + *i;
		rmax = max(rmax, rsum);
	}
	return max(rmax + lmax, max(f(l, mid), f(mid + 1, u-1)));
}
int main(){
	while (cin>>m)
	{
		n.push_back(m);

	}
	
	int maxfar = 0;//存储最大值
	maxfar = f(n.begin(), n.end()-1);

	cout << maxfar;
	cin >> sum;

这种方法类似于折半查找，把序列分成2部分来计算，但是由于最大的序列有可能会横跨2个子序列，所以最后会使用递归来计算横跨2个子序列的情况，虽然最后会分跨2个子序列，但是分跨的子序列是连续的，也就是说一部分在左边，一部分在右边，2部分从序列的中断部分开始向容器的begin和end增长，各自增长到最大的时候则就是2个要找的子序列，再分别和子序列中最大的不是从mid开始的序列进行比较，最大的就是要找的序列，这里最后使用了递归。

#include<iostream>
#include<vector>
#include<assert.h>
#include<algorithm>
using namespace std;

vector<int>x{ 1, 2, 3, 0, -5, -6, 10, 11 };
vector<int>::iterator beg= x.begin();
vector<int>::iterator end1 = x.end();
int m;
vector<int>n;
int sum = 0;

int main(){
	while (cin>>m)
	{
		n.push_back(m);

	}
	
	int maxfar = 0;//存储最大值
	int maxend = 0;
	for (auto i = n.begin(); i != n.end(); ++i)
	{
		maxend = max(maxend + *i, 0);
		maxfar = max(maxfar, maxend);
	}
//	maxfar = f(n.begin(), n.end()-1);

	cout << maxfar;
	cin >> sum;
}

这里maxend存储的是动态的最大和，比如序列｛1 1 1-4 3 6 -10｝，maxend在1 1 1的时候时候值为3，到-4则会放弃之前的之前的值而变成0，因为由于-4的出现导致数值为负数，只能放弃，而maxfar在-4的时候则会比较3和0的大小，而继续取3，也就是说maxfar取的是到现在为止的最大值，而maxend则是每一个区域的最大值，比如由于-4的阻断，使得maxend放弃了之前存储的最大值，而重新开始计算，在3的时候，maxend=3，而maxfar这个时候也是3，所以不变，而当迭代器移动到6的时候，则maxend变成了9，而maxfar这个时候则会放弃原来的3，转而存储现在的9，而当移动到-10的时候，maxend就又变成了0，因为9-10=-1，也就是说之前存储的又被放弃，而又重新开始计算，而maxfar则还是9，等待下一次比9大的和的出现，这里当maxend+*i为负数的时候maxend取0，是如果连续的负数出现，则maxend不会计算，也就是不会记忆负数，否则会对之后和造成影响。