【CF1252L】Road Construction（基环树，最大流）

题意：给定一张n点n边无重边自环的无向图，刚开始每条边都没有被选择，每条边上有一个颜色集合，必须从中选择一种

有K个工人，每个工人有颜色a[i]，需要把工人分配到与其颜色相同的边上

问是否能有一种使得n个点完全联通的方案，如果有则输出

n,K<=2000

思路：考虑n-1条边的树的弱化版，显然每条边都应该被选择，用颜色和边建图跑最大流即可

n点n边的基环树的情况下需要把环抠出来，设环的大小为size，两个端点至少有一个在环中的为A集合，其余为B集合

显然B集合中所有的边都需要被选取，A集合中至多只能选择size-1条

可以另外加源或者汇限制A集合的流量，也可以先加入B集合中的所有边，先跑最大流，判断是否小于n-size，因为A集合至多只有size-1的流量

两种方法都试过，都很快

我猜题解里写的应该就是用最大流跑的匹配，没听说过有能跑这个多重匹配的新算法

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef pair<ll,ll> Pll;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef pair<ll,ll>P;
#define N  200010
#define M  1000000
#define INF 1e9
#define fi first
#define se second
#define MP make_pair
#define pb push_back
#define pi acos(-1)
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for(int i=(int)a;i<=(int)b;i++)
#define per(i,a,b) for(int i=(int)a;i>=(int)b;i--)
#define lowbit(x) x&(-x)
#define Rand (rand()*(1<<16)+rand())
#define id(x) ((x)<=B?(x):m-n/(x)+1)
#define ls p<<1
#define rs p<<1|1
#define fors(i) for(auto i:e[x]) if(i!=p)

const int MOD=1e9+7,inv2=(MOD+1)/2;
      double eps=1e-6;
      int dx[4]={-1,1,0,0};
      int dy[4]={0,0,-1,1};

int head[N],vet[N],len[N],nxt[N],inq[N],inc[N],a[N],
    flag[N],vis[N],stk[N],dis[N],p[N],c[N],match[N],
    tot,top,s,S,T,T1;

VI b[N],co[N];

int read()
{
   int v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

ll readll()
{
   ll v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

void add(int a,int b)
{
    nxt[++tot]=head[a];
    vet[tot]=b;
    head[a]=tot;
}

void Add(int a,int b,int c)
{
    nxt[++tot]=head[a];
    vet[tot]=b;
    len[tot]=c;
    head[a]=tot;

    nxt[++tot]=head[b];
    vet[tot]=a;
    len[tot]=0;
    head[b]=tot;
}

void findc(int u,int fa)
{
    stk[++top]=u;
    inq[u]=vis[u]=1;
    int e=head[u];
    while(e)
    {
        int v=vet[e];
        if(!vis[v]) findc(v,u);
         else if(v!=fa&&inq[v])
         {
             int s=1,t=top;
             while(1)
             {
                 t--;
                 s++;
                 if(stk[t]==v) break;
             }
             if(s>=3)
             {
                t=top;
                while(1)
                {
                    inc[stk[t]]=1;
                    t--;
                    if(stk[t]==v){inc[v]=1; break;}
                }

             }
         }
        e=nxt[e];
    }
    inq[stk[top]]=0;
    top--;
}

int bfs()
{
    queue<int> q;
    rep(i,1,s) dis[i]=-1;
    q.push(S),dis[S]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        int e=head[u];
        while(e)
        {
            int v=vet[e];
            if(len[e]&&dis[v]==-1)
            {
                dis[v]=dis[u]+1;
                q.push(v);
            }
            e=nxt[e];
        }
    }
    return dis[T]!=-1;
}

int dfs(int u,int aug)
{
    if(u==T) return aug;
    int e=head[u],val=0,flow=0;
    while(e)
    {
        int v=vet[e];
        if(len[e]&&dis[v]==dis[u]+1)
        {
            int t=dfs(v,min(len[e],aug));
            if(!t)
            {
                e=nxt[e];
                continue;
            }
            flow+=t;
            aug-=t;
            len[e]-=t;
            len[e^1]+=t;
            if(!aug) break;
        }
        e=nxt[e];
    }
    if(!flow) dis[u]=-1;
    return flow;
}

int main()
{
    int n=read(),K=read();
    int m=0;
    rep(i,1,n)
    {
        p[i]=read();
        int x=read();
        while(x--)
        {
            int y=read();
            b[i].pb(y);
            c[++m]=y;
        }
    }
    rep(i,1,K)
    {
        a[i]=read();
        c[++m]=a[i];
    }
    sort(c+1,c+m+1);
    int k=unique(c+1,c+m+1)-c-1;
    rep(i,1,n)
     for(int j=0;j<b[i].size();j++) b[i][j]=lower_bound(c+1,c+k+1,b[i][j])-c;


    rep(i,1,k) co[i].clear();
    rep(i,1,K)
    {
        a[i]=lower_bound(c+1,c+k+1,a[i])-c;
        co[a[i]].pb(i);
    }

    tot=0;
    rep(i,1,n)
    {
        add(i,p[i]);
        add(p[i],i);
    }
    findc(1,0);
    s=k+n,S=++s,T=++s;
    rep(i,1,s) head[i]=0;
    tot=1;
    int sz=0;
    rep(i,1,k) Add(S,i,co[i].size());
    rep(i,1,n)
     for(int j=0;j<b[i].size();j++) Add(b[i][j],i+k,1);
    rep(i,1,n)
     if(inc[i]==0||inc[p[i]]==0) Add(i+k,T,1);
      else sz++;
    int ans=0;
    while(bfs()) ans+=dfs(S,INF);
    if(ans<(n-1-(sz-1)))
    {
        printf("-1
");
        return 0;
    }
    rep(i,1,n)
     if(inc[i]&&inc[p[i]]) Add(i+k,T,1);
    while(bfs()) ans+=dfs(S,INF);
    if(ans<n-1) printf("-1
");
     else
     {
        rep(i,1,n) flag[i]=0;
        rep(i,1,k)
        {
            int e=head[i],j=0;
            while(e)
            {
                int v=vet[e];
                if(v>=k+1&&v<=k+n&&flag[v-k]==0&&!len[e])
                {
                    j++;
                    if(j>(int)co[i].size()) break;
                    int t=co[i][j-1];
                    match[t]=v-k;
                    flag[v-k]=1;
                }
                e=nxt[e];
            }
        }
        rep(i,1,K) printf("%d %d
",match[i],p[match[i]]);
     }


    return 0;
}