最大子段和的问题相信大家遇到了很多次,碰巧今日我想到了时间复杂度,就在考虑什么情况下可以考虑什么方案呢?
相信最普遍的暴力大家是知道的,今天我们一起来讨论下这个问题吧!
方案一:暴力,可行性❤
最简单的方法当然是最简单粗暴的啦,三层枚举,时间复杂度为O(n^3)。
可行性范围:n<=100
#include
using namespace std;
#define N 101
int node[N];
int main()
{
int n;
while(cin>>n)
{
int i;
for(i=1;i<=n;i++)
cin>>node[i];
//三层暴力求最大和
int maxsum=0,tmpsum=0;
int from=0,to=0;
int j,k;
for(i=1;i<=n;i++)
{
for(j=i;j<=n;j++)
{
tmpsum=0;
for(k=i;k<=j;k++)//求node[i]到node[j]的和
{
tmpsum+=node[k];
}
if(tmpsum>maxsum)
{
maxsum=tmpsum;
from=i;
to=j;
}
}
}
cout<<"From="<
弊端:容易T,起始点和终止点的求取不准确,在1 -1 3中应该是3 3 3 ,无法做妥善处理。
方案二:二层枚举,可行性❤❤
将方案一进行优化,发现k层循环并没有任何必要,2层枚举就够了,时间复杂度为O(n^2)
直接从起点开始即可。
可行性范围:n<=1000
#include
using namespace std;
#define N 101
int node[N];
int main()
{
int n;
while(cin>>n)
{
int i;
for(i=1;i<=n;i++)
cin>>node[i];
//二层枚举求最大和
int maxsum=0,tmpsum=0;
int from=0,to=0;
int j,k;
for (i=1;i<=n;i++)
{
tmpsum = 0;
for (j=i;j<=n;j++)
{
tmpsum += node[j];
if (tmpsum>maxsum)
{
maxsum = tmpsum;
from=i;
to=j;
}
}
}
cout<<"From="<
结果显示:
弊端:方案一相同,起始点和终止点的求取不准确,在1 -1 3中应该是3 3 3 ,无法做妥善处理
方案三:分治,可行性❤❤❤
从上述两种方案中会发现当n很大时,就会超时,那么有没有更快的算法呢?然后就有了分治,时间复杂度为O(nlogn)
分治思想:分而治之,不懂的可以去看http://blog.csdn.net/qq_25931695/article/details/51125800
可行性范围:n<=100000
#include
#define N 100005
int a[N];
struct node
{
int tfrom;
int tto;
int tsum;
};
node getMaxsum(int left,int right);
void print(node ans);
int main()
{
int n;
while(~scanf("%d",&n))
{
int i;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
node an=getMaxsum(1,n);
print(an);
}
return 0;
}
node getMaxsum(int left,int right)
{
int i;
node ret;
if(left==right)
{
if(a[left]>0)
{
ret.tsum=a[left];
ret.tfrom=left;
ret.tto=right;
}
else
{
ret.tsum=0;
ret.tfrom=1;
ret.tto=1;
}
}
else
{
int center=(left+right)/2;
node maxleft,maxright;
maxleft=getMaxsum(left,center);
maxright=getMaxsum(center+1,right);
int ans1=0,ans2=0;
int s1=0,s2=0;
int pi=center+1,pj=center;//这里需要特别注意
for(i=center;i>=left;i--)
{
ans1+=a[i];
if(ans1>s1)
{
s1=ans1;
pi=i;
}
}
for(i=center+1;i<=right;i++)
{
ans2+=a[i];
if(ans2>s2)
{
s2=ans2;
pj=i;
}
}
ret.tsum=s1+s2;
ret.tfrom=pi;
ret.tto=pj;
if((ret.tsum<=maxleft.tsum) && (maxright.tsum<=maxleft.tsum))
{
ret.tsum=maxleft.tsum;
ret.tfrom=maxleft.tfrom;
ret.tto=maxleft.tto;
}
else if(ret.tsum
结果显示:
弊端:发现方案一跟方案二存在的问题解决了,但是可以更进一步优化,万一N很大怎么办呢?
方案四:动态规划,可行性❤❤❤❤
动态规划的过程是:每次决策依赖于当前状态,又随即引起状态的转移。一个决策序列就是在变化的状态中产生的。
所以,关键就是找出状态方程。
这题,假设F(i)表示以位置i为终点的所有子区间中和最大的一个
子问题:如i为终点的最大子区间包含了位置i-1,则以i-1为终点的最大子区间必然包括在其中
如果F[i-1]>0,那么显然F[i]=f[i-1]+a[i]
如果F[i-1]<=0,那么F[i]=a[i],因为既然最大,前面的负数必然不能使之最大
这样,状态转移方程就有了,那么接下来的问题就不是问题了。
你会发现,这样i只要遍历一次就行,其时间复杂度为O(n)
可行性范围:n<=1000000
#include
#include
using namespace std;
#define N 1000001
int a[N];
int F[N];
int n;
void Init();
void Input();
void OutMax();
int main()
{
while(cin>>n)
{
Init();
Input();
OutMax();
}
return 0;
}
void Init()
{
memset(F,0,sizeof(F));
}
void Input()
{
int i;
for(i=1; i<=n; i++)
{
cin>>a[i];
}
}
void OutMax()
{
int i;
int pi=1,pj=1;
int ans=a[1],ti=1;
F[1]=a[1];
for(i=2; i<=n; i++)
{
if(F[i-1]>0)
{
F[i]=F[i-1]+a[i];
}
else
{
F[i]=a[i];
ti=i;
}
if(F[i]>ans)
{
ans=F[i];
pi=ti;
pj=i;
}
}
cout<<"From="<
结果显示:
四个方案各有优缺点,当然动态规划的是最准确最快速的啦,不过让人难以想到啊~
最大子段和问题就讲到这里了,还有不懂的留言吧~我想我应该讲的已经很清楚了~