51Nod 最大M子段和系列 V1 V2 V3

前言

(HE)沾(BJ)的光成功滚回家里了...这堆最大子段和的题抠了半天，然而各位(dalao)们都已经去做概率了...先%为敬。
引流之主：老姚的博客

最大M子段和 V1

思路

• 最简单的ver.数据范围在5000以内，可以考虑暴力一点的做法(O(n^3))，定义(dp)状态(dp[i][j])，递推式子：

[dp[i][j]=max{dp[i-1][j],dp[k][j-1]}+a[i] (j-1le k<i) ]

• 其中(i)表示序列中前(i)个元素且包含第(i)个元素，而(j)则表示划分了(j)个不同的字段。而对于(a[i])来说，要么和最后一个字段合并，要么单独成为一个字段，所以就可以得出动态转移方程。
• 此时我们可以看出，对于第二维(j)，只与(j)和(j-1)有关，所以我们可以互换，使(dp[i][j])表示把序列前(j)个元素分成(i)个子段且包含(a[j])的最大子段和。此时的状态就只和上一行和左边的状态有关了，所以我们就可以把效率压到(O(m*n))。
  此时的动态转移方程：

[dp[i][j]=max{dp[i][j-1],dp[i-1][k]}+a[j] (i-1le k<j) ]

• 还有一个要特判的就是(i=j)的时候，见代码即可。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e4+5;
const ll INF=1e15;
ll a[maxn],dp[2][maxn];
int n,m;

int main(){
    scanf("%d%d",&n,&m);

    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i]);

    int k=1;

    for(int i=1;i<=m;i++,k=k^1){
    	ll temp=-INF;
    	for(int j=i;j<=n;j++){
    		temp=max(temp,dp[k^1][j-1]);
    		if(i==j)
    			dp[k][j]=dp[k^1][j-1]+a[j];
    		else
    			dp[k][j]=max(temp,dp[k][j-1])+a[j]; 		
    	}
    }
    
    ll ans=-INF;
    for(int i=m;i<=n;i++)
    	ans=max(ans,dp[k^1][i]);//注意此处是k^1记录的才是第m行的状态
    printf("%lld
",ans);

    return 0;
}

最大M子段和 V3

思路

• 为什么先说V3因为V3是环形的边界处理比V2还要简单。对于V1的DP虽然效率是(O(m*n))但是显然从V2开始就已经有m接近于n的数据了，所以最差的效率为(O(n^2))，所以DP显然是不行了。这时候用可撤销贪心。
• 可撤销贪心简单来说就是贪心时候的悔棋操作，可能最一开始选择的为最大的贡献(w[i])，但是第二轮选择可能会发现选择(w[i-1])和(w[i+1])更优，那么此时的答案就应加上(w[i-1]+w[i+1]-w[i])，相当于建立了一个新的节点，同时其相邻关系也会发生变化。
• 对于此题，我们可以把相邻的相同符号的数都加在一起（0加在哪里都一样甚至可以选择直接把0删了），这样就得到了一个正负交替的环形序列，而每个数均代表一个区间，此时设序列中正数个数为(cnt)，正数的和为(ans)。
  • 若(cntle m),则依照题目要求直接输出(ans)。
  • 否则需要删减(cnt-m)个区间。
• 考虑如何删减：
  • 可以选择直接删除一个正数。则每次删除最小的正数。
  • 也可以将一个负数和相邻两个正数合并，即将两个正数区间合并成一个。这时选择最大的负数和两边合并。
• 但是此时不能随便删除，因为可能通过多次合并减少区间得到的答案会更优，盗老姚的数据：

  • 10 -4 3 -4 8 -100

  • 若先删除最小的正数3，则第二步要选择最大的负数-4，但是此时的3已经被删除了无法合并，因此我们要用到可撤销贪心思想。
• 实现方法：
  • 将修改后的序列中的正数改为负数，压入大根堆（网上好多题解都说用绝对值，但实际上正变负更方便一点，如果用pair的话都不用重载运算符了）。
  • 可撤销贪心执行(cnt-m)次。

一个不怕死的HACK

• 老姚的代码

