bzoj-2151 种树

题意：

给出一个n个点的环，每个点有一个有正有负的权值；

现要在其中选出m个互不相连的点，使权值和最大；

对于85%的数据：n<=2000；

对于100%的数据：n<=200000；

题解：

论如何出一道大家都开心的题；

只要给暴力85分就好啦！

贪心的取可以取的最大权值肯定不行，所以考虑动态规划；

对于动态规划的状态，一定要有前i个这个状态，也不能省略选了j个的记录；

所以设f[i][j]为前i个点选了j个点，且选了i号点的最大权值和，g[i][j]为前i个点选了j个点，且没有选i号点的最大权值和；

这个状态已经限制了算法的极限，O(n^2)；

实际上如果只列出f只能做到O(n^3)，但是有了g相互转化就是O(n^2)了；

方程为：f[i][j]=g[i-2][j-1]+val[i];

g[i][j]=max(g[i-2][j],f[i-1][j]);

在不选n号点的情况下答案是g[n-1][m]，然后再反着做一遍，这样可以85分；

动态规划的极限已经是这样了，我们再回头看看开头被否掉的贪心；

贪心为什么不行？因为不能保证被删掉的点不能再选出来，也就是没有再反悔的机会；

那么就给它一个反悔的机会，做一个转化；

首先有一个结论，三个连续的点中如果中间的权值最大，那么最优解一定要么选中间的，要么两个都选(或者一个都不选)；

所以我们将“后悔”的机会转化为点，将那三个点删除之后插入到原来的位置；

权值设为val[l]+val[r]-val[mid]，显然如果下一次选了这个点就相当于将原来选的中间点取消而选择了边上点；

这个两边的点是由链表来维护的，每次找最大值则是用一个堆；

实现我写的比较繁琐了似乎，强行优先队列的后果= =；

时间复杂度O(mlogn)；

代码：

#include<queue>
#include<vector>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 220000
using namespace std;
struct node
{
	int l,r,val,to,no;
}a[N<<1];
struct Pcmp
{
	bool operator ()(node* a,node* b)
	{
		return a->val < b->val;
	}
};
bool vis[N<<1];
priority_queue<node*,vector<node*>,Pcmp >q;
int main()
{
	int n,m,i,j,k,ans,tot,L,R;
	scanf("%d%d",&n,&m);
	tot=n;
	for(i=1;i<=n;i++)
 	{
		scanf("%d",&a[i].val);
 		a[i].l=i-1,a[i].r=i+1;
 		a[i].no=i;
	}
	a[1].l=n,a
.r=1;
	if(m>n/2){puts("Error!");return 0;}
	for(i=1;i<=n;i++)
	{
		q.push(&a[i]);
	}
	for(i=1,ans=0;i<=m;i++)
	{
//		printf("%d\n",q.size());
		node *now=q.top();
		q.pop();
		if(vis[now->no]){i--;continue;}
		ans+=now->val;
		vis[now->no]=1;
		L=now->l,R=now->r;
		while(a[L].to)
			L=a[L].to;
		while(a[R].to)
			R=a[R].to;
		tot++;
		a[tot].no=tot;
		a[tot].val=a[L].val+a[R].val-now->val;
		a[tot].l=a[L].l,a[tot].r=a[R].r;
		a[L].to=tot,a[R].to=tot;
		vis[L]=vis[R]=1;
		q.push(&a[tot]);
	}
	printf("%d\n",ans);
	return 0;
}