Description

長者對小明施加了膜法，使得小明每天起床就像馬丁的早晨一樣。 今天小明早上醒來發現自己成了一位倉管員。倉庫可以被描述為一個n?×?m的網格，在每個網格上有幾個箱子（可能沒有）。為了防止傾倒，每個網格上，箱子不應該堆放超過h個。為了滿足要求，小明需要搬一些箱子，每一次，他可以把箱子從一個網格到相鄰的網格（如果兩個網格共享一條邊）。 請計算為了滿足要求，小明至少需要搬多少次。

Input

第一行一個整數T，表示有T組測試數據。 接下來每組數據，第一行有3個整數n,?m,?h(1?≤?n,?m,?h?≤?50), 分別表示倉庫的大小為n?×?m，h意義見描述。 接下來n行，每行包含m個整數A

Output

輸出小明至少需要搬多少次。

Sample Input

1
2 3 5
1 2 9
6 5 4

Sample Output

5


題解:
建立超級源點S，S對每個方格連費用為0，容量為方格箱子個數的邊。
每個方格對其四周的所有方格連容量為正無窮，費用為1的邊。
然後建立超級匯點T，限制每個方格都只能堆放h個盒子，所有方格對T連費用為0，容量為h的邊.

#include <iostream>
#include <algorithm>
#include 
 
<stdio.h>
#include <string.h>
#include <queue>
using namespace std;

int mp[100][100];
int dir[][2] = {{1,0},{0,1},{-1,0},{0,-1}};
const int INF = 999999999;
const int N = 3000;
const int M = 6000000;
struct Edge{
    int u,v,cap,cost,next;
}edge[M];
int head[N],tot,low[N],pre[N];
int total;
bool vis[N];
 
void addEdge(int u,int v,int cap,int cost,int &k){
    edge[k].u=u,edge[k].v=v,edge[k].cap = cap,edge[k].cost = cost,edge[k].next = head[u],head[u] = k++;
    edge[k].u=v,edge[k].v=u,edge[k].cap = 0,edge[k].cost = -cost,edge[k].next = head[v],head[v] = k++;
}
void init(){
    memset(head,-1,sizeof(head));
    tot = 0;
}
bool spfa(int s,int t,int n){
    memset(vis,false,sizeof(vis));
    for(int i=0;i<=n;i++){
        low[i] = (i==s)?0:INF;
        pre[i] = -1;
    }
    queue<int> q;
    q.push(s);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = false;
        for(int k=head[u];k!=-1;k=edge[k].next){
            int v = edge[k].v;
            if(edge[k].cap>0&&low[v]>low[u]+edge[k].cost){
                low[v] = low[u] + edge[k].cost;
                pre[v] = k; ///v為終點對應的邊
                if(!vis[v]){
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t]==-1) return false;
    return true;
}
int MCMF(int s,int t,int n){
    int mincost = 0,minflow,flow=0;
     while(spfa(s,t,n))
    {
        minflow=INF+1;
        for(int i=pre[t];i!=-1;i=pre[edge[i].u])
            minflow=min(minflow,edge[i].cap);
        flow+=minflow;
        for(int i=pre[t];i!=-1;i=pre[edge[i].u])
        {
            edge[i].cap-=minflow;
            edge[i^1].cap+=minflow;
        }
        mincost+=low[t]*minflow;
    }
    total=flow;
    return mincost;
}
int main()
{
    int n,m,h,tcase;
    scanf("%d",&tcase);
    while(tcase--){
        scanf("%d%d%d",&n,&m,&h);
        init();
        memset(mp,0,sizeof(mp));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                scanf("%d",&mp[i][j]);
            }
        }
        int s = 0,t = n*m+5;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(mp[i][j]!=0) addEdge(s,(i-1)*n+j,mp[i][j],0,tot);
                addEdge((i-1)*n+j,t,h,0,tot);
                for(int k=0;k<4;k++){
                    int nexti = i+dir[k][0];
                    int nextj = j+dir[k][1];
                    if(nexti>=1&&nexti<=n&&nextj>=1&&nextj<=m){
                       //printf("%d %d %d\n",nexti,nextj,(nexti-1)*n+nextj);
                        addEdge((i-1)*n+j,(nexti-1)*n+nextj,INF,1,tot);
                    }
                }
            }
        }
        int mincost = MCMF(s,t,n*m+5);
        cout<<mincost<<endl;
    }
    return 0;
}

CSU 1948: 超級管理員(費用流)