BZOJ1808: [Ioi2007]training 训练路径

题面

题意

给出一棵树和几条非树边，每条非树边有一个权值，表示去掉它的代价，树边不能被去掉，问若要让图中没有偶环，至少要付出多少代价。
每个点的度数小于等于10

做法

首先与树组成偶环的边直接去掉，然后我们可以将非树边看作树上两点间的路径，然后可以发现如果两条路径边的交集非空，则这两条非树边一定能与一些树边组成偶环。
然后问题就转化为了：在一棵树上有一些路径，每条路径有一个权值，从中选择一些没有边重合的路径，最大权值是多少。
因为每个点的度数小于等于10，因此我们可以用状压dp来做，记$dp[i][j]$表示在以$i$点为根节点的子树中，$i$点的所有边（除了向父节点连的边）中不考虑边集$j$内的边所指向的子树的最大权值。
然后考虑一条路径对答案的贡献，发现对于一条$lca$为$i$的边$u-v$，它会让$i$少选两条边，贡献为$dp[u][0]+dp[v][0]+dp[$链上除了$i,u,v$的所有点$][$链上的边$]+$该路径的权值。
例：

对于红色的这条路径，其贡献为8的整棵子树+5去掉8这棵子树后的子树+3去掉5这棵子树后的子树+1去掉2,3这两棵子树后的子树+2的整棵子树（虽然为空）。

代码

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#define P pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define INF 0x3f3f3f3f
#define N 1100
#define M 5010
using namespace std;

int n,m,ans,ds[N],fa[N],deep[N],LCA[N][N],mx,a[M],b[M],c[M],dp[N][N],bh[N],tt;
vector<int>son[N],have[N];

inline void Max(int &u,int v){if(v>u) u=v;}

int lca(int u,int v)
{
	if(u==v) return u;
	if(deep[u]<deep[v]) swap(u,v);
	if(LCA[u][v]) return LCA[u][v];
	return LCA[u][v]=lca(fa[u],v);
}

void dfs(int now,int last)
{
	int i,j,t,d=-1;
	for(i=0; i<son[now].size(); i++)
	{
		t=son[now][i];
		if(t==last)
		{
			d=i;
			continue;
		}
		bh[t]=i-(d!=-1);
		deep[t]=deep[now]+1;
		fa[t]=now;
		dfs(t,now);
	}
	if(d!=-1)
	{
		for(i=d;i<son[now].size()-1;i++) son[now][i]=son[now][i+1];
		son[now].pop_back();
	}
}

void Dfs(int now)
{
	int i,j,p,q,o,sum,t,tmp;
	for(i=0;i<son[now].size();i++) Dfs(son[now][i]);
	for(i=0;i<(1 << son[now].size());i++)
	{
		sum=0;
		for(j=0;j<son[now].size();j++)
		{
			if((1 << j)&i) continue;
			sum+=dp[son[now][j]][0];
		}
		dp[now][i]=sum;
	}
	for(i=0;i<have[now].size();i++)
	{
		o=have[now][i];
		sum=c[o];
		p=a[o],q=b[o];
		t=0;
		if(p!=now)
		{
			sum+=dp[p][0];
			for(;fa[p]!=now;p=fa[p]) sum+=dp[fa[p]][(1 << bh[p])];
			t|=(1 << bh[p]);
		}
		if(q!=now)
		{
			sum+=dp[q][0];
			for(;fa[q]!=now;q=fa[q]) sum+=dp[fa[q]][(1 << bh[q])];
			t|=(1 << bh[q]);
		}
		tmp=(t^((1 << son[now].size())-1));
		for(j=tmp;;j=(j-1)&tmp)
		{
			Max(dp[now][j],dp[now][j|t]+sum);
			if(!j) break;
		}
	}
}

int main()
{
	int i,j,p,q,o,l,t;
	cin>>n>>m;
	for(i=1; i<=m; i++)
	{
		scanf("%d%d%d",&p,&q,&o);
		if(!o)
		{
			son[p].push_back(q);
			son[q].push_back(p);
			ds[p]++,ds[q]++;
			mx=max(mx,max(ds[p],ds[q]));
		}
		else a[++tt]=p,b[tt]=q,c[tt]=o;
	}
	deep[1]=1;
	dfs(1,-1);
	for(i=1; i<=tt; i++)
	{
		l=lca(a[i],b[i]);
		if((deep[a[i]]+deep[b[i]]-2*deep[l])%2==0)
			have[l].push_back(i);
		ans+=c[i];
	}
	Dfs(1);
	cout<<ans-dp[1][0];
}