NOIP 模拟 路径求和 - Tarjan+dfs+码

题目大意：

各一个奇环内向森林，求每两个点对间的距离之和。无法到达则距离为-1.

分析：

首先Tarjan找出size大于1的连通分量（环），环中的边的贡献可以单独计算。
然后从入度为0的点向内dfs，直到遇见size大于1的环。记录每个点的to_size(朝向环方向有多少个节点),from_size(朝向入度为0的方向有多少个节点)，还需要配合拓扑。这一步完成后，
单独的边的贡献就可以算出来了。
接下来计算单独的边与环接上的部分对环上的边的贡献增量。在上面dfs时，就可以将环上碰到的第一个点打上标记mark，表示有多少个点通过此点进入联通块，然后对于每个环中每个有标记的点，可以通过预处理得到bin(一个标记的增量)，答案增量就是(mark * bin[size-1])。
最后就是减去不互通的点对。将size>1的联通块中的每个点的tosize置为1，贡献就是\(-\sum{(n - tosize_i)}\).

code

#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;
namespace IO{
    template<typename T>
    inline void read(T &x){
        T i = 0, f = 1; char ch = getchar();
        for(; (ch < '0' || ch > '9') && ch != '-'; ch = getchar());
        if(ch == '-') f = -1, ch = getchar();
        for(; ch <= '9' && ch >= '0'; ch = getchar()) i = (i << 3) + (i << 1) + (ch - '0');
        x = i * f;
    }
    template<typename T>
    inline void wr(T x){
        if(x < 0) x = -x, putchar('-');
        if(x > 9) wr(x / 10);
        putchar(x % 10 + '0');
    }
}using namespace IO;

const int N = 5e5 + 50, mod = 1e9 + 7;
typedef long long ll;
int n, vt;
struct node{
    node *to;
    ll dis;
    ll bin;
    int from_size;
    int to_size;
    int low;
    int id;
    int dfn;
    int deg;
    int in_deg;
    int sccno;
    int vst;
    int mark;
    node():to(NULL), from_size(0), to_size(0), in_deg(0), low(0), dfn(0), deg(0), sccno(0), vst(0), mark(0), dis(0), bin(0){}
}*point[N], pool[N], *tail = pool;
ll clk, scc_cnt;
ll ans, bin[N];
vector<node*> cir[N];
stack<node*> stk;
queue<node*> que;

inline void Tarjan(node *u){
    u->low = u->dfn = ++clk;
    stk.push(u);

    node *v = u->to;
    if(!v->dfn){
        Tarjan(v);
        u->low = min(u->low, v->low);
    }
    else if(!v->sccno)
        u->low = min(u->low, v->dfn);

    if(u->low == u->dfn){
        node *x; 
        scc_cnt++;
        for(; ; ) {
            x = stk.top();
            stk.pop();
            x->sccno = scc_cnt;
            cir[scc_cnt].push_back(x);
            if(x == u) break;
        }
    }
}

inline void dfs(node *u){
    u->to_size = cir[u->sccno].size();
    u->vst = vt;
    if(u->to == u) return;
    if(cir[u->to->sccno].size() > 1) {
        u->to_size += cir[u->to->sccno].size();
        return;
    }
    if(u->to->vst == vt){
        u->to_size += u->to->to_size;
        return;
    }
    dfs(u->to);
    u->to_size += u->to->to_size;
}

inline void dfs2(node *u){
    u->vst = vt;
    if(u->to == u) return;
    if(cir[u->to->sccno].size() > 1) {
        u->to->mark += 1ll*u->from_size;
        return;
    }
    if(u->to->vst == vt) return;
    dfs2(u->to);
}

inline void init_bin(int k){
    ll sum = 0;
    for(register int i = 0, s = cir[k].size(); i < s; i++) sum = (sum + cir[k][i]->dis) % mod;
    node *now = cir[k][0], *last;
    for(register int i = 0, s = cir[k].size(); i < s; i++) cir[k][0]->bin = (now->dis * (s - i - 1) + cir[k][0]->bin) % mod, now = now->to;
    last = now;
    now = cir[k][0]->to;
    for(register int i = 1, s = cir[k].size(); i < s; i++){
        now->bin = (last->bin - 1ll*last->dis * (s - 1) + sum - last->dis) % mod;
        last = now, now = now->to;
    }
}

int main(){
    
    int _q=50<<20;
    char *_p=(char*)malloc(_q)+_q;
    __asm__("movl %0, %%esp\n"::"r"(_p));
    
    read(n);
    for(register int i = 1; i <= n; i++) bin[i] = (bin[i - 1] + i) % mod;
    for(register int i = 1; i <= n; i++) point[i] = tail++, point[i]->id = i;
    for(register int i = 1; i <= n; i++){
        int x;
        ll dis;
        read(x);
        read(dis);
        point[i]->to = point[x];
        point[i]->dis = dis;
        if(x != i) point[x]->in_deg++, point[x]->deg++;
    }

    for(register int i = 1; i <= n; i++) 
        if(!point[i]->dfn)
            Tarjan(point[i]);
            
    vt++;
    for(register int i = 1; i <= n; i++){
        if(cir[point[i]->sccno].size() <= 1) point[i]->from_size = 1;
        if(!point[i]->in_deg)
            dfs(point[i]), que.push(point[i]);
    }
        
    while(!que.empty()){
        node *u = que.front(); que.pop(); 
        if(cir[u->to->sccno].size() > 1) continue;
        u->to->from_size += u->from_size;
        if(!(--u->to->deg)) que.push(u->to);
    }
    vt++;
    for(register int i = 1; i <= n; i++)
        if(!point[i]->in_deg)
            dfs2(point[i]);
    
    for(register int i = 1; i <= n; i++)
        ans = (ans + 1ll*point[i]->dis * (point[i]->to_size - 1) * point[i]->from_size) % mod;
        
    for(register int i = 1; i <= scc_cnt; i++){
        if(cir[i].size() <= 1) continue;
        init_bin(i);
        for(register int j = 0, s = cir[i].size(); j < s; j++){
            ans = (ans + 1ll*cir[i][j]->mark * cir[i][j]->bin) % mod;
            ans = (ans + 1ll*cir[i][j]->dis * bin[s - 1]) % mod;
        }
    }
        
    for(register int i = 1; i <= n; i++){
        if(cir[point[i]->sccno].size() > 1) point[i]->to_size = cir[point[i]->sccno].size();
        ans = ((ans - (n - point[i]->to_size)) % mod + mod) % mod;
    }

    wr((ans % mod + mod) % mod);
    return 0;
}

转载于:https://www.cnblogs.com/CzYoL/p/7807655.html