tc srm633 600 最大权闭合图

       给两棵树，两棵树编号相同的节点具有相同的价值，现在让选出一个集合S，使得S中的编号在两棵树中都恰好是一个连通子图，并且要使选择的点的权值尽可能大。

       首先枚举一个节点p表示p一定要取，然后在两棵树中分别以p为根节点dfs，并且对每个节点向其父节点连一条单向边（两棵树节点都是0--n-1,所以实际上是把两颗树合并成一个图），然后注意到新图的一个对于新图的一个闭合子图，分别在两颗树上对应一个连通的子图，那么问题就转换成一个球最大权闭合图的问题了，因为最大权=节点正权值之和-最小割，所以可以用最小割求解。新建原点s汇点t，原图中的每条边保留成一条容量无穷大的边，对每个节点，若权值w大于0，则从s向其连一条容量w的边，否则由该节点向t连一条容量-w的边，然后跑最大流就可以了。

/*=============================================================================
#  Author:Erich
#  FileName:
=============================================================================*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#define lson id<<1,l,m
#define rson id<<1|1,m+1,r

using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=1ll<<60;
const double PI=acos(-1.0);
const int maxn=105;
struct Edge
{
	int u,v,cap,flow,next;
}edge[1050];
int g[maxn];
int n,m,k;
int en;
bool vis[maxn];
int d[maxn];
int cur[maxn];
void addedge(int x,int y,int z)
{
	edge[en].u=x;
	edge[en].v=y;
	edge[en].cap=z;
	edge[en].flow=0;
	edge[en].next=g[x];
	g[x]=en++;

	edge[en].u=y;
	edge[en].v=x;
	edge[en].cap=edge[en].flow=0;
	edge[en].next=g[y];
	g[y]=en++;
}
int w[maxn];
int need[maxn];
int s,t;
bool bfs()
{
	memset(vis,0,sizeof vis);
	queue<int> q;
	q.push(s);
	d[s]=0;
	vis[s]=1;
	while(!q.empty())
	{
		int x=q.front();
		q.pop();
		for (int j=g[x]; j!=-1; j=edge[j].next)
		{
			int v=edge[j].v;
			if (!vis[v] && edge[j].cap>edge[j].flow)
			{
				vis[v]=1;
				d[v]=d[x]+1;
				q.push(v);
			}
		}
	}
	return vis[t];
}
int dfs(int x,int a)
{
	if (x==t || a==0) return a;
	int flow=0,f;
	for (int &j=cur[x]; j!=-1; j=edge[j].next)
	{
		int v=edge[j].v;
		if (d[x]+1==d[v] && (f=dfs(v,min(a,edge[j].cap-edge[j].flow)))>0)
		{
			edge[j].flow+=f;
			edge[j^1].flow-=f;
			flow+=f;
			a-=f;
			if (a==0) break;
		}
	}
	return flow;
}
int Maxflow(int s,int t)
{
	memset(d,0,sizeof d);
	int flow=0;
	while(bfs())
	{
		for (int i=0; i<=n+1; i++)
			cur[i]=g[i];
		flow+=dfs(s,inf);
	}
	return flow;
}
vector<int> g1[maxn];
vector<int> g2[maxn];
int fa[2][maxn];
void dfs2(int u,int f,int x,vector<int> g[])
{
	fa[x][u]=f;
	vis[u]=true;
	for (int j=0; j<g[u].size();j++)
	{
		int v=g[u][j];
		if (!vis[v] && v!=f) dfs2(v,u,x,g);
	}
}
int calc(int r)
{
	memset(fa,-1,sizeof fa);
	memset(vis,false,sizeof vis);
	dfs2(r,-1,0,g1);
	memset(vis,false,sizeof vis);
	dfs2(r,-1,1,g2);
	en=0;
	memset(g,-1,sizeof g);
	s=n;
	t=n+1;

	for (int i=0; i<n; i++)
	{
		if (fa[0][i]!=-1) addedge(i,fa[0][i],inf);
		if (fa[1][i]!=-1) addedge(i,fa[1][i],inf);
	}
	int sum=0;
	for (int i=0; i<n; i++)
		if (w[i]>0) addedge(s,i,w[i]),sum+=w[i];
		else addedge(i,t,-w[i]);
	return sum-Maxflow(s,t);
}

class DoubleTree
{
	public:
	int maximalScore(vector <int> a, vector <int> b, vector <int> c, vector <int> d, vector <int> s)
	{
		n=s.size();
		for (int i=0; i<n; i++) w[i]=s[i];
		m=a.size();
		int x,y;
		for (int i=0; i<m; i++)
		{
			x=a[i]; y=b[i];
			g1[x].push_back(y);
			g1[y].push_back(x);
			x=c[i];	y=d[i];
			g2[x].push_back(y);
			g2[y].push_back(x);
		}
		int ans=-inf;
		for (int i=0; i<n; i++)
		{
			ans=max(ans,calc(i));
		}
		return ans;
	}
}ff;