P5180 【模板】支配树

这个题乱七八糟的，和之前的灭绝树有点像，但是不一样。那个是DAG，这个是有向图。简单步骤就是先求出来dfs序，然后求出半支配点（？），然后通过这个求支配点。

算法不是很理解，先放在这。

题干：

题目背景

模板题，无背景
题目描述

给定一张有向图，求从1号点出发，每个点能支配的点的个数（包括自己）
输入输出格式
输入格式：

第一行两个正整数n,mn,mn,m，表示点数和边数 接下来mmm行，每行输入两个整数u,vu,vu,v，表示有一条uuu到vvv的有向边

输出格式：

一行输出nnn个整数，表示每个点能支配的点的个数

代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<ctime>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
#define duke(i,a,n) for(register int i = a;i <= n;++i)
#define lv(i,a,n) for(register int i = a;i >= n;--i)
#define clean(a) memset(a,0,sizeof(a))
const int INF =  << ;
typedef long long ll;
typedef double db;
template <class T>
void read(T &x)
{
    char c;
    bool op = ;
    while(c = getchar(), c < '' || c > '')
        if(c == '-') op = ;
    x = c - '';
    while(c = getchar(), c >= '' && c <= '')
        x = x *  + c - '';
    if(op) x = -x;
}
template <class T>
void write(T x)
{
    if(x < ) putchar('-'), x = -x;
    if(x >= ) write(x / );
    putchar('' + x % );
}
const int N = 1e6 + ;
int dfn[N],n,m;
struct node
{
    int l,r,nxt;
}a[N << ],b[N << ],c[N << ];
int len = ,len1 = ,lst[N],pre[N],len2 = ,lat[N];
void add(int x,int y)
{
    a[++len].l = x;
    a[len].r = y;
    a[len].nxt = lst[x];
    lst[x] = len;
}
void dda(int x,int y)
{
    b[++len1].l = x;
    b[len1].r = y;
    b[len1].nxt = pre[x];
    pre[x] = len1;
}
void add1(int x,int y)
{
    c[++len2].l = x;
    c[len2].r = y;
    c[len2].nxt = lat[x];
    lat[x] = len2;
}
int sdom[N],bel[N],id[N],val[N],cnt = ;
int fa[N],tot = ,idom[N];
void dfs(int now)
{
    dfn[now] = ++cnt;
    id[cnt] = now;
    for(int k = lst[now];k;k = a[k].nxt)
    {
        int y = a[k].r;
        if(dfn[y]) continue;
        dfs(y);
        fa[y] = now;
    }
}
int find(int x)
{
    if(x == bel[x]) return x;
    int root = find(bel[x]);
    if(dfn[sdom[val[bel[x]]]] < dfn[sdom[val[x]]])
    val[x] = val[bel[x]];
    return bel[x] = root;
}
/*int find(int x)
{
    if(x==bel[x]) return x;
    int root=find(bel[x]);
    if(dfn[sdom[val[bel[x]]]]<dfn[sdom[val[x]]])
    val[x]=val[bel[x]];
    return bel[x]=root;
}*/
void tarjan()
{
    for(int i = cnt;i >= ;i--)
    {
        int now = id[i];
        for(int k = pre[now];k;k = b[k].nxt)
        {
            int y = b[k].r;
            if(!dfn[y]) continue;
            find(y);
            if(dfn[sdom[val[y]]] < dfn[sdom[now]])
            sdom[now] = sdom[val[y]];
        }
        add1(sdom[now],now);
        bel[now] = fa[now];
        now = fa[now];
        for(int k = lat[now];k;k = c[k].nxt)
        {
            int v = c[k].r;
            find(v);
            if(sdom[val[v]] == now) idom[v] = now;
            else idom[v] = val[v];
        }
    }
    for(int i = ,now;i <= cnt;i++)
    {
        now = id[i];
        if(idom[now] != sdom[now])
        idom[now] = idom[idom[now]];
    }
}
int ans[N];
void dfs_ans(int now)
{
    ans[now] = ;
    for(int k = lst[now];k;k = a[k].nxt)
    {
        int y = a[k].r;
        dfs_ans(y);
        ans[now] += ans[y];
    }
}
int main()
{
    read(n);read(m);
    duke(i,,m)
    {
        int x,y;
        read(x);read(y);
        add(x,y);dda(y,x);
    }
    duke(i,,n)
    {
        sdom[i] = bel[i] = val[i] = i;
    }
    dfs();
    tarjan();
    len = ;
    clean(lst);
    for(int i = ;i <= n;i++)
    if(idom[i]) add(idom[i],i);
    dfs_ans();
    duke(i,,n)
    {
        printf("%d ",ans[i]);
    }
    return ;
}