Toyota Programming Contest 2024#3（AtCoder Beginner Contest 344）

C

先预处理出三个数组能拼出的数，存放到 map 中。

查询的时候只需要看这个数是否出现在 map 里即可。

时间复杂度 $O(n^3\log v+Q\log v)$，$n\leq100$，$\log v$ 是 map 的时间复杂度。

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

#define int long long
const int N = 3e5 + 5;

int n, m, l, q, a[N], b[N], c[N], d[N];
map<int, int> vis;

signed main() {
	cin >> n;
	for (int i = 1; i <= n; i++) cin >> a[i];
	cin >> m;
	for (int i = 1; i <= m; i++) cin >> b[i];
	cin >> l;
	for (int i = 1; i <= l; i++) cin >> c[i];
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			for (int k = 1; k <= l; k++) {
				vis[a[i] + b[j] + c[k]] = 1;
			}
		}
	}
	cin >> q;
	for (int i = 1; i <= q; i++) {
		cin >> d[i];
		if (vis[d[i]]) puts("Yes");
		else puts("No");
	}
}

D

考虑 dp。定义 $dp_{i,j}$ 表示前 $i$ 个组拼成所给字符串前 $j$ 个字符的最小花费。

对第 $i$ 个组进行扫描，看这一个字符串能不能拼上去。

比赛时没有精细实现，所以代码看看就好了：

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

#define int long long
const int N = 3e5 + 5;

char a[N];
int m, cnt[105], dp[205][205]; 
string s[105][105]; 

signed main() {
	memset(dp, 0x3f, sizeof dp);
	dp[0][0] = 0;
	cin >> (a + 1);
	int n = strlen(a + 1); 
	cin >> m;
	for (int i = 1; i <= m; i++) {
		cin >> cnt[i];
		for (int j = 1; j <= cnt[i]; j++) cin >> s[i][j];
	}
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= cnt[i]; j++) {
			int len = s[i][j].size();
			for (int k = 0; k <= n; k++) {
				if (k + len > n) continue;
				string tmp = "";
				for (int w = k + 1; w <= k + len; w++) tmp += a[w];
				for (int w = 0; w <= m; w++) {
					if (tmp == s[i][j] && i > w) dp[k + len][i] = min(dp[k + len][i], dp[k][w] + 1);
				}
			}
		}
	}
	int res = 2e9;
	for (int i = 1; i <= m; i++) res = min(res, dp[n][i]);
	if (res == 2e9) puts("-1");
	else cout << res << endl;
}

E

问题陈述

给你一个长度为 $N$ 的序列 $A=(A_1,\ldots,A_N)$。$A$ 中的元素是不同的。

请按照给出的顺序处理 $Q$ 个查询。每个查询属于以下两种类型之一：

• 1 x y：在 $A$ 中元素 $x$ 后面紧接着插入 $y$。当给出此查询时，保证 $x$ 存在于 $A$ 中。
• 2 x：从 $A$ 中删除元素 $x$。当给出此查询时，保证 $x$ 存在于 $A$ 中。

保证在处理完每一个查询后，$A$ 都不是空的，并且其元素都是不同的。

处理完所有查询后，打印 $A$。

思路

这道题为什么可以用链表做呢？因为这道题只需要最后输出整个序列，而不是实时查询。题目保证 $A$ 中的元素是不同的，这也是可以用链表的核心。

所以链表写扩展性极低，所以比赛时写的分块。为什么某某部分人都写链表呢？不言而喻。俺就不写链表！但是又想到有个 rope 的玩意，于是很开心的写出了以下代码：

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include <bits/stdc++.h>
#include <ext/rope>
using namespace __gnu_cxx;
using namespace std;

const int N = 4e5 + 5;

int n, a[N];
rope<int> b;

signed main() {
	scanf("%d", &n); 
	b.push_back(0);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
		b.push_back(a[i]);
	}
	int q;
	scanf("%d",&q);
	while (q--) {
		int op, x, y;
		scanf("%d%d",&op,&x);
		if (op == 1) {
			scanf("%d",&y);
			b.insert(b.find(x)+1, y);
		}
		else {
			b.erase(b.find(x), 1);
		}
	}
	int t = b.size();
	for (int i = 1; i < t; i++) printf("%d ", b.at(i));
}

