基环树学习笔记

基环树学习笔记

往一个树上额外添加一条边，称得到的图为基环树。

基环树点数和边数相同，但是点数和边数相同的图不一定是基环树。

另外，满足以下性质的图是基环森林（当联通时是基环树）：

• 每个点有且仅有一条出边，这时候称得到的图为外向基环森林。
• 每个点有且仅有一条入边，这时候称得到的图为内向基环森林。

---

对基环树通常的处理方法有两种。

第一种是任意断开环上的一条边，当作树上问题做。最后再考虑这条边对答案的影响。

第二种是断开环上的所有边，对得到的所有树处理得到根的答案，转化成环上的问题。

实现上，可以用 dfs 找出环，然后正常做。或者是在拓扑排序的过程中维护。

---

例题：

P4381 [IOI 2008] Island

求基环树的直径。

将环全部断开，求出每个子树内的最大值。dp 可以直接求出。

令 \(d_x\) 表示 \(x\) 子树内的最深点的深度。

取环上任意一点 \(p\)，从 \(p\) 点处断开得到链。令 \(s_x\) 表示 \(x\) 点在这条链上到 \(p\) 的距离。

那么经过环的最长距离就是

\[\max_{s_y>s_x} d_x+d_y+\max(s_y-s_x,s_x-s_y+\text{len}) \]

拆开可以直接线性维护。

code

#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>

const int N = 1e6 + 7;
typedef long long i64;

namespace wyx {

int n, deg[N];
std::vector<std::pair<int, int>> g[N];
i64 dp[N], de[N], ans;

inline void pushup(int u) {
	dp[u] = 0;
	for(auto& [v, w]: g[u]) {
		if(deg[v] == 1) {
			dp[u] = std::max(dp[u], dp[v]);
			dp[u] = std::max(dp[u], de[u] + de[v] + w);
			de[u] = std::max(de[u], de[v] + w);
		}
	}
}

void toposort() {
	std::queue<int> q;
	for(int i = 1; i <= n; ++i) {
		if(deg[i] == 1) {
			q.push(i);
		}
	}
	while(!q.empty()) {
		int u = q.front(); q.pop();
		pushup(u);
		for(auto& [v, w]: g[u]) {
			if(--deg[v] == 1) q.push(v);
		}
	}
}

inline void solve(int x) {
	i64 res = 0;
	i64 a1 = -1e18, a2 = -1e18, b1 = -1e18, b2 = -1e18, pre = 0;
	int y = x;
	while(x) {
		deg[x] = 0;
		int nv = 0, nw = 0;
		for(auto& [v, w]: g[x]) {
			if(deg[v] == 2) {
				nv = v, nw = w; break;
			} 
		}

		pushup(x);
		res = std::max(res, dp[x]);

		b1 = std::max(b1, a1 + de[x] + pre);
		b2 = std::max(b2, a2 + de[x] - pre);
		a1 = std::max(a1, de[x] - pre);
		a2 = std::max(a2, de[x] + pre);

		if(!nv) {
			std::reverse(g[x].begin(), g[x].end());
			for(auto& [v, w]: g[x]) {
				if(v == y) { pre += w; break; }
			}
			break;
		}
		pre += nw, x = nv;
	}

	res = std::max(res, std::max(b1, b2 + pre));
	ans += res;
}

inline void main() {
	std::cin >> n;
	for(int i = 1; i <= n; ++i) {
		int x = i, y, z;
		std::cin >> y >> z;
		g[x].emplace_back(y, z);
		g[y].emplace_back(x, z);
		++deg[x], ++deg[y];
	}
	toposort();
	for(int i = 1; i <= n; ++i) {
		if(deg[i] == 2) {
			solve(i);
		}
	}
	std::cout << ans << "\n";	
}

};

int main() {
	std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
	wyx::main();
}

---

P2607 [ZJOI2008] 骑士

求基环树上最大独立集。

树内用类似上一题的方法处理。

环上的部分，可以从任意边 \(x \rightarrow y\) 断开。

dp 时钦定 \(x\) 选/不选，dp 到 \(y\) 的状态时合并答案。

code

#include <algorithm>
#include <iostream>
#include <queue>
#include <tuple>

namespace wyx {

const int N = 1e6 + 7;

typedef long long i64;
int n, deg[N]; i64 dp[N][2], w[N];
std::basic_string<int> g[N];

inline void pushup(int u) {
	dp[u][0] = 0, dp[u][1] = w[u];
	for(int& v: g[u]) {
		if(deg[v] == 1) {
			dp[u][0] += std::max(dp[v][0], dp[v][1]);
			dp[u][1] += dp[v][0];
		}
	}
}

inline void toposort() {
	std::queue<int> q;
	for(int i = 1; i <= n; ++i) {
		if(deg[i] == 1) q.push(i);
	}
	while(!q.empty()) {
		int u = q.front(); q.pop();
		pushup(u);
		for(int& v: g[u]) {
			if(--deg[v] == 1) q.push(v);
		}
	}
}

i64 ans = 0;
inline void solve(int x) {
	auto findnext = [](int x) { for(int& v: g[x]) if(deg[v] == 2) return v; return 0; };

	i64 dp[2][2];

	pushup(x);
	dp[1][1] = wyx::dp[x][1], dp[0][0] = wyx::dp[x][0];
	dp[1][0] = dp[0][1] = -1e18;	
	deg[x] = 0, x = findnext(x);

	while(x) {
		pushup(x);
		for(int k = 0; k < 2; ++k) {
			std::tie(dp[k][0], dp[k][1]) = std::make_pair(
				std::max(dp[k][0], dp[k][1]) + wyx::dp[x][0], 
				dp[k][0] + wyx::dp[x][1]
			);
		}

		deg[x] = 0, x = findnext(x);
	}		

	i64 res = std::max({dp[0][0], dp[0][1], dp[1][0]});
	ans += res;
}

inline void main() {
	std::cin >> n;
	for(int y, i = 1; i <= n; ++i) {
		std::cin >> w[i] >> y;
		g[i] += y, g[y] += i;
		++deg[i], ++deg[y];
	}
	toposort();
	for(int i = 1; i <= n; ++i) {
		if(deg[i] == 2) {
			solve(i);
		}
	}
	std::cout << ans << "\n";
}

};

int main() {
	std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
	wyx::main();
}