HDU 4862 Jump（最小费用最大流-mcmf）

Description
给定一个N*M(10*10)的矩阵，每个格子里有一个数（0-9），每个格子可以一步跳到它右面或者下面的格子，花费费用为两个格子的曼哈顿距离减一。假如起跳的格子和终止的格子里的数相同，那么花费可以减去这个数。问能不能在至多跳K次的情况下，遍历每个格子，且每个格子只被经过一次，如果可以，那么花费的最小费用是多少。
Input
第一行为一个整数T表示用例组数，每组用例第一行为三个整数N,M,K表示矩阵行列数以及起跳次数限制，之后为一个N*M矩阵表示每个格子里的数
Output
对于每组用例，如果可以在至多跳K次的情况下，遍历每个格子，且每个格子只被经过一次则输出最小费用，否则输出-1
Sample Input
5
1 5 1
91929
1 5 2
91929
1 5 3
91929
3 3 3
333
333
333
3 3 2
333
333
333
Sample Output
Case 1 : 0
Case 2 : 15
Case 3 : 16
Case 4 : 18
Case 5 : -1
Solution
拆点，源点向每个i连一条边，流量1，费用0，每个i’向汇点连一条边，流量1，费用0，如果u可以在一步之内到达v，那么就连边u->v’，费用为从u格子到v格子的花费能量减去得到的能量，流量1，再增加一个新的节点temp，表示可以从任意节点出发K次，源点向其连边，费用0，流量K，这个点向每个i’连边，费用0，流量1，对这个图跑最小费用最大流，如果满流就是存在解，反之不存在，最小费用的相反数就是可以获得的最大能量
Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define maxn 222
#define maxm 222222
#define INF 0x3f3f3f3f
int head[maxn],d[maxn],s,e,no,dis[maxn][maxn],vis[maxn],pre[maxn];
int T,N,M,K,Map[11][11];
struct point
{
    int u,v,flow,next,cost;
    point(){};
    point(int x,int y,int z,int w,int c):u(x),v(y),next(z),flow(w),cost(c){};
}p[maxm];
void add(int x,int y,int z,int c)
{
    p[no]=point(x,y,head[x],z,c);   
    head[x]=no++;
    p[no]=point(y,x,head[y],0,-c);  
    head[y]=no++;
}
void init()
{
    memset(head,-1,sizeof(head));
    no=0;
}
bool spfa()
{
    int i,x,y;
    queue<int>q;
    memset(d,0x3f,sizeof(d));
    memset(vis,false,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    d[s]=0;   
    vis[s]=true;  
    q.push(s);
    while(!q.empty())
    {
        x=q.front();  
        q.pop();    
        vis[x]=false;
        for(i=head[x];i!=-1;i=p[i].next)
        {
            if(p[i].flow&&d[y=p[i].v]>d[x]+p[i].cost)
            {
                d[y]=d[x]+p[i].cost;   
                pre[y]=i;
                if(vis[y])  
                    continue;
                vis[y]=true;  
                q.push(y);
            }  
        }  
    }
    return d[e]!=d[e+1];
}
int mcmf()
{
    int mincost=0,maxflow=0,minflow,i;
    while(spfa())
    {
        minflow=INF;
        for(i =pre[e];i!=-1;i=pre[p[i].u])
            minflow=min(minflow,p[i].flow);
        for(i=pre[e];i!=-1;i=pre[p[i].u])
        {
            p[i].flow-=minflow;
            p[i^1].flow+=minflow;
        }
        mincost+=d[e]*minflow; 
        maxflow+=minflow;
    }
    if(maxflow==N*M)//判断是否满流 
        return mincost;
    return -1;
}
int main()
{
    scanf("%d",&T);
    int res=1;
    while(T--)
    {
        scanf("%d%d%d",&N,&M,&K);
        init();//初始化 
        char c[11];
        for(int i=1;i<=N;i++)
        {
            scanf("%s",c);
            for(int j=1;j<=M;j++)
                Map[i][j]=c[j-1]-'0';
        }
        s=0;//源点为0 
        e=2*N*M+2;//汇点为2*N*M+2 
        int temp=2*N*M+1;//增肌一个新节点temp 
        for(int i=1;i<=N*M;i++)//源点到每个点建容量为1,花费为0的边 
            add(s,i,1,0);
        for(int i=N*M+1;i<=2*N*M;i++)//每个拆过后的点到汇点建容量为1,花费为0的边 
            add(i,e,1,0);
        add(s,temp,K,0);//源点到temp建容量为K,花费为0的边 
        for(int i=N*M+1;i<=2*N*M;i++)//temp到每个拆过后的点建容量为1,花费为0的边 
            add(temp,i,1,0);
        for(int i=1;i<=N;i++)
            for(int j=1;j<=M;j++)
            {
                for(int k=i+1;k<=N;k++)//向下跳 
                {
                    int dist=k-i-1;//花费 
                    if(Map[i][j]==Map[k][j])//两格数字相同则花费减去该数 
                        dist-=Map[i][j];
                    add((i-1)*M+j,(k-1)*M+j+N*M,1,dist);
                }
                for(int k=j+1;k<=M;k++)//向右跳 
                {
                    int dist=k-j-1;//花费 
                    if(Map[i][j]==Map[i][k])//两格数字相同则花费减去该数 
                        dist-=Map[i][j];
                    add((i-1)*M+j,(i-1)*M+k+N*M,1,dist);
                }
            }
        int ans=mcmf();
        printf("Case %d : ",res++);
        if(ans==-1)//不满流 
            printf("-1\n");
        else// 满流则最小花费的负值即为能够得到的最大能量数 
            printf("%d\n",-ans);
    }
    return 0;
}