FZU 2143 Board Game

Board Game

Accept: 95    Submit: 246
Time Limit: 1000 mSec    Memory Limit : 32768 KB

 Problem Description

Fat brother and Maze are playing a kind of special (hentai) game on an N*M board (N rows, M columns). At the beginning, each grid of the board which is own by Fat brother is consisting of an integer 0. At each turn, he can choose two adjacent grids and add both the integer inside them by 1. But due to some unknown reason, the number of each grid can not be large than a given integer K. Also, Maze has already drown an N*M board with N*M integers inside each grid. What Fat brother would like to do is adding his board to be as same as Maze’s. Now we define the different value of two boards A and B as:

Now your task is to help Fat brother the minimal value of S he can get.

 Input

The first line of the date is an integer T, which is the number of the text cases.

Then T cases follow, each case contains three integers N, M and K which are mention above. Then N lines with M integers describe the board.

1 <= T <= 100, 1 <= N, M, K <= 9

0 <= the integers in the given board <= 9

 Output

For each case, output the case number first, then output the minimal value of S Fat brother can get.

 Sample Input

5
2 2 9
3 4
2 3
1 3 9
4 6 4
1 1 9
9
3 3 5
1 2 3
4 5 6
7 8 9
3 3 9
1 2 3
4 5 6
7 8 9

 Sample Output

Case 1: 0
Case 2: 2
Case 3: 81
Case 4: 33
Case 5: 5

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;

 const int E = ;
 const int oo = 0x7fffffff;
 const int inf = ;
 const int maxn = ;

 struct edge
 {
     int next,v,flow,cost;
 } e[E];

 struct MCMF
 {
     int head[maxn];
     queue<int> q;
     int cnt, S, T;
     void init(int __S,int __T)
     {
         S = __S;
         T = __T;
         memset(head,-,sizeof(head));
         cnt = ;
     }
     void add(int u,int v,int flow,int cost)
     {
         e[cnt].v = v;
         e[cnt].flow = flow;
         e[cnt].cost = cost;
         e[cnt].next = head[u];
         head[u] = cnt ++;
     }

     void AddEdge(int u,int v,int flow,int cost)
     {
         add(u,v,flow,cost);
         add(v,u,, -cost);
     }

     int dis[maxn],cc[maxn],visit[maxn],pre[maxn],dd[maxn];

     int spfa()
     {
         fill(dis,dis + T + , oo);
         dis[S] = ;
         pre[S] = -;
         q.push(S);
         while(!q.empty())
         {
             int u = q.front();
             q.pop();
             visit[u] = ;
             for(int i = head[u]; i != -; i = e[i].next)
             {
                 if(e[i].flow >  && dis[e[i].v] > dis[u] + e[i].cost)
                 {
                     dis[e[i].v] = dis[u] + e[i].cost;
                     pre[e[i].v] = u;
                     cc[e[i].v] = i;
                     dd[e[i].v] = e[i].cost;
                     if(!visit[e[i].v])
                     {
                         q.push(e[i].v);
                         visit[e[i].v] = ;
                     }
                 }
             }
         }
         return dis[T] < ;
     }

     int argument()
     {
         int aug = oo;
         int u,v;
         int ans = ;
         for(u = pre[v = T]; v != S; v = u, u = pre[v])
             if(e[cc[v]].flow < aug) aug = e[cc[v]].flow;
         for(u = pre[v = T]; v != S; v = u, u = pre[v])
         {
             e[cc[v]].flow -= aug;
             e[cc[v] ^ ].flow += aug;
             ans += dd[v] * aug;
         }
         return ans;
     }

     int mcmf()
     {
         int res = ;
         memset(visit,,sizeof(visit));
         while(spfa()) res += argument();
         return res;
     }
 } MC;

 int N,M,K;
 int b[][];

 int main()
 {
     int cas, cast = ;
     scanf("%d",&cas);
     while (cas--)
     {
         scanf("%d%d%d",&N,&M,&K);
         for (int i=;i<=N;i++)
         {
             for (int j=;j<=M;j++)
             {
                 scanf("%d",&b[i][j]);
             }
         }

         int nn = N * M + , s = , t = N*M + ;
         MC.init(s,t);
         int ans = ;
         for (int i=;i<=N;i++)
         for (int j=;j<=M;j++)
         {
             ans += b[i][j] * b[i][j];
             int p = i*M - M + j;
             if ((i+j)%==){
                 for (int k=;k<=K;k++)
                 {
                     int tmp =  * k -  -  * b[i][j];
                     MC.AddEdge(s,p, ,tmp);
                 }
                 int pp = ;
                 if (i<N)
                 {
                     pp = p + M;
                     MC.AddEdge(p,pp,inf,);
                 }
                 if (i>)
                 {
                     pp = p - M;
                     MC.AddEdge(p,pp,inf,);
                 }
                 if (j<M)
                 {
                     pp = p + ;
                     MC.AddEdge(p,pp,inf,);
                 }
                 if (j>)
                 {
                     pp = p - ;
                     MC.AddEdge(p,pp,inf,);
                 }
             }else{
                 for (int k=;k<=K;k++)
                 {
                     int tmp =  * k -  -  * b[i][j];
                     MC.AddEdge(p,t, ,tmp);
                 }
             }
         }
       //  MC.AddEdge(s,t,INF,0);
         printf("Case %d: %d\n",++cast, ans + MC.mcmf());
     }
     return ;
 }