hdoj 3657 Game（网络流 最小割）

题目链接：hdoj 3657 Game

题意：给定一个矩阵，矩阵的每个方格有一个权值，从中取出方格，使取出的值最大。但是有两个约束：1、去相邻方格要付出一些代价 2、有一些方格必须要选

解题思路：
取出的值最大也就是不取的值最小，问题实际是最小割问题。本题建图方法与hdoj 1565 方格取数类似，根据行列相加的奇偶性将方格染色，黑点与源点S连接，白点与汇点T连接。（此题题解：hdoj 1565 方格取数(1)（最大流最小割））而本题新增的两个约束，可以通过改变边上的容量来实现。

1、方格取数（1）中的约束是相邻方格不能取，因此相邻方格之间连边的容量是∞，代表不能割断，使得想要源点S与汇点T不连通，一定要将”S——黑点”或”白点——T”的其中一条边割断；而本题只需付出一些代价就可以连接相邻的方格，那么就将上面的容量∞变为题中给出的代价，这样既可以取到”S——黑点”，又可以取到”白点——T”，因为最后算最大值时采用 总值 - 最小割 的方式，所以这一部分会算在最小割中被减去。

2、有些方格必须选，说明这些方格不能被割去，那么就将”S——黑点”或”白点——T”的容量设为∞，因为在计算”最小”割的时候，∞必然不会被选进。

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<utility>
#define JOJO cout<<"JOJO"<<endl;
using namespace std;

const long long INF = ~0ull>>2;
const int Inf = 0x3f3f3f3f;
const int maxn = 1e4+5;
const int dirx[] = {-1, 1, 0, 0}, diry[] = {0, 0, -1, 1};
int head[maxn], cur[maxn];
int lev[maxn];
int a[110][110];
bool must[110][110];//must[i][j]==true代表(i, j)必须要选
int S = 0, T;
int t;

struct tagedge{
    int to, next;
    int cap;
}edge[2*maxn];

bool LevelGraph()
{
    queue<int> q;
    fill(lev, lev+maxn, -1);
    lev[S] = 0;
    q.push(S);
    while (!q.empty()){
        int k = q.front();
        q.pop();

        for (int i = head[k]; i != -1; i = edge[i].next){
            int v = edge[i].to;

            if (lev[v] == -1 && edge[i].cap > 0){
                lev[v] = lev[k] + 1;
                q.push(v);
            }
        }
    }

    if (lev[T] == -1)
        return false;
    else
        return true;
}

int FindPath(int k, int flow_in)
{
    if (k == T)
        return flow_in;

    int flow_out = 0;
    for (int i = cur[k]; i != -1; i = edge[i].next){
        cur[k] = i;
        int v = edge[i].to;

        if (lev[v] == lev[k]+1 && edge[i].cap > 0){
            int flow = FindPath(v, min(flow_in, edge[i].cap));
            if (flow == 0)  continue;

            flow_in -= flow;
            flow_out += flow;

            edge[i].cap -= flow;
            edge[i^1].cap += flow;

            if (flow_in == 0)   break;
        }
    }
    return flow_out;
}

int Dinic()
{
    int res = 0;
    while (LevelGraph()){
        memcpy(cur, head, sizeof(head));
        res += FindPath(0, Inf);
    }
    return res;
}

void AddEdge(int u, int v, int w)
{
    edge[t].to = v;
    edge[t].cap = w;
    edge[t].next = head[u];
    head[u] = t++;
    return;
}

void init()
{
    fill(head, head+maxn, -1);
    fill(must[0], must[0]+110*110, false);
    memset(edge, 0, sizeof(edge));
    t = 0;
    return;
}

int main()
{
    int n, m, k;
    while (scanf("%d%d%d", &n, &m, &k) != EOF){
        init();

        T = n*m+1;
        int sum = 0;
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= m; j++){
                scanf("%d", &a[i][j]);
                sum += a[i][j];
            }
        }

        while (k--){
            int x, y;
            scanf("%d%d", &x, &y);
            must[x][y] = true;
        }

        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= m; j++){
                int id = (i-1)*m+j;
                if ((i+j)%2){
                    /*黑点与源点S连边*/
                    if (must[i][j] == false){
                        AddEdge(S, id, a[i][j]);
                        AddEdge(id, S, 0);
                    }
                    else{
                        AddEdge(S, id, Inf);
                        AddEdge(id, S, 0);
                    }

                    /*黑点与相邻白点连边*/
                    for (int p = 0; p < 4; p++){
                        int ii = i+dirx[p], jj = j+diry[p];
                        int idd = (ii-1)*m+jj;
                        if (ii < 1 || ii > n || jj < 1 || jj > m)   continue;
                        AddEdge(id, idd, 2*(a[i][j]&a[ii][jj]));
                        AddEdge(idd, id, 0);
                    }
                }
                else{
                    /*白点与汇点T连边*/
                    if (must[i][j] == false){
                        AddEdge(id, T, a[i][j]);
                        AddEdge(T, id, 0);
                    }
                    else{
                        AddEdge(id, T, Inf);
                        AddEdge(T, id, 0);
                    }
                }
            }
        }

        /*最大值 = 总值 - 最小割*/
        printf("%d\n", sum-Dinic());
    }
    return 0;
}