bzoj千题计划311：bzoj5017: [Snoi2017]炸弹（线段树优化tarjan构图）

https://www.lydsy.com/JudgeOnline/problem.php?id=5017

暴力：

对于每一个炸弹，枚举所有的炸弹，看它爆炸能不能引爆那个炸弹

如果能，由这个炸弹向引爆的炸弹连单向边

tarjan所点后拓扑排序

在拓扑图上倒着统计答案

可以得到一个炸弹能引爆的编号最小mi和最大的炸弹mx，mx-mi+1就是先引爆这个炸弹一共能引爆的炸弹数

优化：

一个炸弹一定是向一段区间连边

所以用线段树优化，这样向一个区间连边就变成了向一个点连边

注意存边的空间一定要开的足够大

还有tarjan缩完点后不一定是一棵树，因为是有向图缩点

#include<cstdio>
#include<vector>
#include<iostream>
#include<algorithm>

using namespace std;

const int mod=1e9+;

#define N 500001 

typedef long long LL;

int n;

int id[N*],num;
int front[N*],to[N*],nxt[N*],from[N*],tot;

LL pos[N],rad[N];

int dfn[N*],low[N*],tim;
int st[N*],top;
bool vis[N*];

int cnt;
int bl[N*],mi[N*],mx[N*];

vector<int>V[N*];
int in[N*];

int q[N*];

template<typename T>
void read(T &x)
{
    x=; int f=; char c=getchar();
    while(!isdigit(c)) { if(c=='-') f=-; c=getchar(); }
    while(isdigit(c)) { x=x*+c-''; c=getchar(); }
    x*=f;
}

void add(int u,int v)
{
    to[++tot]=v; nxt[tot]=front[u]; front[u]=tot; from[tot]=u;
    //printf("%d %d\n",u,v);
}

/*void add2(int u,int v)
{
    to2[++tot2]=v; nxt2[tot2]=front2[u]; front2[u]=tot2;
}*/

void build(int k,int l,int r)
{
    id[k]=++num;
    if(l==r)
    {
        add(id[k],l);
        return;
    }
    int mid=l+r>>;
    build(k<<,l,mid);
    build(k<<|,mid+,r);
    add(id[k],id[k<<]);
    add(id[k],id[k<<|]);
}

void burst(int k,int l,int r,int opl,int opr,int who)
{
    if(l>=opl && r<=opr)
    {
        add(who,id[k]);
        return;
    }
    int mid=l+r>>;
    if(opl<=mid) burst(k<<,l,mid,opl,opr,who);
    if(opr>mid) burst(k<<|,mid+,r,opl,opr,who);
}

void init()
{
    read(n);
    num=n;
    build(,,n);
    for(int i=;i<=n;++i) read(pos[i]),read(rad[i]);
    for(int i=;i<=n;++i) burst(,,n,lower_bound(pos+,pos+n+,pos[i]-rad[i])-pos,upper_bound(pos+,pos+n+,pos[i]+rad[i])-pos-,i);
}

void tarjan(int x)
{
    dfn[x]=low[x]=++tim;
    st[++top]=x;
    vis[x]=true;
    for(int i=front[x];i;i=nxt[i])
        if(!dfn[to[i]])
        {
            tarjan(to[i]);
            low[x]=min(low[x],low[to[i]]);
        }
        else if(vis[to[i]]) low[x]=min(low[x],dfn[to[i]]);
    int y;
    if(low[x]==dfn[x])
    {
        cnt++;
        mi[cnt]=n+;
        mx[cnt]=;
        while(x!=y)
        {
            y=st[top--];
            vis[y]=false;
            bl[y]=cnt;
            if(y<=n)
            {
                mi[cnt]=min(mi[cnt],y);
                mx[cnt]=max(mx[cnt],y);
            }
        }
    }
}

void rebuild()
{
    for(int i=;i<=tot;++i)
        if(bl[from[i]]!=bl[to[i]])
        {
            //add2(bl[from[i]],bl[to[i]]);
            V[bl[from[i]]].push_back(bl[to[i]]);
            in[bl[to[i]]]++;
        }
}

void topsort()
{
    int head=,tail=;
    for(int i=;i<=cnt;++i)
        if(!in[i]) q[tail++]=i;
    int now,siz,t;
    while(head<tail)
    {
        now=q[head++];
        siz=V[now].size();
        for(int i=;i<siz;++i)
        {
            t=V[now][i];
            in[t]--;
            if(!in[t]) q[tail++]=t;
        }
    }
    for(int i=tail-;i;--i)
    {
        now=q[i];
        siz=V[now].size();
        for(int i=;i<siz;++i)
        {
            t=V[now][i];
            mi[now]=min(mi[now],mi[t]);
            mx[now]=max(mx[now],mx[t]);
        }
    }
}

void work()
{
//  printf("%d %d\n",num,tot);
    for(int i=;i<=num;++i)
        if(!dfn[i]) tarjan(i);
    rebuild();
    topsort();
    int ans=;
    for(int i=;i<=n;++i)
    {
        ans+=1LL*i*(mx[bl[i]]-mi[bl[i]]+)%mod;
        ans-=ans>=mod ? mod : ;
    }
    printf("%d",ans);
}

int main()
{
    init();
    work();
}