这份代码只过了 $10$ 个点，不知道是 rope 的 find 函数是 $O(n)$ 的，还是常数太大。

---

于是又去写分块了。

而分块思路简单，代码好调好写，清晰明了，常数小，大部分链表代码跑不过分块。

考虑把序列分成 $\sqrt n$ 块，每块用一个 vector 动态维护，即把这个块的所有数都放到对应的 vector 里面。在某个元素后面插入一个数时，只需要在这个元素的对应块的 vector 中插入，由于每块的 vector 大小只有 $\sqrt n$，所以插入的时间复杂度只有 $O(\sqrt n)$。删除一个数也是同样的道理。

但是，真的能保证每个 vector 都是 $\sqrt n$ 的大小吗？如果我们在固定一个位置加进很多个数，可能对应 vector 的大小就达到了 $O(n)$ 级别。所以我们考虑块重构。即对整个序列重新分组，使得所有 vector 的大小变平均。

什么时候可以块重构？块重构是需要消耗 $O(n)$ 的时间的，显然不能加一个数重构一次，可以间隔 $\sqrt n$ 次重构一次，块重构复杂度 $O(n\sqrt n)$。

总的时间复杂度也是 $O(n\sqrt n)$，事实上，vector 的 insert 非常快，所以不比链表慢多少。

注意事项：

• 题目不是在某个位置后面添加一个数，而是在某个元素后面添加一个数，所以需要开一个数组 $bel_x$ 代表 $x$ 在序列的第几个块内。

• 本题值域较大，用 $bel$ 数组需要离散化！用 map 复杂度就会变成 $O(n\sqrt n\log n)$，会 TLE！

// 只用了394ms
#include <bits/stdc++.h>
using namespace std;

const int N = 6e5 + 5, M = 2000;

int n, q, a[N], lx[N], rx[N], len, b[N], tot;
int tmp[N], tl, sum[M], bel[N];
vector<int> bk[M];
// bk_i 存储这个块内的数
// lx_i,rx_i存储这个块的左右端点
// bel存储这个数所在的块 

struct edge {
	int op, l, r;
}ed[N]; 

signed main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[++tot] = a[i];
	int sq = sqrt(n);
	len = n / sq;
	for (int i = 1; i <= n / sq; i++) lx[i] = (i - 1) * sq + 1, rx[i] = lx[i] + sq - 1;
	if (n % sq) {
		len++;
		lx[len] = rx[len - 1] + 1;
		rx[len] = n;
	}
	int cnt = 0;
	scanf("%d", &q);
	for (int i = 1; i <= q; i++) {
		scanf("%d", &ed[i].op);
		if (ed[i].op == 1) scanf("%d%d", &ed[i].l, &ed[i].r), b[++tot] = ed[i].l, b[++tot] = ed[i].r;
		else scanf("%d", &ed[i].l); 
	}
	sort(b + 1, b + tot + 1);
	tot = unique(b + 1, b + tot + 1) - b - 1;
	for (int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + tot + 1, a[i]) - b;
	for (int i = 1; i <= q; i++) {
		if (ed[i].op == 1) ed[i].r = lower_bound(b + 1, b + tot + 1, ed[i].r) - b;
		ed[i].l = lower_bound(b + 1, b + tot + 1, ed[i].l) - b; 
	}
	for (int i = 1; i <= len; i++) {
		for (int j = lx[i]; j <= rx[i]; j++) bk[i].push_back(a[j]), bel[a[j]] = i; 
	}
	for (int cas = 1; cas <= q; cas++) {
		int op = 0, l = 0, r = 0;
		op = ed[cas].op;
		cnt++;
		if (op == 1) {
			l = ed[cas].l, r = ed[cas].r;
			int L = bel[l], lenb = bk[L].size(); // L是l所在的块 
			for (int i = 0; i < lenb; i++) {
				if (bk[L][i] == l) {
					l = i; // 扫描到l的位置 
					break;
				}
			}
			if (l == lenb - 1) bk[L].push_back(r);
			else bk[L].insert(bk[L].begin() + l + 1, r);  
			bel[r] = L;
			rx[L]++;
			for (int i = L + 1; i <= len; i++) lx[i]++, rx[i]++;
		}
		if (op == 2) {
			l = ed[cas].l;
			int L = bel[l], lenb = bk[L].size();
			for (int i = 0; i < lenb; i++) {
				if (bk[L][i] == l) {
					l = i;
					break;
				}
			}
			bel[bk[L][l]] = 0;
			bk[L].erase(bk[L].begin() + l);
			rx[L]--;
			for (int i = L + 1; i <= len; i++) lx[i]--, rx[i]--;
		}
		if (cnt >= 5 * sq) { // 一定次数后块重构 
			tl = 0;
			for (int i = 1; i <= len; i++) {
				for (auto j : bk[i]) tmp[++tl] = j;
			}
			sq = sqrt(tl);
			len = tl / sq;
			for (int i = 1; i <= tl / sq; i++) {
				lx[i] = (i - 1) * sq + 1, rx[i] = lx[i] + sq - 1; 
			}
			if (tl % sq) {
				len++;
				lx[len] = rx[len - 1] + 1;
				rx[len] = tl;
			}
			for (int i = 1; i <= len; i++) {
				bk[i].clear();
				for (int j = lx[i]; j <= rx[i]; j++) bk[i].push_back(tmp[j]), bel[tmp[j]] = i; 
			}
			cnt = 0;
		}
	}
	for (int i = 1; i <= len; i++) {
		if (bk[i].size() == 0) continue;	
		for (auto v : bk[i]) printf("%d ", b[v]);
	}
}

