2023.10.31 模拟赛总结

总结
- 时间安排
- 考试总结
题解
T1
T2
T3

总结

时间安排

$\qquad$ 没啥可说的，罚坐全场，~~中间有一段狂交 rand 刷分，开启 IOI 赛制~~。

考试总结

$\qquad$ 虽然本场题非常恶心，区分度不高，但是还是有些分没拿到。像 $\text{T3}$ 的 $O (q n)$ 的 $\text{dp}$ 或贪心， $\text{T1}$ 的爆搜（没写是因为感觉细节太多，不是很会处理）。考场上看到难题要想尽办法磕部分分啊……

题解

T1

$\qquad$ 看到数据范围，果断状压 $\text{dp}$ 。容易想到的一个 $\text{dp}$ 转移方法是：设 $\text{dp}_{mask}$ 表示由 $\text{mask}$ 状态到最终状态所需的最短时间，然后每次进行一个新操作去转移。但是，不难发现，这么转移有两个弊端：其一，它有后效性，因为你不知道当前状态 $\text{mask}$ 在新加一个操作后的新状态 $\text{mask'}$ 跟 $\text{mask}$ 比谁大，这意味着转移时不能固定一个枚举顺序。但是这个问题很好解决，每当状态有后效性的时候，考虑加维度即可。其二，我们往后加操作时，前面所有操作都需要往后延伸一秒，非常难处理。而这个问题的解决方案很妙。

$\qquad$ 我们考虑两个操作序列：1，从第 $1$ 秒开始，以后三秒内分别操作第 $1, 2, 3$ 号节点；2，第 $1$ 秒不进行任何操作，从第 $2$ 秒开始，以后三秒内分别操作第 $1, 2, 3$ 号节点。不难发现，这两种操作序列的最终状态是相同的。这意味着，我们可以把向后添加操作转变为向前添加操作，这样我们就只需关心新添加操作在若干秒后的状态了。

$\qquad$ 综上，我们最终的 $\text{dp}$ 为：设 $\text{dp}_{i,mask}$ 表示第 $i$ 秒后能否到达状态 $\text{mask}$ ，同时，我们预处理一个 $\text{w}_{i,j}$ 表示对点 $\text{i}$ 进行操作， $\text{j}$ 秒后树的状态，那么 $\text{dp}$ 转移式就很好写了，具体见 $\text{Code}$ 。

$\qquad$ 核心 $\text{Code}$ ：

for(int i = 1; i <= n; i ++) {//预处理 w 数组
	int k = i;
	for(int j = 1; j <= n; j ++) {
		if(k) w[i][j] = w[i][j - 1] + (1 << (k - 1));
		else w[i][j] = w[i][j - 1];
		k = f[k];
	}
}
dp[0][0] = 1;
for(int i = 0; i <= n; i ++) {
	if(dp[i][ed]) return printf("%d\n", i), 0;//若第i秒能达到目标状态就直接输出
	for(int j = 0; j < (1 << n); j ++) {
		if(!dp[i][j]) continue;
		dp[i + 1][j] = 1;//意味着不往前添加操作
		for(int k = 1; k <= n; k ++) {//枚举往前添加操作哪一个点
			dp[i + 1][j ^ w[k][i + 1]] = 1;
		}
	}
}

T2

$\qquad$ 这题真的很难想……

$\qquad$ 看到本题，第一直觉应该就是隐式建图。但是怎么建呢？考虑到本题给了每个人一个最终状态，学会、没学会或无所谓，这相当于是一个限制，所以我们就从限制入手。我们设 $\text{maxT}_i$ 表示第 $\text{i}$ 个人最早得在什么时候学会算法。形式化地说，如果设 $\text{t}_i$ 表示第 $i$ 个人学会毒瘤算法的时间，那么 $\text{maxT}_i \leq \text{t}_i$ 。显然，最终没学会的人（设其状态为 $\text{w}_i = -1$ ）的 $\text{maxT}_i$ 为 $+\infty$ 。我们想：如果有一个 $\text{w}_i\ne -1$ 与 $\text{w}_j=-1$ 的人必须要在 $[\text{L}_k,\text{R}_k]$ 内吃饭，那么人 $\text{j}$ 可以给人 $\text{i}$ 一个什么限制呢？如下图：

$\qquad$ 我们想：若 $\text{maxT}_i$ 处于位置①，那么就意味着在他们吃饭前人 $\text{i}$ 就学会了算法，这就意味着无论他们在哪一天吃饭，人 $j$ 都将学会毒瘤算法，这显然是不合法的。但是，如果 $\text{maxT}_i$ 处于位置②，那么我们只要将他们吃饭的时间安排在 $[\text{L}_k,\text{maxT}_i-1]$ ，就可以同时保证两人维持合法状态。所以此时人 $\text{j}$ 会限制人 $\text{i}$ 的 $\text{maxT}\geq \text{L}+1$ 。那么，我们继续想：若一个人 $\text{i}$ 要在 $[\text{L}_{k1},\text{R}_k]$ 和 $[\text{L}_{k2},\text{R}_k]$ 这两个时间段分别与两个 $\text{w}_j=-1$ 的人吃饭，那么此时 $\text{maxT}_i$ 会受到什么限制呢？显然是 $\text{maxT}\geq \max(\text{L}_{k1}+1,\text{L}_{k2}+1)$ ，需要取 $\max$ 。

$\qquad$ 通过上面的分析，我们知道 $\text{w}=-1$ 的人可以限制 $\text{w}\ne -1$ 的人，那么 $\text{w}\ne -1$ 的人之间能不能互相限制呢？答案是可以的。我们想，什么情况下这种限制才是有意义的呢？

$\qquad$ 我们想：假设当前人 $\text{i,j}$ 的 $\text{w}\ne -1$ ， $\text{maxT}_i$ 在③或④位置， $\text{maxT}_j$ 在①或②位置。我们分类讨论一下：1、若 $\text{maxT}_i$ 在③位置，那么如果我们把两人的吃饭时间安排在 $[\text{maxT}_i,\text{R}_k]$ 之间，便可以让人 $\text{i,j}$ 同时满足条件。因为此时人 $\text{i}$ 已经学会了，完全可以教给人 $\text{j}$ ，并不会给 $\text{maxT}_j$ 带来限制。但是如果 $\text{maxT}_i$ 在位置④，就意味着人 $\text{i}$ 在此次饭局中不能学会，那么我们就可以把他们安排在 $\text{L}$ 吃饭，然后限制 $\text{maxT}_j=\text{L}+1$ 。所以这表明，只有当 $\text{maxT}_i > \text{R}+1$ 的时候才会给 $\text{maxT}_j$ 带来限制。2、若 $\text{maxT}_j$ 在位置②，就意味着之前已经有一个 $\text{i'}$ 限制了 $\text{maxT}_j$ ，而且限制的要比 $\text{i}$ 更晚，这就意味着 $\text{i}$ 并不会给 $\text{j}$ 带来限制。综上，只有当 $\text{maxT}_j\leq \text{L}\leq \text{R}<\text{maxT}_i$ 的时候，转移才有意义。

$\qquad$ 清楚了转移的原理，我们来想一下转移的实现。通过上面的分析，我们不难发现： $\text{maxT}$ 的值总是由大的一个转到小的一个，而且对于单个 $\text{maxT}_i$ 只会越转越大，最终在所有可能的转移中取 $\max$ 。这是不是类似于 $\text{Dijkstra}$ 呢？我们每次从堆顶取出 $\text{maxT}$ 最大的一个（保证已被限制到了最终状态），然后去更新其他的。这样，我们的转移就成功实现了。

$\qquad$ 在这一转移结束后，我们想：如果 $\text{maxT}_1>0$ ，是不是意味着一号节点被限制在 $0$ 时刻之后才能学会？这与 $1$ 节点开始就会的规定不符，所以我们可以直接判 $\text{Impossible}$ 。

$\qquad$ 接下来，我们考虑，上面这个转移结束后，整道题就结束了吗？显然没有。上面这一转移中我们只说明了存在一种方案使得所有 $w = - 1$ 的人满足条件，但是并没有顾及到 $w = 1$ 的人。怎么办呢？考虑到如果一个 $w = 1$ 的人要学会，那肯定是越早越好。我们效仿上面的过程，设 $\text{d}_i$ 表示人 $i$ 最早什么时候能学会。显然，初始时 $\text{d}_1=0$ ，其余的为正无穷。我们思考，人 $\text{i}$ 给人 $\text{j}$ 转移时，有哪些限制条件呢？

$\qquad$ 在上图中，我们可以清晰地发现， $\text{d}_j$ 需要同时满足：大于等于 $\text{d}_i$ ，大于等于 $\text{L}_k$ ，大于等于 $\text{maxT}_j$ 。同时， $\text{d}_j$ 还需要小于等于 $\text{R}_k$ 。形式化地说，我们设 $\text{maxx}=\max(\text{d}_i,\max(\text{L}_k,\text{maxT}_j))$ ，当 $\text{maxx}\leq \text{R}$ 且 $\text{maxx}<\text{d}_j$ 时， $\text{d}_j=\text{maxx}$ 。最后，如果有一个 $\text{w}=1$ 的人 $\text{i}$ ，他的 $\text{d}_i=+\infty$ ，那么我们就可以直接判 $\text{Impossible}$ 。

$\qquad$ 这个转移结束后，所有 $\text{w}=1,-1$ 的人全都考虑到了，一定存在一个合法状态使得他们都满足条件。但是我们好像忽略了一种人： $\text{w}=0$ 的人！那么 $\text{w}=0$ 的人怎么处理呢？显然的是， $\text{w}=0$ 的人是不能用来判 $\text{Impossible}$ 的，因为他最终状态是啥无所谓。但是他有一个传递限制的作用。例如一个 $\text{w}=1$ 和另一个 $\text{w}=-1$ 的人要同时和一个 $\text{w}=0$ 的人吃饭，那么这个 $\text{w}=0$ 的人就会把 $- 1$ 带来的限制传给 $\text{w}=1$ 的人。这意味着我们并不需要对 $\text{w}=0$ 的人做任何特殊操作，正常转即可。

$\qquad$ 核心 $\text{Code}$ ：

for(int i = 1; i <= n; i ++) {
	scanf("%d", &a[i]);
	if(a[i] == -1) maxT[i] = INF, q1.push((node1){i, maxT[i]});
}
while(!q1.empty()) {//让maxT大的优先出堆
	node1 Top = q1.top(); q1.pop();
	int l = Top.loc, r = Top.road;
	if(vis[l]) continue;
	vis[l] = 1;
	for(auto p : to[l]) {
		int v = p.to, L = p.L, R = p.R;
		if(a[v] != -1) {
			if(maxT[v] < L && R < maxT[l])//若maxT[l]<=R,那么完全可以让x提前学会后在maxT[l]~R中的某一天安排x，y见面，这样的话转移毫无意义，也不会对x提出限制
				maxT[v] = L + 1, q1.push((node1){v, maxT[v]});
		}
	}
}
if(maxT[1] > 0) return puts("Impossible"), 0;
memset(d, 0x7f, sizeof d), memset(vis, 0, sizeof vis);
d[1] = 0, q2.push((node2){1, 0});
while(!q2.empty()) {
	node2 Top = q2.top(); q2.pop();
	int l = Top.loc, r = Top.road;
	if(vis[l]) continue;
	vis[l] = 1;
	for(auto p : to[l]) {
		int v = p.to, L = p.L, R = p.R;
		int maxx = max(d[l], max(L, maxT[v]));
		if(maxx <= R && maxx < d[v]) d[v] = maxx, q2.push((node2){v, d[v]});//满足限制
	}
}
for(int i = 1; i <= n; i ++) {
	if(a[i] == 1 && d[i] == INF) return puts("Impossible"), 0;
}
puts("JJXSM");

T3

$\qquad$ 首先，我们先考虑本题的 $\Theta(\text{Qn})$ 做法怎么写？既然要在 $\Theta(\text{len})$ 的时间复杂度内完成区间查询，那就一定是一维 $\text{dp}$ 或贪心去搞。但是考虑到贪心拓展性小，我们考虑设计 $\text{dp}$ 状态。设 $\text{dp}_{i,0/1}$ 表示：考虑到第 $i$ 个位置， $0$ 表示全是 $0$ ， $1$ 表示末尾有一段连续一的最小操作步数。状态设计好之后，转移其实并不难，简单分讨一下即可。

$\qquad$ 核心 $\text{Code}$ ：

if(s[x] == '0') f[x][0] = 0, f[x][1] = 1;//0->0:0  0->1:1
else f[x][1] = 0, f[x][0] = 1;//1->0:1  1->1:0
for(int j = x + 1; j <= y; j ++) {
	if(s[j] == '0') {
		f[j][0] = min(f[j - 1][1] + 2, f[j - 1][0]);//要么两步让前面连续1变为0，要么直接与前面0拼上
		f[j][1] = min(f[j - 1][1] + 1, f[j - 1][0] + 1);//一定要花费1让当前0变为1
	}
	else {//类似上面
		f[j][0] = min(f[j - 1][0] + 1, f[j - 1][1] + 2);
		f[j][1] = min(f[j - 1][0], f[j - 1][1]);
	}
}
printf("%d\n", min(f[y][0], f[y][1] + 2));

$\qquad$ 现在我们考虑优化。注意到每次的转移只与 $\text{i}-1$ 有关，而且当 $\text{s}_i$ 定了之后，每次转移在 $0/1$ 之间加的系数是相同的，所以我们考虑用线段树维护一个类似矩阵的转移。建树和修改就变得非常简单，但是查询的时候有一点细节。我们不能直接查 $[\text{l},\text{r}]$ 的矩阵，而是应该判断 $\text{l}$ 的值，然后与 $[\text{l}+1,\text{r}]$ 的矩阵结合后再输出。

$\qquad$ $\text{Code}$ ：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 3e5 + 10;
int n, Q;
char s[maxn];
struct Matrix {
	int mt[2][2];
	Matrix() {memset(mt, 0x3f, sizeof mt);}//定义时自动初始化
	
	friend Matrix operator * (Matrix a, Matrix b) {//重载乘号
		Matrix c;
		for(int i = 0; i < 2; i ++)
			for(int j = 0; j < 2; j ++)
				for(int k = 0; k < 2; k ++)
					c.mt[i][j] = min(c.mt[i][j], a.mt[i][k] + b.mt[k][j]);
		return c;
	}
};
struct Segment {
	int l, r;
	Matrix dat;
	#define l(x) tree[x].l
	#define r(x) tree[x].r
	#define dat(x, a, b) tree[x].dat.mt[a][b]
	#define d(x) tree[x].dat
}tree[maxn << 2];

inline void update(int p) {
	d(p) = d(p << 1) * d(p << 1 | 1);
}

void build(int p, int l, int r) {
	l(p) = l, r(p) = r;
	if(l == r) {
		if(s[l] == '0') dat(p, 0, 0) = 0, dat(p, 1, 0) = 2, dat(p, 0, 1) = dat(p, 1, 1) = 1;
		else dat(p, 0, 0) = 1, dat(p, 1, 0) = 2, dat(p, 0, 1) = dat(p, 1, 1) = 0;
		return ;
	}
	int mid = l + r >> 1;
	build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
	update(p);
}

void modify(int p, int x, int val) {
	if(l(p) == r(p)) {
		if(val == 0) dat(p, 0, 0) = 0, dat(p, 1, 0) = 2, dat(p, 0, 1) = dat(p, 1, 1) = 1;
		else dat(p, 0, 0) = 1, dat(p, 1, 0) = 2, dat(p, 0, 1) = dat(p, 1, 1) = 0;
		return ;
	}
	int mid = l(p) + r(p) >> 1;
	if(x <= mid) modify(p << 1, x, val);
	else modify(p << 1 | 1, x, val);
	update(p);
}

Matrix query(int p, int l, int r) {
	if(l <= l(p) && r(p) <= r) return d(p);
	int mid = l(p) + r(p) >> 1;
	if(r <= mid) return query(p << 1, l, r);
	if(l > mid) return query(p << 1 | 1, l, r);
	return query(p << 1, l, r) * query(p << 1 | 1, l, r);
}

int solve(int l, int r) {
	Matrix res;
	if(s[l] == '0') res.mt[0][0] = 0, res.mt[0][1] = 1;//l与[l+1,r]的矩阵相乘
	else res.mt[0][0] = 1, res.mt[0][1] = 0;
	if(l == r) return res.mt[0][0];
	res = res * query(1, l + 1, r);
	return res.mt[0][0];
}

int main() {
	scanf("%d%s%d", &n, s + 1, &Q);
	build(1, 1, n);
	for(int i = 1, opt, x, y; i <= Q; i ++) {
		scanf("%d%d%d", &opt, &x, &y);
		if(opt == 1) printf("%d\n", solve(x, y));
		else modify(1, x, y), s[x] = y + '0';
	}
	return 0;
}

__EOF__

本文作者：best_brain
本文链接：https://www.cnblogs.com/best-brain/p/18006556.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2023-11-03 07:39 best_brain 阅读(6) 评论(0) 编辑收藏举报来源

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2023.10.25 模拟赛总结

· 国庆模拟赛题解

· 2023.01.06 模拟赛小结

· 模拟赛总结

· 暑期模拟赛总结（上）

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· .NET10 - 预览版1新功能体验（一）

公告

2023.10.31 模拟赛总结

发表于 2023-11-03 07:39阅读：6评论：0推荐：0

个人总结模拟考总结算法

Alipay

WeChat

关注

跳至底部

昵称： best_brain
园龄： 1年3个月
粉丝： 1
关注： 1

+加关注

best-brain

蒟蒻best_brain的博客

2023.10.31 模拟赛总结

2023.10.31 模拟赛总结

总结

时间安排

考试总结

题解

T1

T2

T3

公告

best_brain

2023.10.31 模拟赛总结

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

推荐排行榜