HDU6203 ping ping ping 【LCA+BIT】

传送门

---

先求dfs序in[]和out[]，以及lca
将不能连通的(u,v)按lca深度从大到小排序
树状数组维护数组flag[]
$flag[in_i]=0 : i点与任意\{v|flag[in_v]=0\}连通$
$flag[in_i]>0 : i点与任意\{v|flag[in_v]=0\}不连通$
依次处理每对(u,v)
$若flag[in_u]>0||flag[in_v]>0,则u,v已经不连通,跳过$
$否则,将lca_{u,v}视为坏点,将flag[in_{lca}...out_{lca}]全都+1$

---

$因为当前取出的(u,v),lca_{u,v}深度比之前的都小,所以要么flag[in_u]=flag[in_v]=0,要么一个=0，一个>0$
$而以后取出的(u',v'),其中一点的深度必然>=lca_{u,v}深度,所以(u',v')的位置只能有3种情况$
$①:2点都在lca_{u,v}为根的子树内，且lca_{u',v'}=lca_{u,v} (flag>0)$
$②:一点在lca_{u,v}为根的子树内(flag>0)，一点不在(flag=0)$
$③:2点都不在lca_{u,v}为根的子树内(flag=0)$
$所以当u点被确定为坏点,u为根的子树内的点,与之后查询的点都不连通,flag[in_u]>0$

#include<stdio.h>
#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define MEM(a,x) memset(a,x,sizeof(a))
#define lowbit(x) ((x)&-(x))

using namespace std;

const int inf=1e9+7;
const int INF = inf;

const int N = 1e4 + 5;//顶点数
const int M = 50000 + 5;//查询数

struct Query{
    int u,v,lca;
};
vector<int>G[N];//fist:to  second:w边权
vector<pii>queryTo[N];//first:to second:这个查询在query[M]中的下标
Query query[M];
int par[N];//并查集
bool visited[N];//Tarjan标记是否被访问过
inline int find(int x){
    return x==par[x]?x:par[x]=find(par[x]);
}

void Tarjan(int u){
    visited[u]=true;
    for(int i=0;i<G[u].size();++i){
        int to=G[u][i];
        if(visited[to]==false){
            Tarjan(to);
            par[to]=u;
        }
    }
    for(int i=0;i<queryTo[u].size();++i){
        int v=queryTo[u][i].first;
        int index=queryTo[u][i].second;
        if(visited[v])
            query[index].lca=find(v);
    }
}

void init(int n){
    fill(visited,visited+n+1,0);
    for(int i=0;i<=n;++i){
        par[i]=i;
    }
}

int in[N],out[N],depth[N];
void dfs(int u,int &t,int fa,int d){
    in[u]=++t;
    depth[u]=d;
    for(int v:G[u]){
        if(v!=fa){
            dfs(v,t,u,d+1);
        }
    }
    out[u]=t;
}

struct Bit{
    int c[N],n;
    void init(int n){
        this->n=n+1;
        fill(c,c+n+2,0);
    }
    void add(int x,int val){//a[x]...a[n] 全部+val
        x+=1;
        while(x<=n){
            c[x]+=val;
            x+=lowbit(x);
        }
    }
    ll sum(int x){//a[x]
        ll ans=0;
        x+=1;
        while(x){
            ans+=c[x];
            x-=lowbit(x);
        }
        return ans;
    }
}bit;

bool operator>(const Query&a,const Query&b){
    return depth[a.lca]>depth[b.lca];
}

int slove(int n,int q){
    init(n);
    {
        int t=-1;
        dfs(0,t,-1,0);
    }
    bit.init(n);
    Tarjan(0);
    sort(query,query+q,greater<Query>());
    int ans=0;
    for(int i=0;i<q;++i){
        Query&t=query[i];
        if(bit.sum(in[t.u])||bit.sum(in[t.v])){
            continue;
        }
        ++ans;
        int st=in[t.lca],ed=out[t.lca];
        bit.add(st,1);
        bit.add(ed+1,-1);
    }
    return ans;
}

int main(){
    //freopen("/home/lu/code/r.txt","r",stdin);
    //freopen("/home/lu/code/w.txt","w",stdout);
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<=n;++i){
            G[i].clear();
            queryTo[i].clear();
        }
        for(int i=1;i<=n;++i){
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        int p;
        scanf("%d",&p);
        for(int i=0;i<p;++i){
            int u,v;
            scanf("%d%d",&u,&v);
            query[i]={u,v,-1};
            queryTo[u].push_back({v,i});
            queryTo[v].push_back({u,i});
        }
        printf("%d\n",slove(n,p));
    }
    return 0;
}