Codeforces 757F Team Rocket Rises Again 支配树

Team Rocket Rises Again

直接求支配树就好啦。

#include<bits/stdc++.h>
#define LL long long
#define LD long double
#define ull unsigned long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ALL(x) (x).begin(), (x).end()
#define fio ios::sync_with_stdio(false); cin.tie(0);

using namespace std;

const int N = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);

template<class T, class S> inline void add(T& a, S b) {a += b; if(a >= mod) a -= mod;}
template<class T, class S> inline void sub(T& a, S b) {a -= b; if(a < 0) a += mod;}
template<class T, class S> inline bool chkmax(T& a, S b) {return a < b ? a = b, true : false;}
template<class T, class S> inline bool chkmin(T& a, S b) {return a > b ? a = b, true : false;}

int n, m, s, deg[N];
int pa[N][20], fa[N], depth[N];
int ans, son[N];
LL d[N];
vector<PLI> G[N];
vector<int> dG[N];
vector<int> rG[N];
vector<int> tG[N];

int getLca(int u, int v) {
    if(depth[u] < depth[v]) swap(u, v);
    int dis = depth[u] - depth[v];
    for(int i = 19; i >= 0; i--)
        if(dis >> i & 1) u = pa[u][i];
    if(u == v) return u;
    for(int i = 19; i >= 0; i--)
        if(pa[u][i] != pa[v][i])
            u = pa[u][i], v = pa[v][i];
    return pa[u][0];
}

void dfs(int u) {
    son[u] = 1;
    for(auto& v : tG[u]) {
        dfs(v);
        son[u] += son[v];
    }
    if(u != s) chkmax(ans, son[u]);
}

int main() {
    memset(d, 0x3f, sizeof(d));
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 1; i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(mk(w, v));
        G[v].push_back(mk(w, u));
    }
    priority_queue<PLI, vector<PLI>, greater<PLI> > que;
    d[s] = 0;
    que.push(mk(0, s));
    while(!que.empty()) {
        int u = que.top().se;
        LL dis = que.top().fi;
        que.pop();
        if(dis < d[u]) continue;
        for(auto& e : G[u]) {
            if(chkmin(d[e.se], dis + e.fi)) {
                que.push(mk(d[e.se], e.se));
            }
        }
    }
    for(int u = 1; u <= n; u++) {
        for(auto& e : G[u]) {
            if(d[u] + e.fi == d[e.se]) {
                dG[u].push_back(e.se);
                rG[e.se].push_back(u);
                deg[e.se]++;
            }
        }
    }
    queue<int> que2;
    for(int i = 1; i <= n; i++)
        if(d[i] < INF && !deg[i]) que2.push(i);
    depth[s] = 1;
    while(!que2.empty()) {
        int u = que2.front(); que2.pop();
        if(u != s) {
            int lca = -1;
            for(auto& v : rG[u]) {
                if(~lca) lca = getLca(lca, v);
                else lca = v;
            }
            fa[u] = pa[u][0] = lca;
            for(int i = 1; i < 20; i++)
                pa[u][i] = pa[pa[u][i - 1]][i - 1];
            depth[u] = depth[fa[u]] + 1;
            tG[fa[u]].push_back(u);
        }
        for(auto& v : dG[u]) {
            deg[v]--;
            if(!deg[v]) que2.push(v);
        }
    }
    dfs(s);
    printf("%d
", ans);
    return 0;
}

/*
*/