【bzoj1066】[SCOI2007]蜥蜴

Description

在一个r行c列的网格地图中有一些高度不同的石柱，一些石柱上站着一些蜥蜴，你的任务是让尽量多的蜥蜴逃到边界外。每行每列中相邻石柱的距离为1，蜥蜴的跳跃距离是d，即蜥蜴可以跳到平面距离不超过d的任何一个石柱上。石柱都不稳定，每次当蜥蜴跳跃时，所离开的石柱高度减1（如果仍然落在地图内部，则到达的石柱高度不变），如果该石柱原来高度为1，则蜥蜴离开后消失。以后其他蜥蜴不能落脚。任何时刻不能有两只蜥蜴在同一个石柱上。

Input

输入第一行为三个整数r，c，d，即地图的规模与最大跳跃距离。以下r行为石竹的初始状态，0表示没有石柱，1~3表示石柱的初始高度。以下r行为蜥蜴位置，“L”表示蜥蜴，“.”表示没有蜥蜴。

Output

输出仅一行，包含一个整数，即无法逃离的蜥蜴总数的最小值。

Sample Input

5 8 2
00000000
02000000
00321100
02000000
00000000
……..
……..
..LLLL..
……..
……..

Sample Output

HINT

100%的数据满足：1<=r, c<=20, 1<=d<=3

代码

对于每根石柱，采取一分为二的想法，即把一个点分为两个点（可抽象为石柱底部到顶部），其连线容量限制为石柱高度。

超级源与所有有蜥蜴的点相连，容量为1。

超级汇与地图内所有能跳出的点的底端相连，容量为INF。

对于地图内任意两个石柱，如果间距小于d，就将其中一根石柱的底部与另一根石柱的顶部相连，其连线容量为INF。

构图完成，剩下就是跑一遍最大流，然后用蜥蜴数量减去最大流就是最终结果。

#include <cstdio>

#include <cmath>

#include <cstring>

#include <ctime>

#include <iostream>

#include <algorithm>

#include <set>

#include <vector>

#include <queue>

#include <typeinfo>

#include <map>

#include <stack>

typedef long long ll;

using namespace std;

inline ll read()

{

    ll x=,f=;

    char ch=getchar();

    while(ch<''||ch>'')

    {

        if(ch=='-')f=-;

        ch=getchar();

    }

    while(ch>=''&&ch<='')

    {

        x=x*+ch-'';

        ch=getchar();

    }

    return x*f;

}

//***************************

namespace NetFlow

{

const int MAXN=,MAXM=,inf=1e9;

struct Edge

{

    int v,c,f,nx;

    Edge() {}

    Edge(int v,int c,int f,int nx):v(v),c(c),f(f),nx(nx) {}

} E[MAXM];

int G[MAXN],cur[MAXN],pre[MAXN],dis[MAXN],gap[MAXN],N,sz;

void init(int _n)

{

    N=_n,sz=;

    memset(G,-,sizeof(G[])*N);

}

void link(int u,int v,int c)

{

    E[sz]=Edge(v,c,,G[u]);

    G[u]=sz++;

    E[sz]=Edge(u,,,G[v]);

    G[v]=sz++;

}

int ISAP(int S,int T)

{

    //S -> T

    int maxflow=,aug=inf,flag=false,u,v;

    for (int i=; i<N; ++i)cur[i]=G[i],gap[i]=dis[i]=;

    for (gap[S]=N,u=pre[S]=S; dis[S]<N; flag=false)

    {

        for (int &it=cur[u]; ~it; it=E[it].nx)

        {

            if (E[it].c>E[it].f&&dis[u]==dis[v=E[it].v]+)

            {

                if (aug>E[it].c-E[it].f) aug=E[it].c-E[it].f;

                pre[v]=u,u=v;

                flag=true;

                if (u==T)

                {

                    for (maxflow+=aug; u!=S;)

                    {

                        E[cur[u=pre[u]]].f+=aug;

                        E[cur[u]^].f-=aug;

                    }

                    aug=inf;

                }

                break;

            }

        }

        if (flag) continue;

        int mx=N;

        for (int it=G[u]; ~it; it=E[it].nx)

        {

            if (E[it].c>E[it].f&&dis[E[it].v]<mx)

            {

                mx=dis[E[it].v];

                cur[u]=it;

            }

        }

        if ((--gap[dis[u]])==) break;

        ++gap[dis[u]=mx+];

        u=pre[u];

    }

    return maxflow;

}

bool bfs(int S,int T)

{

    static int Q[MAXN];

    memset(dis,-,sizeof(dis[])*N);

    dis[S]=;

    Q[]=S;

    for (int h=,t=,u,v,it; h<t; ++h)

    {

        for (u=Q[h],it=G[u]; ~it; it=E[it].nx)

        {

            if (dis[v=E[it].v]==-&&E[it].c>E[it].f)

            {

                dis[v]=dis[u]+;

                Q[t++]=v;

            }

        }

    }

    return dis[T]!=-;

}

int dfs(int u,int T,int low)

{

    if (u==T) return low;

    int ret=,tmp,v;

    for (int &it=cur[u]; ~it&&ret<low; it=E[it].nx)

    {

        if (dis[v=E[it].v]==dis[u]+&&E[it].c>E[it].f)

        {

            if (tmp=dfs(v,T,min(low-ret,E[it].c-E[it].f)))

            {

                ret+=tmp;

                E[it].f+=tmp;

                E[it^].f-=tmp;

            }

        }

    }

    if (!ret) dis[u]=-;

    return ret;

}

int dinic(int S,int T)

{

    int maxflow=,tmp;

    while (bfs(S,T))

    {

        memcpy(cur,G,sizeof(G[])*N);

        while (tmp=dfs(S,T,inf)) maxflow+=tmp;

    }

    return maxflow;

}

}

