UVa 753 (二分图最大匹配) A Plug for UNIX

题意：

有n个插座，m个设备以及k种转化器(每种转化器视为有无限个)。

转换器A->B可以将A类型的插头转化成B类型的插头，所以可以插在B类型的插座上。

求最少剩多少不匹配的设备。

分析：

抛开转换器不讲，插头插在插座上就是一个最大二分图匹配。

可以用最大流的算法，增加一个连接每个插头的源点s和连接每个插座的汇点t，每条弧容量都为1.

然后求最大流量，就是二分图的最大基数匹配。

既然有了转换器，一种插头可以用转换器转换成多种类型的插头，所以可以Floyd一次，求出每种插头可以转换成的所有的插头类型。

然后构二分图，求最大匹配即可。

 #include <bits/stdc++.h>

 using namespace std;

 const int maxn =  + ;

 vector<string> names;
 int ID(const string& s)
 {
     for(int i = ; i < names.size(); ++i)
         if(names[i] == s) return i;
     names.push_back(s);
     return names.size() - ;
 }

 int n, m, k;
 bool d[maxn][maxn];
 int target[maxn], device[maxn];

 const int INF = ;

 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 EdmondsKarp
 {
     int n, m;
     vector<Edge> edges;
     vector<int> G[maxn];
     int a[maxn];
     int p[maxn];

     void Init(int n)
     {
         for(int i = ; i < n; ++i) G[i].clear();
         edges.clear();
     }

     void AddEdge(int from, int to, int cap)
     {
         edges.push_back(Edge(from, to, cap, ));
         edges.push_back(Edge(to, from, , ));
         m = edges.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }

     int MaxFlow(int s, int t)
     {
         int flow = ;
         for(;;)
         {
             memset(a, , sizeof(a));
             queue<int> Q;
             Q.push(s);
             a[s] = INF;
             while(!Q.empty())
             {
                 int x = Q.front(); Q.pop();
                 for(int i = ; i < G[x].size(); ++i)
                 {
                     Edge& e = edges[G[x][i]];
                     if(!a[e.to] && e.cap > e.flow)
                     {
                         p[e.to] = G[x][i];
                         a[e.to] = min(a[x], e.cap - e.flow);
                         Q.push(e.to);
                     }
                 }
                 if(a[t]) break;
             }
             if(!a[t]) break;
             for(int u = t; u != s; u = edges[p[u]].from)
             {
                 edges[p[u]].flow += a[u];
                 edges[p[u]^].flow -= a[u];
             }
             flow += a[t];
         }
         return flow;
     }
 };

 EdmondsKarp g;

 int main()
 {
     //freopen("in.txt", "r", stdin);
     int T;
     scanf("%d", &T);
     while(T--)
     {
         names.clear();
         memset(d, , sizeof(d));
         string s1, s2;
         scanf("%d", &n);
         for(int i = ; i < n; ++i) { cin >> s1; target[i] = ID(s1); }
         scanf("%d", &m);
         for(int i = ; i < m; ++i) { cin >> s1 >> s2; device[i] = ID(s2); }
         scanf("%d", &k);
         for(int i = ; i < k; ++i) { cin >> s1 >> s2; d[ID(s1)][ID(s2)] = true;    }
         //Floyd
         int V = names.size();
         for(int k = ; k < V; ++k)
             for(int i = ; i < V; ++i)
                 for(int j = ; j < V; ++j)
                     d[i][j] |= d[i][k] && d[k][j];

         //Build Graph
         g.Init(V+);
         for(int i = ; i < m; ++i) g.AddEdge(V, device[i], );//源点到每个设备
         for(int i = ; i < n; ++i) g.AddEdge(target[i], V+, );//每个插座到汇点
         for(int i = ; i < m; ++i)
             for(int j = ; j < n; ++j)
                 if(d[device[i]][target[j]]) g.AddEdge(device[i], target[j], INF);
         int ans = g.MaxFlow(V, V+);
         printf("%d\n", m-ans);
         if(T) puts("");
     }

     return ;
 }

代码君

紫书后面又介绍了一种更简单的做法，就是直接把k种转换器对应的k条弧加到图中去，然后求最大流。

代码就不贴了，=_=||