#include <bits/stdc++.h>
typedef long long LL;
const int maxn=2e5+5;
struct Node{
	int id;
	LL w;
	Node(){};
	Node(int x,LL y){id=x;w=y;}
	bool operator <(const Node &a)const{
		return w<a.w;
	}
};
int n,m,N=0,L[maxn],R[maxn]; 
LL ans=0,a[maxn],b[maxn];
std::priority_queue<Node> q; 
bool flag[maxn];
void Init(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;++i){
		scanf("%lld",&a[i]);//原始数组
		if(!N || (a[i]>=0)!=(b[N]>=0))
			b[++N]=a[i];//新数组，上个数和当前数符号不一样节点++ 
		else
			b[N]+=a[i];//符号一样，累加
	}
	if((b[1]>=0)==(b[N]>=0))//因为是环，b[1]和b[N]同号就合并
		b[1]+=b[N--];//合并后新数组个数减一，记得N--
}
void Solve(){
	Init();	
	int tot=0;//记录正数个数
	for(int i=1;i<=N;++i){//遍历新数组，压入大根堆
		L[i]=i-1; R[i]=i+1;//初始化i的左右邻居
		if(b[i]>0){//正数累加到答案，然后变负
			ans+=b[i]; b[i]=-b[i]; tot++;
		}
		q.push(Node(i,b[i]));
	}
	R[N]=1; L[1]=N;//注意是环形
	if(m>=tot){//正数个数小于m，则全部选
		printf("%lld
",ans);return;
	}
	m=tot-m;//正数大于m则合并或删除tot-m个区间
	while(m--){
		Node t=q.top(); q.pop();
		int i=t.id;
		if(flag[i]){++m; continue;}
		else{//可撤销贪心
			ans+=b[i];
			flag[L[i]]=1;
			flag[R[i]]=1;
			b[i]=b[L[i]]+b[R[i]]-b[i];			
			R[L[L[i]]]=i;
			L[R[R[i]]]=i;
			q.push(Node(i,b[i]));//压入新点			
			L[i]=L[L[i]];
			R[i]=R[R[i]];			
		}
	}
	printf("%lld
",std::max(0LL,ans));
}
int main(){
	Solve();
	return 0;
}

• 在51Nod直接AC了，不得不说51Nod真的都是随机数据。
• 有个很明显的错误就是如果给出的序列都是一个符号，例如下面这个HACK数据:

  • Input:
    5 4
    1 1 1 1 1
    Output:
    5

  • 然而老姚的代码会输出0，问题在这行：

  • if((b[1]>=0)==(b[N]>=0))
    	b[1]+=b[N--];
    

  • 如果全为一个符号，最后(N=1)，显然(b[1]=b[N])，这样会导致(N)变成(0)。如果对于全负，答案必输出0没什么影响，但是全正的话就不行了。不过也很好弄，加个特判即可。具体见代码（把老姚的代码改了改增加可读性（雾））。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+10;

struct Node{
	int id;
	ll w;
	Node(){};
	Node(int x,ll y){
		id=x;w=y;
	}
	friend bool operator <(const Node &a,const Node &b){
		return a.w<b.w;
	}
};

int n,m,N;
int L[maxn],R[maxn];
ll ans;
ll a[maxn],b[maxn];
bool vis[maxn],flag=1;
priority_queue<Node> q;

void Init(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i]);

		if(a[i]<0)flag=0;
		else ans+=a[i];

		if(!N || (a[i]>=0)!=(b[N]>=0))
			b[++N]=a[i];
		else 
			b[N]+=a[i];
	}
	if((b[1]>=0)==(b[N]>=0))
		b[1]+=b[N--];
}

int main(){
	Init();

	int tot=0;
	for(int i=1;i<=N;i++){
		L[i]=i-1;R[i]=i+1;
		if(b[i]>0){
			b[i]=-b[i];
			tot++;
		}
		q.push(Node(i,b[i]));
	}
	
	R[N]=1;L[1]=N;

	if(m>=tot||flag){
		printf("%lld",ans);
		return 0;
	}
		
	m=tot-m;

	while(m--){
		Node t=q.top();
		q.pop();

		int i=t.id;
		if(vis[i]){
			m++;
			continue;
		}else{
			ans+=b[i];
			q.push(Node(i,b[i]));
			
			vis[L[i]]=1;vis[R[i]]=1;
			b[i]=b[L[i]]+b[R[i]]-b[i];
			R[L[L[i]]]=i;
			L[R[R[i]]]=i;
			L[i]=L[L[i]];
			R[i]=R[R[i]];
		}
	}

	printf("%lld",max(ans,0LL));

	return 0;
}

最大M子段和 V2

• 最后就是V2了，一开始尝试特判(0)和(N)处的边界但发现巨难写，后来发现其实只需要加上一个权值为负无穷的(0)号节点就行了...

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=5e4+10;

struct Node{
	int id;
	ll w;
	Node(){};
	Node(int x,ll y){
		id=x;w=y;
	}
	friend bool operator <(const Node &a,const Node &b){
		return a.w<b.w;
	}
};

int n,m,N;
int L[maxn],R[maxn];
ll ans;
ll a[maxn],b[maxn];
bool vis[maxn],flag=1;
priority_queue<Node> q;

void Init(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i]);
		if(a[i]<0)flag=0;
		else ans+=a[i];
		if(!N && a[i]<0)continue;

		if(!N || (a[i]>=0)!=(b[N]>=0))
			b[++N]=a[i];
		else 
			b[N]+=a[i];
	}

	while(b[N]<0)b[N--]=0;
}

int main(){
	Init();

	int tot=0;
	for(int i=1;i<=N;i++){
		L[i]=i-1;R[i]=i+1;
		if(b[i]>0){
			b[i]=-b[i];
			tot++;
		}
		q.push(Node(i,b[i]));
	}
	
	R[N]=0;L[0]=N;R[0]=1;
	q.push(Node(0,b[0]=-1e15));

	if(m>=tot||flag){
		printf("%lld",ans);
		return 0;
	}
		
	m=tot-m;

	while(m--){
		Node t=q.top();
		q.pop();

		int i=t.id;
		if(vis[i]){
			m++;
			continue;
		}else{
			ans+=b[i];
			q.push(Node(i,b[i]));

			vis[L[i]]=1;vis[R[i]]=1;
			b[i]=b[L[i]]+b[R[i]]-b[i];
			R[L[L[i]]]=i;
			L[R[R[i]]]=i;
			L[i]=L[L[i]];
			R[i]=R[R[i]];
		}
	}

	printf("%lld",max(ans,0LL));

	return 0;
}