【Codeforces 板刷】【814D Permutation for Burenka】

Permutation of Burenka

link

题意

给一个排列P，和一个挖空数组A，以及一个集合S，集合大小为挖空的数量-1，每次询问给一个数d，问 S ∪ { d } S \cup \{d\} S∪{d}能否以合适顺序填空使得任意l<r，A[l-r]最大值所在位置与P[l-r]相同

观察

思路1，对于每个点，只需确定最左和最优的第一个大于它的位置在两个排列中一样

思路2，每次挑出区间最大值，将区间分成两半，左右无关

由1，2可知，每次从P找的区间最大，这个数一定大于左右两侧区间分别的最大，如此可以得到一个二叉树，我们只需保证填后二叉树上所有父节点大于子节点

尝试的贪心做法1：每次从树上选最小固定点，填满，递归操作，填时选可选的最小点。

猜做法

1. 正着贪心，反着贪心各一遍，如果都能填进去则d可以任意取，否则再遇到第一个无法填的格子跳过，如果可填满，从小到大得到上线，反之得到下限。
   1.1 上下限之间都可以
   1.2. 如此得到两种填法，如果填的点不同设为A，B，则以一定可以得到一条路径从A到B（把点填到A，然后和另一种填法里填A格子的点交换，不断交换一定会到B），有且仅有路径上的点可作为答案。

突破点

树上每个点的硬性限制为上限=最近非空祖先，下限=最大非空子孙，则若存在一种方法使每个空点都匹配到一个在上下限内的点，一定可以通过调整得到一个满足上大下小的合法树（否则调换父亲和较大儿子，递归至没有即可）

解法

由突破点，可以讲题目转换为有n个线段，n个点，需要每个点匹配一个线段的题
结合1.1，1.2，可以知道路径上的点的硬性限制组成的一定可以覆盖由正反贪心得到的上下限的区域（如果两个点可以换位置，则两个线段一定有交），因此上下限内一定是答案，如果不在上下限之内，则由贪心做法正确性保证不是合法解

代码

#include <bits/stdc++.h>

using namespace std;

int a[303030],p[303030],s[303030],ma[303030][20];
vector<int> to[303030];
int fa[303030];
int getmax(int l,int r) {
	int j = 0;
	while ((1<<j) <= r-l+1)
		j++;
	return (p[ma[l][j-1]] > p[ma[r+1-(1<<(j-1))][j-1]]) ? ma[l][j-1]:ma[r+1-(1<<(j-1))][j-1];
}

struct Pa {
	int l,r;
}pa[303030];
int tot = 0;
int buildTree(int l,int r) {
	if (r < l) {
		return -1;
	}
	if (r == l) {
		return l;
	}
	int mid = getmax(l,r);
	int lch = buildTree(l,mid-1),rch = buildTree(mid+1,r);
	if (lch > 0) {
		to[lch].push_back(mid);
		to[mid].push_back(lch);
		fa[lch] = mid;
	}
	if (rch > 0) {
		to[rch].push_back(mid);
		to[mid].push_back(rch);
		fa[rch] = mid;
	}
	return mid;
}
bool cmp1(Pa &A,Pa &B) {
	if (A.r != B.r) {
		return A.r < B.r;
	}
	return A.l < B.l;
}
bool flag;
int dfs(int now, int cei) {
	int ma = 0;
	if (a[now])
		cei = a[now];
	for (int i : to[now]) {
		if (i == fa[now]) {
			continue;
		}
		if (a[now]) {
			ma = max(ma,dfs(i, a[now]));
		}
		else {
			ma = max(ma,dfs(i,cei));
		}
	}
	//cout << now << " " << cei << " " << ma << endl;
	if (cei < ma) {
		flag = 1;
	}
	if (!a[now]) {
		pa[++tot].l = ma;
		pa[tot].r = cei;
		return ma;
	}
	else {
		return a[now];
	}
	
}

int main() {
	int T;
	scanf("%d",&T);
	while(T--) { 
		flag = 0;
		int n,m,k = 0;
		tot = 0;
		scanf("%d%d",&n,&m);
		for (int i = 1;i <= n; i++) {
			fa[i] = 0;
			scanf("%d",&p[i]);
			ma[i][0] = i;
			to[i].resize(0);
		}
		for (int j = 1;j < 20; j++)
			for (int i = 1;i <= n; i++) {
				ma[i][j] = (p[ma[i][j-1]] > p[ma[min(n,i+(1<<(j-1)))][j-1]]) ? ma[i][j-1]:ma[min(n,i+(1<<(j-1)))][j-1];
			}
		for (int i = 1;i <= n; i++) {
			scanf("%d",&a[i]);
			if (a[i] == 0)
				k++;
		}

		for (int i = 1;i < k; i++) {
			scanf("%d",&s[i]);
		}
		
		int root = buildTree(1,n);
		dfs(root, 1000001);
		sort(pa+1,pa+tot+1,cmp1);
		set<int> S;
		for (int i = 1;i < k; i++) {
			S.insert(s[i]);
		}
		int cei = 0, fol = 0;
		for (int i = 1;i <= tot; i++) {
			auto it = S.lower_bound(pa[i].l); 
			if (it == S.end() || *it > pa[i].r) {
				if (!cei) {
					cei = pa[i].r;
				}
				else {
					flag = 1;
				}
			}
			else  {
				S.erase(it);
			}
		}
		for (int i = 1;i <= tot; i++) {
			swap(pa[i].l,pa[i].r);
			pa[i].l *= -1;
			pa[i].r *= -1;
		}
		for (int i = 1;i < k; i++) {
			S.insert(-s[i]);
		}
		sort(pa+1,pa+tot+1,cmp1);
		for (int i = 1;i <= tot; i++) {
			auto it = S.lower_bound(pa[i].l); 
			if (it == S.end() || *it > pa[i].r) {
				if (!fol) {
					fol = -pa[i].r;
				}
				else {
					flag = 1;
				}
			}
			else  {
				S.erase(it);
			}
		}
		if (flag) {
			fol = cei+1;
		}
		int d;
		//cout << cei << "$$$" << fol << endl;
		for (int i = 1;i <= m; i++) {
			scanf("%d",&d);
			if (d <= cei && d >= fol) {
				printf("YES\n");
			}
			else {
				printf("NO\n");
			}
		}
	}
	return 0;
}