【bzoj1018】堵塞的交通

【bzoj1018】堵塞的交通

题意

一个\(2*n\)的格子,相邻格子之间有一条道路。初始时道路是不通的。

\(C\)个操作,每个操作为三种中的一种:(1)某条道路连起来;(2)某条道路断开;(3)询问某两个格子是否相连。

数据范围:\(C\leq 100000\)

分析

这的确是一道好题。

不仅体现在思想的巧妙,而且体现在其一题多解。

参阅了百度前两页的题解,有所感想。

思路1:线段树

前人之述备矣。

用线段树维护区间内的信息:

\(a1[2][2]\):a1[i][j]表示左端点的\(i\)到右端点的\(j\)是否联通;

\(a2[2]\):a2[i]表示左或者右端点的上下是否联通;

还需要用到中点的信息\(b[2]\):mid与mid+1是否联通,来完成合并。

注意是块内合并。

最后的询问才考虑到块外的情况。

时间复杂度:\(O(n\log n)\)

一份被我加了注释的代码 from invoid的题解

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 800000 + 10;

char s[20]; //操作
int x1,x2,y1,y2,c;

struct Segtree {
    #define lc(x) ((x)<<1)
    #define rc(x) (((x)<<1)|1)
    #define root 1

    struct Status {
        int a1[2][2],a2[2];
        //a1表示左右断电联通情况,a2表示左右端点分别上下联通情况
    }s[maxn];

    bool b[maxn][2];
    int l[maxn],r[maxn],m[maxn];    //l[x]:左端点  r[x]:右端点  m[x]:中点 

    Status update(Status s1,Status s2,bool b[]) {   //左态,右态,中间态
        Status res;
        for(int i=0;i<=1;i++)
        for(int j=0;j<=1;j++)
            res.a1[i][j]=s1.a1[i][0] && b[0] && s2.a1[0][j] || s1.a1[i][1] && b[1] && s2.a1[1][j];
        //基本联通,此时s1.a1已经包括了连出去的情况

        res.a2[0]=s1.a2[0] || s1.a1[0][0] && b[0] && s2.a2[0] && b[1] && s1.a1[1][1];
        res.a2[1]=s2.a2[1] || s2.a1[0][0] && b[0] && s1.a2[1] && b[1] && s2.a1[1][1];
        //弄清一个误区:s[i]指表示[l,r]中的情况,最后处理答案的时候才考虑连到外面的情况 

        return res;
    }

    Status access (int x,int y1,int y2) {
        if(y1<=l[x] && r[x]<=y2) return s[x];
        else if(y2<=m[x]) return access(lc(x),y1,y2);
        else if(y1>m[x]) return access(rc(x),y1,y2);
        else return update(access(lc(x),y1,y2),access(rc(x),y1,y2),b[x]);
        //access,b[x]为中间态
    }

    void change(bool k,int x,int x1,int y1,int x2,int y2) {
        if(x1==x2 && y1==m[x]) {    //同一行相邻两个
            b[x][x1]=k;             //x的mid到mid+1的连通性为k
            s[x]=update(s[lc(x)],s[rc(x)],b[x]);    //update
        }
        else if(l[x]==r[x])         //上下联通
            s[x].a1[0][1]=s[x].a1[1][0]=s[x].a2[0]=s[x].a2[1]=k;    //都是k
        else {
            change(k,y2<=m[x]?lc(x):rc(x),x1,y1,x2,y2); //递归
            s[x]=update(s[lc(x)],s[rc(x)],b[x]);    //update
        }
    }

    void ask(int x1,int y1,int x2,int y2) {
        Status left=access(root,1,y1),  //1到y1
               right=access(root,y2,c), //y2到c
               mid=access(root,y1,y2);  //y1到y2
        bool res=false;
        for(int i=0;i<=1;i++)
        for(int j=0;j<=1;j++)
            if(mid.a1[i][j]&&(i==x1||left.a2[1])&&(j==x2||right.a2[0])) {
                //若mid[i][j]联通,i=x1或左联通,j=x2或右联通,则res=1
                res=true; break;
            }
        printf(res?"Y\n":"N\n");    //返回res
    }

