POJ 3422 矩阵取数 最小费用流拆点+负边

Posted 2020-07-06 smilesundream

Kaka‘s Matrix Travels

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 9153		Accepted: 3696

Description

On an N × N chessboard with a non-negative number in each grid, Kaka starts his matrix travels with SUM = 0. For each travel, Kaka moves one rook from the left-upper grid to the right-bottom one, taking care that the rook moves only to the right or down. Kaka adds the number to SUM in each grid the rook visited, and replaces it with zero. It is not difficult to know the maximum SUM Kaka can obtain for his first travel. Now Kaka is wondering what is the maximum SUM he can obtain after his Kth travel. Note the SUM is accumulative during the K travels.

Input

The first line contains two integers N and K (1 ≤ N ≤ 50, 0 ≤ K ≤ 10) described above. The following N lines represents the matrix. You can assume the numbers in the matrix are no more than 1000.

Output

The maximum SUM Kaka can obtain after his Kth travel.

Sample Input

3 2
1 2 3
0 2 1
1 4 2

Sample Output

15

Source

POJ Monthly--2007.10.06, Huang, Jinsong

题意：

1. 有个方阵，每个格子里都有一个非负数，从左上角走到右下角，每次走一步，只能往右或往下走，经过的数字拿走 
2. 每次都找可以拿到数字和最大的路径走，走k次，求最大和 

3. #include <iostream>
   #include <cstdio>
   #include <cstring>
   #include <cstdlib>
   #include <cmath>
   #include <vector>
   #include <queue>
   #include <map>
   #include <algorithm>
   #include <set>
   using namespace std;
   #define MM(a,b) memset(a,b,sizeof(a))
   typedef long long ll;
   typedef unsigned long long ULL;
   const int mod = 1000000007;
   const double eps = 1e-10;
   const int inf = 0x3f3f3f3f;
   const int big=50000;
   int max(int a,int b) {return a>b?a:b;};
   int min(int a,int b) {return a<b?a:b;};
   const int N = 70;
   const int M=10000+100;
   struct edge{
      int to,cap,cost,rev;
   };
   
   vector<edge> G[5005];
   int mp[55][55], dist[5005],inq[5005],prev[5005],prel[5005];
   struct Point{
      int x,y;
   };
   
   int n,k,m,x,y,c,cnth,cntm;
   
   void add_edge(int u,int v,int cap,int cost)
   {
       G[u].push_back(edge{v,cap,cost,G[v].size()});
       G[v].push_back(edge{u,0,-cost,G[u].size()-1});
   }
   
   int mincost(int s,int t,int f)
   {
       int ans=0;
       while(f>0)
       {
         memset(dist,inf,sizeof(dist));
         memset(inq,0,sizeof(inq));
         dist[s]=0;
         queue<int> q;
         q.push(s);
         inq[s]=1;
         MM(prev,-1);
         while(!q.empty())
         {
             int u=q.front();
             q.pop();inq[u]=0;
             for(int j=0;j<G[u].size();j++)
               {
                   edge &e=G[u][j];
                   if(e.cap>0&&dist[e.to]>dist[u]+e.cost)
                      {
                          dist[e.to]=dist[u]+e.cost;
                          prev[e.to]=u;
                          prel[e.to]=j;
                          if(!inq[e.to])
                          {
                              q.push(e.to);
                              inq[e.to]=1;
                          }
                      }
               }
          }
          for(int i=t;i>s;)
          {
              int f=prev[i];
              if(f==-1) return -1;
              int j=prel[i];
              G[f][j].cap-=1;
              G[i][G[f][j].rev].cap+=1;
              ans+=G[f][j].cost;
              i=prev[i];
          }
          f-=1;
       }
       return ans;
   }
   
   int in(int i,int j)
   {
       return (i-1)*2*n+j;
   }
   
   int out(int i,int j)
   {
      return (i-1)*2*n+n+j;
   }
   
   void build(int k)
   {
       add_edge(0,1,k,0);
   
       for(int i=1;i<=n;i++)
         for(int j=1;j<=n;j++)
            {
                add_edge(in(i,j),out(i,j),1,-mp[i][j]);
                add_edge(in(i,j),out(i,j),k-1,0);
            }
   
       for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
           if(i!=n)
             add_edge(out(i,j),in(i+1,j),k,0);
           if(j!=n)
             add_edge(out(i,j),in(i,j+1),k,0);
        }
   
       add_edge(out(n,n),out(n,n)+1,k,0);
   }
   
   int main()
   {
       while(~scanf("%d %d",&n,&k))
       {
           for(int i=1;i<=n;i++)
             for(int j=1;j<=n;j++)
                scanf("%d",&mp[i][j]);
           build(k);
           printf("%d\n",-mincost(0,out(n,n)+1,k));
       }
       return 0;
   }
   

   　　分析：1.建图时一个节点拆成两个，并且中间连接两条边，一条是费用该点的价值取反，另一条是为了保证这个节点能经过多次      

4. 2因为是最小费用流，所以需要将费用取反，跑完最小费用流后再取反就好