bzoj1066题解

【解题思路】

　　考虑拆点，把每根石柱拆成两个点，具体可以理解为石柱底部和石柱顶部，能爬到石柱顶部的蜥蜴只有有限只，而且蜥蜴只有爬到了石柱顶部才能跳到其他石柱的底部。

　　这样，考虑如下建图：

　　将每个有蜥蜴的石柱底部和源点连边，容量为1；

　　将每个可以跳出边界的石柱顶部和汇点连边，容量为∞；

　　将每根石柱顶底相连，容量为该石柱最大承受蜥蜴个数；

　　将可以相互跳达的任意两根石柱顶底相连，容量为∞。

　　这样，该图的最大流即为最多可逃脱蜥蜴数，最终答案即为总蜥蜴数-最大流，复杂度o(r³c³d²)。

【参考代码】

#include <bits/stdc++.h>
#define range(i,low,high) for(register int i=(low);i<(high);++i)
#define dange(i,high,low) for(register int i=(high);i>(low);--i)
 
//#define __debug
#ifdef __debug
    #define __function__(type) type
    #define __procedure__      void
#else
    #define __function__(type) __attribute__((optimize("-O2"))) inline type
    #define __procedure__      __attribute__((optimize("-O2"))) inline void
#endif
 
using namespace std;
 
static const int N=800,M=50000,INF=0x7f7f7f7f;
static int r,c,d,cardE=0; int hed[N+5],h[25][25];
 
struct edge
{
    int fr,to,cap,nxt;
    edge(
        const int&f=0,const int&t=0,
        const int&c=0,const int&x=0
    ):fr(f),to(t),cap(c),nxt(x) {}
}edg[M<<2|3];
 
__procedure__ addedge(
    const int&fr,const int&to,const int&cp
)
{
    edg[cardE]=edge(fr,to,cp,hed[fr]),hed[fr]=cardE++;
}
__procedure__ add_edge(
    const int&fr,const int&to,const int&cp
)
{
    addedge(fr,to,cp),addedge(to,fr,0);
}
 
//SAP {
static const int S=0,T=801;
int aug[N+5],cur[N+5],dis[N+5],gap[N+5],path[N+5];
 
__function__(int) augment()
{
    for(int i=T;i!=S;i=edg[path[i]].fr)
    {
        edg[path[i]].cap-=aug[T],edg[path[i]^1].cap+=aug[T];
    }
    return aug[T];
}
 
__function__(int) SAP(const int&N)
{
    memset(aug,0,sizeof aug),memset(gap,0,sizeof gap);
    memset(dis,0,sizeof dis),aug[S]=INF,gap[0]=N; int ret=0;
    range(i,1,max(N,T)+1) cur[i]=hed[i];
    for(int fr=S;dis[S]<N;)
    {
        if(fr==T) fr=S,ret+=augment(); bool flag=1;
        for(int i=cur[fr];~i;i=edg[i].nxt)
        {
            int to=edg[i].to;
            if(edg[i].cap&&dis[fr]==dis[to]+1)
            {
                aug[to]=min(aug[fr],edg[i].cap),
                path[to]=cur[fr]=i,fr=to,flag=0; break;
            }
        }
        if(flag)
        {
            if(!--gap[dis[fr]]) break; dis[fr]=N;
            for(int i=hed[fr];~i;i=edg[i].nxt) if(edg[i].cap)
            {
                dis[fr]=min(dis[fr],dis[edg[i].to]+1);
            }
            ++gap[dis[fr]],cur[fr]=hed[fr];
            if(fr!=S) fr=edg[path[fr]].fr;
        }
    }
    return ret;
}
//} SAP
 
__function__(bool) ok(const int&x,const int&y)
{
    return x+d>=r||x<d||y+d>c||y<=d;
}
 
__function__(int) calc(const int&x,const int&y,const bool&up)
{
    return x*c+y+up*(N>>1);
}
 
int main()
{
    scanf("%d%d%d",&r,&c,&d); int cnt=0;
    memset(hed,-1,sizeof hed);
    range(i,0,r) range(j,1,c+1)
    {
        while(!isdigit(h[i][j]=getchar()));
        add_edge(calc(i,j,0),calc(i,j,1),h[i][j]-='0');
    }
    range(i,0,r) range(j,1,c+1)
    {
        char ch=getchar();
        for(;ch!='.'&&ch!='L';ch=getchar());
        if(ch=='L') add_edge(S,calc(i,j,0),1),++cnt;
    }
    range(i,0,r) range(j,1,c+1) if(ok(i,j))
    {
        add_edge(calc(i,j,1),T,INF);
    }
    range(i,0,r) range(j,1,c+1) range(k,-d,d+1)
    {
        int rest=d-abs(k);
        range(l,-rest,rest+1) if(k||l)
        {
            int x=i+k,y=j+l;
            if(x>=0&&x<r&&y>0&&y<=c&&h[i][j]&&h[x][y])
            {
                add_edge(calc(i,j,1),calc(x,y,0),INF);
            }
        }
    }
    return printf("%d
",cnt-SAP(r*c+1<<1)),0;
}