『炸弹线段树优化建图 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

Sample Output

解析

很自然我们可以将问题转化为图论的模型：每个炸弹当做一个点，向可以连环引爆的其他点连边，然后一个点的答案就是这个点出发$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;

}

<后记>