poj 3422(最小费用最大流)

题目链接：http://poj.org/problem?id=3422

思路：求从起点到终点走k次获得的最大值，最小费用最大流的应用：将点权转化为边权，需要拆点，边容量为1，费用为该点的点权，表示该点的权值只能获取一次，另外，应该连一条容量为inf,费用为0的边，因为每条边都可以走多次。另外就是增加源点和汇点了，源点与起点连容量为k,费用为0的边，表示可以走k次，同理终点与汇点也如此。然后就是求最大费用了，这与求最小费用类似，只需将spfa函数稍作修改即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define MAXN 8888
#define MAXM 4444444
#define inf 1<<30

struct Edge {
    int v,cap,cost,next;
} edge[MAXM];

int n,m,vs,vt,NE;
int head[MAXN];

void Insert(int u,int v,int cap,int cost)
{
    edge[NE].v=v;
    edge[NE].cap=cap;
    edge[NE].cost=cost;
    edge[NE].next=head[u];
    head[u]=NE++;

    edge[NE].v=u;
    edge[NE].cap=0;
    edge[NE].cost=-cost;
    edge[NE].next=head[v];
    head[v]=NE++;
}

int cur[MAXN],pre[MAXN];
bool mark[MAXN];
int dist[MAXN];

bool spfa(int vs,int vt)
{
    memset(mark,false,sizeof(mark));
    fill(dist,dist+vt+1,-inf);
    dist[vs]=0;
    queue<int>que;
    que.push(vs);
    while(!que.empty()) {
        int u=que.front();
        que.pop();
        mark[u]=false;
        for(int i=head[u]; i!=-1; i=edge[i].next) {
            int v=edge[i].v,cost=edge[i].cost;
            if(edge[i].cap>0&&dist[u]+cost>dist[v]) {
                dist[v]=dist[u]+cost;
                pre[v]=u;
                cur[v]=i;
                if(!mark[v]) {
                    mark[v]=true;
                    que.push(v);
                }
            }
        }
    }
    return dist[vt]!=-inf;
}


int MinCostFlow(int vs,int vt)
{
    int flow=0,cost=0;
    while(spfa(vs,vt)) {
        int aug=inf;
        for(int u=vt; u!=vs; u=pre[u]) {
            aug=min(aug,edge[cur[u]].cap);
        }
        flow+=aug;
        cost+=dist[vt]*aug;
        for(int u=vt; u!=vs; u=pre[u]) {
            edge[cur[u]].cap-=aug;
            edge[cur[u]^1].cap+=aug;
        }
    }
    return cost;
}

int map[55][55];
int dir[2][2]= {{1,0},{0,1}};

int main()
{
  //  freopen("1.txt","r",stdin);
    while(~scanf("%d%d",&n,&m)) {
        NE=0;
        vs=0,vt=2*n*n+1;
        memset(head,-1,sizeof(head));
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                scanf("%d",&map[i][j]);
        for(int i=1; i<=n; i++) {
            for(int j=1; j<=n; j++) {
                Insert((i-1)*n+j,(i-1)*n+j+n*n,1,map[i][j]);
                Insert((i-1)*n+j,(i-1)*n+j+n*n,inf,0);
                for(int k=0; k<2; k++) {
                    int x=i+dir[k][0],y=j+dir[k][1];
                    if(x<=n&&y<=n)
                        Insert((i-1)*n+j+n*n,(x-1)*n+y,inf,0);
                }
            }
        }
        Insert(vs,1,m,0);
        Insert(2*n*n,vt,m,0);
        printf("%d
",MinCostFlow(vs,vt));
    }
    return 0;
}