【SNOI2017】 炸弹
Description
在一条直线上有 N 个炸弹,每个炸弹的坐标是 Xi,爆炸半径是 Ri,当一个炸弹爆炸时,如果另一个炸弹所在位置 Xj 满足:
Xi−Ri≤Xj≤Xi+Ri,那么,该炸弹也会被引爆。
现在,请你帮忙计算一下,先把第 i 个炸弹引爆,将引爆多少个炸弹呢?
Input
第一行,一个数字 N,表示炸弹个数。
第 行,每行 2 个数字,表示 保证 严格递增。
Output
一个数字,表示
输出答案 。
Sample Input
4
1 1
5 1
6 5
15 15
Sample Output
32
显然的标准解法 : 线段树优化建图+Tarjan+拓扑排序+DP
时间复杂度
常见的错误解法 : 扫两遍,同时维护左右的最远值
时间复杂度
给出一组来自LOJ的hack
5
1 0
30 100
50 20
90 0
100 0
ans : 35
output :29
常见的错解会输出29。。。
如果不能肯定的话可以提交一下LOJ。
以上是网上的常见解法(但是正解速度总是被错解吊打)。
我们发现,解法一的时间瓶颈在于线段树优化建图上,其余部分都是
的。
这道题有没有什么更好的方法呢?
并查集!
对于点
,如果我们能够连向点
,那么点
能够到达的左边界就至少是点
的左边界。
将当前点并到能够到达的最远点上。
向右的操作同理。
接下来,我们对当前图进行Tarjan缩点。
本来应该做的事情是统计DAG中的可达点数,好像只能够bitset解决。
但是由于这张图的特殊性质,我们发现:一个联通块的点一定是连续的一段区间。
所以我们直接用并查集合并size
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int Maxn=500005;
const int mod=1e9+7;
typedef long long ll;
inline ll read() {
char c; ll rec=0,f=0;
while((c=getchar())<'0'||c>'9') f|=c=='-';
while(c>='0'&&c<='9') rec=rec*10+c-'0',c=getchar();
return f?-rec:rec;
}
ll ans=0;
int n,fa[Maxn];
inline int getfa(int x) {return x==fa[x]?x:fa[x]=getfa(fa[x]);}
struct node {ll x,r;} b[Maxn];
struct Branch {int next,to;} branch[Maxn<<2];
int h[Maxn],cnt=0;
inline void add(int x,int y) {
branch[++cnt].to=y; branch[cnt].next=h[x]; h[x]=cnt; return ;
}
int Scc=0,bl[Maxn],size[Maxn],val[Maxn];
int dfn[Maxn],low[Maxn],ind=0;
int S[Maxn],vis[Maxn],top=0;
inline void Tarjan(int v) {
dfn[v]=low[v]=++ind;
S[++top]=v; vis[v]=1;
for(int i=h[v];i;i=branch[i].next) {
int j=branch[i].to;
if(!dfn[j]) Tarjan(j),low[v]=min(low[v],low[j]);
else if(vis[j]) low[v]=min(low[v],dfn[j]);
}
if(dfn[v]==low[v]) {
int p=0; ++Scc;
while(p!=v) {
p=S[top--],vis[p]=0,bl[p]=Scc;
++size[Scc]; val[Scc]=(val[Scc]+p)%mod;
}
} return ;
}// Tarjan
struct Edge {int next,to;} edge[Maxn<<2];
int e[Maxn],idx=0;
inline void Add(int x,int y) {
edge[++idx].to=y; edge[idx].next=e[x]; e[x]=idx; return ;
}// 重构图
void Count(int v) {
if(vis[v]) return ;
for(int i=e[v];i;i=edge[i].next){
int j=edge[i].to;
int f1=getfa(v),f2=getfa(j);
if(f1^f2){
fa[f2]=f1;
size[f1]+=size[f2];
}
} vis[v]=1;
return ;
} // Tarjan 合并统计size
int main() {
n=read();
for(int i=1;i<=n;++i) b[i]=(node){read(),read()};
for(int i=1;i<=n;++i) fa[i]=i;
for(int i=2;i<=n;++i) {
int p=i-1;
while(p) {
if(b[i].x-b[i].r<=b[p].x) {
add(i,p);
fa[getfa(i)]=getfa(p);
p=getfa(i)-1;
}
else break;
}
}
for(int i=1;i<=n;++i) fa[i]=i;
for(int i=n-1;i;--i) {
int p=i+1;
while(p<=n) {
if(b[i].x+b[i].r>=b[p].x) {
add(i,p);
fa[getfa(i)]=getfa(p);
p=getfa(i)+1;
}
else break;
}
}
// 分别向左和向右合并
for(int i=1;i<=n;++i) if(!dfn[i]) Tarjan(i);
for(int v=1;v<=n;++v) {
for(int i=h[v];i;i=branch[i].next) {
int j=branch[i].to;
if(bl[v]!=bl[j]) Add(bl[v],bl[j]);
}
}
for(int i=1;i<=Scc;++i) fa[i]=i;
for(int i=1;i<=Scc;++i) Count(i),ans=(ans+1ll*val[i]*size[i]%mod)%mod;
cout<<ans;
// 统计答案并输出
}