HIT 2715

题目链接：http://acm.hit.edu.cn/hoj/problem/view?id=2715

Time limit : 5 sec Memory limit : 64 M

Zhouguyue is a "驴友" and nowadays he likes traveling on an N * N matrix with a non-negative number in each grid, and each grid has a height. Zhouguyue starts his matrix travel with POINT = 0. For each travel, zhouguyue can land on any grid he wants with the help of bin3's helicopter, and then he can only move to ajacent grids whose height is less than his current height. Notice that when he is at the side of the matrix, he can also move out of the matrix. After he moves out of the matrix, he completes one travel. He adds the number in each grid he visited to POINT, and replaces it with zero. Now zhouguyue is wondering what is the maximum POINT he can obtain after he travels at most K times. Note the POINT is accumulative during the travels.

Input

The first line is a integer T indicating the number of test cases.T cases fllows. The first line of each case contains two integers N and K (1 ≤ N ≤ 50, 0 ≤ K ≤ 50) described above. The following N lines represents the matrix. You can assume the numbers in the matrix are non-negative integers and no more than 10000. The following N lines represents the height of each grid. The heghts are also non-negative integers.

Output

The maximum POINT zhouguyue can obtain after he travels at most K times.

Sample Input

1
3 2
1 2 3
3 2 1
2 4 2

3 5 3
2 1 0
1 2 3

Sample Output

17

题意：

一个 N*N 的网格，每个单元都有一个数字number[i][j]，和一个高度height[i][j]。

现在 ZhouGuyue 要作至多 K 次旅行，每次旅行如下：

他可以借助 bin3 的直升机飞到 任意一个单元格，之后他每次只能向相邻的且高度比当前所在格子低的格子移动。

当他移动到一个边界的格子上时，他可以跳出这个网格并完成一次旅行。

旅行开始前，他有一个POINT，初始值为0；旅行途中，所到的每一格的number[i][j]可以加到他的POINT里，一旦加上，格子里number[i][j]就变成0。

问POINT最大有多大。（1 <= N <= 50, 0 <= K <= 50, 0 <= Vi <= 10000）

解题思路：

本题属于最大费用最大流问题，对cost取负后转变成为最小费用最大流问题，构图完成后可以直接上模板，最后求出mincost再取个负即为答案。

构图：

将每个格子 i 进行拆点，并加边(i’, i’’, 1,  -number[i]), (i’, i’’, ∞, 0), (s, i’, ∞, 0)；（分别对应from,to,cap,cost）

　　这代表，他走第一次，可以走(i’, i’’, 1,  -number[i])，由于算法保证最小费用，他也只会先走(i’, i’’, 1,  -number[i])；

　　走过这个格子，可以得到number，然后后面虽然可以继续走这个格子，但只能通过(i’, i’’, ∞, 0)这条边走，就得不到number；

　　另外，由于他可以从任意格子出发，故要建立超级源点s，连接每个格子。

对相邻的四个格子 j，若 Hi > Hj 则加边(i’’, j’, ∞, 0)；

　　这条边很简单，代表可以同行，并且想走多少次都可以。

若格子 i在边界上则加边(i’’, t, ∞, 0)；

　　代表走到边界，可以直接结束本次旅行，由于边界上有许多格子，故也要建立超级汇点。

限制增广次数小于等于 K 。

　　有增广一次可以看做沿某个路线走了一遍，并且获得了沿途的每个格子的number，增广次数不超过K，即代表旅行次数最多为K。

注意要点：

HIT的OJ可能卡STL，使用vector做邻接表超时（然后就只好自己写数组模拟邻接表呗，不过改一下也挺快，没啥问题）；

如果使用的是刘汝佳书上的MCMF模板，while(spfa())语句增加限制次数K要注意写法，我就是没考虑到K==0的情况，刚开始写挫了，WA了一发；

代码：

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#define MAXN 2*53*53
#define MAXM 8*MAXN
#define INF 0x3f3f3f3f
#define in(x) x
#define out(x) x+n
using namespace std; 
int n,N,K;
struct Edge{
    int u,v,c,f,a;
};
struct MCMF
{
    int s,t,ne;
    Edge E[MAXM];
    int head[MAXN],next[MAXM];
    int vis[MAXN];
    int d[MAXN];
    int pre[MAXN];
    int aug[MAXN];
    void init()
    {
        ne=0;
        memset(head,-1,sizeof(head));
    }
    void addedge(int from,int to,int cap,int cost)
    {
        E[ne].u=from, E[ne].v=to, E[ne].c=cap, E[ne].f=0, E[ne].a=cost;
        next[ne]=head[from]; head[from]=ne++;
        E[ne].u=to, E[ne].v=from, E[ne].c=0, E[ne].f=0, E[ne].a=-cost;
        next[ne]=head[to]; head[to]=ne++;
    }
    bool SPFA(int s,int t,int &flow,int &cost)
    {
        memset(d,INF,sizeof(d));
        memset(vis,0,sizeof(vis));
        d[s]=0, vis[s]=1, pre[s]=0, aug[s]=INF;
        queue<int> q;
        q.push(s);
        while(!q.empty())
        {
            int now=q.front(); q.pop();
            vis[now]=0;
            for(int i=head[now];i!=-1;i=next[i])
            {
                Edge& e=E[i];
                int nex=e.v;
                if(e.c>e.f && d[nex]>d[now]+e.a)
                {
                    d[nex]=d[now]+e.a;
                    pre[nex]=i;
                    aug[nex]=min(aug[now],e.c-e.f);
                    if(!vis[nex])
                    {
                        q.push(nex);
                        vis[nex]=1;
                    }
                }
            }
        }
        if(d[t]==INF) return 0;
        flow+=aug[t];
        cost+=d[t]*aug[t];
        for(int i=t;i!=s;i=E[pre[i]].u)
        {
            E[pre[i]].f+=aug[t];
            E[pre[i]^1].f-=aug[t];
        }
        return 1;
    }
    int mincost()
    {
        int flow=0,cost=0,cnt=0;
        while(cnt<K && SPFA(s,t,flow,cost)) cnt++;
        return cost;
    }
}mcmf;

int number[53][53],height[53][53];
int d[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
int inmap(int i,int j)
{
    if(1<=i && i<=N && 1<=j && j<=N) return (i-1)*N+j;
    else return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&N,&K);
        for(int i=1;i<=N;i++) for(int j=1;j<=N;j++) scanf("%d",&number[i][j]);
        for(int i=1;i<=N;i++) for(int j=1;j<=N;j++) scanf("%d",&height[i][j]);
        n=N*N;
        mcmf.init();
        mcmf.s=0, mcmf.t=2*n+1;
        for(int i=1;i<=N;i++)
        {
            for(int j=1;j<=N;j++)
            {
                int id=(i-1)*N+j;
                mcmf.addedge(mcmf.s,in(id),INF,0);
                mcmf.addedge(in(id),out(id),1,-number[i][j]);
                mcmf.addedge(in(id),out(id),INF,0);
                if(i==1 || i==N || j==1 || j==N) mcmf.addedge(out(id),mcmf.t,INF,0);
                for(int k=0;k<4;k++)
                {
                    int nex_i=i+d[k][0], nex_j=j+d[k][1],nex_id;
                    if((nex_id=inmap(nex_i,nex_j)) && height[i][j]>height[nex_i][nex_j]) mcmf.addedge(out(id),in(nex_id),INF,0);
                }
            }
        }
        printf("%d
",-mcmf.mincost());
    }
}