[HDOJ3657]Game

方格取数问题，最小割模型~

#include <cstdio>
#include <cstring>

 using namespace std;

 const int maxN = 64;
const int INF = (1 << 30);
const int dx[] = { -1, 0, 1, 0 };
const int dy[] = { 0, 1, 0, -1 };

class Network {
private:
    const static int MAXV = 10240; // ¶¥µãÊý
    const static int MAXE = 100000; // ±ßÊý * 2

    struct List {
        int v;
        int f;
        List * rev;
        List * next;
    };

    List pool[MAXE];
    List * path[MAXV];
    List * head[MAXV];
    List * cur[MAXV];
    List * pp;

    int n;
    int s;
    int t;
    int dist[MAXV];
    int num[MAXV];
    int pred[MAXV];

    inline List * create(int v, int f, List * next) {
        pp->v = v;
        pp->f = f;
        pp->next = next;
        return pp++;
    }

    void InitDist();
    int Augment(int &);
public:
    void Init(int nv, int ss, int tt);
    void addEdge(int u, int v, int f);
    int maxFlow();
};

void Network::Init(int nv, int ss, int tt) {
    int i;

    n = nv;
    s = ss;
    t = tt;

    pp = pool;
    memset(head, 0, n * sizeof(head[0]));
    memset(cur, 0, n * sizeof(cur[0]));
    memset(num, 0, n * sizeof(int));

    pred[s] = -1;

    for (i = 0; i < n; i++)
        dist[i] = n;

    return;
}

void Network::addEdge(int u, int v, int f) {
    head[u] = create(v, f, head[u]);
    head[v] = create(u, 0, head[v]);

    head[u]->rev = head[v];
    head[v]->rev = head[u];

    return;
}

void Network::InitDist() {
    int queue[MAXV];
    int qh = -1;
    int qe = 0;

    List * p;

    dist[t] = 0;
    queue[0] = t;

    while (qh != qe) {
        qh++;
        int u = queue[qh];
        for (p = head[u]; p; p = p->next)
            if (p->f == 0 && dist[p->v] == n) {
                dist[p->v] = dist[u] + 1;
                num[dist[p->v]]++;
                queue[++qe] = p->v;
            }
    }

    return;
}

int Network::Augment(int & sum) {
    int u;
    int last = s;
    int minl = INF;

    for (u = t; u != s; u = pred[u])
        minl = minl < path[u]->f ? minl : path[u]->f;
    sum += minl;
    for (u = t; u != s; u = pred[u]) {
        path[u]->f -= minl;
        path[u]->rev->f += minl;
        if (path[u]->f == 0)
            last = pred[u];
    }

    return last;
}

int Network::maxFlow() {
    bool update;
    int u = s;
    int ret = 0;

    List * p;

    InitDist();
    memcpy(cur, head, sizeof(head));

    while (dist[s] < n) {
        update = false;
        for (p = cur[u]; p; p = p->next)
            if (dist[p->v] + 1 == dist[u] && p->f > 0) {
                update = true;
                pred[p->v] = u;
                path[p->v] = p;
                cur[u] = p;
                u = p->v; // Ç°œø²œ
                if (u == t)
                    u = Augment(ret);
                break;
            }
        if (!update) {
            if (--num[dist[u]] == 0) // Œä϶ÓÅ»¯
                break;
            cur[u] = head[u];
            dist[u] = n;
            for (p = head[u]; p; p = p->next) // ÖرêºÅ
                if (p->f > 0 && dist[u] > dist[p->v] + 1)
                    dist[u] = dist[p->v] + 1;
            if (dist[u] < n)
                num[dist[u]]++;
            if (u != s) // »ØÍ˲œ
                u = pred[u];
        }
    }
    return ret;
}

Network net;

int maze[maxN][maxN];
bool must[maxN][maxN];

int main() {
    int nr;
    int nc;
    int nk;
    int sum;

    while (scanf("%d %d %d", &nr, &nc, &nk) != EOF) {
        sum = 0;
        memset(must, false, sizeof(must));
        for (int i = 0; i < nr; i++) {
            for (int j = 0; j < nc; j++) {
                scanf("%d", &maze[i][j]);
                sum += maze[i][j];
            }
        }
        for (int i = 0; i < nk; i++) {
            int x, y;
            scanf("%d %d", &x, &y);
            must[x - 1][y - 1] = true;
        }

        net.Init(nr * nc + 2, 0, nr * nc + 1);
        for (int i = 0; i < nr; i++) {
            for (int j = 0; j < nc; j++) {
                if ((i + j) & 1) {
                    net.addEdge(0, i * nc + j + 1, must[i][j] ? INF : maze[i][j]);
                    for (int k = 0; k < 4; k++) {
                        int ni = i + dx[k];
                        int nj = j + dy[k];
                        if (ni >= 0 && ni < nr && nj >= 0 && nj < nc) {
                            net.addEdge(i * nc + j + 1, ni * nc + nj + 1, 2
                                    * (maze[i][j] & maze[ni][nj]));
                        }
                    }
                } else {
                    net.addEdge(i * nc + j + 1, nr * nc + 1, must[i][j] ? INF : maze[i][j]);
                }
            }
        }

        int maxFlow = net.maxFlow();
        printf("%d\n", sum - maxFlow);
    }
    return 0;
}