UVA 753 A Plug for UNIX

最新推荐文章于 2021-02-22 10:25:44 发布

原创最新推荐文章于 2021-02-22 10:25:44 发布 · 798 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#拆点

acm 同时被 3 个专栏收录

8 篇文章

订阅专栏

UVA

4 篇文章

订阅专栏

最大流

3 篇文章

订阅专栏

本文介绍了一种使用ISAP算法解决最大流问题的方法，通过构建复杂的图模型来模拟插板、设备及转换器间的匹配过程。文章详细展示了如何将设备、转换器等元素转化为图中的节点，并建立合适的边以反映它们之间的匹配关系。

n个插板，m台设备，k种转换器，一开始WA了一次，原来是忘了每种转换器的数目时无限多的，建立边时需要注意和UVA 11045 My T-shirt suits me 有点类似，稍微复杂一点，并且需要查询匹配再添加相应的边。

大体思路：

将每台设备拆分成两点，建立容量为1的边，并且建立从源点0到该设备拆分点的一条边，容量为1；每个转换器同样拆分建立容量无限的边，然后插板拆分，建立容量为1的边，再把插板拆分后的点连接到汇点1，建立容量为1的边。

接下来便是查找相应匹配接口，如对设备，需要查找能够和它的插口匹配的转换器和插板，对转换器则需要查找匹配其他转换器和所有的插板，对所有查找到的匹配建立相应的边，容量为1。

然后利用ISAP求解0-->>>1的最大流即可。

似乎对这样的小数据，spfa算法似乎能够快很多。

代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <iostream>
#include <cctype>
#include <queue>
#include <algorithm>
#include <cmath>
#define esp 1e-6
#define inf 0x0f0f0f0f
#define print(a) printf("%d\n", (a));
#define bug  puts("(****");
#define judge  freopen("in.txt","r",stdin);
using namespace std;
#define N 10000
#define M 400000
struct EDGE
{
    int i, c;
    EDGE *next, *ani;
} *Edge[N], E[M];
int Dfn[N], Now[N], cnt;
typedef struct
{
    char a[100];
    char b[100];
    int type;
} sft;
sft node[N];
int n, m, k, src, sink;
void add(int i, int j, int c, EDGE &e1, EDGE &e2)
{
    e1.i = j, e1.c = c, e1.next = Edge[i], e1.ani = &e2, Edge[i] = &e1;
    e2.i = i, e2.c = 0, e2.next = Edge[j], e2.ani = &e1, Edge[j] = &e2;
}
void init(void)
{
    memset(Edge, 0, sizeof(Edge));
    src = cnt = 0;
    sink = 1;
}
bool f(int i, int j)
{
  return !strcmp(node[i].b, node[j].a);
}
int ISAP(int s, int end, int flow)
{
    if(s == end)
        return flow;
    int i, tab = n-1, vary, now = 0;
    for(EDGE *p =Edge[s]; p && flow - now; p = p->next)
        if(p->c)
        {
            if(Dfn[s] == Dfn[i = p->i] + 1)
                vary = ISAP(i, end, min(flow - now, p->c)),
                p->c -= vary, now += vary, p->ani->c += vary;
            if(p->c)
                tab = min(tab, Dfn[i]);
            if(Dfn[src] == n)
                return now;
        }
    if(now == 0)
    {
        if(--Now[Dfn[s]] == 0)
            Dfn[src] = n;
        Now[Dfn[s] = tab +1]++;
    }
    return now;
}
int Max_flow(int s, int end)
{
    memset(Dfn, 0, sizeof(Dfn));
    memset(Now, 0, sizeof(Now));
    Now[0] = n;
    int ret = 0;
    for(; Dfn[s] < n;)
    {
        ret += ISAP(s, end, inf);
    }
    return ret;
}
int main(void)
{
    int T;
    for(int t = scanf("%d", &T); t <= T; t++)
    {
        init();
        int ct = 1;
        for(int i = scanf("%d", &n); i <= n; i++, ct++)
        {
            scanf("%s", node[ct].a);
            node[ct].type = 1;
            strcpy(node[ct].b, node[ct].a);
            add(2*ct^1, sink, 1, E[cnt],E[cnt + 1]);
            cnt += 2;
            add(2*ct, 2*ct^1, 1, E[cnt], E[cnt + 1]);
            cnt += 2;
        }
        for(int i = scanf("%d", &m); i <= m; i++, ct++)
        {
            scanf("%*s%s", node[ct].a);
            node[ct].type = 2;
            strcpy(node[ct].b, node[ct].a);
            add(0, 2*ct, 1, E[cnt], E[cnt + 1]);
            cnt += 2;
            add(2*ct, 2*ct^1, 1, E[cnt], E[cnt + 1]);
            cnt += 2;
        }
        for(int i = scanf("%d", &k); i <= k; i++, ct++)
        {
            scanf("%s%s", node[ct].a, node[ct].b);
            node[ct].type = 3;
            add(2*ct, 2*ct^1, inf, E[cnt], E[cnt + 1]);
            cnt += 2;
        }
        for(int i = n + 1; i <= n+m+k; i++)
            for(int j = 1; j <= n+m+k; j++)
                if(i - j && node[j].type != 2)
                {
                    if(f(i, j))
                        add(2*i^1, 2*j, 1, E[cnt], E[cnt + 1]),
                            cnt += 2;
                }
        n = 2*n+2*m+2*k+2;
        int ans = Max_flow(src, sink);
        ans = m - ans;
        if(t - 1)
           puts("");
        printf("%d\n",ans);
    }
    return 0;
}