POJ 3422 Kaka's Matrix Travels【最大费用流】

题意：给定N,K，和N*N矩阵表示该点权值，从左上到右下，求走K次所得的权值和最大

最大费用流：把最小费用流的权值改为负数，输出也加个负数就行。

建图：因为权值附在点上，所以拆点是必须的，然后点A到点A'要两条边，一条的费用为权值，容量为1，另一条费用为0，容量为K-1，使得走一次时有权，走其他K-1次时没有（每个点最多K次访问）。建立一个源点连接一号点，容量为K，费用0，汇点同理。然后每个点跟自己的左上两点建边（如果有左上的话），容量为K，费用0。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define CLR( a , x ) memset ( a , x , sizeof (a) )
#define RE freopen("1.in","r",stdin);
#define WE freopen("1.out","w",stdout);

//模板大法好
const int inf = 0x3f3f3f3f;
const int maxn = 5025;
const int maxm = 30000;
struct Edge {
    int to, next, cap, flow, cost;
} edge[maxm * 2];
int head[maxn], tol;
int pre[maxn], dis[maxn];
bool vis[maxn];
void init() {
    tol = 0;
    memset(head, -1, sizeof(head));
}
void addEdge(int u, int v, int cap, int cost) {
    edge[tol].to = v;
    edge[tol].cap = cap;
    edge[tol].cost = cost;
    edge[tol].flow = 0;
    edge[tol].next = head[u];
    head[u] = tol++;
    edge[tol].to = u;
    edge[tol].cap = 0;
    edge[tol].cost = -cost;
    edge[tol].flow = 0;
    edge[tol].next = head[v];
    head[v] = tol++;
}
bool spfa(int s, int t) {
    queue<int>q;
    memset(dis, inf, sizeof(dis));
    memset(vis, false, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (edge[i].cap > edge[i].flow &&
                    dis[v] > dis[u] + edge[i].cost ) {
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if (!vis[v]) {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    return pre[t] != -1;
}
//返回最大流，cost存最小费用
int minCostMaxflow(int s, int t, int &cost) {
    int flow = 0;
    cost = 0;
    while (spfa(s, t)) {
        int Min = inf;
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
            if (Min > edge[i].cap - edge[i].flow) {
                Min = edge[i].cap - edge[i].flow;
            }
        }
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
            edge[i].flow += Min;
            edge[i ^ 1].flow -= Min;
            cost += edge[i].cost * Min;
        }
        flow += Min;
    }
    return flow;
}
int main() {
    int val;
    int n, k;
//    freopen("1.in","r",stdin);
    while (~scanf("%d%d",&n,&k)) {
        int ss = 0, tt = 2*n*n + 1;     //包含了拆点，所以是2*n*n
        init();
        int cnt=1;
        FOR(i,1,n)
        {
            FOR(j,1,n)
            {
                scanf("%d",&val);
                val=-val;   //最大流取负数
                addEdge(cnt,n*n+cnt,1,val);     //A对A'建边
                addEdge(cnt,n*n+cnt,k-1,0);     //A对A'建边
                if(j!=1)
                    addEdge(cnt-1+n*n,cnt,k,0); //不是第一列就跟做左一列的建边
                if(i!=1)
                    addEdge(cnt-n+n*n,cnt,k,0); //不是第一行就对上一行的建边
                cnt++;
            }
        }

        addEdge(ss,1,k,0);      //源点向1号点建K容量边
        addEdge(n*n*2,tt,k,0);  //汇点向终号点建K容量边

        int cost;
        minCostMaxflow(ss, tt, cost);
        printf("%d\n",-cost);
    }
    return 0;
}