F

update at 2023/3/10：更新了一些正确性说明。

场切。贪心+动态规划。

先把图建出来，可以将问题转化为在图上行走，抽象为如下问题（这是原题的严格强化）：

一个人在一张有向图的 $1$ 号结点，他要去到 $n$ 结点。每条边 $(a_i,b_i)$ 有边权 $s_i$，表示走过这条边需要花 $s_i$ 元。这个人一开始有 $0$ 元，到了一个点 $u$，他可以进行若干次停留，每次停留收获 $w_u$ 元。问到达 $n$ 的最小停留次数，并将答案加上 $2\times n-2$。若无解输出 -1。

为什么答案要加 $2\times n-2$，因为我们只算了停留次数。但是中间行走的步数是确定的为 $2\times n-2$。

考虑贪心，考虑从 $u$ 点走到 $v$ 点（$u,v$ 不一定是一条边），且在 $u,v$ 两点都赚钱停留。如果 $u$ 停留一次赚的钱比 $v$ 停留一次赚的钱多，那么不如不在 $v$ 这里停留（不如在 $u$ 点先把钱赚了）。那么就先将 $w_i$ 从小到大排序，路径中停留的点的 $w_i$ 是递增关系，如果当前点走不到比它更赚钱的点，直接走到 $n$ 号点。

---

预处理出 $d_{i,j}$ 代表 $i$ 走到 $j$ 的最小路径长度（边权）。

从 $u$ 号点赚钱完毕走到 $v$ 去赚钱，是把钱赚够就走（赚够代表当前的钱可以支付 $d_{u,v}$），还是可以在 $u$ 号点多赚一点，并使得到达 $v$ 号点时钱更多？

答案是赚够就走，因为在 $u$ 点多赚一点钱，不如走到 $v$ 号点去赚，因为 $w_u<w_v$。

---

既然赚够就走，那么 $u$ 到 $v$ 的路径，到达 $v$ 点后有许多种状态，用二元组 $(f,g)$ 表示。$f$ 代表到达 $v$ 点后停留次数，$g$ 代表到达 $v$ 点后所剩的钱。到底哪种方案更优？停留次数 $f$ 最小的更优？赚的钱 $g$ 越多更优？停留次数越少的答案越少，赚的钱越多后面就能越少停留。

考虑 $(f_1,g_1)$ 和 $(f_2,g_2)$ 两种状态，若 $f_1<f_2$ 且 $g_1<g_2$，此时我们怎么判断谁更优？

