poj 3422(最小费用最大流)

题目链接：http://poj.org/problem?id=3422

思路：求从起点到终点走k次获得的最大值，最小费用最大流的应用：将点权转化为边权，需要拆点，边容量为1，费用为该点的点权，表示该点的权值只能获取一次，另外，应该连一条容量为inf,费用为0的边，因为每条边都可以走多次。另外就是增加源点和汇点了，源点与起点连容量为k,费用为0的边，表示可以走k次，同理终点与汇点也如此。然后就是求最大费用了，这与求最小费用类似，只需将spfa函数稍作修改即可。

  1 #include<iostream>

  2 #include<cstdio>

  3 #include<cstring>

  4 #include<algorithm>

  5 #include<queue>

  6 using namespace std;

  7 #define MAXN 8888

  8 #define MAXM 4444444

  9 #define inf 1<<30

 10 

 11 struct Edge {

 12     int v,cap,cost,next;

 13 } edge[MAXM];

 14 

 15 int n,m,vs,vt,NE;

 16 int head[MAXN];

 17 

 18 void Insert(int u,int v,int cap,int cost)

 19 {

 20     edge[NE].v=v;

 21     edge[NE].cap=cap;

 22     edge[NE].cost=cost;

 23     edge[NE].next=head[u];

 24     head[u]=NE++;

 25 

 26     edge[NE].v=u;

 27     edge[NE].cap=0;

 28     edge[NE].cost=-cost;

 29     edge[NE].next=head[v];

 30     head[v]=NE++;

 31 }

 32 

 33 int cur[MAXN],pre[MAXN];

 34 bool mark[MAXN];

 35 int dist[MAXN];

 36 

 37 bool spfa(int vs,int vt)

 38 {

 39     memset(mark,false,sizeof(mark));

 40     fill(dist,dist+vt+1,-inf);

 41     dist[vs]=0;

 42     queue<int>que;

 43     que.push(vs);

 44     while(!que.empty()) {

 45         int u=que.front();

 46         que.pop();

 47         mark[u]=false;

 48         for(int i=head[u]; i!=-1; i=edge[i].next) {

 49             int v=edge[i].v,cost=edge[i].cost;

 50             if(edge[i].cap>0&&dist[u]+cost>dist[v]) {

 51                 dist[v]=dist[u]+cost;

 52                 pre[v]=u;

 53                 cur[v]=i;

 54                 if(!mark[v]) {

 55                     mark[v]=true;

 56                     que.push(v);

 57                 }

 58             }

 59         }

 60     }

 61     return dist[vt]!=-inf;

 62 }

 63 

 64 

 65 int MinCostFlow(int vs,int vt)

 66 {

 67     int flow=0,cost=0;

 68     while(spfa(vs,vt)) {

 69         int aug=inf;

 70         for(int u=vt; u!=vs; u=pre[u]) {

 71             aug=min(aug,edge[cur[u]].cap);

 72         }

 73         flow+=aug;

 74         cost+=dist[vt]*aug;

 75         for(int u=vt; u!=vs; u=pre[u]) {

 76             edge[cur[u]].cap-=aug;

 77             edge[cur[u]^1].cap+=aug;

 78         }

 79     }

 80     return cost;

 81 }

 82 

 83 int map[55][55];

 84 int dir[2][2]= {{1,0},{0,1}};

 85 

 86 int main()

 87 {

 88   //  freopen("1.txt","r",stdin);

 89     while(~scanf("%d%d",&n,&m)) {

 90         NE=0;

 91         vs=0,vt=2*n*n+1;

 92         memset(head,-1,sizeof(head));

 93         for(int i=1; i<=n; i++)

 94             for(int j=1; j<=n; j++)

 95                 scanf("%d",&map[i][j]);

 96         for(int i=1; i<=n; i++) {

 97             for(int j=1; j<=n; j++) {

 98                 Insert((i-1)*n+j,(i-1)*n+j+n*n,1,map[i][j]);

 99                 Insert((i-1)*n+j,(i-1)*n+j+n*n,inf,0);

100                 for(int k=0; k<2; k++) {

101                     int x=i+dir[k][0],y=j+dir[k][1];

102                     if(x<=n&&y<=n)

103                         Insert((i-1)*n+j+n*n,(x-1)*n+y,inf,0);

104                 }

105             }

106         }

107         Insert(vs,1,m,0);

108         Insert(2*n*n,vt,m,0);

109         printf("%d\n",MinCostFlow(vs,vt));

110     }

111     return 0;

112 }

View Code