【BZOJ 1969】 1969: [Ahoi2005]LANE 航线规划 （树链剖分+线段树）

1969: [Ahoi2005]LANE 航线规划

Description

对Samuel星球的探险已经取得了非常巨大的成就，于是科学家们将目光投向了Samuel星球所在的星系——一个巨大的由千百万星球构成的Samuel星系。 星际空间站的Samuel II巨型计算机经过长期探测，已经锁定了Samuel星系中许多星球的空间坐标，并对这些星球从1开始编号1、2、3……。 一些先遣飞船已经出发，在星球之间开辟探险航线。 探险航线是双向的，例如从1号星球到3号星球开辟探险航线，那么从3号星球到1号星球也可以使用这条航线。 例如下图所示：  在5个星球之间，有5条探险航线。 A、B两星球之间，如果某条航线不存在，就无法从A星球抵达B星球，我们则称这条航线为关键航线。 显然上图中，1号与5号星球之间的关键航线有1条：即为4-5航线。 然而，在宇宙中一些未知的磁暴和行星的冲撞，使得已有的某些航线被破坏，随着越来越多的航线被破坏，探险飞船又不能及时回复这些航线，可见两个星球之间的关键航线会越来越多。 假设在上图中，航线4-2（从4号星球到2号星球）被破坏。此时，1号与5号星球之间的关键航线就有3条：1-3，3-4，4-5。 小联的任务是，不断关注航线被破坏的情况，并随时给出两个星球之间的关键航线数目。现在请你帮助完成。

Input

第一行有两个整数N，M。表示有N个星球（1< N < 30000），初始时已经有M条航线（1 < M < 100000）。随后有M行，每行有两个不相同的整数A、B表示在星球A与B之间存在一条航线。接下来每行有三个整数C、A、B。C为1表示询问当前星球A和星球B之间有多少条关键航线；C为0表示在星球A和星球B之间的航线被破坏，当后面再遇到C为1的情况时，表示询问航线被破坏后，关键路径的情况，且航线破坏后不可恢复； C为-1表示输入文件结束，这时该行没有A,B的值。被破坏的航线数目与询问的次数总和不超过40000。

Output

对每个C为1的询问，输出一行一个整数表示关键航线数目。 注意：我们保证无论航线如何被破坏，任意时刻任意两个星球都能够相互到达。在整个数据中，任意两个星球之间最多只可能存在一条直接的航线。

Sample Input

5 5
1 2
1 3
3 4
4 5
4 2
1 1 5
0 4 2
1 5 1
-1

Sample Output

1
3

HINT

Source

【分析】

　　hh想出来了。。

　　删边不好做，考虑加边，题目保证删完边还是联通的，我们维护一棵树（假设是一棵树）

　　假设现在把x，y连起来，假设他们的LCA为z，显然可以把x->y路径上的点全部缩成一个点，加边后这条路径上的边成环，所以之后一定不是关键边。

　　事实上呢，不用缩点，直接把两个点的路径的边权清0，即z->x,z->y路径的边清零。

　　没有清0的边边权为1，询问就是问x->y路径的边权和。

　　用树剖和线段树维护就好了。

　　【预处理别人都是MAP什么的，表示不会= =就排了个序搞搞了。。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define Maxn 30010
#define Maxm 100010

struct node
{
    int x,y,next;
    int bj,id;
}t[Maxn*2],tt[Maxm*4];
int first[Maxn],len;

void ins(int x,int y)
{
    // printf("%d -> %d
",x,y);
    t[++len].x=x;t[len].y=y;
    t[len].next=first[x];first[x]=len;
}

struct nnode
{
    int l,r,lc,rc,sm;
}tr[Maxn*2];

void upd(int x)
{
    if(tr[x].l==tr[x].r||tr[x].sm!=0) return;
    int lc=tr[x].lc,rc=tr[x].rc;
    tr[lc].sm=tr[rc].sm=0;
}

int tot;
int build(int l,int r)
{
    int x=++tot;
    tr[x].l=l;tr[x].r=r;
    if(l!=r)
    {
        int mid=(l+r)>>1;
        tr[x].lc=build(l,mid);
        tr[x].rc=build(mid+1,r);
    }
    else tr[x].lc=tr[x].rc=0;
    tr[x].sm=r-l+1;
    return x;
}

void change(int x,int l,int r)
{
    if(tr[x].l==l&&tr[x].r==r)
    {
        tr[x].sm=0;
        return;
    }
    upd(x);
    int mid=(tr[x].l+tr[x].r)>>1,lc=tr[x].lc,rc=tr[x].rc;
    if(r<=mid) change(lc,l,r);
    else if(l>mid) change(rc,l,r);
    else
    {
        change(lc,l,mid);
        change(rc,mid+1,r);
    }
    tr[x].sm=tr[lc].sm+tr[rc].sm;
}