    void build(int x,int y1,int y2) {
        l[x]=y1,r[x]=y2,m[x]=(l[x]+r[x])>>1;
        if(y1==y2)
            s[x].a1[0][0]=s[x].a1[1][1]=true;
        else {
            build(lc(x),y1,m[x]);
            build(rc(x),m[x]+1,y2);
        }
    }
    //连通
}seg;

int main() {
    scanf("%d",&c);
    seg.build(1,1,c);
    while(1) {
        scanf("%s",s);
        if(s[0]=='E') break;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        --x1; --x2; //从0开始

        if(y1>y2) {
            swap(x1,x2);
            swap(y1,y2);
        }
        //y1在前,y2在后 

        if(s[0]=='O') seg.change(1,1,x1,y1,x2,y2);  //增边
        else if(s[0]=='C') seg.change(0,1,x1,y1,x2,y2); //删边
        else seg.ask(x1,y1,x2,y2);  //查连
    }
    return 0;
}

思路2:分块+并查集

http://blog.csdn.net/cjk_cjk/article/details/43489473

并查集有一定的局限性:只支持快速合并,不支持快速删除。

所以我们打算直接合并+初始化,而不使用删除。

但是初始化的速度较慢,所以我们考虑分块,对于询问只需要合并各个块即可。

根据平衡规划的思想,我们要是的初始化的速度尽可能快,而且块间的合并尽可能快,所以我们取\(O(\sqrt n)\)分一块。

【bzoj1018】堵塞的交通

Open:在同一块中就维护并查集,在不同块互相连通就用一个link数组记录

Close:在同一块中就把块中元素的fa[]全部重新计算,在不同块中直接把link赋零

Ask:判断A及能到达的4个顶点,再递归4个顶点到其他块的顶点,看顶点与B是否连通

时间复杂度:\(O(n\sqrt n)\)

思路3:定期重建 + [按秩合并 & 路径压缩]并查集

离线处理。

并查集有一定的局限性:只支持快速合并,不支持快速删除,但是按秩合并的并查集可以逐个删除。

所以我们打算直接合并+顺序撤除。

按照操作顺序,每\(\sqrt c\)个就分一次块。

每次处理出块前的并查集,然后按秩合并处理块内的询问,然后每次再撤销回块的初始状态。

时间复杂度:\(O(n\sqrt n\log n)\)

思路4:线段树+并查集

http://www.cnblogs.com/ccz181078/p/5346077.html

离线处理。

将每条存在的边的按存在时间插入到线段树中,对线段dfs一次,用按秩合并、支持撤销的并查集维护连通性并回答询问。

此方法适用于离线的图连通性维护。

真的是一种很优美的想法啊。

时间复杂度:\(O(n\log^2 n)\)

小结

(1)线段树的一些理解

①线段树的本质在于维护区间内的信息,假如要维护区间外的信息,正如开始我的想法,或许能够实现,但是未必好些,而且通常也可以转化为区间内信息的维护。

②线段树通常能够维护区间的连通性

(2)并查集的一些理解

并查集能支持快速合并,快速查询,前提:一个条件就可以导致一次合并。

对于删除,通常可以做这样的优化:

①转化为初始化+合并,通过平衡规划(按位置分块等)优化

②转化为按顺序合并,按顺序删除,这样可以通过按秩合并来实现,通过平衡规划(按操作顺序分块)或者回溯(本题线段树回溯)优化

(3)离线处理的一些方法总结

可以使用离线的前提:多个操作

特殊化:多个询问

下面列举一些方法,并举一些例子。

①回代法

bzoj1015

②按照操作顺序分块,定期重建

本题bzoj1018

③莫队算法

小Z的袜子

④确定左端点,移动右端点

HH的项链

⑤单调性,two pointer

noip2016Day1T2:树剖+树状数组

⑥cdq分治

bzoj简单题

⑦快速覆盖区间,从前往后遍历

本题bzoj1018,用线段树按照操作时间插入边,然后遍历线段树,访问每个时间(叶子节点)

能用到离线处理的远远不止这些。

只是积累一点经验罢了。

毕竟我不是一些可能存在的大神。

说什么劳资纯刷题就可以虐爆你。。

上一篇:Project facet Java version 1.8 is not supported解决记录


下一篇:RubyCritic:一款不错的检测代码质量工具