BZOJ 4242: 水壶 Kruskal+BFS

4242: 水壶

Time Limit: 40 Sec Memory Limit: 256 MB
Submit: 427 Solved: 112
[Submit][Status][Discuss]

Description

JOI君所居住的IOI市以一年四季都十分炎热著称。

IOI市是一个被分成纵H*横W块区域的长方形，每个区域都是建筑物、原野、墙壁之一。建筑物的区域有P个，编号为1...P。

JOI君只能进入建筑物与原野，而且每次只能走到相邻的区域中，且不能移动到市外。

JOI君因为各种各样的事情，必须在各个建筑物之间往返。虽然建筑物中的冷气设备非常好，但原野上的日光十分强烈，因此在原野上每走过一个区域都需要1单位的水。此外，原野上没有诸如自动售货机、饮水处之类的东西，因此IOI市的市民一般都携带水壶出行。大小为x的水壶最多可以装x单位的水，建筑物里有自来水可以将水壶装满。

由于携带大水壶是一件很困难的事情，因此JOI君决定携带尽量小的水壶移动。因此，为了随时能在建筑物之间移动，请你帮他写一个程序来计算最少需要多大的水壶。

现在给出IOI市的地图和Q个询问，第i个询问(1<=i<=Q)为“在建筑物Si和Ti之间移动，最小需要多大的水壶？”，请你对于每个询问输出对应的答案。

Input

第一行四个空格分隔的整数H,W,P,Q，表示IOI市被分成了纵H*横W块区域，有P个建筑物，Q次询问。

接下来H行，第i行(1<=i<=H)有一个长度为W的字符串，每个字符都是’.’或’#’之一，’.’表示这个位置是建筑物或原野，’#’表示这个位置是墙壁。

接下来P行描述IOI市每个建筑物的位置，第i行(1<=i<=P)有两个空格分隔的整数Ai和Bi，表示第i个建筑物的位置在第Ai行第Bi列。保证这个位置在地图中是’.’

接下来Q行，第i行(1<=i<=Q)有两个空格分隔的整数Si和Ti，表示第i个询问为“在建筑物Si和Ti之间移动，最小需要多大的水壶？”

Output

输出Q行，第i行(1<=i<=Q)一个整数，表示在建筑物Si和Ti之间移动最小需要多大的水壶。如果无法到达，输出-1。此外，如果不需要经过原野就能到达，输出0。

Sample Input

5 5 4 4
.....
..##.
.#...
..#..
.....
1 1
4 2
3 3
2 5
1 2
2 4
1 3
3 4

Sample Output

3
4
4
2

HINT

1<=H<=2000

1<=W<=2000

2<=P<=2*10^5

1<=Q<=2*10^5

1<=Ai<=H(1<=i<=P)

1<=Bi<=W(1<=i<=P)

(Ai,Bi)≠(Aj,Bj)(1<=i<j<=P)

1<=Si<Ti<=P(1<=i<=Q)

Source

JOI 2013~2014 春季training合宿竞技2 By PoPoQQQ

朴素的暴力：得到任意两点的间的最短距离，然后kruskal。因为是求最大值，所以可以直接用并查集(按秩合并)上的路径最值。树高为O(logP)。共O(P*W*H)

考虑慢慢增加每个建筑物连出去的边权，这个和Kruskal很相似。然后又一个朴素的想法，搞P个队列，同时扩展。碰到一个建筑物才停下来并不扩展这个建筑物，合并这个两个建筑物。O(P*W*H)

既然是同时扩展，那么边权肯定都一样。那么碰到一个已经被扩展的点就可以将距离加起来，用来更新当成这个两个建筑物的距离。边权都*2肯定还是满足kruskal的算法。一个点最多被碰四次。O(W*H*4)

细节:可能边权并没有*2，而是一个奇一个偶，可能会影响同一种边权的kruskal加边顺序，所以我把这些边都存下来......

然后求一发Kruskal就可以了。

#include<cstdio>

#include<cstring>

#include<algorithm>

const int HW(),len(),N();

const int dx[]={,,-,};

const int dy[]={-,,,};

int O[HW][HW],last[HW][HW],dis[HW][HW],H,W,P,Q;

struct Palce{int x,y;}q[N+],now; int l,h;

char ch[HW];int x,y;

struct Node{int a,b,c;}bot[N+];int top;

int f[len+],cost[len+],rank[len+],depth[len+];

bool cmp(Node A,Node B){return A.c<B.c;}

int max(int a,int b){return a>b?a:b;}

template <class T>void read(T &x)

{

    x=;int f=; char ch=getchar();

    while(ch<''||ch>''){f=(ch=='-');ch=getchar();}

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

    x=f?-x:x;

}

int gf(int x){return x==f[x]?x:gf(f[x]);}

int gf_d(int x)

{

    int d; for(d=;x!=f[x];x=f[x])d++;

    return d;

}

void swap(int &a,int &b){if(a==b)return;a^=b;b^=a;a^=b;}

void union_fa(int x,int y,int d)

{

    x=gf(x),y=gf(y); if(x==y)return;

    if(rank[x]>rank[y])   swap(x,y);

    if(rank[x]==rank[y])  rank[y]++;

    f[x]=y; cost[x]=d;

}

void BFS()

{

    h=;

    while(h<l)

    {

        now=q[++h];

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

        if(O[now.x+dx[d]][now.y+dy[d]])

        {

            if(last[now.x+dx[d]][now.y+dy[d]]&&last[now.x+dx[d]][now.y+dy[d]]!=last[now.x][now.y])

                bot[++top]=(Node){last[now.x+dx[d]][now.y+dy[d]],last[now.x][now.y],dis[now.x+dx[d]][now.y+dy[d]]+dis[now.x][now.y]};

            else

            if(!dis[now.x+dx[d]][now.y+dy[d]])

            {

                dis[now.x+dx[d]][now.y+dy[d]]=dis[now.x][now.y]+;

                last[now.x+dx[d]][now.y+dy[d]]=last[now.x][now.y];

                q[++l]=(Palce){now.x+dx[d],now.y+dy[d]};

            }

        }

    }

}

int jump(int x,int y)

{

    int d=;

    if(depth[x]<depth[y])swap(x,y);

    for(;depth[x]!=depth[y];)d=max(d,cost[x]),x=f[x];

    for(;x!=y;)d=max(d,cost[x]),d=max(d,cost[y]),x=f[x],y=f[y];

    return d;

}

int main()

{

//    freopen("C.in","r",stdin);

//    freopen("C.out","w",stdout);

    read(H),read(W);

    read(P),read(Q);

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

    {

        scanf("%s",ch+);

        for(int j=;j<=W;j++)O[i][j]=(ch[j]!='#');

    }

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

    {

        read(x),read(y); f[i]=i; rank[i]=;

        last[x][y]=i;  q[++l]=(Palce){x,y};

    }

    BFS();//O(H*W)

    std::sort(bot+,bot++top,cmp);

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

    union_fa(bot[i].a,bot[i].b,bot[i].c);//按kruskal走，那么两个连通块之间的过往最大值就是这条边，所以可以直接在并查集的树上求最值。

    for(int i=;i<=P;i++)depth[i]=gf_d(i);//O(PlogP)

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

    {

        read(x);read(y);

        if(gf(x)!=gf(y))printf("-1\n");

        else printf("%d\n",jump(x,y));//O(logP)

    }

    return ;

}