int query(int x,int l,int r)
{
    if(tr[x].sm==0) return 0;
    if(tr[x].l==l&&tr[x].r==r) return tr[x].sm;
    upd(x);
    int mid=(tr[x].l+tr[x].r)>>1,lc=tr[x].lc,rc=tr[x].rc;
    if(r<=mid) return query(lc,l,r);
    else if(l>mid) return query(rc,l,r);
    else return query(lc,l,mid)+query(rc,mid+1,r);
}

int tp[Maxn],sum[Maxn],son[Maxn],dfn[Maxn],dep[Maxn];
int ff[Maxn];
int cnt;
void dfs(int x,int f)
{
    son[x]=0;sum[x]=1;dep[x]=dep[f]+1;
    ff[x]=f;
    for(int i=first[x];i;i=t[i].next) if(t[i].y!=f)
    {
        int y=t[i].y;
        dfs(y,x);
        sum[x]+=sum[y];
        if(son[x]==0||sum[son[x]]<sum[y]) son[x]=y;
    }
}

void dfs2(int x,int tpp)
{
    dfn[x]=++cnt;tp[x]=tpp;
    if(son[x]) dfs2(son[x],tpp);
    for(int i=first[x];i;i=t[i].next) if(t[i].y!=ff[x]&&t[i].y!=son[x])
    {
        int y=t[i].y;
        dfs2(y,y);
    }
}

void fchange(int x,int y)
{
    while(tp[x]!=tp[y])
    {
        if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
        change(1,dfn[tp[x]],dfn[x]);
        x=ff[tp[x]];
    }
    if(dep[x]<dep[y]) swap(x,y);
    if(x!=y) change(1,dfn[y]+1,dfn[x]);
}

int fquery(int x,int y)
{
    int ans=0;
    while(tp[x]!=tp[y])
    {
        if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
        ans+=query(1,dfn[tp[x]],dfn[x]);
        x=ff[tp[x]];
    }
    if(dep[x]<dep[y]) swap(x,y);
    if(x!=y)
    {
        // if(dfn[y]+1>dfn[x]) while(1);
        ans+=query(1,dfn[y]+1,dfn[x]);
    }
    return ans;
}

int fa[Maxn];
int ffa(int x)
{
    if(fa[x]!=x) fa[x]=ffa(fa[x]);
    return fa[x];
}

bool cmp(node x,node y)
{
    if(x.x==y.x&&x.y==y.y) return x.bj<y.bj;
    return (x.x==y.x)?(x.y<y.y):(x.x<y.x);
}
bool cmp2(node x,node y) {return x.id<y.id;}

int ans[Maxn];

void solve()
{
    int n,m;
    scanf("%d%d",&n,&m);
    int ll=0;
    for(int i=1;i<=m;i++)
    {
        int x,y;
        ll++;
        scanf("%d%d",&tt[ll].x,&tt[ll].y);
        tt[ll].bj=1;//cha ru
    }
    int ct=0;
    while(1)
    {
        int cs=0;
        scanf("%d",&cs);
        if(cs==-1) break;
        ll++;
        scanf("%d%d",&tt[ll].x,&tt[ll].y);
        if(cs==0) tt[ll].bj=-1;//shan chu
        else tt[ll].bj=0;//xun wen
        tt[ll].id=++ct;
    }
    sort(tt+1,tt+1+ll,cmp);
    for(int i=1;i<=n;i++) fa[i]=i;
    ct++;
    int pp=0;
    for(int i=1;i<=ll;i++)
    {
        if(tt[i].bj==0) continue;
        if(tt[i].bj==1)
        {
            if(pp==0||tt[i].x!=tt[pp].x||tt[i].y!=tt[pp].y)
            {
                if(ffa(tt[i].x)==ffa(tt[i].y))
                {
                    tt[i].bj=-1;
                    tt[i].id=ct;
                }
                else
                {
                    ins(tt[i].x,tt[i].y);
                    ins(tt[i].y,tt[i].x);
                    fa[ffa(tt[i].x)]=tt[i].y;
                }
            }
        }
        pp=i;
    }
    dep[0]=0;
    dfs(1,0);cnt=0;
    dfs2(1,1);
    build(1,n);
    sort(tt+1,tt+1+ll,cmp2);
    // return ;
    ans[0]=0;
    for(int i=ll;i>=1;i--)
    {
        if(tt[i].bj==1) continue;
        if(tt[i].bj==-1)
        {
            fchange(tt[i].x,tt[i].y);
        }
        else
        {
            ans[++ans[0]]=fquery(tt[i].x,tt[i].y);
        }
    }
    for(int i=ans[0];i>=1;i--) printf("%d
",ans[i]);
}

int main()
{
    solve();
    return 0;
}

2017-03-06 14:04:26