HDU 3376 Matrix Again(费用流)

题目大意：给出一张网格，网格上面有相应的正数，现在要求你从左上角出发，走到右下角，再从右下角出发，走回左上角，沿路经过的格子不能重复(除了左上角和右下角的格子)，且从左上角走到右下角时只能往右或者往下走，从右下角走到左上角只能往上或者往左。现在问所走的格子的最大总和是多少

解题思路：遵守规则的话，从左上角到右下角，和从右下角到左上角，其实走的路径是对称的，能从上往下走，就表示能从下往上走，所以我们以左上角为源点，右下角为汇点建图
因为每个格子(除了左上角和右下角)只能走一次，所以拆点，容量为1，费用取格子的数的相反数，这样就能保证只走一次了
两个特殊的格子特殊考虑，容量为2，费用还是取相反数

这样，只要流了2的流量，就表示任务完成了，最后的最小费用取反，再减去重复走的两个特殊格子的费用

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXNODE = 600 * 600 * 2 + 10;
const int MAXEDGE = 4 * MAXNODE;
typedef int Type;
const Type INF = 0x3f3f3f3f;

struct Edge{
    int u, v, next;
    Type cap, flow, cost;
    Edge() {}
    Edge(int u, int v, Type cap, Type flow, Type cost, int next): u(u), v(v), cap(cap), flow(flow), cost(cost), next(next) {}
};

struct MCMF{
    int n, m, s, t;
    Edge edges[MAXEDGE];
    int head[MAXNODE];
    int p[MAXNODE];
    Type d[MAXNODE];
    Type a[MAXNODE];
    bool inq[MAXNODE];
    int flow, cost;

    void init(int n) {
        this->n = n;
        memset(head, -1, sizeof(head));
        m = 0;
    }

    void AddEdge(int u, int v, Type cap, Type cost) {
        edges[m] = Edge(u, v, cap, 0, cost, head[u]);
        head[u] = m++;
        edges[m] = Edge(v, u, 0, 0, -cost, head[v]);
        head[v] = m++;
    }

    bool BellmanFord(int s, int t, Type &flow, Type &cost) {
        for (int i = 0; i < n; i++) d[i] = INF;
        memset(inq, 0, sizeof(inq));
        d[s] = 0; inq[s] = true; p[s] = 0; a[s] = INF;
        queue<int> Q;
        Q.push(s);

        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            inq[u] = false;
            for (int i = head[u]; ~i; i = edges[i].next) {
                Edge &e = edges[i];
                if (e.cap > e.flow && d[e.v] > d[u] + e.cost) {
                    d[e.v] = d[u] + e.cost;
                    p[e.v] = i;
                    a[e.v] = min(a[u], e.cap - e.flow);
                    if (!inq[e.v]) { 
                        Q.push(e.v); inq[e.v] = true;
                    }
                } 
            }
        }

        if (d[t] == INF) return false;
        flow += a[t];
        cost += a[t] * d[t];
        int u = t;
        while (u != s) {
            edges[p[u]].flow += a[t];
            edges[p[u] ^ 1].flow -= a[t];
            u = edges[p[u]].u;
        }
        return true;
    }

    Type MinCost(int s, int t) {
        this->s = s; this->t = t;
         flow = 0, cost = 0;
        while (BellmanFord(s, t, flow, cost));
        return cost;
    }

}mcmf;

#define maxn 610
int map[maxn][maxn];
int dir[2][2] = {{0, 1}, {1, 0}};
int n;

void init() {
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            scanf("%d", &map[i][j]);
}

void solve() {
    int source = 0, sink = n * n * 2 + 1;
    int t = n * n;
    mcmf.init(sink + 1);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            if (i == j && (i == 1 || i == n))
                mcmf.AddEdge((i - 1) * n + j, (i - 1) * n + j + t, 2, -map[i][j]);
            else 
                mcmf.AddEdge((i - 1) * n + j, (i - 1) * n + j + t, 1, -map[i][j]);
            for (int k = 0; k < 2; k++) {
                int tx = i + dir[k][0];
                int ty = j + dir[k][1];
                if (tx < 1 || tx > n || ty < 1 || ty > n) continue;
                mcmf.AddEdge((i - 1) * n + j + t, (tx - 1) * n + ty, 1, 0);
            }
        }
    mcmf.AddEdge(source, 1, 2, 0);
    mcmf.AddEdge(t * 2, sink, 2, 0);
    printf("%d\n", -mcmf.MinCost(source, sink) - map[1][1] - map[n][n]);
}

int main() {
    while (scanf("%d", &n) != EOF) {
        init();
        solve();
    }
    return 0;
}