2024.9.7 提高组模拟赛题解

T1网瘾少年

解题思路

注意到从第$i$个店走到第$i+1$个店，所花费的电量可能由某个编号$<i$的充电单价更优的店所充。

记$ti$表示：第$i$个店往后，第一个比当前充电便宜的店的编号（可以使用单调栈预处理）。

则从第$i$个店走到第$ti$个店，中间路过的所有店的充电代价都比第$i$家店更大，故我们希望从第$i$个店走到第$ti$个店的电量都在第$$个店里充。

故可以考虑从第$$0个店考虑到第$n$个店，记$e$表示当前的电量，假设当前考虑到第$i$个店：记$dist$表示从第$i$个店走到第$ti$个店所需电量花费（可以用前缀和快速计算）。

对第$i$个店到第$ti$个店进行判定：

若$e>=dist$，则已经足够走到第$ti$个店。
若$e<dist$，则目前不够走到第$ti$个店，考虑充电，将电量充至$min(dist,T)$。
将当前的电量$e$减去$Di$（从第$i$个店走到第$i+1$个店）。

时间复杂度$O(n)$。

参考代码

#include <bits/stdc++.h>

template <class T>
inline void read(T &x) {
	static char s;
	static bool opt;
	while (s = getchar(), (s < '0' || s > '9') && s != '-');
	x = (opt = s == '-') ? 0 : s - '0';
	while (s = getchar(), s >= '0' && s <= '9') x = x * 10 + s - '0';
	if (opt) x = ~x + 1;
}

typedef long long s64;

const int N = 500100;

int n, T;

int d[N], P[N];
s64 S[N];

int top, stk[N];
int go[N];

int e;
s64 cost;

