poj3422 Kaka's Matrix Travels(最小费用最大流问题)

 /*
 poj3422 Kaka's Matrix Travels
 不知道 k次 dp做为什么不对？？？
 看了大牛的代码，才知道还可以这样做！
 开始没有理解将a 和 a‘ 之间建立怎样的两条边，导致程序一直陷入死循环，真心花了好长时间，快崩溃了。无语.....
 题意：有个方阵，每个格子里都有一个非负数，从左上角走到右下角，每次走一步，只能往右或往下走，经过的数字拿走
 每次都找可以拿到数字和最大的路径走，走k次，求最大和 

 这是 最大费用最大流 问题  每次spfa都找的是一条和最大的路径 s--到左上角的边流量是K限制增广次数 

 求最大费用最大流只需要把费用换成相反数，用最小费用最大流求解即可 

 构图过程：
 每个点拆分成两个  a   a'   之间建两条边(当然还要建退边)，分别是   (费用为该点相反数,流量为1) (费用为0,流量为k-1)
 路过这点时，可以通过前边那条边拿到数字，
 以后再从这儿过，就没有数字可拿了，走的就是第二条边 

 然后是 没点向 右和下 建一条边  费用0，流量k
 */
 #include<iostream>
 #include<queue>
 #include<cstring>
 #include<cstdio>
 #define N 50000
 #define M 5005
 #define Max 0x3f3f3f3f
 using namespace std;
 class EDGE
 {
 public:
    int u, v, c, f;
    int next;
 };
 queue<int>q;
 EDGE edge[N];
 int cap[][], n, k;
 int pre[N], first[N];
 int dist[M], vis[M];
 int edgeN;
 int s, t;
 int maxFlow;

 int spfa()
 {
     memset(dist, 0x3f, sizeof(dist));
     memset(vis, , sizeof(vis));
     memset(pre, -, sizeof(pre));
     dist[s]=;
     q.push(s);
     vis[s]=;
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         vis[u]=;
         for(int e=first[u]; e!=-; e=edge[e].next)
         {
           int v=edge[e].v;
           if(dist[v]>dist[u] + edge[e].c && edge[e].f>)
            {
                dist[v]=dist[u] + edge[e].c;
                pre[v]=e;
                if(!vis[v])
                {
                      vis[v]=;
                      q.push(v);
            }
        }
     }
      }
      if(dist[t]==Max)
        return ;
      return ;
 }

 void updateFlow()
 {
    int minF=Max;
    for(int e=pre[t]; e!=-; e=pre[edge[e].u])
      if(minF>edge[e].f)
         minF=edge[e].f;
    for(int e=pre[t]; e!=-; e=pre[edge[e].u])
    {
       edge[e].f-=minF;
       edge[e^].f+=minF;
       maxFlow+=minF*edge[e].c;
    }
 }

 void adde(int u, int v, int c, int f)
 {
     edge[edgeN].u=u; edge[edgeN].v=v;
     edge[edgeN].c=c; edge[edgeN].f=f;
     edge[edgeN].next=first[u]; first[u]=edgeN++;

     edge[edgeN].u=v; edge[edgeN].v=u;
     edge[edgeN].c=-c; edge[edgeN].f=;
     edge[edgeN].next=first[v]; first[v]=edgeN++;
 }

 int main()
 {
    int i, j;
    while(scanf("%d%d", &n, &k)!=EOF)
    {
       maxFlow=;
       edgeN=;
       memset(first, -, sizeof(first));
       s=; t=n*n*+;
       for(i=; i<=n; ++i)
         for(j=; j<=n; ++j)
           scanf("%d", &cap[i][j]);
       adde(s, , , k);
       for(i=; i<=n; ++i)
         for(j=; j<=n; ++j)//n*n个节点，拆点之后变成2*n*n个节点
         {
            int nb=(i-)*n+j;
            adde(*nb-, *nb, -cap[i][j], );//注意：a到a`是建立两条边，但是两条边的费用和容量不一样
            adde(*nb-, *nb, , k-);
            if(j<n)//向右建图
              adde(*nb, *(nb+)-, , k);
            if(i<n)//向下建图
              adde(*nb, *(nb+n)-, , k);
     }
        adde(n*n*, t, , k);

        while(spfa())//建好图之后，直接调用最小费用最大流模板就好了
           updateFlow();
        printf("%d\n", -maxFlow);
    }
    return ;
 }