[loj2255][SNOI2017]炸弹——线段树优化建图+缩点+DAGDP

题目大意：

在一条直线上有 N 个炸弹，每个炸弹的坐标是 Xi，爆炸半径是 Ri，当一个炸弹爆炸时，如果另一个炸弹所在位置 Xj 满足：
Xi−Ri≤Xj≤Xi+Ri,那么，该炸弹也会被引爆。
现在，请你帮忙计算一下，先把第 i 个炸弹引爆，将引爆多少个炸弹呢？

思路：

简单地在序列上面建图然后DAG DP即可，注意要先缩点。
但是发现边数可能会有$n^2$，于是利用线段树来由建图。
具体的，对于每一个点连向的点集必定是一个连续的区间，于是对于整个序列建一颗线段数，对于一个点连向的一段固定的区间，利用线段树区间分治的方法连边，这样每个点的边数就只有$logn$级别了，然后线段树上父亲儿子之间连边，直接连到叶子结点，注意只有叶子节点计算贡献。

#include<bits/stdc++.h>

#define REP(i,a,b) for(int i=a,i##_end_=b;i<=i##_end_;++i)
typedef long long ll;

using namespace std;

void File(){
    freopen("loj2255.in","r",stdin);
    freopen("loj2255.out","w",stdout);
}

template<typename T>void read(T &_){
    T __=0,mul=1; char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-')mul=-1;
        ch=getchar();
    }
    while(isdigit(ch))__=(__<<1)+(__<<3)+(ch^'0'),ch=getchar();
    _=__*mul;
}

const int maxn=5e5+10;
const int maxm=2e7+10;
const ll mod=1e9+7;
int n,lp[maxn],rp[maxn],tot,num[maxn];
ll x[maxn],y[maxn],ans;
vector<int>G[maxn<<2]; 
int beg[maxn<<2],to[maxm],las[maxm],cnte=1;

int val[maxn<<2],dp[maxn<<2];
int low[maxn<<2],dfn[maxn<<2],cnt_dfn,cnt_scc,bel[maxn<<2];
bool in[maxn<<2],isleaf[maxn<<2];
stack<int>stk;

void add(int u,int v){las[++cnte]=beg[u]; beg[u]=cnte; to[cnte]=v;}

struct Segment_Tree{
#define mid ((l+r)>>1)
#define lc rt<<1
#define rc rt<<1|1
#define lson lc,l,mid
#define rson rc,mid+1,r
    void build(int rt,int l,int r){
        tot=max(tot,rt);
        if(l==r){isleaf[rt]=1;num[l]=rt;return;}
        add(rt,lc); add(rt,rc);
        build(lson); build(rson);
    }
    void link(int rt,int l,int r,int L,int R,int id){
        if(L<=l && r<=R)add(id,rt);
        else{
            if(L<=mid)link(lson,L,R,id);
            if(R>=mid+1)link(rson,L,R,id);
        }
    }
}T;

void tarjan(int u){
    stk.push(u); in[u]=1;
    low[u]=dfn[u]=++cnt_dfn;
    for(int i=beg[u];i;i=las[i]){
        if(!dfn[to[i]]){
            tarjan(to[i]);
            low[u]=min(low[u],low[to[i]]);
        }
        else if(in[to[i]])low[u]=min(low[u],dfn[to[i]]);
    }
    if(low[u]==dfn[u]){
        ++cnt_scc;
        for(int p=0;p!=u;stk.pop()){
            p=stk.top();
            val[cnt_scc]+=isleaf[p];
            in[p]=0;
            bel[p]=cnt_scc;
        }
    }
}

int dfs(int u){
    if(dp[u])return dp[u];
    dp[u]=val[u];
    REP(i,0,G[u].size()-1){
        int v=G[u][i];
        dp[u]+=dfs(v);
    }
    return dp[u];
}

void solve(){
    read(n);
    REP(i,1,n)read(x[i]),read(y[i]);
    REP(i,1,n){
        lp[i]=lower_bound(x+1,x+n+1,x[i]-y[i])-x;
        rp[i]=upper_bound(x+1,x+n+1,x[i]+y[i])-x-1;
        //cout<<lp[i]<<" "<<rp[i]<<endl;
    }
    T.build(1,1,n);
    REP(i,1,n)T.link(1,1,n,lp[i],rp[i],num[i]);
    REP(i,1,tot)if(!dfn[i])tarjan(i);
    REP(i,1,tot)for(int j=beg[i];j;j=las[j])
        if(bel[i]!=bel[to[j]])G[bel[i]].push_back(bel[to[j]]);
    REP(i,1,cnt_scc){
        sort(G[i].begin(),G[i].end());
        //unique(G[i].begin(),G[i].end());
        G[i].erase(unique(G[i].begin(),G[i].end()),G[i].end());
        //REP(j,0,G[i].size()-1)cout<<G[i][j]<<" ";
        //cout<<endl;
    }
    //REP(i,1,cnt_scc+5)cout<<val[i]<<endl;
    REP(i,1,cnt_scc)if(!dp[i])dfs(i);
    //REP(i,1,n)cout<<dp[bel[num[i]]]<<endl;
    REP(i,1,n)ans=(ans+1ll*i*dp[bel[num[i]]])%mod;
    printf("%lld\n",ans);
}

int main(){
    File();
    solve();
    return 0;
}