BZOJ5017 [SNOI2017]炸弹

Solution

一个点向一个区间内的所有点连边， 可以用线段树优化建图来优化 ： 前置技能传送门

然后就得到一个有向图， 一个联通块内的炸弹可以互相引爆， 所以进行缩点变成$DAG$

然后拓扑排序。 由于一次引爆的炸弹 一定是一个连续的区间内， 所以只需要记录左右边界， 并将左右边界转移给能到达它的联通块。

没写手工栈一直RE的我心里$mmp$啊。 为什么网上的题解都不写手工栈$QAQ$

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#define rd read()
#define ll long long
using namespace std;
  
const int N = 2000010;
const int mod = 1e9 + 7;
const ll inf = 3e18;
  
int n, lscnt;
int head[N], tot;
int Head[N], Tot;
int low[N], dfn[N], dfstot;
int c[N], col;
ll minn[N], maxn[N], ls[N];
int st[N], tp;
bool vis[N], inq[N];
  
struct edge {
    int nxt, to;
}e[N * 10], E[N * 10];
  
struct boom {
    ll pos, r;
}bo[N];
  
ll read() {
    ll X = 0, p = 1; char c = getchar();
    for (; c > '9' || c < '0'; c = getchar())
        if (c == '-') p = -1;
    for (; c >= '0' && c <= '9'; c = getchar())
        X = X * 10 + c - '0';
    return X * p;
}
  
void add(int u, int v) {
    e[++tot].to = v;
    e[tot].nxt = head[u];
    head[u] = tot;
}
  
void Add(int u, int v) {
    E[++Tot].to = v;
    E[Tot].nxt = Head[u];
    Head[u] = Tot;
}
  
namespace SegT {
#define mid ((l + r) >> 1)
    int lc[N], rc[N], root, cnt;
  
    void build(int &p, int l, int r) {
        if (l == r) {
            p = l; return;
        }
        p = ++cnt;
        build(lc[p], l, mid);
        build(rc[p], mid + 1, r);
        add(p, lc[p]); add(p, rc[p]);
    }
  
    void update(int L, int R, int c, int l, int r, int x) {
        if (L > R) return;
        if (L <= l && r <= R) {
            add(c, x); return;
        }
        if (mid >= L)
            update(L, R, c, l,mid, lc[x]);
        if (mid < R)
            update(L, R, c, mid + 1, r, rc[x]);
    }
}using namespace SegT;
  
#define R register
int stx[N], sti[N], lv, stnt[N];
#define u stx[lv]
#define nt stnt[lv]
#define i sti[lv]
void tarjan(int x) {
    lv = 1; stx[1] = x;
start:;
    low[u] = dfn[u] = ++dfstot;
    inq[u] = true; st[++tp] = u;
    for (i = head[u]; i; i = e[i].nxt) {
        nt = e[i].to;
        if (!dfn[nt]) {
//         tarjan(nt);
            stx[lv + 1] = nt;
            lv++;
            goto start;
            end:;
            low[u] = min(low[u], low[nt]);
        }
        else if (inq[nt]) low[u] = min(low[u], dfn[nt]);
    }
    if (low[u] == dfn[u]) {
        col++;
        for (; tp;) {
            int z = st[tp--];
            inq[z] = false;
            if (z <= n) 
                maxn[col] = max(maxn[col], bo[z].pos + bo[z].r),
                minn[col] = min(minn[col], bo[z].pos - bo[z].r);
            c[z] = col;
            if (z == u) break;
        }
    }
    --lv;
if (lv) goto end;
}
#undef u
#undef nt
#undef i
  
void dfs(int u) {
    vis[u] = true;
    for (R int i = Head[u]; i; i = E[i].nxt) {
        int nt = E[i].to;
        if (vis[nt] == false) dfs(nt);
        minn[u] = min(minn[u], minn[nt]);
        maxn[u] = max(maxn[u], maxn[nt]);
    }
}
  
int fdl(ll x) {
    return lower_bound(ls + 1, ls + 1 + lscnt, x) - ls;
}
  
int fdr(ll x) {
    int re = lower_bound(ls + 1, ls + 1 + lscnt, x) - ls;
    if (ls[re] == x) return re;
    else return re - 1;
}
  
int main()
{
    cnt = n = rd;
    for (R int i = 1; i <= n; ++i) {
        bo[i].pos = rd; bo[i].r = rd;
        ls[++lscnt] = bo[i].pos;
    }
    sort(ls + 1, ls + 1 + lscnt);
    lscnt = unique(ls + 1, ls + 1 + lscnt) - ls - 1;
    build(root, 1, n);
    for (int i = 1; i <= n; ++i) {
        int l = fdl(bo[i].pos - bo[i].r), r = fdr(bo[i].pos + bo[i].r), m = fdl(bo[i].pos);
        update(l, m - 1, m, 1, n, root);
        update(m + 1, r, m, 1, n, root);
    }
    for (int i = 1; i < N; ++i)
        maxn[i] = -inf, minn[i] = inf;
    for (int i = 1; i <= cnt; ++i)
        if (!dfn[i]) tarjan(i);
    for (int u = 1; u <= cnt; ++u) 
        for (int i = head[u]; i; i = e[i].nxt) {
            int v = e[i].to;
            if (c[u] == c[v])
                continue;
            Add(c[u], c[v]);
        }
    for (int i = 1; i <= col; ++i) dfs(i);
    ll ans = 0;
    for (int i = 1; i <= n; ++i) {
        int l = fdl(minn[c[i]]), r = fdr(maxn[c[i]]);
        (ans += 1LL * i * (r - l + 1) % mod) %= mod;
    }
    printf("%lld
", ans);
}