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 = 400 + 10;

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

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

const int INF = 1000000000;

struct Edge
{
    int from, to, cap, flow;
    Edge(int u=0, int v=0, int c=0, int f=0):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 = 0; i < n; ++i) G[i].clear();
        edges.clear();
    }

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

    int MaxFlow(int s, int t)
    {
        int flow = 0;
        for(;;)
        {
            memset(a, 0, sizeof(a));
            queue<int> Q;
            Q.push(s);
            a[s] = INF;
            while(!Q.empty())
            {
                int x = Q.front(); Q.pop();
                for(int i = 0; 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]^1].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, 0, sizeof(d));
        string s1, s2;
        scanf("%d", &n);
        for(int i = 0; i < n; ++i) { cin >> s1; target[i] = ID(s1); }
        scanf("%d", &m);
        for(int i = 0; i < m; ++i) { cin >> s1 >> s2; device[i] = ID(s2); }
        scanf("%d", &k);
        for(int i = 0; i < k; ++i) { cin >> s1 >> s2; d[ID(s1)][ID(s2)] = true;    }
        //Floyd
        int V = names.size();
        for(int k = 0; k < V; ++k)
            for(int i = 0; i < V; ++i)
                for(int j = 0; j < V; ++j)
                    d[i][j] |= d[i][k] && d[k][j];

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

    return 0;
}

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

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