题目
题目链接：https://loj.ac/problem/2255
在一条直线上有 \(n\) 个炸弹，每个炸弹的坐标是 \(x_i\)，爆炸半径是 \(r_i\)，当一个炸弹爆炸时，如果另一个炸弹所在位置 \(x_j\) 满足 \(|x_j-x_i|\le r_i\) ，那么，该炸弹也会被引爆。
现在，请你帮忙计算一下，先把第 \(i\) 个炸弹引爆，将引爆多少个炸弹呢？
答案对 \(10^9 + 7\) 取模。
思路
首先显然每个炸弹炸的范围是一个区间。我们可以先求出这个区间 \([p_i,q_i]\)。
然后如果我们将 \(i\) 向满足 \(x\in [p_i,i)∪(i,q_i]\)，那么就将 \(i\) 向 \(x\) 连边。然后在这张图中，每个点能到达的点就是能炸到的炸弹。
然而这种算法时空复杂度都不够优秀。考虑优化。
首先解决空间复杂度，即建图的问题。普通的建图最高复杂度会达到 \(O(n^2)\)。但是由于每一个炸弹炸到的范围是一个区间，我们可以用线段树优化建图。线段树的每个子节点向父亲连边，然后对于每一个点 \(i\)，将 \([p_i,i)\) 和 \((i,q_i]\) 的在线段树中的区间连向 \(i\)。这样每个点最多连 \(\log n\) 条边，空间复杂度 \(O(n\log n)\)。
接下来考虑如何求每个点能到达哪些点。显然的，先将图缩点，变成一张 DAG。由于每一个炸弹爆炸到的点是一个范围，所以可以直接维护每一个 SCC 能爆炸到的最小/最大编号的炸弹，那么这个 SCC 能炸到的点数量即为两者的差加一。
接下来处理 DAG 中的边。显然可以用 topsort 来解决不是一个 SCC 内的点的爆炸关系。具体的，如果在 DAG 中有一条边 \((x,y)\)，那么就让 \(y\) 所能爆炸到的最值与 \(x\) 所能爆炸到的最值取 \(\operatorname{min/max}\)。
那么最终假设点 \(i\) 处于第 \(col[i]\) 个 SCC，那么点 \(i\) 做出的贡献即为 \(i\times (R[col[i]]-L[col[i]]+1)\)。其中 \(L,R\) 分别为这个 SCC 所能爆炸到的点的编号范围。
时间复杂度 \(O(n\log n+n)\)。在洛谷上吸氧能过，LOJ 上直接过了。
代码
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define reg register
using namespace std;
typedef long long ll;
const int N=2000010,M=500010*30,MOD=1e9+7;
int head[M],From[M],To[M],id[N],dfn[N],low[N],col[N],p[N],q[N],deg[N],L[N],R[N];
int n,tot,Maxn,cnt;
ll ans,pos[N],len[N];
bool vis[N];
stack<int> st;
struct edge
{
int next,to;
}e[M];
inline ll read()
{
ll d=0,f=1; char ch=getchar();
while (!isdigit(ch)) f=(ch=='-'?-1:f),ch=getchar();
while (isdigit(ch)) d=(d<<3)+(d<<1)+ch-48,ch=getchar();
return d*f;
}
void add(int from,int to)
{
e[++tot].to=to;
e[tot].next=head[from];
head[from]=tot;
From[tot]=from; To[tot]=to;
}
struct SegTree
{
int l[M],r[M];
void build(int x,int ql,int qr)
{
l[x]=ql; r[x]=qr;
Maxn=max(Maxn,x);
if (ql==qr)
{
id[ql]=x;
return;
}
int mid=(ql+qr)>>1;
build(x*2,ql,mid);
build(x*2+1,mid+1,qr);
add(x*2,x); add(x*2+1,x);
}
void update(int x,int ql,int qr,int i)
{
if (ql>qr) return;
if (ql==l[x] && qr==r[x])
{
add(x,id[i]);
return;
}
int mid=(l[x]+r[x])>>1;
if (qr<=mid) update(x*2,ql,qr,i);
else if (ql>mid) update(x*2+1,ql,qr,i);
else update(x*2,ql,mid,i),update(x*2+1,mid+1,qr,i);
}
}seg;
void tarjan(int x)
{
dfn[x]=low[x]=++tot;
st.push(x); vis[x]=1;
for(reg int i=head[x];~i;i=e[i].next)
{
int v=e[i].to;
if (!dfn[v])
{
tarjan(v);
low[x]=min(low[x],low[v]);
}
else if (vis[v])
low[x]=min(low[x],dfn[v]);
}
if (dfn[x]==low[x])
{
int y; cnt++;
do {
y=st.top(); st.pop();
vis[y]=0; col[y]=cnt;
L[cnt]=min(L[cnt],p[y]);
R[cnt]=max(R[cnt],q[y]);
} while (x!=y);
}
}
inline void topsort()
{
queue<int> Q;
for(reg int i=1;i<=cnt;i++)
if (!deg[i]) Q.push(i);
while (Q.size())
{
int u=Q.front(); Q.pop();
for(reg int i=head[u];~i;i=e[i].next)
{
int v=e[i].to;
L[v]=min(L[v],L[u]);
R[v]=max(R[v],R[u]);
deg[v]--;
if (!deg[v]) Q.push(v);
}
}
}
int main()
{
memset(head,-1,sizeof(head));
memset(p,0x3f3f3f3f,sizeof(p));
memset(L,0x3f3f3f3f,sizeof(L));
n=read();
seg.build(1,1,n);
for(reg int i=1;i<=n;i++)
pos[i]=read(),len[i]=read();
pos[0]=-9223372036854775808LL;
pos[n+1]=9223372036854775807LL;
for(reg int i=1;i<=n;i++)
{
p[id[i]]=lower_bound(pos,pos+n+2,pos[i]-len[i])-pos;
q[id[i]]=upper_bound(pos,pos+n+2,pos[i]+len[i])-pos-1;
seg.update(1,p[id[i]],i-1,i);
seg.update(1,i+1,q[id[i]],i);
}
int tot2=tot;
tot=0;
for(reg int i=1;i<=Maxn;i++)
if (!dfn[i]) tarjan(i);
memset(head,-1,sizeof(head));
tot=0;
for(reg int i=1;i<=tot2;i++)
{
int x=col[From[i]],y=col[To[i]];
if (x!=y)
{
add(x,y);
deg[y]++;
}
}
topsort();
for(reg int i=1;i<=n;i++)
ans=(ans+1LL*i*(R[col[id[i]]]-L[col[id[i]]]+1))%MOD;
printf("%lld",ans);
return 0;
}