bzoj5017 [Snoi2017]炸弹 (线段树优化建图+)tarjan 缩点+拓扑排序

题目传送门

https://lydsy.com/JudgeOnline/problem.php?id=5017

题解

这个题目方法挺多的。

线段树优化建图

线段树优化建图的做法应该挺显然的，一个炸弹能够引爆的炸弹的显然应该是一个区间里面的，直接对这个区间进行线段树优化建图。

这样可以得到一个带环图，缩点以后这个炸弹能够炸到的炸弹就是从这个点能够走到的点。

但是这个不太好做，不过可以发现最终的炸弹也是一个区间，所以可以通过缩点后的 DAG 来求出左右端点。

时间复杂度 \(O(n\log n)\)，空间复杂度 \(O(n\log n)\)。

---

一般的建图

可以发现在一个点可以炸到的炸弹中，真正会对最终答案的左右端点有贡献的只有这些炸弹里面左端点最小的和右端点最大的炸弹。

直接对这两个炸弹建边就可以了，然后和上面一样，先 tarjan 缩点，然后在 DAG 上跑出来左右端点。

但是因为想要确定左右端点对应的位置，所以这个 \(log\) 还是没有办法去掉。

时间复杂度 \(O(n\log n)\)，空间复杂度 \(O(n)\)。

---

神仙的线性递推做法

https://www.cnblogs.com/saigyouji-yuyuko/p/11771364.html

丢个链接跑路。

我不会，好像很神仙的样子。

听说是时空都是线性的哦。

---

#include<bits/stdc++.h>

#define fec(i, x, y) (int i = head[x], y = g[i].to; i; i = g[i].ne, y = g[i].to)
#define dbg(...) fprintf(stderr, __VA_ARGS__)
#define File(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)
#define fi first
#define se second
#define pb push_back

template<typename A, typename B> inline char smax(A &a, const B &b) {return a < b ? a = b, 1 : 0;}
template<typename A, typename B> inline char smin(A &a, const B &b) {return b < a ? a = b, 1 : 0;}

typedef long long ll; typedef unsigned long long ull; //typedef std::pair<int, int> pii;

template<typename I> inline void read(I &x) {
	int f = 0, c;
	while (!isdigit(c = getchar())) c == '-' ? f = 1 : 0;
	x = c & 15;
	while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + (c & 15);
	f ? x = -x : 0;
}

const int N = 500000 + 7;
const int M = 500000 * 2 + 7;
const int P = 1e9 + 7;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int LOG = 19;

typedef std::pair<ll, int> pii;

int n, m, sccno, dfc, tp;
int dfn[N], low[N], scc[N], s[N];
std::vector<int> v[N];
ll a[N], r[N], dpl[N], dpr[N];
pii minl[N][LOG], maxr[N][LOG];

struct Edge { int to, ne; } g[M]; int head[N], tot;
inline void addedge(int x, int y) { g[++tot].to = y, g[tot].ne = head[x], head[x] = tot; }
inline void adde(int x, int y) { addedge(x, y), addedge(y, x); }

inline void dfs(int x) {
	dfn[x] = low[x] = ++dfc, s[++tp] = x;
	for fec(i, x, y) if (!dfn[y]) dfs(y), smin(low[x], low[y]);
	else if (!scc[y]) smin(low[x], dfn[y]);
	if (low[x] == dfn[x]) {
		++sccno;
		dpl[sccno] = INF, dpr[sccno] = -INF;
		while (1) {
			int y = s[tp--];
			scc[y] = sccno, smax(dpr[scc[y]], a[y] + r[y]), smin(dpl[scc[y]], a[y] - r[y]);
			v[scc[y]].pb(y);
			if (x == y) break;
		}
	}
}
inline void tarjan() {
	for (int i = 1; i <= n; ++i)
		if (!dfn[i]) dfs(i);
}

inline void rmq_init() {
	for (int i = 1; i <= n; ++i) minl[i][0] = pii(a[i] - r[i], i), maxr[i][0] = pii(a[i] + r[i], i);
	for (int j = 1; (1 << j) <= n; ++j)
		for (int i = 1; i + (1 << j) - 1 <= n; ++i)
			minl[i][j] = std::min(minl[i][j - 1], minl[i + (1 << (j - 1))][j - 1]),
			maxr[i][j] = std::max(maxr[i][j - 1], maxr[i + (1 << (j - 1))][j - 1]);
}
inline pii qmin(int l, int r) {
	int k = std::__lg(r - l + 1);
	return std::min(minl[l][k], minl[r - (1 << k) + 1][k]);
}
inline pii qmax(int l, int r) {
	int k = std::__lg(r - l + 1);
	return std::max(maxr[l][k], maxr[r - (1 << k) + 1][k]);
}

inline void work() {
	rmq_init();
	for (int i = 1; i <= n; ++i) {
		int pl = std::lower_bound(a + 1, a + n + 1, a[i] - r[i]) - a,
			pr = std::upper_bound(a + 1, a + n + 1, a[i] + r[i]) - a - 1;
		addedge(i, qmin(pl, pr).se);
		addedge(i, qmax(pl, pr).se);
	}
	tarjan();
	for (int i = 1; i <= sccno; ++i) {
		int len = v[i].size();
		for (int j = 0; j < len; ++j) {
			int x = v[i][j];
			for fec(iii, x, y) smin(dpl[i], dpl[scc[y]]), smax(dpr[i], dpr[scc[y]]), assert(scc[y] <= i);
		}
	}
	ll ans = 0;
	for (int i = 1; i <= n; ++i) {
		int pl = std::lower_bound(a + 1, a + n + 1, dpl[scc[i]]) - a,
			pr = std::upper_bound(a + 1, a + n + 1, dpr[scc[i]]) - a - 1;
		ans += (ll)i * (pr - pl + 1);
	}
	printf("%lld\n", ans % P);
}

inline void init() {
	read(n);
	for (int i = 1; i <= n; ++i) read(a[i]), read(r[i]);
}

int main() {
#ifdef hzhkk
	freopen("hkk.in", "r", stdin);
#endif
	init();
	work();
	fclose(stdin), fclose(stdout);
	return 0;
}