事实上，$(f_1,g_1)$ 只需要到达 $v$ 后再多停留一次，所剩余的钱就比 $g_2$ 多。

因为 $0\leq g_1< g_2\leq w_u<w_v$（$g_1\leq g_2\leq w_u$ 是因为赚够就走），所以 $g_1+w_v>g_2$。这就说明 $(f_1,g_1)$ 优于 $(f_2,g_2)$。

综上：停留次数越少，方案越优。如果停留次数相等，则剩的钱越多越优。

于是直接定义 $(f_i,g_i)$ 代表 $i$ 号点的最少停留次数与最多赚钱数，按照 w 从小到大的顺序转移即可。

复杂度 $O(n^4)$。但是，这道题不排序也是对的，可能本题是一个拓扑图的缘故。

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

#define PII pair<int, int>
#define int long long
const int N = 6405;

int T, n, m, p, w[N], f[N], g[N], st[N];
// f_i,g_i 即为i号点(最少停留次数，最多赚钱数)
int dist[N][N]; 
vector<pair<int, int> > G[N];

struct edge {
	int x, id;
}a[N];
bool cmp(edge x, edge y) { return x.x < y.x; }

void dijstra(int s) {
	priority_queue<PII, vector<PII>, greater<PII> > q;
	memset(st, 0, sizeof st);
	dist[s][s] = 0; q.push({0, s});
	while (q.size()) {
		auto t = q.top();
		q.pop();
		int u = t.second;
		if (st[u]) continue;
		st[u] = 1;
		for (auto e : G[u]) {
			auto v = e.first, d = e.second;
			if (dist[s][v] > dist[s][u] + d) {
				dist[s][v] = dist[s][u] + d;
				q.push({dist[s][v], v});
			}
		}
	}
}

void change(int x, int nf, int ng) {
	if (nf < f[x]) f[x] = nf, g[x] = ng;
	else if (nf == f[x] && ng > g[x]) f[x] = nf, g[x] = ng;
}

int get(int x, int y) {
	return (x - 1) * n + y;
} 

signed main() {
	memset(dist, 0, sizeof dist);
	cin >> n; p = 0;
	for (int i = 1; i <= n * n; i++) {
		for (int j = 1; j <= n * n; j++) {
			if (i == j) dist[i][j] = 0;
			else dist[i][j] = 1e18;
		}
	}
	for (int i = 1; i <= n * n; i++) cin >> w[i], a[i].x = w[i], a[i].id = i;
	sort(a + 1, a + n * n + 1, cmp);
	a[n * n + 1].x = 0, a[n * n + 1].id = n * n; // 要加入 n 号点，因为如果一个点走不到比它更赚钱的点，直接走到 n 好点
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n - 1; j++) {
			int x;
			cin >> x;
			G[get(i, j)].push_back({get(i, j + 1), x}); 
		}
	}
	for (int i = 1; i < n; i++) {
		for (int j = 1; j <= n; j++) {
			int x;
			cin >> x;
			G[get(i, j)].push_back({get(i + 1, j), x}); 
		}
	}
	for (int i = 1; i <= n * n; i++) {
		dijstra(i); // 预处理最短路，当然，这是一个拓扑图，直接递推也可以
	}
	for (int i = 1; i <= n * n; i++) f[i] = 1e18, g[i] = 0;
	f[1] = 0, g[1] = p;
	for (int i = 1; i <= n * n; i++) {
		for (int j = i + 1; j <= n * n + 1; j++) {
			int x = a[i].id, y = a[j].id;
			if (dist[x][y] == 1e18) continue;
			if (g[x] >= dist[x][y]) change(y, f[x], g[x] - dist[x][y]); // 如果钱足够，直接走
			else {
				int t = dist[x][y] - g[x];
				int k = (t + w[x] - 1) / w[x];
				change(y, f[x] + k, g[x] + k * w[x] - dist[x][y]);
			}
		}
	}
	if (f[n * n] <= 3e12) cout << f[n * n] + 2 * n - 2 << endl;
	else puts("-1"); 
}