『炸弹 线段树优化建图 Tarjan』
<更新提示>
<第一次更新>
<正文>
炸弹(SNOI2017)
Description
在一条直线上有 N 个炸弹，每个炸弹的坐标是 Xi，爆炸半径是 Ri，当一个炸弹爆炸 时，如果另一个炸弹所在位置 Xj 满足：
Xi−Ri≤Xj≤Xi+Ri,那么，该炸弹也会被引爆。 现在，请你帮忙计算一下，先把第 i 个炸弹引爆，将引爆多少个炸弹呢？
Input Format
第一行，一个数字 N，表示炸弹个数。 第 2∼N+1行，每行 2 个数字，表示 Xi，Ri，保证 Xi 严格递增。
N≤500000
−10 ^18≤Xi≤10 ^18
0≤Ri≤2×10 ^18
Output Format
一个数字，表示Sigma(i*炸弹i能引爆的炸弹个数),1<=i<=N mod10^9+7。
Sample Input
4
1 1
5 1
6 5
15 15
Sample Output
32
解析
很自然我们可以将问题转化为图论的模型：每个炸弹当做一个点，向可以连环引爆的其他点连边，然后一个点的答案就是这个点出发\(dfs\)可以遍历到的所有点。
直接连边的话建图就会超时，边数的\(n^2\)的，不难发现每一个点要连边的点处于连续的一段区间中，于是想到线段树优化建图。
什么是线段树优化建图？就是把线段树用邻接表显式的建出来，然后对于一个区间内的连续若干个点的连边，就可以利用线段树区间划分的方式，向不超过\(log_2(r-l+1)\)个线段树节点连边，以达到向这当中所有点连边的目的。
建完图后，我们又发现对每一个点都\(dfs\)会超时，于是想到将互相可达的点先处理掉，也就是\(SCC\)缩点，然后在剩下的\(DAG\)上，反图\(dp\)即可统计每一个点的答案。在这当中，我们需要维护一下每个点可达区间的最小左端点和最大右端点即可。
\(Code:\)
#include <bits/stdc++.h>
using namespace std;
const int N = 500020 , Mod = 1000000007;
struct edge { int ver,next; } e1[N*25],e2[N*25];
struct SegmentTree
{
int l,r,id,re;
#define l(p) ver[p].l
#define r(p) ver[p].r
#define id(p) ver[p].id
#define re(p) ver[p].re
}ver[N<<2];
int n,t1,t2,Head1[N*2],Head2[N*2],indeg[N*2],tot;
int dfn[N*2],low[N*2],ins[N*2],st[N*2],c[N*2],top,num,cnt;
int Min[N*2],Max[N*2];
long long x[N],r[N],ans;
inline void insert1(int x,int y)
{
e1[++t1] = (edge){y,Head1[x]} , Head1[x] = t1;
}
inline void insert2(int x,int y)
{
e2[++t2] = (edge){y,Head2[x]} , Head2[x] = t2;
}
inline void chmin(int &a,int b) { a = min( a , b ); }
inline void chmax(int &a,int b) { a = max( a , b ); }
inline void input(void)
{
scanf("%d",&n);
for ( int i = 1; i <= n; i++ )
scanf("%lld%lld",&x[i],&r[i]);
}
inline void BuildTree(int p,int l,int r)
{
l(p) = l , r(p) = r;
if ( l == r ) { id(p) = l , re(l) = p; return; }
id(p) = ++tot , re(tot) = p;
int mid = l + r >> 1;
BuildTree( p<<1 , l , mid );
BuildTree( p<<1|1 , mid+1 , r );
insert1( id(p) , id(p<<1) );
insert1( id(p) , id(p<<1|1) );
}
inline void connect(int p,int l,int r,int x)
{
if ( l <= l(p) && r >= r(p) ) return insert1( x , id(p) );
int mid = l(p) + r(p) >> 1;
if ( l <= mid ) connect( p<<1 , l , r , x );
if ( r > mid ) connect( p<<1|1 , l , r , x );
}
inline void Tarjan(int x)
{
dfn[x] = low[x] = ++num;
st[++top] = x , ins[x] = true;
for ( int i = Head1[x]; i; i = e1[i].next )
{
int y = e1[i].ver;
if ( !dfn[y] )
{
Tarjan( y );
low[x] = min( low[x] , low[y] );
}
else if ( ins[y] )
low[x] = min( low[x] , dfn[y] );
}
if ( dfn[x] == low[x] )
{
++cnt; int y;
do
{
y = st[top--] , ins[y] = false;
c[y] = cnt;
chmin( Min[cnt] , l(re(y)) );
chmax( Max[cnt] , r(re(y)) );
}
while ( x != y );
}
}
inline void Topsort(void)
{
queue < int > q;
for ( int i = 1; i <= tot; i++ )
if ( !indeg[i] ) q.push(i);
while ( !q.empty() )
{
int x = q.front(); q.pop();
for ( int i = Head2[x]; i; i = e2[i].next )
{
int y = e2[i].ver;
chmin( Min[y] , Min[x] );
chmax( Max[y] , Max[x] );
if ( ! -- indeg[y] ) q.push( y );
}
}
}
inline void BuildGraph(void)
{
for ( int i = 1; i <= n; i++ )
{
int L = lower_bound( x+1 , x+i+1 , x[i] - r[i] ) - x;
int R = upper_bound( x+i+1 , x+n+1 , x[i] + r[i] ) - x - 1;
connect( 1 , L , R , i );
}
}
inline void rebuild(void)
{
for ( int x = 1; x <= tot; x++ )
{
for ( int i = Head1[x]; i; i = e1[i].next )
{
int y = e1[i].ver;
if ( c[x] != c[y] )
insert2( c[y] , c[x] ) , indeg[c[x]]++;
}
}
}
inline void solve(void)
{
for ( int i = 1; i <= n; i++ )
ans = ( ans + 1LL * i * ( Max[c[i]] - Min[c[i]] + 1 ) % Mod ) % Mod;
}
int main(void)
{
input();
tot = n , BuildTree( 1 , 1 , n );
BuildGraph();
memset( Min , 0x3f , sizeof Min );
memset( Max , 0x00 , sizeof Max );
for ( int i = 1; i <= tot; i++ )
if ( !dfn[i] ) Tarjan( i );
rebuild();
Topsort();
solve();
printf("%lld\n",ans);
return 0;
}
<后记>
