【练习】UVA 11419 SAM I AM （网络流最大流/最小点覆盖）

题意

给出一个网格图，网格中有一些怪物，可以从选择横向或者纵向发射炮弹，每发炮弹会把对应行或者列的全部怪物清除，最少需要几发炮弹，并给出发射炮弹的行列。

题解

之前没做过这样的题目。
网格图套路就是按行或者按列建图，每一行作为一个节点，每一列作为一个节点，如果行列交叉部分有怪物，那么在建图中就加入一条边。如下图

表示1行1列，1行3列和2行4列有怪物。
忽略掉S和T的部分，这样可以组成一个二分图。由于一发炮弹可以解决一行或者一列的怪物，所以问题转换为最小点覆盖的问题。即选择一些点，使得图中所有边被覆盖。

如果我们将其建为一个网络，那么原图的最小点覆盖，对应一个最小割，而最小割又对应最大流。
所以我们求一个最大流就好了，这样，第一问解决。

第二问需要我们求出最小割的边，也就是求出具体在哪个位置发出炮弹。
在残量网络中，容量大于0表示可以走。将从源点出发可以到达的点看作S集，剩下的看作T集。如果边(u,v)满足u属于S集，v属于T集，那么该边就是最小割边集中的边。
而确定S集和边集可以通过一次DFS或BFS标记得到。
这样就可以确定了。

代码

#include
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int nmax = 1000000 + 10;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const ull p = 67;
const ull MOD = 1610612741;
struct Dinic {
    int head[nmax], cur[nmax], d[nmax];
    bool vis[nmax],iscut[nmax];
    int tot, n, m, s, t;
    struct edge {
        int nxt, to, w, cap, flow;
    } e[nmax<<1];
    void init(int n) {
        this->n = n;
        this->tot = 0;
        memset(head, -1, sizeof head);
        memset(iscut,0,sizeof iscut);
    }
    void add_edge(int u, int v, int c) {
        e[tot].to = v, e[tot].cap = c, e[tot].flow = 0;
        e[tot].nxt = head[u];
        head[u] = tot++;
        e[tot].to = u, e[tot].cap = c, e[tot].flow = c;
        e[tot].nxt = head[v];
        head[v] = tot++;
    }
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        queue<int>Q;
        vis[s] = 1; d[s] = 0;
        Q.push(s);
        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            for (int i = head[u]; i != -1; i = e[i].nxt) {
                int v = e[i].to;
                if (!vis[v] && e[i].cap > e[i].flow) {
                    vis[v] = 1;
                    d[v] = d[u] + 1;
                    Q.push(v);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a) {
        if (x == t || a == 0) return a;
        int Flow = 0, f;
        for (int& i = cur[x]; i != -1; i = e[i].nxt) {
            int v = e[i].to;
            if (d[v] == d[x] + 1 && (f = DFS(v, min(a, e[i].cap - e[i].flow))) > 0) {
                Flow += f;
                e[i].flow += f;
                e[i ^ 1].flow -= f;
                a -= f;
                if (a == 0) break;
            }
        }
        return Flow;
    }
    int Maxflow(int s, int t) {
        this->s = s, this->t = t;
        int Flow = 0;
        while (BFS()) {
            for (int i = 0; i <= n; i++) cur[i] = head[i];
            while(int once = DFS(s, INF)) Flow += once;
        }
        return Flow;
    }
    void get_cut(int u){
        iscut[u] = true;
        for (int i = head[u]; i != -1; i = e[i].nxt) {
            int v = e[i].to;
            if (!iscut[v] && e[i].cap > e[i].flow)
                get_cut(v);
        }
        return;
    }
} dinic;
int R, C, N;
int main() {
    while (scanf("%d%d%d", &R, &C, &N) != EOF && (R || C || N)) {
        dinic.init(R + C + 5);
        int r, c;
        for (int i = 1; i <= N; i++) scanf("%d%d", &r, &c), dinic.add_edge(r, c + R, 1);
        for (int i = 1; i <= R; i++) dinic.add_edge(0, i, 1);
        for (int i = 1; i <= C; i++) dinic.add_edge(i + R, C + R + 1, 1);
        int ans = dinic.Maxflow(0, C + R + 1);
        printf("%d ", ans);
        dinic.get_cut(0);
        for (int i = 1; i <= R; i++) if (!dinic.iscut[i])  printf("r%d ", i);
        for (int i = 1; i <= C; i++) if (dinic.iscut[i + R]) printf("c%d ", i);
        printf("\n");
    }
}