P5157 The Cow Gathering [拓扑排序/树上差分]

$The Cow Gathering$

$mathcal{Description}$

给定 $N$ 个节点的树, 有 $M$ 条限制条件 : $a_i$ 比 $b_i$ 先删除.
请输出 所有节点能否最后被删除.

$mathcal{Solution_1}$

$color{red}{步骤:}$

找到任意一个满足条件的点 $root$
统计答案

$color{blue}{找 root:}$

$a_i$ 向 $b_i$ 连有向边
$color{black}{拓扑排序}$
若存在 $环$ , 说明无解,
否则取出 $color{purple}{拓扑序最大的节点}$ , 即为一个满足条件的节点 $root$ .

$color{blue}{统计答案:}$

以 $root$ 为根建树 :

对于一颗子树, 设该节点为 $s$ ,

$分两种情况讨论:$

$color{red}{s}$ 有连出去的 有向边.

以 $color{red}{s}$ 为根节点的子树所有节点全部不能作为最后一个节点出去

$color{purple}理由: 不明$
$color{red}{s}$ 没有连出去的 有向边 .

不操作

$mathcal{Solution_2}$

使用 树上差分, 以 $dfn[]$ 为下标建立 $差分数组$ ,

对于 $a_i, b_i$ , 同样 $a_i$ 向 $b_i$ 连一条有向边,

先使用 $拓扑排序$ 判环, 若有环说明无解, 否则 :

此时分为三种情况 :

$a$ 在 $b$ 上方
$b$ 在 $a$ 上方
$a$ 和 $b$ 拥有 最近公共祖先

对于 $情况2$ 和 $情况3$ , 直接将 $dfn[a], dfn[a]+size[a]$ 进行差分操作,
对于 $情况1$ , 记 全局数组 $flag$ , 将 $flag++$ ,

$b$ 跳到 $a$ 的正下方后 !!

$dfn[b], dfn[b]+1$ 进行 反差分操作.

最后根据 $差分数组$ 统计答案.

$mathcal{Code}$

#include<bits/stdc++.h>
#define reg register

int read(){
        char c;
        int s = 0, flag = 1;
        while((c=getchar()) && !isdigit(c))
                if(c == '-'){ flag = -1, c = getchar(); break ; }
        while(isdigit(c)) s = s*10 + c-'0', c = getchar();
        return s * flag;
}

const int maxn = 100005;

int N;
int M;
int num0;
int tot;
int flag;
int C[maxn];
int rd[maxn];
int dfn[maxn];
int dep[maxn];
int size[maxn];
int head[maxn];
int Fk[maxn][20];

bool Used[maxn];

struct Edge{ int nxt, to; } edge[maxn<<2];
void Add(int from, int to){
        edge[++ num0] = (Edge){ head[from], to };
        head[from] = num0;
}

void DFS(int k, int fa){
        dfn[k] = ++ tot;
        dep[k] = dep[fa] + 1;
        size[k] = 1;
        for(reg int i = 1; i <= 19; i ++) Fk[k][i] = Fk[Fk[k][i-1]][i-1];
        for(reg int i = head[k]; i; i = edge[i].nxt){
                int to = edge[i].to;
                if(to == fa) continue ;
                Fk[to][0] = k;
                DFS(to, k);
                size[k] += size[to];
        }
}

int LCA(int a, int b){
        if(dep[a] < dep[b]) std::swap(a, b);
        for(reg int i = 19; i >= 0; i --)
                if(dep[Fk[a][i]] >= dep[b]) a = Fk[a][i];
        if(a == b) return a;
        for(reg int i = 19; i >= 0; i --)
                if(Fk[a][i] != Fk[b][i]) a = Fk[a][i], b = Fk[b][i];
        return Fk[a][0];
}

bool chk(){
        tot = 0;
        std::queue <int> Q;
        for(int i = 1; i <= N; i ++)
                if(rd[i] == 1) Q.push(i), rd[i] --;
        while(!Q.empty()){
                int ft = Q.front(); Q.pop();
                tot ++, rd[ft] --;
                for(reg int i = head[ft]; i; i = edge[i].nxt){
                        int to = edge[i].to;
                        if(-- rd[to] == 1) Q.push(to);
                }
        }
        if(tot < N) return 0;
        return 1;
}

int jump(int a, int b){
        for(reg int i = 19; i >= 0; i --)
                if(dep[Fk[a][i]] > dep[b]) a = Fk[a][i];
        return a;
}

int main(){
        freopen("visit.in", "r", stdin);
        freopen("visit.out", "w", stdout);
        N = read();
        M = read();
        for(reg int i = 1; i < N; i ++){
                int x = read(), y = read();
                Add(x, y), Add(y, x);
                rd[x] ++, rd[y] ++;
        }
        DFS(1, 0);
        for(reg int i = 1; i <= M; i ++){
                int a = read(), b = read();
                Add(a, b), rd[b] ++;
                int lca = LCA(a, b);
                if(lca == a){  // a up b
                        int t = jump(b, a);
                        C[dfn[t]] --, C[dfn[t]+size[t]] ++;
                        flag ++;
                }else if(lca != a && lca != b){ // a ^ b
                        C[dfn[a]] ++;
                        C[dfn[a]+size[a]] --;
                }else if(lca == b){ // b up a
                        C[dfn[a]] ++;
                        C[dfn[a]+size[a]] --;
                }
        }
        if(!chk()){
                for(reg int i = 1; i <= N; i ++) printf("0
");
                return 0;
        }else{
                for(reg int i = 1; i <= N; i ++) C[i] += C[i-1];
                for(reg int i = 1; i <= N; i ++)
                        if(C[dfn[i]]+flag > 0) printf("0
");
                        else printf("1
");
        }
        return 0;
}