POJ3422 Kaka's Matrix Travels 拆点+费用流(SPFA)

链接:http://poj.org/problem?id=3422
       题意：一个n*n的矩阵，走k次，每次从左上角开始，右下角结束。每个点有个值，走上去的时候获得这个值，但是走过之后就会变成0，也就是说只能吃一次。每次走只能向下或者向右，问你走k次之后能获得的最大值。
       思路：走一次的时候很容易，只要n*n递推一下就好了，那么走k次是不是递推k次呢？错，因为即使第一次的时候走的是最大值，但是走两次加起来也许就不是最大值了。思路跟UVA10806很相似，那题是往返，但是求两次最短路不一定是最优解，所以要考虑用费用流做这题。将每个点拆成两个，入点和出点，自己的入点和自己的出点连——两条边！一条边流量为1，费用为当前点的值，表示这个点能吃一次。第二条边流量为k-1，费用为0，也就是说除了第一次的1流量吃掉了这个点，别的边都是0费用“路过”。然后原本存在的边，那些竖边和横边，就0费用建一下。然后跑一下费用流。要注意的是，这个费用流是求最大费用。
(UVA 10806:http://blog.csdn.net/xtttgo/article/details/50768565)

代码：

#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<iostream>
#include<vector>
#include<cstdlib>
#include<cmath>
#include<stack>
#include<cctype>
#include<set>
#include<ctime>
#include<cassert>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int INF=1e9+7;
#define MP make_pair
#define PB push_back
#define DEBUG printf("here\n")
#define in(x) (x)
#define out(x) ((x)+n*n)
struct EE{
    int from,to,cap,cost;
    EE(){}
    EE(int from,int to,int cap,int cost):from(from),to(to),cap(cap),cost(cost){}
}edge[21000];
int st,ed,n,k,Ecnt,pic[55][55],d[5050],pre[5050],flow[5050];
bool vis[5050];
vector<vector<int> >G;
inline int ID(int x,int y){
    return n*(x-1)+y;
}
inline void add(int from,int to,int cap,int cost){
    G[from].PB(Ecnt);
    edge[Ecnt++]=EE(from,to,cap,cost);
    G[to].PB(Ecnt);
    edge[Ecnt++]=EE(to,from,0,-cost);
}
void build(){
    G.clear();G.resize(n*n*2+1);
    Ecnt=0;
    st=0;ed=out(ID(n,n));
    add(st,1,k,0);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            int s=in(ID(i,j)),t=out(ID(i,j));//拆点
            add(s,t,1,pic[i][j]);//有一个流量能拿到pic[i][j]
            add(s,t,k-1,0);//其余的流量走过来只能拿到0
            if(j!=n){//竖边
                s=out(ID(i,j)),t=in(ID(i,j+1));
                add(s,t,k,0);
            }
            if(i!=n){//横边
                s=out(ID(i,j)),t=in(ID(i+1,j));
                add(s,t,k,0);
            }
        }
    }
}
bool spfa(int &ans){
    queue<int> Q;
    memset(d,-1,sizeof d);
    memset(vis,false,sizeof vis);
    d[st]=0;pre[st]=-1;flow[st]=INF;vis[st]=true;Q.push(st);
    while(!Q.empty()){
        int s=Q.front();Q.pop();
        vis[s]=false;
        for(int i=0;i<(int)G[s].size();i++){
            EE e=edge[G[s][i]];
            if(e.cap>0&&d[e.to]<d[s]+e.cost){
                d[e.to]=d[s]+e.cost;
                pre[e.to]=G[s][i];
                flow[e.to]=min(flow[s],e.cap);
                if(!flow[e.to])break;
                if(!vis[e.to]){vis[e.to]=true;Q.push(e.to);}
            }
        }
    }
    if(d[ed]==-1)return false;
    ans+=d[ed];
    int now=ed;
    while(now!=st){
        now=pre[now];
        edge[now].cap-=flow[ed];
        edge[now^1].cap+=flow[ed];
        now=edge[now].from;
    }
    return true;
}
void solve(){
    int ans=0;
    while(spfa(ans));
    printf("%d\n",ans);
}
int main()
{
//    freopen("D://input.txt","r",stdin);
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%d",&pic[i][j]);
        }
    }
    build();
    solve();
    return 0;
}