K路径覆盖问题，最小费用最大流。。。。

最小K路径覆盖的模型，用费用流或者KM算法解决，构造二部图，X部有N*M个节点，源点向X部每一个节点连一条边，流量1，费用0，Y部有N*M个节点，每一个节点向汇点连一条边，流量1，费用0，假设X部的节点x能够在一步之内到达Y部的节点y，那么就连边x->y，费用为从x格子到y格子的花费能量减去得到的能量，流量1，再在X部添加一个新的节点，表示能够从随意节点出发K次，源点向其连边，费用0，流量K，这个点向Y部每一个点连边，费用0，流量1，最这个图跑最小费用最大流，假设满流就是存在解，反之不存在，最小费用的相反数就是能够获得的最大能量

Jump

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

Case 1 : 0
Case 2 : 15
Case 3 : 16
Case 4 : 18
Case 5 : -1

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int maxn=110000;
const int INF=0x3f3f3f3f;

int n,m,k;
int a[20][20];

struct Edge
{
	int to,next,cap,flow,cost;
}edge[maxn];

int Adj[maxn],Size,N;

void init()
{
	memset(Adj,-1,sizeof(Adj)); Size=0;
}

void addedge(int u,int v,int cap,int cost)
{
	edge[Size].to=v;
	edge[Size].next=Adj[u];
	edge[Size].cost=cost;
	edge[Size].cap=cap;
	edge[Size].flow=0;
	Adj[u]=Size++;
}

void Add_Edge(int u,int v,int cap,int cost)
{
	addedge(u,v,cap,cost);
	addedge(v,u,0,-cost);
}

int dist[1000],vis[1000],pre[1000];

bool spfa(int s,int t)
{
	queue<int> q;
	for(int i=0;i<N;i++)
	{
		dist[i]=INF;vis[i]=false; pre[i]=-1;
	}
	dist[s]=0; vis[s]=true; q.push(s);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		vis[u]=false;
		for(int i=Adj[u];~i;i=edge[i].next)
		{
			int v=edge[i].to;
			if(edge[i].cap>edge[i].flow&&
				dist[v]>dist[u]+edge[i].cost)
			{
				dist[v]=dist[u]+edge[i].cost;
				pre[v]=i;
				if(!vis[v])
				{
					vis[v]=true;
					q.push(v);
				}
			}
		}
	}
	if(pre[t]==-1) return false;
	return true;
}

int MinCostMaxFlow(int s,int t,int& cost)
{
	int flow=0;
	cost=0;
	while(spfa(s,t))
	{
		int Min=INF;
		for(int i=pre[t];~i;i=pre[edge[i^1].to])
		{
			if(Min>edge[i].cap-edge[i].flow)
				Min=edge[i].cap-edge[i].flow;
		}
		for(int i=pre[t];~i;i=pre[edge[i^1].to])
		{
			edge[i].flow+=Min;
			edge[i^1].flow-=Min;
			cost+=edge[i].cost*Min;
		}
		flow+=Min;
	}
	return flow;
}
char in[10010];
int main()
{
	int T_T,cas=1;
	scanf("%d",&T_T);
while(T_T--)
{
	init();
	scanf("%d%d%d",&n,&m,&k);
	memset(a,0,sizeof(a));
	for(int i=0;i<n;i++)	
	{
		scanf("%s",in);
		for(int j=0;j<m;j++)
		{
 			a[i][j]=in[j]-'0';
		}
	}
	///source:2*n*m sink:2*n*m+1 mid:2*n*m+2;
	int source=2*n*m,sink=2*n*m+1,mid=2*n*m+2;	
	N=mid+1;
	Add_Edge(source,mid,k,0);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			int from=i*m+j;
			Add_Edge(source,from,1,0);
			Add_Edge(from+n*m,sink,1,0);
			Add_Edge(mid,from+n*m,1,0);
			for(int ii=i+1;ii<n;ii++)
			{
				int to=ii*m+j+n*m;
				int cost=0;
				if(a[i][j]==a[ii][j])
					cost=a[i][j];
				cost-=ii-i-1;
				Add_Edge(from,to,1,-cost);
			}
			for(int jj=j+1;jj<m;jj++)
			{
				int to=i*m+jj+n*m;
				int cost=0;
				if(a[i][j]==a[i][jj])
					cost=a[i][j];
				cost-=jj-j-1;
				Add_Edge(from,to,1,-cost);
			}
		}
	}
	int C,F;
	F=MinCostMaxFlow(source,sink,C);
	C=-C;
	if(F!=n*m) C=-1;
	printf("Case %d : %d\n",cas++,C);
}
	return 0;
}