BZOJ 3144: [Hnoi2013]切糕题解

本文链接：https://blog.csdn.net/NOIAu/article/details/74516444

3144: [Hnoi2013]切糕

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 1936 Solved: 1049

Description

这里写图片描述

Input

第一行是三个正整数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。

Output

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

Sample Input

2 2 2

6 1

2 6

Sample Output

HINT

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

这道题显然是一个网络流，我们如果不考虑每次要切的相邻的范围的地方的话，直接从每一竖列的下一层往上一层连边，大概是这么个效果

这里写图片描述
对于切糕中的点，我们以虚线的所示方法连边，然后两边以INF的边连S和T，显然跑一边最小割就可以了，然而现在我们还要解决每次切的相邻的范围在d之内…这个对于我这个垃圾来说…简直是难题！…然后我们可以这样连
这里写图片描述
我们从上往下，建INF的边，具体操作是如果可以就向周围的下面的竖直坐标相差为d的点建边，这样一来为什么就可以保证割的边在范围之内呢？我们看上面的图，箭头为正向边的方向，假如图中的A部分被我们割掉了，现在如何才能保证左侧割掉的边一定在左侧的D区域呢？首先我们感性认知一下，现在还存在的路是C-D-B中间进过两条INF的边，还有一条路可以增广，也就是F-D-E这条路，D同时在这两条路里，如果只割一次，那么只能割D

下一步我们看来思考为什么在两条路中各割一条会比在D中割一条不优…可能是我太智障了，我思考这个图思考了好久233，其实道理很简单啊，观察这张图，如果我们割掉三条长度为1的边，我们能把图增广完嘛？明显不是最小割嘛，割都没割，这里还有一条路嘛

这里写图片描述

也就是说，你割外面的边而不割蓝色部分的边，你割都没割到要点，反而多花费了，并且还是有路（并且改路的最大流没有减少）可以通过去，也就是说图上还有一条经过蓝色边的路径可以被割，并且在你割不在蓝色路径上的边之后并没有对这条还可以增广的路造成影响
233
233
233
我真蠢

#include<cstdio>
#include<cstring>
#include<iostream>
#define INF 100000000
using namespace std;
int readin(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int directionx[4]={0,0,1,-1},directiony[4]={1,-1,0,0};
int p,q,r,d,T;
int val[45][45][45];
int cur[100005],head[100005],level[100005],qq[100005];
int cal_loc(int x,int y,int z){if(z==0) return 0;return p*q*(z-1)+(x-1)*q+y;}
int tail=1;
struct Line{int to,nxt,flow;}line[100005*2];
void add_line(int a,int b,int w){
    tail++;line[tail].to=b;line[tail].flow=w;line[tail].nxt=head[a];head[a]=tail;
    tail++;line[tail].to=a;line[tail].flow=0;line[tail].nxt=head[b];head[b]=tail;
}
//长p、宽q、高r   
void build(){
    for(register int i=1;i<=p;i++){
        for(register int j=1;j<=q;j++){
            for(register int k=1;k<=r;k++){
                add_line(cal_loc(i,j,k-1),cal_loc(i,j,k),val[i][j][k]);
                if(k>d){
                    for(register int ii=0;ii<=3;ii++){
                        int tempx=i+directionx[ii];int tempy=j+directiony[ii];
                        if(tempx<1||tempy<1||tempx>p||tempy>q) continue;
                        add_line(cal_loc(i,j,k),cal_loc(tempx,tempy,k-d),INF);
                    }
                }
            }
            add_line(cal_loc(i,j,r),T,INF);
        }
    }
}
bool bfs(){
    memset(level,-1,sizeof(level));
    level[0]=0;
    qq[0]=0;
    int h=0,t=1;
    while(h!=t){
        int u=qq[h];h++;
        for(register int i=head[u];i;i=line[i].nxt){
            int v=line[i].to;
            if(level[v]==-1&&line[i].flow){
                level[v]=level[u]+1;
                qq[t++]=v;
            }
        }
    }
    if(level[T]==-1) return false;
    return true;
}
int dfs(int u,int maxflow){
    if(u==T) return maxflow;
    int used=0;
    for(register int i=cur[u];i;i=line[i].nxt){
        int v=line[i].to;
        if(level[u]+1==level[v]){
            int flow=dfs(v,min(maxflow-used,line[i].flow));
            used+=flow;
            line[i].flow-=flow;
            line[i^1].flow+=flow;
            if(line[i].flow) cur[u]=i;
            if(used==maxflow)return maxflow;
        }
    }
    if(used==0) level[u]=-1;
    return used;
}
int dinic(){
    int ans=0;
    while(bfs()){
        for(register int i=0;i<=T;i++) cur[i]=head[i];
        ans+=dfs(0,INF);
    }
    return ans;
}
int main(){
    scanf("%d%d%d%d",&p,&q,&r,&d);T=p*q*r+1;
    for(register int i=1;i<=r;i++){
        for(register int j=1;j<=p;j++){
            for(register int k=1;k<=q;k++){
                scanf("%d",&val[j][k][i]);
            }
        }
    }
    build();
    printf("%d\n",dinic());
}