hdu 2686 Matrix / 3376 Matrix Again最大费用流

题意：给出一个矩阵，从左上角走到右下角，再从右下角走回左上角，往下走的过程中只能向右或下，往上走只能左和上，且往上往下的两条路不能重合，求经过矩阵的最大值。

很明显的多线程dp，这里用费用流来做，往下走的过程中每个点拆点a, a'，其中a到a‘建边，除了第一个点和最后一个点，都是费用为矩阵的值*-1，转换成求最大费用，流量为1，表示只经过这个点一次。而一趟来回可以看成是从第一个点到最后一个点的两条不想交的路径，那么第一个点和最后一个点拆出来的点之间建边就是花费为矩阵的值*-1，流量为2，表示两条路径，最后第一个点和最后一个点分别和超源超汇连边，每个点与其右下的两个点连边，流量1，花费0，跑下MCMF即可。注意最后要减去第一个和最后一个点的值，因为流量为2经过了两次，所以要减回去。

#include <bits/stdc++.h>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <cmath>
#include <time.h>
#include <vector>
#include <cstdio>
#include <string>
#include <iomanip>
///cout << fixed << setprecision(13) << (double) x << endl;
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define ls rt << 1
#define rs rt << 1 | 1
#define pi acos(-1.0)
#define eps 1e-8
#define Mp(a, b) make_pair(a, b)
#define asd puts("asdasdasdasdasdf");
typedef long long ll;
typedef pair <int, int> pl;
//typedef __int64 LL;
const int inf = 0x3f3f3f3f;
const int N = 50000;
const int st = N-9, ed = N-8;

struct node{
    int v, w, c, nxt;    //c--->cap  w--->cost(dis)
}e[N*100];

int cnt, n, m;
int head[N];
int dis[N];    //费用看成距离
int cap[N];        //流量
int cur[N];        //当前弧
int vis[N];
queue <int> q;
int flow, cost;
int a[33][33];

void init()
{
    cnt = 0;
    memset( head, -1, sizeof( head ) );
}

void add( int u, int v, int c, int w )
{
    e[cnt].v = v;
    e[cnt].c = c;
    e[cnt].w = w;
    e[cnt].nxt = head[u];
    head[u] = cnt++;

    e[cnt].v = u;
    e[cnt].c = 0;
    e[cnt].w = -w;
    e[cnt].nxt = head[v];
    head[v] = cnt++;
}

bool spfa()
{
    memset( dis, inf, sizeof( dis ) );
    memset( vis, 0, sizeof( vis ) );
    while( !q.empty() )    q.pop();
    cap[st] = inf;
    cur[st] = -1;
    dis[st] = 0;
    q.push( st );
    while( !q.empty() ) {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for( int i = head[u]; ~i; i = e[i].nxt ) {
            int v = e[i].v, c = e[i].c, w = e[i].w;
            if( c && dis[v] > dis[u] + w ) {
                dis[v] = dis[u] + w;
                cap[v] = min( c, cap[u] );
                cur[v] = i;
                if( !vis[v] ) {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
    if( dis[ed] == inf )
        return 0;
    flow += cap[ed];
    cost += cap[ed] * dis[ed];
    for( int i = cur[ed]; ~i; i = cur[e[i^1].v] ) {
        e[i].c -= cap[ed];
        e[i^1].c += cap[ed];
    }
    return 1;
}

int MCMF()
{
    flow = cost = 0;
    while( spfa() );
    return cost;
}

int main()
{
    while( ~scanf("%d", &n) ) {
        init();
        for( int i = 0; i < n; ++i ) {
            for( int j = 0, x, cap = 1; j < n; ++j ) {
                scanf("%d", &x);
                a[i][j] = x;
                int u = i*n+j, v = i*n+j+n*n;
                if( (i == 0 && j == 0) || (j == n-1 && i == n-1) )
                    cap++;
                add( u, v, cap, -x );
                if( i < n-1 )
                    add( v, u+n, 1, 0 );
                if( j < n-1 )
                    add( v, u+1, 1, 0 );
            }
        }
        add( st, 0, 2, 0 );
        add( n*n*2-1, ed, 2, 0 );
        int ans = MCMF();
        printf("%d\n", -ans-a[0][0]-a[n-1][n-1]);
    }
    return 0;
}

3376只需要把数组开的大一点就行了