P3227 [HNOI2013]切糕

题目描述

经过千辛万苦小 A 得到了一块切糕，切糕的形状是长方体，小 A 打算拦腰将切糕切成两半分给小 B。出于美观考虑，小 A 希望切面能尽量光滑且和谐。于是她找到你，希望你能帮她找出最好的切割方案。

出于简便考虑，我们将切糕视作一个长 P、宽 Q、高 R 的长方体点阵。我们将位于第 z层中第 x 行、第 y 列上(1≤x≤P, 1≤y≤Q, 1≤z≤R)的点称为(x,y,z)，它有一个非负的不和谐值 v(x,y,z)。一个合法的切面满足以下两个条件：

与每个纵轴(一共有 P*Q 个纵轴)有且仅有一个交点。即切面是一个函数 f(x,y)，对于所有 1≤x≤P, 1≤y≤Q,我们需指定一个切割点 f(x,y),且 1≤f(x,y)≤R。
切面需要满足一定的光滑性要求，即相邻纵轴上的切割点不能相距太远。对于所有的 1≤x,x’≤P 和 1≤y,y’≤Q，若|x-x’|+|y-y’|=1，则|f(x,y)-f(x’,y’)| ≤D，其中 D 是给定的一个非负整数。可能有许多切面f 满足上面的条件，小A 希望找出总的切割点上的不和谐值最小的那个。

输入输出格式

输入格式：

第一行是三个正整数P,Q,R，表示切糕的长P、宽Q、高R。第二行有一个非负整数D，表示光滑性要求。接下来是R个P行Q列的矩阵，第z个矩阵的第x行第y列是v(x,y,z) (1<=x<=P, 1<=y<=Q, 1<=z<=R)。 100%的数据满足P,Q,R<=40，0<=D<=R，且给出的所有的不和谐值不超过1000。

输出格式：

仅包含一个整数，表示在合法基础上最小的总不和谐值。

输入输出样例

输入样例#1：

输出样例#1：

说明

最佳切面的f为f(1,1)=f(2,1)=2,f(1,2)=f(2,2)=1

我们将点转化成边，那么选点就等于割边，第一个条件满足

对于第二个条件我们可以用一些inf的边来"屏蔽"那些不能割的边，从z向"相邻的"路径的z-d号点连inf的边（如上图）这样做之后，如果删了这条边，我们还可以通过这些桥梁，从相邻的路径的一段[z-d,z+d]绕过，所以割那些边就没有意义了

从而实现必须割[z-d,z+d]的目的

来源：洛谷题解

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<cmath>

 #include<queue>

 using namespace std;

 const int MAXN=;

 const int INF = 1e8;

 inline void read(int &n)

 {

     char c='+';int x=;bool flag=;

     while(c<''||c>''){c=getchar();if(c=='-')flag=;}

     while(c>=''&&c<=''){x=x*+c-;c=getchar();}

     n=flag==?-x:x;

 }

 int n,m,s,t;

 struct node

 {

     int u,v,flow,nxt;

 }edge[MAXN];

 int head[MAXN];

 int cur[MAXN];

 int num=;

 int deep[MAXN];

 int tot=;

 void add_edge(int x,int y,int z)

 {

     edge[num].u=x;

     edge[num].v=y;

     edge[num].flow=z;

     edge[num].nxt=head[x];

     head[x]=num++;

 }

 void add(int x,int y,int z)

 {

     add_edge(x,y,z);

     add_edge(y,x,);

 }

 bool BFS()

 {

     memset(deep,,sizeof(deep));

     deep[s]=;

     queue<int>q;

     q.push(s);

     while(q.size()!=)

     {

         int p=q.front();

         q.pop();

         for(int i=head[p];i!=-;i=edge[i].nxt)

             if(!deep[edge[i].v]&&edge[i].flow)

                 deep[edge[i].v]=deep[edge[i].u]+,

                 q.push(edge[i].v);

     }

     return deep[t];

 }

 int DFS(int now,int nowflow)

 {

     if(now==t||nowflow<=)

         return nowflow;

     int totflow=;

     for(int &i=cur[now];i!=-;i=edge[i].nxt)

     {

         if(deep[edge[i].v]==deep[edge[i].u]+&&edge[i].flow)

         {

             int canflow=DFS(edge[i].v,min(nowflow,edge[i].flow));

             edge[i].flow-=canflow;

             edge[i^].flow+=canflow;

             totflow+=canflow;

             nowflow-=canflow;

             if(nowflow<=)

                 break;

         }

     }

     return totflow;

 }

 void Dinic()

 {

     int ans=;

     while(BFS())

     {

         memcpy(cur,head,MAXN);

         ans+=DFS(s,1e8);

     }

     printf("%d",ans);

 }

 int a[][][];

 int cnt=;

 int xx[]={-,+,,};

 int yy[]={,,-,+};

 int main()

 {

     memset(head,-,sizeof(head));

     int P,Q,R,D;

     read(P);read(Q);read(R);read(D);

     for(int i=;i<=R+;i++)

         for(int j=;j<=P;j++)

             for(int k=;k<=Q;k++)

                 a[i][j][k]=++cnt;

     s=;t=cnt+;

     for(int i=;i<=P;i++)

         for(int j=;j<=Q;j++)

         {

             add(s,a[][i][j],INF);

             add(a[R+][i][j],t,INF);//上下界

         }

     for(int i=;i<=R;i++)

         for(int j=;j<=P;j++)

             for(int k=;k<=Q;k++)

             {

                 int p;read(p);

                 add(a[i][j][k],a[i+][j][k],p);

             }// 连边

     for(int i=D+;i<=R;i++)

         for(int j=;j<=P;j++)

             for(int k=;k<=Q;k++)

                 for(int m=;m<;m++)

                     if(a[i-D][j+xx[m]][k+yy[m]]>)

                         add(a[i][j][k],a[i-D][j+xx[m]][k+yy[m]],INF);

     //for(int i=1;i<=num-1;i++)

     //printf("%d %d %d\n",edge[i].u,edge[i].v,edge[i].flow);

     Dinic();

     return  ;

 }