UVA753：A Plug for UNIX

题意：给定一些插座和一些插头，还有一些单向接头，比如A->B

接头可以串联A->B->C->D

使得插座和插头匹配数目最大

题解：

首先接头可以用Floyd处理

这题可以转化为二分图的模型，就是直接连边，不做处理

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #include<cstring>
 #include<map>
 #include<iostream>
 #include<algorithm>
 #include<string>
 #include<vector>
 #include<queue>
 #define MAXN 505
 #define INF 0x7f7f7f7f
 #define ll long long
 #define P 203
 using namespace std;
 int n,m,e,N;
 int V1[MAXN],V2[MAXN];
 int G[MAXN<<][MAXN<<];
 map<ll,int> mp;
 ll Hash(string s){
     ll ret=;
     for(string::iterator it=s.begin();it!=s.end();it++){
         ret=ret*P+(*it);
     }
     return ret;
 }
 struct Edge{
     int from,to,cap,flow;
     Edge(int u=,int v=,int c=,int f=){
         from=u,to=v,cap=c,flow=f;
     }
 };
 struct Dinic{
     int n,m,s,t;
     vector<Edge> edges;
     vector<int> G[MAXN];
     int b[MAXN];
     int d[MAXN];
     int cur[MAXN];
     void init(int n,int s,int t){
         this->n=n;
         this->s=s,this->t=t;
         edges.clear();
         for(int i=;i<=n;i++){
             G[i].clear();
         }
     }
     void AddEdge(int x,int y,int cap){
         edges.push_back(Edge(x,y,cap,));
         edges.push_back(Edge(y,x,,));
         m=edges.size();
         G[x].push_back(m-);
         G[y].push_back(m-);
     }
     bool BFS(){
         memset(b,,sizeof(b));
         queue<int> q;
         d[s]=;
         q.push(s);
         b[s]=;
         while(!q.empty()){
             int x=q.front();q.pop();
             for(int i=;i<G[x].size();i++){
                 Edge& e=edges[G[x][i]];
                 if(e.cap>e.flow&&!b[e.to]){
                     d[e.to]=d[x]+;
                     q.push(e.to);
                     b[e.to]=;
                 }
             }
         }
         return b[t];
     }
     int dfs(int x,int a){
         if(x==t||!a)return a;
         int flow=,f;
         for(int& i=cur[x];i<G[x].size();i++){
             Edge& e=edges[G[x][i]];
             if(d[e.to]==d[x]+&&(f=dfs(e.to,min(a,e.cap-e.flow)))>){
                 edges[G[x][i]].flow+=f;
                 edges[G[x][i]^].flow-=f;
                 flow+=f;
                 a-=f;
                 if(!a){
                     break;
                 }
             }
         }
         return flow;
     }
     int Maxflow(){
         int flow=;
         while(BFS()){
             memset(cur,,sizeof(cur));
             flow+=dfs(s,INF);
         }
         return flow;
     }
 }D;
 void init(){
     memset(G,,sizeof(G));
     mp.clear();
     N=;
     ll h;
     string t1,t2;
     scanf("%d",&n);
     for(int i=;i<=n;i++){
         cin>>t1;
         h=Hash(t1);
         if(mp.count(h)){
             V1[i]=mp[h];
         }
         else{
             N++;
             mp[h]=N;
             V1[i]=N;
         }
     }
     scanf("%d",&m);
     for(int i=;i<=m;i++){
         cin>>t2>>t1;
         h=Hash(t1);
         if(mp.count(h)){
             V2[i]=mp[h];
         }
         else{
             N++;
             mp[h]=N;
             V2[i]=N;
         }
     }
     scanf("%d",&e);
     for(int i=;i<=e;i++){
         cin>>t1>>t2;
         int c1,c2;
         h=Hash(t1);
         if(mp.count(h)){
             c1=mp[h];
         }
         else{
             N++;
             mp[h]=N;
             c1=N;
         }
         h=Hash(t2);
         if(mp.count(h)){
             c2=mp[h];
         }
         else{
             N++;
             mp[h]=N;
             c2=N;
         }
         G[c1][c2]=;
     }
     for(int i=;i<=n;i++){
         G[i][i]=;
     }
     for(int k=;k<=N;k++){
         for(int i=;i<=N;i++){
             for(int j=;j<=N;j++){
                 G[i][j]|=(G[i][k]&G[k][j]);
             }
         }
     }
 }
 void solve(){
     D.init(n,,n+m+);
     for(int i=;i<=m;i++){
         for(int j=;j<=n;j++){
             if(G[V2[i]][V1[j]]){
                 D.AddEdge(i,j+m,);
             }
         }
     }
     for(int i=;i<=m;i++){
         D.AddEdge(,i,);
     }
     for(int j=;j<=n;j++){
         D.AddEdge(j+m,n+m+,);
     }
     printf("%d\n",m-D.Maxflow());
 }
 int main()
 {
 //    freopen("data.in","r",stdin);
 //    freopen("my.out","w",stdout);
     int T;
     scanf("%d",&T);
     while(T--){
         init();
         solve();
         if(T){
             printf("\n");
         }
     }
     return ;
 }

二分图匹配

也可以把相同类型的压在一起处理，

源点到某类型插头的容量就是该类型的数目，汇点同理

如果相连的话建一条长度为INF的边，

