CodeForces - 1326E Bombs(线段树+思维)

题目链接：点击查看

题目大意：给出一个 n 的排列记为 p[ i ] ，现在有一个初始时为空的集合A，对于每个 i 遍历 1 ~ n ，每次的操作如下：

1. 向集合中添加 p[ i ]
2. 如果位置 i 有炸弹，那么删除掉集合中的最大值

最后的答案就是保留在集合中的最大值

接下来给出一个数组 q ，表示炸弹的位置，对于每个前缀炸弹给出答案，此处的前缀可以理解为：

1. 对于第一个答案，输出不包含炸弹的的答案
2. 对于第二个答案，输出包含炸弹 q[ 1 ] 的答案
3. 对于第三个答案，输出包含炸弹 q[ 1 ] , q[ 2 ] 的答案
4. 对于第四个答案，输出包含炸弹 q[ 1 ] , q[ 2 ] , q[ 3 ] 的答案
5. .....
6. 对于第 n 个答案，输出包含炸弹 q[ 1 ] , q[ 2 ] ... q[ n - 1 ] 的答案

题目分析：比赛时感觉是线段树，但自己维护的线段树无法动态维护炸弹，因为每次添加的炸弹位置都是有大有小的，所以后续添加的炸弹很有可能会影响前面的决策，最后也是实力不够，没办法解决这个问题

赛后看了官方题解后也是思考了好久才勉强想明白，这里就大体说一下题解的意思吧

因为动态维护炸弹比较困难，所以我们不妨将问题转换为判断答案是否合理，不难看出，随着炸弹数量的增加，输出的答案也会保持着非严格递减的趋势，所以我们从最大的答案开始不断递减，每次判断是否合理即可

转换思路后，接下来的任务就是对于一个答案 x ，我们如何判断他的合理性，如果答案 x 满足条件，也就是所有炸弹都炸掉了极大值后，x 成为了最后集合中的最大值，这也就必须满足所有大于 x 的值都被炸弹炸掉了，因为炸弹影响的范围是 [ 1 , q[ i ] ] ，也就是会影响一个前缀，那么：

1. 右边开始第一个 > x 的数的右边必须至少有一个炸弹
2. 右边开始第二个 > x 的数的右边必须至少有两个炸弹
3. ....
4. 右边开始第 k 个 > x 的数的右边必须至少有 k 个炸弹

如果满足上述条件的话，就说明 > x 的所有数都会被炸弹炸掉，那么答案就肯定不可能是 x + 1 及以上了，只可能是 x 及以下

此时我们可以用线段树维护一下每个节点 右侧炸弹的个数 - 右侧大于 x 的数的个数 ，显然对于每个节点而言，如果这个值大于等于 0 的话，那么 x + 1 及以上的答案是肯定不可能的，因为全都被炸弹炸没了，我们就可以用一个 while 维护符合条件的答案了，又因为我们需要所有的答案都大于等于 0 时才满足条件，所以我们只需要维护一下区间最小值就好了，最小值如果大于等于 0 的话，那么就说明所有节点都满足这个条件了

明白了思路后代码写起来就简单多了，线段树维护最小值+区间更新

代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
using namespace std;
      
typedef long long LL;

typedef unsigned long long ull;
      
const int inf=0x3f3f3f3f;
 
const int N=3e5+100;

int pos[N];

struct Node
{
	int l,r,mmin,lazy;
}tree[N<<2];

void build(int k,int l,int r)
{
	tree[k].l=l;
	tree[k].r=r;
	tree[k].lazy=tree[k].mmin=0;
	if(l==r)
		return;
	int mid=l+r>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
}

void pushdown(int k)
{
	if(tree[k].lazy)
	{
		int lz=tree[k].lazy;
		tree[k].lazy=0;
		tree[k<<1].mmin+=lz;
		tree[k<<1].lazy+=lz;
		tree[k<<1|1].mmin+=lz;
		tree[k<<1|1].lazy+=lz;
	}
}

void update(int k,int l,int r,int val)
{
	if(tree[k].l>r||tree[k].r<l)
		return;
	if(tree[k].l>=l&&tree[k].r<=r)
	{
		tree[k].mmin+=val;
		tree[k].lazy+=val;
		return;
	}
	pushdown(k);
	update(k<<1,l,r,val);
	update(k<<1|1,l,r,val);
	tree[k].mmin=min(tree[k<<1].mmin,tree[k<<1|1].mmin);
}

int main()
{
#ifndef ONLINE_JUDGE
//	freopen("input.txt","r",stdin);
//	freopen("output.txt","w",stdout);
#endif
//	ios::sync_with_stdio(false);
	int n;
	scanf("%d",&n);
	build(1,1,n);
	for(int i=1;i<=n;i++)
	{
		int num;
		scanf("%d",&num);
		pos[num]=i;
	}
	int ans=n+1;
	for(int i=1;i<=n;i++)
	{
		int q;
		scanf("%d",&q);
		while(tree[1].mmin>=0)
		{
			ans--;
			update(1,1,pos[ans],-1);
		}
		printf("%d ",ans);
		update(1,1,q,1);
	}
	
	
	
	
	
	
    
    
    
    
    
    
    
    
    
    return 0;
}