JZOJ 5939. 【NOIP2018模拟10.30】阻击计划

题目

一张n个点m条边的图，其中有n-1条树边，m-n+1条非树边。
求删掉多少条非树边之后，每条边最多属于一个简单奇环。

题解

60分链

考虑留边而不是考虑删边。
如果考虑删边，那是个网络流模型。
如果考虑留边，那是个线段覆盖模型。
设$f[i][0]$表示i和i的儿子的连边没有包含在任意一个简单环内的答案。
$f[i][1]$表示i和i的儿子的连边包含在任意一个简单环内的答案。
$f[i][0]=h[son[i]]$
$f[i][1]=max(h[y]+w[(i,y)]),(i,y)为非树边$
$h[i]=max(f[i][0],f[i][1])$

100分做法

仙人掌。
显然，如果边的两个端点的深度值和（根深度为0）为奇数，那么加上这条边必存在偶环。所以这种边必须删。
剩余的边，如果一条树边属于了两个简单环。那么必然又产生新的偶环。
所以最后剩下了一个仙人掌。
又每个点的度数最多为10，考虑状压。
$f[i][s]$表示第i个点，哪些边被包含在简单环内。
删边比较难转移，考虑留边。使留下来的边权最大。
$g[x][i]$表示x的子树，除去i子树这一部分外，最优的答案是多少。
$h[x]$表示x的子树的最优答案。
暴力跳lca即可。
先不考虑加$h[son[x]]$。等到以x为lca的边全部处理完了之后，再加上$h[son[x]]$

心得

重温了状压怎么转移。（太菜了）
其实就像个背包那样。。。。。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define N 1010
#define M 5010
#define P(a) putchar(a)
#define Max(x,y) ((x)>(y)?(x):(y))
#define Min(x,y) ((x)<(y)?(x):(y))
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fd(i,a,b) for(i=a;i>=b;i--)
using namespace std;
struct note{
	int to,next;
}edge[N<<1];
struct note1{
	int u,v,w,lca;
}c[M],d[M];
int tot,head[N];
int i,j,k,l,n,m,ans,Ans;
int fa[11][N],dep[N],T,cnt,c1,sum;
int x1,x2;
int g[N][N],h[N];
int bj[N][M],mp[N][N],mp1[N][N],son[N];
int u,v,w,mx,_2[14],u3,v3,u2,v2;
int W[N],W1[N];
int f[N][4100],CNT;
bool bz[N];
bool p0,p1;
int read(){
	int fh=0,rs=0;char ch=0;
	while((ch<'0'||ch>'9')&&(ch^'-'))ch=getchar();
	if(ch=='-')fh=1,ch=getchar();
	while(ch>='0'&&ch<='9')rs=(rs<<3)+(rs<<1)+(ch^'0'),ch=getchar();
	return fh?-rs:rs;
}
void write(int x){
	if(x>9)write(x/10);
	P(x%10+'0');
}
void lb(int x,int y){
	edge[++tot].to=y;
	edge[tot].next=head[x];
	head[x]=tot;
}
void dg(int x){
	int i;
	for(i=head[x];i;i=edge[i].next)
	    if(edge[i].to^fa[0][x]){
	    	fa[0][edge[i].to]=x;
	    	son[x]++;
	    	mp[x][son[x]]=edge[i].to;
	    	mp1[x][edge[i].to]=son[x];
	    	dep[edge[i].to]=dep[x]+1;
	    	dg(edge[i].to);
		}
}
int getlca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	int i;
	fd(i,10,0)if(dep[fa[i][x]]>=dep[y])x=fa[i][x];
	if(x==y)return x;
	fd(i,10,0)if(fa[i][x]^fa[i][y])x=fa[i][x],y=fa[i][y];
	return fa[0][x];
}
void dp(int x){
	int i,j,u,v,_0,_1;
	fo(i,1,son[x])dp(mp[x][i]);
	fo(i,0,_2[son[1]+1]-1)W[i]=0;
	fo(i,1,bj[x][0]){
		j=bj[x][i];
		u=u2=d[j].u,v=v2=d[j].v;
		_1=h[u2]+h[v2];
		u3=v3=0;
		while(u^x){
			if(fa[0][u]==x){
				u3=u;
				break;
			}
			_1+=g[fa[0][u]][u];
			u=fa[0][u];
		}
		while(v^x){
			if(fa[0][v]==x){
				v3=v;
				break;
			}
			_1+=g[fa[0][v]][v];
			v=fa[0][v];
		}
		x1=mp1[x][u3],x2=mp1[x][v3];
		_0=0;
		if(x1)_0|=_2[x1];
		if(x2)_0|=_2[x2];
		W1[i]=_0;
		_1=_1+d[j].w;
		fo(j,1,_2[son[x]+1]-1)if((_0&j)==_0){
			f[x][j]=Max(f[x][j],f[x][j^_0]+_1);
		}
	}
	fo(i,0,_2[son[x]+1]-1){
		fo(j,1,son[x])if(!(_2[j]&i)){
			f[x][i]=f[x][i]+h[mp[x][j]];
		}
		h[x]=Max(h[x],f[x][i]);
	}
	fo(i,1,son[x]){
		fo(j,0,_2[son[x]+1]-1)if(!(_2[i]&j)){
			g[x][mp[x][i]]=Max(g[x][mp[x][i]],f[x][j]-h[mp[x][i]]);
		}
	}
}
int main(){
	n=read(),m=read();
	fo(i,1,m){
		u=read(),v=read(),w=read();
		if(!w)lb(u,v),lb(v,u);
		else{
			c[++cnt].u=u;
			c[cnt].v=v;
			c[cnt].w=w;
		}
	}
	dep[1]=1;
	dg(1);
	fo(j,1,10)fo(i,1,n)fa[j][i]=fa[j-1][fa[j-1][i]];
	ans=0;
	fo(i,1,cnt){
		if((dep[c[i].u]+dep[c[i].v])&1){
			ans=ans+c[i].w;
		}else{
			d[++c1]=c[i];
			sum+=c[i].w;
		}
	}
	if(c1==0){printf("%d",ans);return 0;}
	fo(i,1,c1){
		d[i].lca=getlca(d[i].u,d[i].v);
		bj[d[i].lca][++bj[d[i].lca][0]]=i;
	}
	_2[1]=1;
	fo(i,2,13)_2[i]=_2[i-1]<<1;
	dp(1);
	Ans=0;
	fo(i,0,_2[son[1]+1]-1)Ans=Max(Ans,f[1][i]);
	ans=ans+sum-Ans;
	printf("%d",ans);
	return 0;
}