using namespace NetFlow;

double dist(int a,int b,int x,int y)

{

    return sqrt((b-y)*(b-y)+(a-x)*(a-x));

}

int  main()

{

    int n,m,d;

    char mp[][],mp2[][];

    cin>>n>>m>>d;

    init();

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

    {

        scanf("%s",mp[i]+);

    }

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

    {

        scanf("%s",mp2[i]+);

    }

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

    {

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

        {

            if((mp[i][j]-'')>)

            {

                for(int h=i-d; h<=i+d; h++)

                {

                    for(int k=j-d; k<=j+d; k++)

                    {

                        if(h==i&&j==k)continue;

                        if(h<||k<||h>n+||k>m+)

                            continue;

                        double dd=d*1.0;

                        if(dist(i,j,h,k)>dd)continue;

                        if(h==||k==||h==n+||k==m+)

                            link((i-)*m+j+,,inf);

                        else  link((i-)*m+j+,(h-)*m+k,inf);

                    }

                }

                link((i-)*m+j,(i-)*m+j+,mp[i][j]-'');

            }

        }

    }

    int sum=;

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

    {

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

        {

            if(mp2[i][j]=='L')

            {

                sum++;

                link(,(i-)*m+j,);

            }

        }

    }

    cout<<sum-dinic(,)<<endl;

    return ;

}

补：

#include<bits/stdc++.h>

using namespace std;

#pragma comment(linker, "/STACK:102400000,102400000")

#define ls i<<1

#define rs ls | 1

#define mid ((ll+rr)>>1)

#define pii pair<int,int>

#define MP make_pair

typedef long long LL;

const long long INF = 1e18+1LL;

const double Pi = acos(-1.0);

const int N = 1e3+, M = 1e3+, mod = 1e9+, inf = 2e9;

char s[];

int head[N],S,T,r,c,d,t=,h[N],height[][],q[N],ans;

struct edge{int to,next,v;}e[N*N];

void adds(int u,int v,int w) {e[t].next=head[u];e[t].to=v;e[t].v=w;head[u]=t++;}

void add(int u,int v,int w) {adds(u,v,w);adds(v,u,);}

bool bfs() {

    memset(h,-,sizeof(h));

    int l = , r = ,now;

    q[l] = S;

    h[S] = ;

    while(l!=r) {

        now=q[l++];if(l == ) l=;

        for(int i=head[now];i;i=e[i].next) {

            if(e[i].v&&h[e[i].to]==-) {

                h[e[i].to] = h[now] + ;

                q[r++]=e[i].to;

                if(r == ) r = ;

            }

        }

    }

    if(h[T] == -) return ;

    return ;

}

int dfs(int x,int f) {

    if(x == T) return f;

    int used=,w;

    for(int i=head[x];i;i=e[i].next) {

        if(e[i].v&&h[e[i].to] == h[x]+) {

            w = dfs(e[i].to,min(f-used,e[i].v));

            used+=w;e[i].v-=w;e[i^].v+=w;

            if(used == f) return f;

        }

    }

    return used;

}

void dinic() {while(bfs()) ans+=dfs(S,inf);}

double dis(int i,int j,int k,int h) {return sqrt(1.0*(i-k)*(i-k) + 1.0*(j-h)*(j-h));}

int main() {

    scanf("%d%d%d",&r,&c,&d);

    S=*r*c,T=S+;

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

    {

        scanf("%s",s+);

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

        {

            height[i][j] = s[j]-'';

            add((i-)*c+j,(i-)*c+j+r*c,height[i][j]);

            if(i-d<=||j-d<=||i+d>r||j+d>c)

            {

                add((i-)*c+j+r*c,T,inf);

            }

        }

    }

    int sum = ;

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

    {

        scanf("%s",s+);

        for(int j = ; j <= c; ++j) {

            if(s[j] == 'L')

            {

                sum++;

                add(S,(i-)*c+j,);

            }

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

            for(int h = ; h <= c; ++h) {

                if((k!=i||j!=h) && dis(i,j,k,h) <= 1.0*d)

                {

                    add((i-)*c+j+r*c,(k-)*c+h,inf);

                }

            }

        }

    }

    dinic();

    printf("%d\n",sum-ans);

    //cout<<sum-ans<<endl;

    return ;

}

dinic