int main() {
	freopen("wayhome.in", "r", stdin);
	freopen("wayhome.out", "w", stdout);

	read(n), read(T);

	for (int i = 1; i <= n; i ++)
		read(d[i]), read(P[i]);

	bool flag = 0;
	for (int i = 1; i <= n; i ++)
		if (T < d[i]) { flag = 1; break; } // 判断无解的情况 

	if (flag) {
		puts("-1");
		return 0;
	}

	for (int i = 1; i <= n; i ++)
		S[i] = S[i - 1] + d[i];

	stk[top = 1] = n + 1;
	for (int i = n; i >= 1; i --) { // 使用单调栈维护 go[i] 
		while (top && P[i] < P[stk[top]]) top --;
		go[i] = stk[top];
		stk[++ top] = i;
	}

	for (int i = 1; i <= n; i ++) {
		s64 dist = S[go[i] - 1] - S[i - 1]; // 计算从 i 到达 go[i] 的距离 

		if (e < dist) {
			if (dist > T)
				cost += 1ll * (T - e) * P[i], e = T;
			else
				cost += 1ll * (dist - e) * P[i], e = dist;
		}

		e -= d[i];
	}

	printf("%lld\n", cost);

	return 0;
}`

T2宝石之国

解题思路

注意到两个相同宝石的最近距离，一定在相邻的两个相同宝石（即两个相同宝石之间，无同色宝石）取到。

设$las{t}_i$表示：第$i$个宝石往前，第一个与第$i$个宝石同色的宝石编号。

形式化地，对区间$[l,r]$的询问，答案即为：
$$\underset{l\le i\le r,las{t}_i\ge l}{\min }i-las{t}_i$$

显然，若$las{t}_i\ge l$，则必有$i\ge l$，则答案为：
$$\underset{i\le r,las{t}_i\ge l}{\min }i-las{t}_i$$

问题转化为了一个简单的二维偏序问题。

此处介绍一个简单的离线做法：暴力处理第一维$i$，使用线段树维护第二维$las{t}_i$。将所有询问按照右端点$r$从小到大排序，每次当右端点右移时，将所有经过的点加入。每次加入一个点$i$时，将$i-las{t}_i$插入线段树的位置$las{t}_i$中。查询时，只需查询线段树中$\ge l$部分的最小值即可。

时间复杂度$O((n+m)logn)$。

参考代码

#include <bits/stdc++.h>

template <class T>
inline void read(T &x) {
	static char s;
	static bool opt;
	while (s = getchar(), (s < '0' || s > '9') && s != '-');
	x = (opt = s == '-') ? 0 : s - '0';
	while (s = getchar(), s >= '0' && s <= '9') x = x * 10 + s - '0';
	if (opt) x = ~x + 1;
}

const int N = 200100;
const int inf = 0x3f3f3f3f;

int n, m;
int a[N], b[N];

int len, mapval[N];
int turn(int x) {
	return std::lower_bound(mapval + 1, mapval + 1 + len, x) - mapval;
}

int pos[N];
int Last[N];

namespace SGT { // 线段树模板 
	struct node {
		int l, r;
		int min;
	} t[N * 4];

	void upd(int p) {
		t[p].min = std::min(t[p * 2].min, t[p * 2 + 1].min);
	}

	void build(int p, int l, int r) {
		t[p].l = l, t[p].r = r, t[p].min = inf;
		if (l == r) return;
		int mid = (l + r) >> 1;
		build(p * 2, l, mid), build(p * 2 + 1, mid + 1, r);
	}

	void change(int p, int x, int val) {
		if (t[p].l == t[p].r) {
			t[p].min = std::min(t[p].min, val);
			return;
		}
		int mid = (t[p].l + t[p].r) >> 1;
		if (x <= mid)
			change(p * 2, x, val);
		else
			change(p * 2 + 1, x, val);
		upd(p);
	}

	int ask(int p, int l, int r) {
		if (l <= t[p].l && t[p].r <= r) return t[p].min;
		int mid = (t[p].l + t[p].r) >> 1;
		int ans = inf;
		if (l <= mid)
			ans = std::min(ans, ask(p * 2, l, r));
		if (mid < r)
			ans = std::min(ans, ask(p * 2 + 1, l, r));
		return ans; 
	}
}

int ans[N];
struct query {
	int l, r, id;
	bool operator < (const query &rhs) const {
		return r < rhs.r;
	}
} q[N];

int main() {
	freopen("jewel.in", "r", stdin);
	freopen("jewel.out", "w", stdout);

	read(n), read(m);

	for (int i = 1; i <= n; i ++) read(b[i]);

	for (int i = 1; i <= n; i ++) mapval[++ len] = b[i];
	std::sort(mapval + 1, mapval + 1 + len);
	len = std::unique(mapval + 1, mapval + 1 + len) - mapval - 1;
	for (int i = 1; i <= n; i ++) a[i] = turn(b[i]); // 离散化 

	for (int i = 1; i <= n; i ++) { // 计算 last[i] 
		Last[i] = pos[a[i]];
		pos[a[i]] = i;
	}

	SGT::build(1, 1, n);

	for (int i = 1; i <= m; i ++)
		read(q[i].l), read(q[i].r), q[i].id = i;

	std::sort(q + 1, q + 1 + m);

	for (int i = 1, r = 0; i <= m; i ++) {
		while (r < q[i].r) { // 右端点右移 
			r ++;
			if (Last[r]) SGT::change(1, Last[r], r - Last[r]);
		}

		ans[q[i].id] = SGT::ask(1, q[i].l, r);
	}

	for (int i = 1; i <= m; i ++)
		printf("%d\n", ans[i] == inf ? -1 : ans[i]);

	return 0;
}

T3网格连通

解题思路

考虑先预处理出原来的$n\ast n$正方形网格图中所有的连通块，并编号。

每次将一个$k\ast k$的子正方形区域内的障碍物变为空白格子，本质上是将所有与该$k\ast k$子正方形相接的连通块进行合并。故该$k\ast k$子正方形所产生的连通块大小即为所有与该$k\ast k$子正方形相接的连通块总大小加上该$k\ast k$子正方形中的障碍物个数。

注意到所有$k\ast k$的子正方形个数为$O(n^2)$ ，每次暴力处理一个$k\ast k$的子正方形是$O(k^2)$的，显然会超时。假设我们已知某一个$k\ast k$的子正方形的信息，现在考虑将该$k\ast k$的子正方形右移一个单位长度，则发生变动的点数为$O(k)$级别，我们只需对这些发生变动的点进行修改即可，故每次右移一个单位长度的时间复杂度为$O(k)$。

时间复杂度$O(n^3)$。

参考代码

#include <bits/stdc++.h>

template <class T>
inline void read(T &x) {
	static char s;
	static bool opt;
	while (s = getchar(), (s < '0' || s > '9') && s != '-');
	x = (opt = s == '-') ? 0 : s - '0';
	while (s = getchar(), s >= '0' && s <= '9') x = x * 10 + s - '0';
	if (opt) x = ~x + 1;
}

const int N = 510;

int n, k;

char str[N][N];

int dx[4] = { 0, +1, 0, -1 },
	dy[4] = { +1, 0, -1, 0 };

bool exist(int x, int y) {
	return 1 <= x && x <= n && 1 <= y && y <= n && str[x][y] == '.';
}

int colClock;
int col[N][N], sum[N * N];

void dfs(int x, int y, int color) { // dfs 确定每一个连通块 
	col[x][y] = color, sum[color] ++;
	for (int i = 0; i < 4; i ++) {
		int nx = x + dx[i],
			ny = y + dy[i];
		if (exist(nx, ny) && !col[nx][ny]) dfs(nx, ny, color);
	}
}

int pre[N][N]; // 二维前缀和 

int cur;
int cnt[N * N];

void add(int x) { // 加入编号为 x 的连通块 
	if (!x) return;
	if (++ cnt[x] == 1) cur += sum[x];
}

void dec(int x) { // 退出编号为 x 的连通块 
	if (!x) return;
	if (-- cnt[x] == 0) cur -= sum[x];
}

int ans;
int calc(int i, int j) { // 计算以 (i, j) 为左上角的 k * k 子矩阵的贡献 
	int ni = i + k - 1, nj = j + k - 1;
	return cur + (pre[ni][nj] - pre[i - 1][nj] - pre[ni][j - 1] + pre[i - 1][j - 1]);
}

int main() {
	freopen("grid.in", "r", stdin);
	freopen("grid.out", "w", stdout); 

	read(n), read(k);

	for (int i = 1; i <= n; i ++) scanf("%s", str[i] + 1);

	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= n; j ++)
			if (str[i][j] == '.' && !col[i][j]) dfs(i, j, ++ colClock);

	for (int i = 1; i <= n; i ++) // 计算二维前缀和 
		for (int j = 1; j <= n; j ++)
			pre[i][j] = pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1]
				+ (str[i][j] == 'X');

	for (int i = 1; i + k - 1 <= n; i ++) {
		// 对左上角为 (i, 1) 的 k * k 矩阵进行初始化 

		for (int x = i; x <= i + k - 1; x ++)
			for (int y = 1; y <= k; y ++) add(col[x][y]);

		if (i > 1)
			for (int y = 1; y <= k; y ++) add(col[i - 1][y]);

		if (i + k - 1 < n)
			for (int y = 1; y <= k; y ++) add(col[i + k][y]);

		if (k < n)
			for (int x = i; x <= i + k - 1; x ++) add(col[x][k + 1]);

		ans = std::max(ans, calc(i, 1));

		for (int j = 2; j + k - 1 <= n; j ++) { // 计算每次右移的影响 
			dec(col[i - 1][j - 1]), add(col[i - 1][j + k - 1]);
			dec(col[i + k][j - 1]), add(col[i + k][j + k - 1]);

			if (j - 2 >= 1)
				for (int x = i; x <= i + k - 1; x ++) dec(col[x][j - 2]);

			if (j + k <= n)
				for (int x = i; x <= i + k - 1; x ++) add(col[x][j + k]);

			ans = std::max(ans, calc(i, j)); 
		}

		// 撤销 

		for (int x = i; x <= i + k - 1; x ++)
			for (int y = n - k + 1; y <= n; y ++) dec(col[x][y]);

		if (i > 1)
			for (int y = n - k + 1; y <= n; y ++) dec(col[i - 1][y]);

		if (i + k - 1 < n)
			for (int y = n - k + 1; y <= n; y ++) dec(col[i + k][y]);

		if (k < n)
			for (int x = i; x <= i + k - 1; x ++) dec(col[x][n - k]);
	}

	printf("%d\n", ans);

	return 0;
}

T4星际争霸

解题思路

注意到，要使得每个人的能量相等，则最后每个人的能量均为$\frac{sum}{n}$，其中$sum$表示所有人的能量之和。此时可以将每个人的能量减去$\frac{sum}{n}$，则问题转化为了使得每个人的能量均为0。

在所有能进行能量交换的人之间连边，可以证明： $n$个点可以被分成若干个互不干扰的环，环中相邻的两个点之间可以进行能量交换。我们只需对每个环取最优情况即可。

例如：样例中的a=[1,3,9,7],k=1 ，可以被拆成环1,9与环3,7。

证明：每个人$x$连出去的边$(x+k)modn+1$只有一条，故每个点的出度为1 。同时，任意两个不同的$x$所对应的$(x+k)modn+1$也是不同的，故每个点的入度为1 。同时满足这两点的图，一定是由若干个环构成的。

链的情况

首先考虑链的情况。

第一个人的能量为$a_1$，若要想变成$0$，则他需要花费$|a_1|$的代价将能量移向第二个人。

第二个人的能量为$a_1+a_2$，若想要变成$0$，则他需要花费$|a_1+a_2|$的代价将能量移向第三个人。

…

第$i$个人的能量为$S_i$，若想要变成$0$，则他需要花费$S_i$的代价将能量移向第$i+1$个人（其中$S_i$表示前缀$i$的和）。

…

故总代价为：
$$\sum _{i=1}^n|S_i|$$

环的情况

可以证明：在环中，一定存在相邻的两个点之间不进行任何能量交换。故我们可以考虑选出这两个点，断环为链。

暴力枚举断开的地方，显然会超时。形式化地，设断开的地方为$k,k+1$，则该环被拆成了一条(k+1) $\to$ n $\to$ 1 $\to$ k的链。考虑断环对前缀和的贡献：

当$k<i\le n$时，前缀和为$S_i-S_k$。
当$1\le i\le k$时，前缀和为$S_i+S_n-S_k$，注意到$S_n=0$，则前缀和仍为$S_i-S_k$。
故总代价为：
${\sum }_{i=1}^n|S_i-S_k|$

为使得上式最小， $S_k$取$S_i$ 的中位数即可。特判一下断开的地方为$n,1$的情况。

时间复杂度$O(nlogn)$。

参考代码

#include <bits/stdc++.h>

template <class T>
inline void read(T &x) {
	static char s;
	static bool opt;
	while (s = getchar(), (s < '0' || s > '9') && s != '-');
	x = (opt = s == '-') ? 0 : s - '0';
	while (s = getchar(), s >= '0' && s <= '9') x = x * 10 + s - '0';
	if (opt) x = ~x + 1;
}

typedef long long s64;

const int N = 500100; 

int abs(int x) {
	return x > 0 ? x : -x;
}

int n, k;
int a[N];

s64 sum;
int avg;

bool vis[N];

int len, seq[N];
s64 S[N];

s64 ans;

s64 solve() {
	for (int i = 1; i <= len; i ++) S[i] = S[i - 1] + seq[i];
	std::sort(S + 1, S + 1 + len);

	s64 sumA = 0, sumB = 0;
	for (int i = 1; i <= len; i ++) sumA += abs(S[i]); // 特判断开 len, 1 的情况 
	for (int i = 1; i <= len; i ++) sumB += abs(S[i] - S[(len + 1) / 2]); // 一般情况 

	return std::min(sumA, sumB);
}

int main() {
	freopen("energy.in", "r", stdin);
	freopen("energy.out", "w", stdout);

	read(n), read(k), k ++;

	for (int i = 1; i <= n; i ++) read(a[i]);

	for (int i = 1; i <= n; i ++) sum += a[i];
	avg = sum / n;

	for (int i = 1; i <= n; i ++) a[i] -= avg; // 第一步转化 

	for (int i = 1; i <= n; i ++) {
		if (vis[i]) continue;

		len = 0;

		int x = i;
		while (!vis[x]) { // 找环 
			seq[++ len] = a[x];
			vis[x] = 1, x = (x + k - 1) % n + 1;
		}

		ans += solve();
	}

	printf("%lld\n", ans);

	return 0;
}