BZOJ2127 happiness（最小割）

题目链接

思路：
$\ \ \ \ $论文题。。最大化收益， 可以转化为最小化损失收益，用最小割模型：如果共同选择的只有一种情况的话， 那么可以直接源点连向每个同学，容量为选理科的喜悦值，每个同学连向汇点，容量为选文科的喜悦值，然后相邻的同学连接双向边，容量为他们共同选择的喜悦值。 但是现在共同选择的喜悦值有两种情况， 对共同的选择单独考虑，可以造出一幅类似的图来，如图所示：

然后解方程

然后直接和之前只有文科理科的收益合并起来， 就得出了最小割的模型， 所有收益和减去最小割就是答案了。
建图如下：

#include<bits/stdc++.h>
typedef long long ll;
const int INF = 2e9 + 10;
const int maxn = 1e2 + 10;
using namespace std;

struct st {
    int to, re;
    int cap;
    st(int t = 0, int c = 0, int r = 0) : to(t), cap(c), re(r) {}
};
int n, m, s, t, k, T, kase = 1;
vector<st> G[maxn * maxn];
int it[maxn * maxn], lv[maxn * maxn];

void add(int f, int t, int c) {
    G[f].push_back(st(t, c, G[t].size()));
    G[t].push_back(st(f, 0, G[f].size() - 1));
}

void bfs() {
    memset(lv, -1, sizeof(lv));
    queue<int> q;
    lv[s] = 0;
    q.push(s);
    while(!q.empty()) {
        int u = q.front(); q.pop();
        for(int i = 0; i < G[u].size(); i++) {
            st &e = G[u][i];
            if(e.cap > 0 && lv[e.to] < 0) {
                lv[e.to] = lv[u] + 1;
                q.push(e.to);
            }
        }
     }
}

int dfs(int v, int t, int f) {
    if(v == t) return f;
    for(int &i = it[v]; i < G[v].size(); i++) {
        st &e = G[v][i];
        if(e.cap > 0 && lv[v] < lv[e.to]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                G[e.to][e.re].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int maxflow() {
    int f = 0;
    while(1) {
        bfs();
        if(lv[t] < 0) return f;
        memset(it, 0, sizeof(it));
        int fl;
        while((fl = dfs(s, t, INF)) > 0) f += fl;
    }
}

int mat[10][maxn][maxn];
int mp[maxn][maxn], cnt, tot;

int build_graph() {
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            int wk = 0, lk = 0;
            if(i < n) { wk += mat[2][i][j]; lk += mat[3][i][j]; }
            if(i > 1) { wk += mat[2][i - 1][j]; lk += mat[3][i - 1][j]; }
            if(j > 1) { wk += mat[4][i][j - 1]; lk += mat[5][i][j - 1]; };
            if(j < m) { wk += mat[4][i][j]; lk += mat[5][i][j]; }
            add(s, mp[i][j], mat[1][i][j] + lk / 2);
            add(mp[i][j], t, mat[0][i][j] + wk / 2);
            if(i < n) {
                add(mp[i + 1][j], mp[i][j], (mat[2][i][j] + mat[3][i][j]) / 2);
                add(mp[i][j], mp[i + 1][j], (mat[2][i][j] + mat[3][i][j]) / 2);
            }
            if(j < n) {
                add(mp[i][j + 1], mp[i][j], (mat[4][i][j] + mat[5][i][j]) / 2);
                add(mp[i][j], mp[i][j + 1], (mat[4][i][j] + mat[5][i][j]) / 2);
            }
        }
    }
    return maxflow();
}

int main() {
    while(scanf("%d %d", &n, &m) != EOF) {
        cnt = 1; tot = 0;
        for(int i = 0; i < 2; i++) {
            for(int j = 1; j <= n; j++) {
                for(int k = 1; k <= m; k++) {
                    scanf("%d", &mat[i][j][k]);
                    tot += mat[i][j][k];
                    mat[i][j][k] <<= 1;
                }
            }
        }
        for(int i = 2; i < 4; i++) {
            for(int j = 1; j < n; j++) {
                for(int k = 1; k <= m; k++) {
                    scanf("%d", &mat[i][j][k]);
                    tot += mat[i][j][k];
                    mat[i][j][k] <<= 1;
                }
            }
        }
        for(int i = 4; i < 6; i++) {
            for(int j = 1; j <= n; j++) {
                for(int k = 1; k < m; k++) {
                    scanf("%d", &mat[i][j][k]);
                    tot += mat[i][j][k];
                    mat[i][j][k] <<= 1;
                }
            }
        }
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++) mp[i][j] = cnt++;
        s = 0; t = n * m + 1;
        for(int i = s; i <= t; i++) G[i].clear();
        int ans = tot - (build_graph() / 2);
        printf("%d\n", ans);
    }
    return 0;
}