51nod1325 两棵树的问题

$n leq 50$的两棵树，同编号的点有同个点权，问如何选一个点集，使得这个点集里的点在两棵树内都连通，且总点权最大，输出最大点权和。

枚举一个点在答案里，然后把树以它为根，此时选儿子一定要选父亲，构成最大权闭合子图。

#include<iostream>
#include<cstring>
#include<cstdio>
//#include<time.h>
//#include<complex>
//#include<set>
//#include<queue>
#include<algorithm>
#include<stdlib.h>
using namespace std;

#define LL long long
int qread()
{
    char c; int s=0,f=1; while ((c=getchar())<'0' || c>'9') (c=='-') && (f=-1);
    do s=s*10+c-'0'; while ((c=getchar())>='0' && c<='9'); return s*f;
}

//Pay attention to '-' , LL and double of qread!!!!

int n,m;
#define maxn 111
#define maxm 1111
struct Edge{int to,next,flow,cap;};
struct Network
{
    Edge edge[maxm]; int first[maxn],le,n;
    void clear(int N) {le=2; memset(first,0,sizeof(first)); n=N;}
    void in(int x,int y,int cap) {Edge &e=edge[le]; e.to=y; e.cap=cap; e.flow=0; e.next=first[x]; first[x]=le++;}
    void insert(int x,int y,int cap) {in(x,y,cap); in(y,x,0);}
    int dis[maxn]; int que[maxn],cur[maxn],head,tail,s,t;
    bool bfs()
    {
        memset(dis,0,sizeof(dis)); dis[s]=1;
        head=tail=0; que[tail++]=s;
        while (head!=tail)
        {
            int x=que[head++];
            for (int i=first[x];i;i=edge[i].next)
            {
                Edge &e=edge[i];
                if (!dis[e.to] && e.cap>e.flow)
                {
                    dis[e.to]=dis[x]+1;
                    que[tail++]=e.to;
                }
            }
        }
        return dis[t];
    }
    int dfs(int x,int a)
    {
        if (x==t || !a) return a;
        int flow=0,f;
        for (int &i=cur[x];i;i=edge[i].next)
        {
            Edge &e=edge[i];
            if (dis[e.to]==dis[x]+1 && (f=dfs(e.to,min(e.cap-e.flow,a)))>0)
            {
                flow+=f; e.flow+=f;
                edge[i^1].flow-=f; a-=f;
                if (!a) break;
            }
        }
        return flow;
    }
    int Dinic(int S,int T)
    {
        s=S; t=T;
        int ans=0;
        while (bfs())
        {
            for (int i=1;i<=n;i++) cur[i]=first[i];
            ans+=dfs(s,0x3f3f3f3f);
        }
        return ans;
    }
    bool vis[maxn];
    void dfs(int x)
    {
        vis[x]=1;
        for (int i=first[x];i;i=edge[i].next)
        {
            Edge &e=edge[i];
            if (e.cap>e.flow && !vis[e.to]) dfs(e.to);
        }
    }
}g;

struct EE{int to,next;};
struct Tree
{
    EE edge[maxn<<1]; int first[maxn],le;
    Tree() {le=2;}
    void in(int x,int y) {EE &e=edge[le]; e.to=y; e.next=first[x]; first[x]=le++;}
    void insert(int x,int y) {in(x,y); in(y,x);}
}t[2];

int ss[maxn];
void dfs(int p,int x,int fa)
{
    for (int i=t[p].first[x];i;i=t[p].edge[i].next)
    {
        EE &e=t[p].edge[i]; if (e.to==fa) continue;
        g.insert(e.to,x,0x3f3f3f3f); dfs(p,e.to,x);
    }
}

int main()
{
    n=qread(); int sum=0;
    for (int i=1;i<=n;i++) {ss[i]=qread(); if (ss[i]>0) sum+=ss[i];}
    for (int i=1;i<n;i++) t[0].insert(qread()+1,qread()+1);
    for (int i=1;i<n;i++) t[1].insert(qread()+1,qread()+1);
    int s=n+1,t=s+1;
    int ans=0;
    for (int i=1;i<=n;i++)
    {
        g.clear(t);
        dfs(0,i,0); dfs(1,i,0);
        for (int j=1;j<=n;j++) if (ss[j]>0) g.insert(s,j,ss[j]);
        else g.insert(j,t,-ss[j]);
        ans=max(ans,sum-g.Dinic(s,t));
    }
    printf("%d
",ans);
    return 0;
}