【笔记】USACO22JAN

My Blog

T1

直接从 \(1\) 到 \(n\) 枚举每一位能填的最小数，可以做到 \(\mathcal{O}(N^2)\) 复杂度。

这本质上是求满足当前数小于前缀最大数的位置，考虑线段树，支持单点修改和整体查询。线段树每个节点维护两个 set，\(s\) 和 \(t\)，分别表示区间中可用的位置集合，与区间中候选的位置集合。均摊复杂度 \(\mathcal{O}(N\log ^2 N)\)。

#define N 100005
int n, k, u[N];
struct node{
	int l, r, mn, mx;
	set<Pr>s, t;
}a[N << 2];
#define ls (x << 1)
#define rs (ls | 1)
#define L a[x].l
#define R a[x].r
void ins(int x,Pr y){
	a[x].s.insert(y);
	while(!(x & 1))x >>= 1, a[x].s.insert(y);
	if(x != 1)a[x >> 1].t.insert(y);
}
void upd(int x){
	a[x].mn = min(a[ls].mn, a[rs].mn);
	a[x].mx = max(a[ls].mx, a[rs].mx);
	vector<Pr>dl;
	int l = a[ls].mx - k, r = a[ls].mn + k;
	auto cur = a[x].t.lower_bound(mp(l, 0));
	while(cur != a[x].t.end()){
		if((*cur).fi > r)break;
		dl.pb(*cur), cur++;
	}
	go(y, dl)a[x].t.erase(y), ins(x, y);
}
void build(int x,int l,int r){
	L = l, R = r;
	if(l == r){
		a[x].mx = a[x].mn = u[l], ins(x, mp(u[l], l));
	}
	else{
		int mid = (l + r) >> 1;
		build(ls, l, mid), 
		build(rs, mid + 1, r),
		upd(x);
	}
}
void del(int x,int pos){
	a[x].s.erase(mp(u[pos], pos));
	if(L == R)a[x].mn = inf / 2, a[x].mx = 0;
	else{
		int mid = (L + R) >> 1;
		if(mid >= pos)del(ls, pos);
		else del(rs, pos);
		upd(x);
	}
}
int main() {
	read(n), read(k);
	rp(i, n)read(u[i]);
	build(1, 1, n);
	rp(i, n){
		int p = (*a[1].s.begin()).se;
		printf("%d\n", u[p]), del(1, p);
	}
	return 0;
}

T2

对于排列中的两个位置 \(i,j\)，如果 \(|h_i - h_j| \ge 2\)，那么这两个数的相对位置永远不会改变。

考虑 \(h_i\le 3\) 的情况，我们将 \(1,3\) 先排好，\(2\) 随便填，答案就是 \(\binom{n}{size_2}\)。

再考虑 \(h_i\le 4\) 的情况，我们将 \(1,3\) 排好，\(2,4\) 排好，得到两个序列，那么答案就是归并两个序列的方案，使得 \(1,4\) 之间的相对位置不变。这我们只用对每个 \(1,4\) 记录在另一个序列中的可行区间即可。

扩展到任意情况，我们将 \(h_i\) 为偶数和奇数的位分开，得到两个序列，然后类似上述方法归并。对于每个数记录在另一个序列中的可行区间即可。

DP 的状态为 \(f_{i,j}\) 表示偶数序列匹配到了第 \(i\) 位，奇数序列第 \(j\) 位的方案数，时间复杂度 \(\mathcal{O}(N^2)\)。

#define N 5005
int n, u[N], a[N], b[N], mat[N], c[N], d[N], f[N][N];
void solve(){
	read(n);
	int l = 0, r = 0;
	rp(i, n){
		read(u[i]);
		if(1 & u[i])a[++l] = i, mat[i] = l;
		else b[++r] = i, mat[i] = r;
	}
	mat[n + 1] = n;
	rp(i, n){
		int j = i;
		while(j && ((!(1 & (u[i] ^ u[j]))) || abs(u[i] - u[j]) <= 1))j--;
		c[i] = mat[j];
	}
	pr(i, n){
		int j = i;
		while(j <= n && (!(1 & (u[i] ^ u[j])) || abs(u[i] - u[j]) <= 1))j ++;
		d[i] = mat[j];
	}
	rep(i, 0, l)rep(j, 0, r)f[i][j] = 0;
	f[0][0] = 1;
	rep(i, 0, l)rep(j, 0, r){
		if(i + j == n)printf("%d\n", f[i][j]);
		else{
			if(i < l && c[a[i + 1]] <= j && j <= d[a[i + 1]])ad(f[i + 1][j], f[i][j]);
			if(j < r && c[b[j + 1]] <= i && i <= d[b[j + 1]])ad(f[i][j + 1], f[i][j]);
		}
	}
}

int main() {
	int T; read(T);
	while(T--)solve();
	return 0;
}

T3

考虑计算出答案向量的方向。

假设方向为 \(x\)，那么对于每一组，肯定选择在该方向上投影长度最大的向量。

直接以 \(1e-3\) 精度枚举方向可以过 Sub1。

我们记以 \(x\) 为方向算出的答案为 \(f(x)\)，\(f(x)\) 大概是几个三角函数叠加取 \(\max\)，分几段三分一下可以过 Sub2。

Sub3 不会，回头填。

Updata：事实上，这个题本质上就是求闵可夫斯基和。

根据闵可夫斯基和的定义，\(C=\{a+b|a\in A,b\in B\}\)，所以我们对每组向量求凸包，然后直接求闵可夫斯基和即可。

（又被卡科技了