Poj3422 Kaka's Matrix Travels

http://poj.org/problem?id=3422

题意：有一个n*n的矩阵，每个方格有一个非负数，每次从左上角走到右下角，而且只能向右走或向下走，将走过的数加起来，再将该方格数置为0，每次走都会得到一个最大的和，走k次，求最大和。

思路：最小费用最大流问题，关键仍然是建图。建好图后，每次spfa找到一条s到t的最长路径，然后增光之。这里求得是最大费用，所以要把边上的费用换成相反数，然后spfa.

每个方格走过一次后，它的值变为0，所以可以将每个点拆成两个点p1和p2，它们之间建两条边（每条边也要建反向边），分别为（花费为-map[i][j],流量为1）（花费为0，流量为k-1），第一次经过该点时，走第一条边，得到其上的数字，因为它流量是1只能增光一次，之后再经过时，就走第二条边.

再加上源点s与汇点t,建图如下：

s到第一个点：花费为0，流量为k,因为要增光k次

每个点拆成两个点 p1.p2:建两条边（每条边也要建反向边），（花费为-map[i][j],流量为1）和（花费为0，流量为k-1）；

每个p2到下一个点（向右）的p1：花费为0，流量为k;

每个p2到下一个点（向下）的p1:：花费为0，流量为k;

最后一个点的p2到汇点：花费为0，流量为k;

EK求最大流是通过bfs找一条最短的路径增光，而最小费用最大流要找一条费用最小的路径增光（对费用流求最短路径）；

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
const int INF = 0x3f3f3f3f;

int map[60][60];
int n,k;
int s,t,cnt;
int maxflow;
int pre[5010],dis[5010],inque[5010];
struct node
{
    int u,v,c,f,next;
} edge[100000];

int p[100000];
//加边
void add(int u, int v, int c, int f)
{
    edge[cnt] = (struct node){u,v,c,f,p[u]};
    p[u] = cnt++;
    edge[cnt] = (struct node){v,u,-c,0,p[v]};//不要忘了加反向边
    p[v] = cnt++;
}

int spfa()
{
    queue<int> que;
    while(!que.empty())
        que.pop();
    for(int i = 0; i <= t; i++)
    {
        pre[i] = -1;
        dis[i] = INF;
        inque[i] = 0;
    }

    dis[s] = 0;
    inque[s] = 1;
    que.push(s);

    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        inque[u] = 0;

        for(int i = p[u]; i!=-1; i = edge[i].next)
        {
            int v = edge[i].v;
            if(edge[i].f > 0 && dis[v] > dis[u] + edge[i].c)
            {
                dis[v] = dis[u] + edge[i].c;
                pre[v] = i;
                if(!inque[v])
                {
                    inque[v] = 1;
                    que.push(v);
                }
            }
        }
    }
    if(dis[t] == INF)
        return 0;
    return 1;
}

void MCMF()
{
    int minflow;
    while(spfa())
    {
        minflow = INF;
        for(int v = pre[t]; edge[v].u != s; v = pre[edge[v].u])
            minflow = min(minflow,edge[v].f);
        for(int v = pre[t]; edge[v].u != s; v = pre[edge[v].u])
        {
            edge[v].f -= minflow;
            edge[v^1].f += minflow;
            maxflow += minflow * edge[v].c;//加到费用流里面
        }
    }
}

int main()
{
    while(~scanf("%d %d",&n,&k))
    {
		maxflow = 0;
        s = n*n*2;//起点
        t = s+1;//汇点
        cnt = 0;
        memset(p,-1,sizeof(p));
        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++)
            {
                int it = (i-1)*n+j-1;
                add(it*2,it*2+1,-map[i][j],1);
                add(it*2,it*2+1,0,k-1);
            }
        }
        //向右建边
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j < n; j++)
            {
                int it = (i-1)*n+j-1;
                add(it*2+1,2*(it+1),0,k);
            }
        }
        //向下建边
        for(int i = 1; i < n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                int it = (i-1)*n+j-1;
                add(it*2+1,(it+n)*2,0,k);
            }
        }

        add(s,0,0,k);//起点到第一个点
        add(n*n*2-1,t,0,k);//最后一个点到汇点
        MCMF();
        printf("%d\n",-maxflow);
    }
    return 0;
}