HDU 6203 ping ping ping （在线倍增lca+DFS序+树状数组）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6203

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll unsigned long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
const int  maxn =1e4+5;
const int mod=9999991;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：有棵树，
有些节点的服务器坏掉了，
现在要找到这些坏服务器，
有一些数据，每一个节点对表面，
u到v的路径不通，问这样下来最后至少有多少个服务器。

分析一下其实思路还是很清楚的，
对一个特定的点对，要想贡献最多的破坏对数，
肯定是lca，那么我们先对于所有的点对按其lca深度从大到小排序，
这样就可以保证无后效性，然后判断当前点对，
如果其中存在已经被删除的点，那该点对无贡献，
否则，累计答案，并把其lca子树删去。

关于子树删除的操作可以用dfs序加上树状数组维护，关于lca
可以用动态倍增算法搞一下，刚开始写的树剖被t了，可能是树剖对于单纯只要个lca的
问题时间复杂度不太给力。

这道题就是一套组合拳，思路并不难。

时间复杂度：O（nlogn），注意内存大小等等。
*/
int n,u,v,p,ans=0;
///链式前向星
struct node{
    int u,nxt;
}e[maxn<<1];
int head[maxn],tot=0,id=0;
void add(int x,int y)
{
    e[tot]=node{y,head[x]};
    head[x]=tot++;
}
/*
///树链剖分求LCA
int dep[maxn],siz[maxn],son[maxn],fa[maxn];
void init()
{
    mst(head,-1),mst(son,0);
    tot=dep[1]=id=0;
}
void dfs1(int u)
{
    siz[u]=1;
    for(int i=head[u];~i;i=e[i].nxt)
    {
        int v=e[i].u;
        if(v!=fa[u])
        {
            dep[v]=dep[u]+1;
            fa[v]=u;
            dfs1(v);
            siz[u]+=siz[v];
            if(siz[son[u]]<siz[v]) son[u]=v;
        }
    }
}
int top[maxn],idx[maxn];
void dfs2(int u,int tp)
{
    top[u]=tp;
    idx[u]=++id;
    if(son[u]) dfs2(son[u],tp);
    for(int i=head[u];~i;i=e[i].nxt)
    {
        int v=e[i].u;
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}
int lca(int u,int v)
{
    int tpu=top[u],tpv=top[v];
    while(tpu!=tpv)
    {
        if(dep[tpu]<dep[tpv])
        {
            swap(u,v);
            swap(tpu,tpv);
        }
        u=fa[tpu];
        tpu=top[u];
    }
    return dep[u]>dep[v]?v:u;
}
*/
///DFS序和树状数组维护
int bit[maxn<<1];
int lowbit(int x)
{
    return x&(-x);
}
void Add(int x,int d)
{
    for(;x<maxn;bit[x]+=d,x+=lowbit(x));
}
int sum(int x)
{
    int ret=0;
    for(;x>0;ret+=bit[x],x-=lowbit(x));
    return ret;
}
int pl[maxn],pr[maxn];///DFS序维护
int pa[maxn][20],dep[maxn];///在线倍增lca
void init()
{
    mst(head,-1),mst(pa,0);
    tot=id=dep[1]=0;
}
void dfs(int u,int pre)
{
    if(pre!=-1) dep[u]=dep[pre]+1;
    pl[u]=++id;
    pa[u][0]=pre;for(int i=1;i<20;i++) pa[u][i]=pa[pa[u][i-1]][i-1];///初始化
    for(int i=head[u];~i;i=e[i].nxt)
    {
        int v=e[i].u;
        if(v==pre) continue;
        dfs(v,u);
    }
    pr[u]=id;
}
int lca(int u,int v)
{
    int i,j;
    if(dep[u]<dep[v]) swap(u,v);///以u为深度大的那个
    for(i=0;(1<<i)<=dep[u];i++);
    i--;
    for(j=i;j>=0;j--) if(dep[u]-(1<<j)>=dep[v])
            u=pa[u][j];
    if(u==v) return u;
    for(j=i;j>=0;j--) if(pa[u][j]&&pa[u][j]!=pa[v][j])
        u=pa[u][j],v=pa[v][j];
    return pa[u][0];
}
///询问点
struct qy
{
    int u,v,f;
    bool operator<(const qy& y) const
    {
        return dep[f]>dep[y.f];
    }
}q[maxn*5];

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        init();///初始化前向星
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            u++,v++;
            add(u,v),add(v,u);
        }
        ///dfs1(1),dfs2(1,1);
        ans=id=0,mst(bit,0),dfs(1,0);///树状数组维护DSF序
        scanf("%d",&p);
        for(int i=0;i<p;i++)
        {
            scanf("%d%d",&q[i].u,&q[i].v);
            q[i].u++,q[i].v++;
            q[i].f=lca(q[i].u,q[i].v);
            ///cout<<q[i].u<<" "<<q[i].v<<" "<<q[i].f<<endl;
        }
        sort(q,q+p);
        for(int i=0;i<p;i++)
        {
            int f=q[i].f;
            if(sum(pl[q[i].u])||sum(pl[q[i].v]));
            else
            {
                ans++;
                Add(pl[f],1),Add(pr[f]+1,-1);
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}