然后跑一遍最大流即可

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #include<cstring>
 #include<map>
 #include<iostream>
 #include<algorithm>
 #include<string>
 #include<vector>
 #include<queue>
 #define MAXN 505
 #define INF 0x7f7f7f7f
 #define ll long long
 #define P 203
 using namespace std;
 int n,m,e,N;
 int V1[MAXN],V2[MAXN];
 int b1[MAXN],b2[MAXN];
 int cnt1,cnt2;
 int G[MAXN<<][MAXN<<];
 map<string,int> mp;
 struct Edge{
     int from,to,cap,flow;
     Edge(int u=,int v=,int c=,int f=){
         from=u,to=v,cap=c,flow=f;
     }
 };
 struct Dinic{
     int n,m,s,t;
     vector<Edge> edges;
     vector<int> G[MAXN];
     int b[MAXN];
     int d[MAXN];
     int cur[MAXN];
     void init(int n,int s,int t){
         this->n=n;
         this->s=s,this->t=t;
         edges.clear();
         for(int i=;i<=n;i++){
             G[i].clear();
         }
     }
     void AddEdge(int x,int y,int cap){
         edges.push_back(Edge(x,y,cap,));
         edges.push_back(Edge(y,x,,));
         m=edges.size();
         G[x].push_back(m-);
         G[y].push_back(m-);
     }
     bool BFS(){
         memset(b,,sizeof(b));
         queue<int> q;
         d[s]=;
         q.push(s);
         b[s]=;
         while(!q.empty()){
             int x=q.front();q.pop();
             for(int i=;i<G[x].size();i++){
                 Edge& e=edges[G[x][i]];
                 if(e.cap>e.flow&&!b[e.to]){
                     d[e.to]=d[x]+;
                     q.push(e.to);
                     b[e.to]=;
                 }
             }
         }
         return b[t];
     }
     int dfs(int x,int a){
         if(x==t||!a)return a;
         int flow=,f;
         for(int& i=cur[x];i<G[x].size();i++){
             Edge& e=edges[G[x][i]];
             if(d[e.to]==d[x]+&&(f=dfs(e.to,min(a,e.cap-e.flow)))>){
                 edges[G[x][i]].flow+=f;
                 edges[G[x][i]^].flow-=f;
                 flow+=f;
                 a-=f;
                 if(!a){
                     break;
                 }
             }
         }
         return flow;
     }
     int Maxflow(){
         int flow=;
         while(BFS()){
             memset(cur,,sizeof(cur));
             flow+=dfs(s,INF);
         }
         return flow;
     }
 }D;
 void init(){
     memset(G,,sizeof(G));
     memset(b1,,sizeof(b1));
     memset(b2,,sizeof(b2));
     cnt1=cnt2=;
     mp.clear();
     N=;
     string t1,t2;
     scanf("%d",&n);
     for(int i=;i<=n;i++){
         cin>>t1;
         if(mp.count(t1)){
             V1[i]=mp[t1];
         }
         else{
             N++;
             mp[t1]=N;
             V1[i]=N;
         }
     }
     scanf("%d",&m);
     for(int i=;i<=m;i++){
         cin>>t2>>t1;
         if(mp.count(t1)){
             V2[i]=mp[t1];
         }
         else{
             N++;
             mp[t1]=N;
             V2[i]=N;
         }
     }
     scanf("%d",&e);
     for(int i=;i<=e;i++){
         cin>>t1>>t2;
         int c1,c2;
         if(mp.count(t1)){
             c1=mp[t1];
         }
         else{
             N++;
             mp[t1]=N;
             c1=N;
         }
         if(mp.count(t2)){
             c2=mp[t2];
         }
         else{
             N++;
             mp[t2]=N;
             c2=N;
         }
         G[c1][c2]=;
     }
     for(int i=;i<=n;i++){
         G[i][i]=;
     }
     for(int k=;k<=N;k++){
         for(int i=;i<=N;i++){
             for(int j=;j<=N;j++){
                 G[i][j]|=(G[i][k]&G[k][j]);
             }
         }
     }
     for(int i=;i<=n;i++){
         if(!b1[V1[i]]){
             cnt1++;
         }
         b1[V1[i]]++;
     }
     for(int i=;i<=m;i++){
         if(!b2[V2[i]]){
             cnt2++;
         }
         b2[V2[i]]++;
     }
 }
 void solve(){
     D.init(n,,cnt1+cnt2+);
     int t1=,t2=cnt1;
     for(int i=;i<=N;i++){
         if(b2[i]) t2++;
         else continue;
         t1=;
         for(int j=;j<=N;j++){
             if(b1[j]){
                 t1++;
                 if(G[i][j]){
                     D.AddEdge(t1,t2,INF);
                 }
             }
         }
     }
     t1=;
     for(int i=;i<=N;i++){
         if(b1[i]){
             t1++;
             D.AddEdge(,t1,b1[i]);
         }
     }
     t2=;
     for(int j=;j<=N;j++){
         if(b2[j]){
             t2++;
             D.AddEdge(t2+cnt1,cnt1+cnt2+,b2[j]);
         }
     }
     printf("%d\n",m-D.Maxflow());
 }
 int main()
 {
 //    freopen("data.in","r",stdin);
 //    freopen("my.out","w",stdout);
     int T;
     scanf("%d",&T);
     while(T--){
         init();
         solve();
         if(T){
             printf("\n");
         }
     }
     return ;
 }

压点最大流