P2894 [USACO08FEB]Hotel G

传送门

一个$N$的数组

支持两种操作

• 查询$1$ ~ $N$ 长度最少为 $x$ 连续的 $1$
• 将区间 $[l,r]$ 的值置为 x , x ∈ { 0 , 1 } x,x \in \{0,1\} x,x∈{0,1}

分析

这道题和【Tunnel Warfare】有点相关

同样是线段树维护

这里有点像，区间连续最大值了。

对于每个位置，维护三个信息 { k , l , r } \{k, l, r\} {k,l,r}

• $k$ 为区间连续的$1$长度
• $l$ 为区间左端点向右走，有多少连续的$1$，也就是连续最后一个$1$的位置$-$左端点$l+1$
• $r$ 为区间右端点往左走，有多少连续的1

假设区间为大小为 $1$， { k = 1 , l = 1 , r = 1 } \{k=1, l=1,r=1\} {k=1,l=1,r=1}

推到区间长度为$2$，对于三个信息讨论，$ls$为左儿子，$rs$为右儿子

• $k=\max (tr[ls].k,tr[rs].k)$​​，$k$肯定会$>=$ 左儿子和右儿子的最大值
• $l=tr[ls].l$，$l$ 肯定会$>=$左儿子的$l$
• $r=tr[ls].r$，$l$ 肯定会$>=$左儿子的$l$

但是，考虑最大值$k$还可能是左右两边拼起来的中间，所以还有取个$\max (k,tr[ls].r+tr[rs].l)$

如果左边都是连续的$1$，就能接上右边的$l$了，$l+=tr[rs].l$

同样如果右边都是连续的$1$，接上左边为，$r+=tr[ls].r$

综上

• $k=\max (\max (tr[ls].k,tr[rs].k),tr[ls].r+tr[rs].r)$​​
• $l=tr[ls].l+(tr[ls].len==tr[ls].l?tr[rs].s:0)$​
• $r=tr[ls].r+(tr[rs].len==tr[rs].r?tr[ls].r:0)$​

对于区间修改$set$，再维护一个标记

查询的话

对于长度至少为$k$的策略：

从区间$[1,N]$开始查询，记左端点为 $l$，右端点为 $r$，中点为 $mid$

• 如果对于区间，左边的连续个数$>=$k，往左边查询$k$
• 上面不满足后，如果右区间的$r+$右区间的$l>=k$，直接返回 $mid-tr[ls].r+1$
• 上面不满足，往右区间查询$k$
• 如果发现区间的$k$都小于查询的$k$，直接返回$0$，因为此区间最大值都小于$k$，不存在解

以下是代码

//P2894
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define int long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

int arr[MAX_N];

struct Tr {
	int k, l, r, len, lazy;
}tr[MAX_N];

void push_up(int rt) {
	int ls = rt << 1;
	int rs = ls|1;
	tr[rt].l = tr[ls].l;
	tr[rt].r = tr[rs].r;
	if (tr[rt].l == tr[ls].len) {
		tr[rt].l += tr[rs].l;
	}
	if (tr[rt].r == tr[rs].len) {
		tr[rt].r += tr[ls].r;
	}
	tr[rt].k = max(tr[ls].r + tr[rs].l, max(tr[ls].k, tr[rs].k));
}

void calc(int rt, int lazy) {
	if (lazy) {
		tr[rt].k =  tr[rt].l = tr[rt].r = tr[rt].len;
	} else {
		tr[rt].k = tr[rt].l = tr[rt].r = 0;
	}
	tr[rt].lazy = lazy;
}

void push_down(int rt) {
	if (tr[rt].lazy==-1) return;
	calc(rt<<1, tr[rt].lazy);
	calc(rt<<1|1, tr[rt].lazy);
	tr[rt].lazy = -1;
}

void build(int rt, int l, int r) {
	tr[rt].len = r - l + 1;
	tr[rt].lazy = -1;
	if (l == r) {
		tr[rt].k = 1;
		tr[rt].l = 1;
		tr[rt].r = 1;
		return;
	}
	int mid = l + ((r-l)>>1);
	build(rt<<1, l, mid);
	build(rt<<1|1, mid+1, r);
	push_up(rt);
}

void update(int rt, int l, int r, int x, int y, int k) {
	if (x <= l && r <= y) {
		calc(rt, k);
		return;
	}
	push_down(rt);
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(rt<<1, l, mid, x, y, k);
	if (y  > mid) update(rt<<1|1, mid+1, r, x, y, k);
	push_up(rt);
}

int query(int rt, int l, int r, int k) {
	if (tr[rt].k < k) return 0;
	if (l == r) {
		return l;
	}
	push_down(rt);
	int mid = l + ((r-l)>>1);
	if (tr[rt<<1].k >= k) return query(rt<<1, l, mid, k);
	if (tr[rt<<1].r + tr[rt<<1|1].l >= k) return mid - tr[rt<<1].r + 1;
	return query(rt<<1|1, mid+1, r, k);
}

int query(int rt, int l, int r, int x, int y) {
	if (l == r) {
		return tr[rt].k;
	}
	push_down(rt);
	int mid = l + ((r-l)>>1);
	if (x <= mid) return query(rt<<1, l, mid, x, y);
	return query(rt<<1|1, mid+1, r, x, y);
}

void solve(){
	sc("%lld%lld", &N, &M);
	int opt, x, y;
	int pos = 0;
	build(1, 1, N);
	for (int i = 1; i <= M; ++i) {
		sc("%lld", &opt);
		if (opt == 1) {
			sc("%lld", &x);
			pr("%lld\n", pos = query(1, 1, N, x));
			if (pos) update(1, 1, N, pos, pos+x-1, 0);
		} else if (opt == 2) {
			sc("%lld%lld", &x, &y);
			update(1, 1, N, x, x+y-1, 1);
		}
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	//FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}