poj 3422 Kaka's Matrix Travels (费用流 + 拆点)

 这道题以前做过了 今天有做了一遍，发现比以前顺手多了，

题意：

给一个N*N的方阵，从[1,1]到[n,n]走K次，走过每个方格加上上面的数（每一个 方格只能向下 后向右走）， 然后这个格上面的数变为0。求可取得的最大的值。

 

题解：

 拆点 + 费用流 ；

将 每一个点拆分成两个 ， 为了  保证 只能算一次  流量为1  花费为  方格的值，有为了 保证 其他的路径 可以 从这个点 走过  再建一条  流量 为  inf  费用 为 0 的 边 

 

 

 

 

 

 

  1 #include<cstdio>
  2 #include<cstring>
  3 #include<cmath>
  4 #include<iostream>
  5 #include<algorithm>
  6 #include< set>
  7 #include<map>
  8 #include<queue>
  9 #include<vector>
 10 #include< string>
 11  #define Min(a,b) a<b?a:b
 12  #define Max(a,b) a>b?a:b
 13  #define CL(a,num) memset(a,num,sizeof(a));
 14  #define eps  1e-12
 15  #define inf 10001000
 16  #define mx 1<<60
 17  #define ll   __int64
 18 
 19  #define  read()  freopen("data.txt","r",stdin) ;
 20  const  double pi  = acos(- 1.0);
 21  const  int maxn =  100000;
 22 
 23  using  namespace std;
 24  int n , m , k ,s,ss,t,N;
 25  int mat[ 60][ 60] ,dis[ 6000],head[ 6000],cnt,pre[ 6000];
 26  bool vis[ 6000] ;
 27  struct node
 28 {
 29      int v;
 30      int cost;
 31      int flow;
 32      int next ;
 33 }p[maxn] ;
 34  struct qnode
 35 {
 36      int u;
 37      int  len ;
 38     qnode( int a, int b):u(a),len(b){}
 39 
 40 };
 41 queue<qnode>que ;
 42 
 43 
 44  void add( int u, int v, int f, int c)
 45 {
 46     p[cnt].v = v;
 47     p[cnt].cost = c ;
 48     p[cnt].flow = f;
 49     p[cnt].next = head[u];
 50     head[u] = cnt++;
 51 
 52 
 53 
 54     p[cnt].v = u;
 55     p[cnt].cost = -c;
 56     p[cnt].flow =  0;
 57     p[cnt].next = head[v] ;
 58     head[v] = cnt++ ;
 59 
 60 }
 61  void build()
 62 {
 63      int  i , j ,b;
 64     CL(head,- 1);
 65 
 66     cnt =  0 ;
 67     N = n*n ;
 68     s = n*n * 2+  1 ;
 69     t = n*n * 2 +  2 ;
 70     add(s, 0,k, 0);
 71 
 72      for(i =  0 ; i < n;i++)
 73     {
 74          for(j =  0 ; j< n;j++)
 75         {
 76               int a = i*n + j;
 77 
 78              add(a,a + N, 1,mat[i][j]) ;
 79              add(a,a+N,inf, 0) ;
 80               if(i +  1 < n)
 81              {
 82                  b = (i +  1)*n + j ;
 83                  add(a + N,b,inf, 0) ;
 84              }
 85 
 86               if(j +  1 < n)
 87              {
 88                  b =  i * n + (j  +  1) ;
 89                  add(a + N,b,inf, 0) ;
 90              }
 91 
 92               if(i == n -  1&&j == n -  1)
 93              {
 94                  add(a + N,t,inf, 0);
 95              }
 96         }
 97     }
 98 
 99 
100 
101 }
102  bool spfa( int s)
103 {
104 
105      int i ;
106      for(i =  0 ; i <= t;i++)
107     {
108         dis[i] = -inf;
109     }
110     dis[s] =  0 ;
111     CL(vis, false) ;
112      while(!que.empty())que.pop() ;
113 
114     que.push(qnode(s, 0));
115     vis[s] = true ;
116      while(!que.empty())
117     {
118         qnode a = que.front() ;que.pop() ;
119 
120          int u = a.u;
121          int len = a.len ;
122         vis[u] =  false ;
123          for(i = head[u];i != -  1;i = p[i].next)
124         {
125              int v = p[i].v;
126              int cost = p[i].cost;
127              int flow = p[i].flow ;
128              if(flow >  0 && dis[v] <  dis[u] + cost)
129             {
130 
131                 dis[v] = dis[u] + cost;
132                 pre[v] = i;
133                  if(!vis[v])
134                 {
135                     vis[v] =  true ;
136                     que.push(qnode(v,dis[v])) ;
137                 }
138             }
139         }
140     }
141      return dis[t] >  0 ;
142 
143 }
144  void solve()
145 {
146      int  i, j;
147      int res = -inf ;
148 
149 
150 
151          int ans =  0 ;
152 
153          while(spfa(s))
154         {
155 
156 
157              int mi =  inf;
158              int tp = t;
159              /* while(tp!= s)
160              {
161 
162 
163                  mi = min(mi,p[pre[tp]].flow) ;
164                  tp = p[pre[tp]^1].v ;// 跳到 出边点
165              }
166              tp = t; */
167              while(tp!= s)
168             {
169 
170                 ans += p[pre[tp]].cost ;
171                 p[pre[tp]].flow -=  1 ;
172                 p[pre[tp]^ 1].flow +=  1;
173 
174                 tp = p[pre[tp]^ 1].v;
175 
176             }
177         }
178 
179 
180 
181      printf( " %d\n ",ans) ;
182 
183 }
184  int main()
185 {
186      int i ,u,v,d,j;
187      // read();
188       while(scanf( " %d%d ",&n,&k)!=EOF)
189     {
190          for(i =  0 ; i< n;i++)
191         {
192              for(j =  0 ; j < n;j++)
193             {
194                 scanf( " %d ",&mat[i][j]) ;
195             }
196         }
197         build() ;
198         solve() ;
199     }
200 }