[BZOJ3144][HNOI2013]切糕-网络流

切糕

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
1
6 1
6 1
2 6
2 6

Sample Output

6

HINT

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

---

话说在做这道题的时候， 偶然路过的老师看到标题后，发出了奇怪的笑声……

---

思路:
哇，为什么全世界除了咱都知道这个“经典模型”啊。
描述一下这个奇妙的建模好了。

考虑使用最小割。

那么首先无视掉光滑性需求，可以得到这样的一张图:

这里咱按深度分层，如上图所示，上图从左到右分层，且每一层有p*q=2个节点。
边的流量定为不和谐度，比如从(x,y,z)处向(x,y,z+1)处连流量为v(x,y,z)的边。
于是，令割掉一条边为选中它的不和谐度，咱要求的就是此图的最小割。

那么现在考虑如何使不和谐度被考虑到:
把图变成这样即可:

考虑割掉那条奇妙的红色边，可以发现在这之后割掉那条原谅色绿色的边并没有什么用。
此时，只有割那个原谅色的点前面的边才会有效，这就相当于限制了高度。
考虑再从反方向+d处连回来一条边，连向红色边的另一头。
这么做相当于彻底锁死高度，从+d处往上的边割掉后将会和上图中的-d点往下的边(原谅色边)一样，变得并无作用。
然后就直接跑网络流就好了~

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

const int K=49;
const int N=1e5+9;
const int M=1e6+9;
const int Inf=1e9;

int p,q,r,d;

int s,t,qu[N],dis[N];
int to[M],nxt[M],cap[M],beg[N],tot=1;

inline int po(int x,int y,int z)
{
    return (x-1)*q+y+(z-1)*p*q;
}

inline void adde(int u,int v,int c)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    cap[tot]=c;
    beg[u]=tot;
}

inline void add(int u,int v,int c)
{
    adde(u,v,c);adde(v,u,0);
}

inline bool bfs()
{
    memset(dis,0,sizeof(dis));
    int ll=0,rr=1;
    qu[1]=s;
    dis[s]=1;

    while(ll!=rr)
    {
        int u=qu[++ll];
        for(int i=beg[u],v;i;i=nxt[i])
            if(!dis[v=to[i]] && cap[i])
            {
                dis[v]=dis[u]+1;
                qu[++rr]=v;
            }
    }
    return dis[t];
}

inline int dfs(int u,int mflow)
{
    if(u==t || !mflow)
        return mflow;
    int cost=0;
    for(int i=beg[u],v,rf;i;i=nxt[i])
        if(dis[v=to[i]]==dis[u]+1 && cap[i])
        {
            rf=dfs(v,min(cap[i],mflow-cost));
            cap[i]-=rf;
            cap[i^1]+=rf;
            cost+=rf;
            if(mflow==cost)break;
        }
    if(cost==0)
        dis[u]=-1;
    return cost;
}

inline int dinic()
{
    int ret=0;
    while(bfs())
        ret+=dfs(s,Inf);
    return ret;
}

int main()
{
    p=read();q=read();
    r=read();d=read();
    s=p*q*r+1,t=s+1;
    for(int k=1;k<=r;k++)
        for(int i=1;i<=p;i++)
            for(int j=1,f;j<=q;j++)
            {
                f=read();
                if(k!=r)
                    add(po(i,j,k),po(i,j,k+1),f);
                else
                    add(po(i,j,k),t,f);
                if(i!=1)
                    add(po(i,j,k),po(i-1,j,k-d),Inf);
                if(i!=p)
                    add(po(i,j,k),po(i+1,j,k-d),Inf);
                if(j!=1)
                    add(po(i,j,k),po(i,j-1,k-d),Inf);
                if(j!=q)
                    add(po(i,j,k),po(i,j+1,k-d),Inf);
            }

    for(int i=1;i<=p;i++)
        for(int j=1;j<=q;j++)
            add(s,po(i,j,1),Inf);

    printf("%d\n",dinic());
    return 0;
}