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;
}