HDU 3376 费用流 Matrix Again

题意：

给出一个n × n的矩阵，每个格子中有一个数字代表权值，找出从左上角出发到右下角的两条不相交的路径(起点和终点除外)，使得两条路径权值之和最大。

分析：

如果n比较小的话是可以DP的，但是现在n非常大，DP会超时的。

这个用费用流来求解：

因为每个点只能走一次，所以先拆点，两点之间连一条容量为1费用为对应格子权值的边，如果是起点或终点，因为要走两次，所以要连容量为2的边。

对于不同格子之间，如果能到达，连一条容量为INF，费用为0的边。

因为算法求的是最小费用，所以我们把每个格子的相反数当做费用去连边，最后再取相反数。

因为起点和终点容量为2，计算出来的最大权值重复计算了左上角和右下角的权值，所以答案应该再减去这两个数。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

const int maxn = 600;
const int maxnode = maxn * maxn * 2;
const int maxm = 1000000 + 10;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int from, to, cap, flow, cost;
    int nxt;
    Edge() {}
    Edge(int u, int v, int cap, int f, int cost, int nxt):from(u), to(v), cap(cap), flow(f), cost(cost), nxt(nxt) {}
};

int ecnt;
Edge edges[maxm << 2];
int head[maxnode];

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

int row;
int A[maxn][maxn];

int n;
int d[maxnode + 10], p[maxnode + 10], a[maxnode + 10];
bool inq[maxnode + 10];

bool SPFA(int s, int t)
{
    memset(inq, false, sizeof(inq));
    memset(p, -1, sizeof(p));
    memset(d, 0x3f, sizeof(d));
    inq[s] = true;
    d[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].nxt)
        {
            Edge& e = edges[i];
            int v = e.to;
            if(e.flow < e.cap && d[u] + e.cost < d[v])
            {
                d[v] = d[u] + e.cost;
                p[v] = i;
                a[v] = min(a[u], e.cap - e.flow);
                if(!inq[v]) { inq[v] = true; Q.push(v); }
            }
        }
    }

    return d[t] != INF;
}

int Mincost(int s, int t)
{
    int flow = 0;
    int cost = 0;
    while(SPFA(s, t))
    {
        flow += a[t];
        cost += d[t] * a[t];
        int u = t;
        while(u != s)
        {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
            u = edges[p[u]].from;
        }
    }
    return cost;
}

int main()
{
    while(scanf("%d", &row) == 1)
    {
        for(int i = 0; i < row; i++)
            for(int j = 0; j < row; j++) scanf("%d", &A[i][j]);

        n = row * row;
        int s = 0, t = n * 2 - 1;
        ecnt = 0;
        memset(head, -1, sizeof(head));

        //build graph
        for(int i = 0; i < row; i++)
            for(int j = 0; j < row; j++)
            {
                int u = i * row + j;
                int v = u + n;
                int cap = 1;
                if(u == 0 || u == n - 1) cap++;
                AddEdge(u, v, cap, -A[i][j]);

                int w;
                if(i < row - 1)
                {
                    w = u + row;
                    AddEdge(v, w, INF, 0);
                }
                if(j < row - 1)
                {
                    w = u + 1;
                    AddEdge(v, w, INF, 0);
                }
            }

        n <<= 1;
        printf("%d
", -Mincost(s, t) - A[0][0] - A[row-1][row-1]);
    }

    return 0;
}