HDU 4685 强联通分量+网络流

Posted 2020-07-13 Dan__ge

点击打开链接

题意：与POJ 1904 极其相像的一道题目，POJ的将一个完备匹配图给了你，并给了你一组可能的情况，很简单，但是这道题目，给的既不是完备匹配也没有给出可行的匹配方案，难的不要不要的

思路：刚开始看以为是和1904一模一样呢，然而难度上升的真快，看了一下是13年的多校题目，过了10几个把，可想而知这难度不是我等能够A掉的，刚自己想的是只加王子使其变成完备匹配，然后WA了，对了说一下为什么非要变成完备匹配呢，因为这道题目里的王子和公主的数量并不一定相同，就算相同也有可能不是完备匹配，这样就会有王子和公主找不到自己的伴侣，然而我们的题目要求是每个王子可以娶的公主的条件下，最大匹配不变，那么就像第二组样例一样，王子1娶了公主1，那么王子1还可以娶公主2，这两种都不会使最大匹配改变，按照1904的想法我们要求强联通分量，在一个分量的每一个王子都可以娶剩下的这个分量里的所有公主而不改变最大匹配，为什么呢，这个分量里的公主和王子是相等的，强联通分量元素可以互相到达，则他们可以换自己的伴侣。现在看这道题，对于没有匹配的公主，再不改变最大匹配的情况下，所有的喜欢这个公主的王子都可以娶她，那么我们的目的就变成了如何使这些王子喜欢的公主与这个公主在一个联通分量里，那么对于没有匹配的王子来说，他可以娶任意一个他喜欢的公主而不改变最大匹配，然后我们的目的就变成了如何将喜欢这些公主的王子与这个单身狗在一个联通分量里，这样我们可以虚拟一些王子和公主，这里只说一个，另一个操作相同，比如公主有k个未匹配，那么添加k个虚拟的王子，这些王子连向所有的公主，这样肯定会保证所有公主都被匹配了，这显而易见把，然后为什么将王子连向所有的公主呢，这是为了在scc时将所有喜欢这个公主的王子与这只单身狗在一个联通分量中，公主的也是一个道理    PS：代码写的太丑了，勿看除非你有兴趣

#include <queue>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=10010;
//强联通start
vector<int> G[maxn];
vector<int> rG[maxn];
vector<int> vs;
bool used[maxn];
int cmp[maxn],V;
void add_edge(int from,int to){
    G[from].push_back(to);
    rG[to].push_back(from);
}
void dfs(int v){
    used[v]=1;
    for(int i=0;i<G[v].size();i++){
        if(!used[G[v][i]]) dfs(G[v][i]);
    }
    vs.push_back(v);
}
void rdfs(int v,int k){
    used[v]=1;
    cmp[v]=k;
    for(int i=0;i<rG[v].size();i++){
        if(!used[rG[v][i]]) rdfs(rG[v][i],k);
    }
}
int scc(){
    memset(used,0,sizeof(used));
    vs.clear();
    for(int v=0;v<V;v++) if(!used[v]) dfs(v);
    memset(used,0,sizeof(used));
    int k=0;
    for(int i=vs.size()-1;i>=0;i--){
        if(!used[vs[i]]) rdfs(vs[i],k++);
    }
    return k;
}//强联通end
int num[maxn];
//网络流start
struct edge{
    int to,cap,rev;
    edge(int a,int b,int c){to=a;cap=b;rev=c;}
};
vector<edge>GG[maxn];
int level[maxn],iter[maxn];
void addedge(int from,int to,int cap){
    GG[from].push_back(edge(to,cap,GG[to].size()));
    GG[to].push_back(edge(from,0,GG[from].size()-1));
}
void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int>que;level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(unsigned int i=0;i<GG[v].size();i++){
            edge &e=GG[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f){
    if(v==t) return f;
    for(int &i=iter[v];i<GG[v].size();i++){
        edge &e=GG[v][i];
        if(e.cap>0&&level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                GG[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
void max_flow(int s,int t){
    int flow=0;
    while(1){
        bfs(s);
        if(level[t]<0) return ;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0) flow+=f;
    }
}//网络流end
int vis[maxn],vis1[maxn];
int main(){
    int T,cas=1,n,m,a,b,c;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(vis,0,sizeof(vis));
        memset(vis1,0,sizeof(vis1));
        for(int i=0;i<maxn;i++){
            G[i].clear();
            rG[i].clear();
            GG[i].clear();
        }
        vs.clear();
        for(int i=1;i<=2000;i++) addedge(0,i,1);
        for(int i=1;i<=m;i++) addedge(i+2000,2000+m+1,1);
        for(int i=1;i<=n;i++){
            scanf("%d",&c);
            while(c--){
                scanf("%d",&a);
                add_edge(i,a+2000);
                addedge(i,a+2000,1);
            }
        }
        max_flow(0,2000+m+1);
        int cnt=n,cnt1=m;
        for(int i=1;i<=n;i++){
            for(unsigned int j=0;j<GG[i].size();j++){
                edge e=GG[i][j];
                if(e.cap==0&&e.to>=2001&&e.to<=2000+m){
                    vis1[i]=1;
                    vis[e.to]=1;break;
                }
            }
        }
        for(int i=1;i<=m;i++) if(vis[i+2000]==0) cnt++;
        for(int j=1;j<=n;j++) if(vis1[j]==0) cnt1++;
        for(int i=0;i<maxn;i++) GG[i].clear();
        for(int i=1;i<=cnt;i++) addedge(0,i,1);
        for(int i=1;i<=cnt1;i++) addedge(i+2000,2000+cnt1+1,1);
        for(int i=n+1;i<=cnt;i++){
            for(int j=1;j<=cnt1;j++){
                addedge(i,j+2000,1);
                add_edge(i,j+2000);
            }
        }
        for(int i=m+1;i<=cnt1;i++){
            for(int j=1;j<=cnt;j++){
                addedge(j,i+2000,1);
                add_edge(j,i+2000);
            }
        }
        for(int i=1;i<=n;i++){
            for(unsigned int j=0;j<G[i].size();j++){
                int t=G[i][j];
                addedge(i,t,1);
            }
        }
        max_flow(0,2000+cnt1+1);
        for(int i=1;i<=cnt;i++){
            for(unsigned int j=0;j<GG[i].size();j++){
                edge e=GG[i][j];
                if(e.cap==0){
                    add_edge(e.to,i);break;
                }
            }
        }
        V=2000+cnt1;
        int ans=scc();
        printf("Case #%d:\n",cas++);
        for(int i=1;i<=n;i++){
            int sum=0;
            for(unsigned int j=0;j<G[i].size();j++){
                int t=G[i][j];
                if(cmp[i]==cmp[t]&&t-2000>=1&&t-2000<=m){
                    num[sum++]=t;
                }
            }
            if(sum==0) printf("%d\n",sum);
            else printf("%d ",sum);
            sort(num,num+sum);
            for(int k=0;k<sum;k++){
                if(k!=sum-1) printf("%d ",num[k]-2000);
                else printf("%d\n",num[k]-2000);
            }
        }
    }
    return 0;
}