噼里啪啦

我们学校的网线结构真神奇。有 n 台服务器编号 1~n,一些服务器直接连接IP 为 0 的网关,所有 n 台服务器网线相互连接。宁波来台风了!噼里啪啦~
一阵雷雨过后,我们发现很多服务器都无法访问了,为了评估破坏情况,我们觉得打开一些服务器随机 ping 其他服务器,然后记录不成功的情况。现在他需要一个程序分析记录,最少有几台服务器遭到雷电破坏。

　　贪心,先求一遍lca，然后根据lca的深度排序lca，从深往浅搜，然后如果用一个lca，那就把lca所在的子树都打上标记。如果后面求lca的时候，发现标记，就不把它计入ans。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=1e5+5, maxq=5e5+5;

inline int max(int x, int y){ return x<y?y:x; }

struct lca{
    int data, a, b, dep;
}q[maxq];
bool operator <(const lca &x, const lca &y){
    return x.dep>y.dep;
}

class Graph{
public:
    struct Edge{
        Graph *belong; int to, next;
        Edge& operator ++(){ *this=belong->edge[next]; return *this; }
        int operator *(){ return to; }
    };
    void reset(){
        edge[0].to=-1;
        memset(fir, 0, sizeof(fir));
        cntedge=0;
    }
    void addedge(int x, int y){
        Edge &e=edge[++cntedge];
        e.belong=this, e.to=y;
        e.next=fir[x], fir[x]=cntedge;
    }
    Edge get_link(int x){ return edge[fir[x]]; }
private:
    int cntedge, fir[maxn];
    Edge edge[maxn];
};

int n, m, dep[maxn], son[maxn], size[maxn], fa[maxn];
int times, top[maxn], dfn[maxn], cnt, L, R;
int seg[maxn*4], mark[maxn*4];
Graph g;

void dfs1(int now, int par){
    int nc, maxsize=0;
    for (Graph::Edge e=g.get_link(now); ~*e; ++e){
        nc=*e;
        if (nc==par) continue;
        fa[nc]=now;
        dep[nc]=dep[now]+1;
        dfs1(nc, now);
        size[now]+=size[nc];
        if (size[nc]>maxsize){
            maxsize=size[nc];
            son[now]=nc;
        }
    }
    ++size[now];
}

void dfs2(int now, int par){
    int nc;
    dfn[now]=++times;
    if (son[now]){ //初始化!
        top[son[now]]=top[now];
        dfs2(son[now], now);
    }
    for (Graph::Edge e=g.get_link(now); ~*e; ++e){
        nc=*e;
        if (nc==par||nc==son[now]) continue;
        top[nc]=nc;
        dfs2(nc, now);
    }
}

int prelca(int x, int y){
    while (top[x]!=top[y]){
        //这里要比较top谁高谁低!
        if (dep[top[x]]>dep[top[y]]) x=fa[top[x]];
        else y=fa[top[y]];
    }
    //这里是小于!!!
    return dep[x]<dep[y]?x:y;
}

int query(int now, int l, int r){
    if (l>=L&&r<=R) return seg[now];
    if (mark[now]){
        seg[now<<1]=seg[now<<1|1]=seg[now];
        mark[now<<1]=mark[now<<1|1]=seg[now]; mark[now]=0;
    }
    int mid=(l+r)>>1, flag=0;
    if (mid>=L) flag=max(query(now<<1, l, mid), flag);
    if (mid<R) flag=max(query(now<<1|1, mid+1, r), flag);
    return flag>0?1:0;
}

void modify(int now, int l, int r){
    if (l>=L&&r<=R){ seg[now]=1; mark[now]=1; return; }
    if (mark[now]){
        seg[now<<1]=seg[now<<1|1]=seg[now];
        mark[now<<1]=mark[now<<1|1]=seg[now];
    }
    int mid=(l+r)>>1;
    if (mid>=L) modify(now<<1, l, mid);
    if (mid<R) modify(now<<1|1, mid+1, r);
    if (seg[now<<1]+seg[now<<1|1]) seg[now]=1;
}

int lalca(int x, int y){
    while (top[x]!=top[y]){
        if (dep[top[x]]>dep[top[y]]){
            L=dfn[top[x]], R=dfn[x];
            if (query(1, 1, n+1)>0) return -1;
            x=fa[top[x]];
        }
        else {
            L=dfn[top[y]], R=dfn[y];
            if (query(1, 1, n+1)>0) return -1;
            y=fa[top[y]];
        }
    }
    //最后也有可能断掉!
    if (dep[x]>dep[y]){
        L=dfn[y], R=dfn[x];
        if (query(1, 1, n+1)>0) return -1;
    } else {
        L=dfn[x], R=dfn[y];
        if (query(1, 1, n+1)>0) return -1;
    }
    return dep[x]<dep[y]?x:y;
}

void init(){
    g.reset();
    times=0, cnt=0;
    memset(size, 0, sizeof(size));
    memset(seg, 0, sizeof(seg));
    memset(mark, 0, sizeof(mark));
    memset(son, 0, sizeof(son));
}

int main(){
    int t;
    scanf("%d", &t);
    int x, y;
    for (int tt=0; tt<t; ++tt){
        init();
        scanf("%d", &n);
        for (int i=0; i<n; ++i){
            scanf("%d%d", &x, &y);
            g.addedge(x, y);
            g.addedge(y, x);
        }
        dfs1(0, -1);
        dfs2(0, -1);
        scanf("%d", &m);
        for (int i=0; i<m; ++i){
            scanf("%d%d", &x, &y);
            q[i].a=x;
            q[i].b=y;
            q[i].dep=dep[prelca(x, y)];
        }
        sort(q, q+m);
        int result, ans=0;
        for (int i=0; i<m; ++i){
            result=lalca(q[i].a, q[i].b);
            if (!~result) continue;
            else {
                L=dfn[result], R=dfn[result]+size[result]-1;
                modify(1, 1, n+1);
                ++ans;
            }
        }
        printf("Case #%d: %d\n", tt+1, ans);
    }
    return 0;
}