炸弹

SNOI2017 省选题
题面

首先这可以是个图论题
一个很显然的解法就是如果这个炸弹能炸到另一个就从这个炸弹为起点向另一个炸弹建边就行
不过显然输入\(O(n)\)缩点\(O(n)\)跑DFS也是个\(O(n)\),然而建边\(O(n^2)\)
显然这个\(n^2\)的建边就直接拖了我们整个时间复杂度的后腿
因此我们要用线段树进行优化，优化完以后建边的复杂度就是个\(n\log n\)了
整体时间复杂度是\(O(n\log n)\)空间\(O(n)，128Mb+4000ms\)管够了
不过非常练码力，就先粘一份标算吧
Code

标算

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#define ll long long
using namespace std;
const int N = 5e5 + 5;
const int mod = 1e9 + 7;
vector<int> G[N << 2], vec[N << 2];
int n, lef[N << 2], rig[N << 2], mxid, id[N], dfn[N << 2], low[N << 2], sta[N << 2], top, num, cnt, col[N << 2];
ll X[N], R[N], ans;
bool vis[N << 2], is[N << 2];
struct node{int l, r;}q[N << 2];
inline ll read()//
{
	ll x = 0, f = 1; char ch = getchar();
	while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
	while(ch >= '0' && ch <= '9') {x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar();}
	return x * f;
}
void add(int x, int y) {vec[x].push_back(y);}
void build(int k, int l, int r)
{
	q[k] = node{l, r}; mxid = max(mxid, k);
	if(l == r) return id[l] = k, void();
	int mid = (l + r) >> 1;
	build(k << 1, l, mid);
	build(k << 1 | 1, mid + 1, r);//k << 1 | 1
	add(k, k << 1); add(k, k << 1 | 1);
}
void change(int k, int l, int r, int x, int y, int id)
{
	if(x <= l && r <= y) return (k == id) ? void() : (add(id, k), void());
	int mid = (l + r) >> 1;
	if(x <= mid) change(k << 1, l, mid, x, y, id);
	if(y > mid) change(k << 1 | 1, mid + 1, r, x, y, id);
}
void tarjan(int x)
{
	dfn[x] = low[x] = ++ num; vis[x] = 1; sta[++ top] = x;
	for(int i = 0; i < (int)vec[x].size(); i ++)
	{
		int y = vec[x][i];
		if(!dfn[y]) {tarjan(y); low[x] = min(low[x], low[y]);}
		else if(vis[y]) low[x] = min(low[x], dfn[y]);
	}
	if(dfn[x] == low[x])
	{
		cnt ++; int now;
		do
		{
			now = sta[top]; col[now] = cnt; vis[now] = 0;
			lef[cnt] = min(lef[cnt], q[now].l);
			rig[cnt] = max(rig[cnt], q[now].r);
		}while(sta[top --] != x);
	}
}
void dfs(int x)
{
	is[x] = 1;
	for(int i = 0; i < (int)G[x].size(); i ++)
	{
		int y = G[x][i]; if(!is[y]) dfs(y);
		lef[x] = min(lef[x], lef[y]);
		rig[x] = max(rig[x], rig[y]);
	}
}
void work()
{
	n = read(); memset(lef, 0x3f, sizeof(lef));//!!!!!
	for(int i = 1; i <= n; i ++) {X[i] = read(); R[i] = read();}
	X[n + 1] = 0x3f3f3f3f3f3f3f3fll; build(1, 1, n);
	for(int i = 1, LL, RR; i <= n; i ++)
	{
		if(!R[i]) continue;
		LL = lower_bound(X + 1, X + n + 1, X[i] - R[i]) - X;
		RR = upper_bound(X + 1, X + n + 1, X[i] + R[i]) - X - 1;
		change(1, 1, n, LL, RR, id[i]); q[id[i]] = node{LL, RR};
	}
	for(int i = 1; i <= mxid; i ++) if(!dfn[i]) tarjan(i);
	for(int i = 1; i <= mxid; i ++)
		for(int j = 0; j < (int)vec[i].size(); j ++)
		{
			int y = vec[i][j];
			if(col[i] == col[y]) continue;
			G[col[i]].push_back(col[y]);
		}
	for(int i = 1; i <= cnt; i ++) {sort(G[i].begin(), G[i].end()); unique(G[i].begin(), G[i].end());}
	for(int i = 1; i <= cnt; i ++) if(!is[i]) dfs(i);
	for(int i = 1; i <= n; i ++) ans = (ans + 1ll * i * (rig[col[id[i]]] - lef[col[id[i]]] + 1)) % mod;
	printf("%lld\n", ans);
}
int main() {return work(), 0;}

然后这可以是个递推题
（没错改良后的递推可以切掉此题,码量少,时间复杂度更优）
很简单，炸弹能炸到的最远距离就是能炸到的炸弹的最远距离
记录下左面的\(max\)和右面的\(max\)然后及时维护更新即可

递推

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
const ll o=5e5+10,mod=1e9+7;
ll a[o],b[o];
ll l[o],r[o],n;
ll ans;
ll read(){
	ll i=1,j=0;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-'){
			i=-1;
		}
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		j=(j<<1)+(j<<3)+ch-'0';
		ch=getchar();
	}
	return i*j;
}
void in(){
	n=read();
	for(int i=1;i<=n;i++){
		a[i]=read();
		b[i]=read();
		r[i]=i;
		l[i]=i;
	}
}
void work(){
	for(int i=2;i<=n;i++){
		while(a[i]-a[l[i]-1]<=b[i]&&l[i]>1){
			b[i]=max(b[i],b[l[i]-1]-(a[i]-a[l[i]-1]));
			l[i]=l[l[i]-1];
		}		
	}
	for(int i=n-1;i>=1;i--){
		while(a[r[i]+1]-a[i]<=b[i]&&r[i]<n){
			l[i]=min(l[i],l[r[i]+1]);
			r[i]=r[r[i]+1];
		}
	}
	for(int i=1;i<=n;i++){
		ans=ans+(ll)(((r[i]-l[i]+1)*i)%mod);
	}
}
void out(){
	cout<<ans%mod;
}
int main(){
	in();
	work();
	out();
	return 0;
}