2024 信友队 noip 冲刺 9.28

最新推荐文章于 2025-12-31 21:25:26 发布

原创最新推荐文章于 2025-12-31 21:25:26 发布 · 961 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#算法

OI题解同时被 2 个专栏收录

39 篇文章

订阅专栏

2024 信友队noip 冲刺

10 篇文章

订阅专栏

T1

给定一个长度为 $n$ 的数组 $a$ ，需要选择若干段不相交子串，使得每个子串的和相等。求最多能选取多少个子串。

$n≤1000n\le 1000$ ， $1≤ai≤201\le a_i\le20$ 。

发现 $∑a\sum a$ 很小可以直接枚举每个子串的和，然后扫一遍即可。赛时用的队列贪心的选取，差点因为选取了相交子串而 $20pts20\mathrm{pts}$ 。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 1005;
int a[maxn], n, sum;
int q[maxn], l, r, ans, tot, now;
int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i ++) scanf("%d", &a[i]), sum += a[i];
	for (int s = 1; s <= sum; s ++) {
		now = 0, l = 1, r = tot = 0; 
		for (int i = 1; i <= n; i ++) {
			for (now += (q[++ r] = a[i]); l <= r && now > s; )
				now -= q[l ++];
			if (now == s) tot ++, l = r + 1, now = 0;
		} ans = max(ans, tot);
	} printf("%d\n", ans);
	return 0;
}

T2

有 $n$ 个套装，第 $i$ 个套装有 $c_i$ 个物品，这些物品有参数 $w_i$ ，选取这个套装代价为 $v_i$ ；还有 $m$ 个任务，完成第 $i$ 个任务需要 $w$ 至少为 $W_i$ 的物品 $C_i$ 个，完成后获得 $V_i$ 的收益。求最大收益减代价。

$n,m≤2000n,m\le 2000$ ， $1≤ci,Ci≤501\le c_i,C_i\le 50$ ， $1≤wi,Wi,vi,Vi≤1091\le w_i,W_i,v_i,V_i\le 10^9$ 。

套路：把买和卖放到一起做，对于买的情况价值取负。考虑 dp，令 $f (i)$ 表示手上有 $i$ 个物品时的最大收益。转移时滚动数组即可。对于 $w$ 的限制，所有信息按照 $w$ 从大到小做就行了。但是排序的时候没有考虑 $w$ 与 $W$ 相等的情况，显然应当先考虑买后考虑卖，痛失 $16pts16\mathrm{pts}$ 。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 2005, maxc = 1e5 + 5;
int n, m; 
struct Object { 
	int c, w, v; 
	inline bool operator<(const Object &oth) const {
		return w == oth.w ? v < oth.v : w > oth.w;
	}
} a[maxn << 1];
ll f[maxc]; const ll inf = 1e18;
inline int read() {
	char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	int s = 0;
	for (; c >= '0' && c <= '9'; c = getchar())
		s = (s << 1) + (s << 3) + (c ^ 48);
	return s;
}
int main() {
	n = read(), m = read(); int tmp = 0;
	for (int i = 1; i <= n; i ++) a[i].c = read(), a[i].w = read(), a[i].v = -read(), tmp += a[i].c;
	for (int i = n + 1; i <= n + m; i ++) a[i].c = read(), a[i].w = read(), a[i].v = read();
	n += m, m = tmp; sort(a + 1, a + n + 1); ll ans = 0;
	for (int i = 1; i <= m; i ++) f[i] = -inf;
	for (int i = 1; i <= n; i ++) {
		int c = a[i].c, v = a[i].v;
		if (v < 0) for (int j = m; j >= c; j --) {
			if (f[j - c] == -inf) continue; 
			ans = max(ans, f[j] = max(f[j], f[j - c] + v));
			// cout << j << ' ' << f[j] << '\n';
		} else for (int j = 0; j + c <= m; j ++) {
			if (f[j + c] == -inf) continue; 
			ans = max(ans, f[j] = max(f[j], f[j + c] + v));
			// cout << j << ' ' << f[j] << '\n';
		}
	} printf("%lld\n", ans);
	return 0;
}

T3

给定一张 $n$ 个点 $m$ 条边的无向图，每条边有值 $0$ 或 $1$ 。给定 $d$ ，对于所有起点为 $1$ 、长度为 $d$ 的路径（可以走重复的点和边），将路径上经过的边的值依次连接可以组成若干 $d$ 位的二进制数。求这些二进制数的种类数。

$n≤90n\le 90$ ， $m≤n(n−1)m\le n(n-1)$ ， $1≤d≤201\le d\le 20$ 。有重边和自环。

看起来就很像有关 $2^d$ 的复杂度的做法，但是没有想出来，最后写了一个 $30pts30\mathrm{pts}$ 的暴搜，如果和 cout << (1 << d) 拼起来大概能拿 $40pts40\mathrm{pts}$ 左右，但是忘了这么做。正解是考虑 meet-in-the-middle，告诉算法后也就会做了。记 $f (i, j, k)$ 和 $g (i, j, k)$ 表示到了 $i$ 点已经走了 $j$ 步是否可以有 $k$ 这个二进制，其中 $j≤10j\le 10$ 。前者起点为 $1$ 后者以所有点为起点，然后 $O(n2^d)$ 合并一下即可。快把这个算法忘了。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 95, maxm = maxn * maxn;
namespace Graph {
	struct Edge { int to, nxt, v; } e[maxm << 1];
	int head[maxn], ecnt;
	void addEdge(int u, int v, int c) {
		e[++ ecnt] = Edge { v, head[u], c }, head[u] = ecnt;
	}
} using namespace Graph;
const int maxd = 15;
bool f[maxn][maxd][1 << 10], g[maxn][maxd][1 << 10]; int n, m, d;
void dfs1(int u, int now, int step) {
	if (f[u][step][now]) return;
	f[u][step][now] = 1;
	if (step == (d >> 1)) return ;
	for (int i = head[u]; i; i = e[i].nxt)
		dfs1(e[i].to, now << 1 | e[i].v, step + 1);
}
void dfs2(int u, int now, int step) {
	if (g[u][step][now]) return;
	g[u][step][now] = 1;
	if (step == (d >> 1) + (d & 1)) return ;
	for (int i = head[u]; i; i = e[i].nxt)
		dfs2(e[i].to, now | (e[i].v << step), step + 1);
}
int main() {
	scanf("%d %d %d", &n, &m, &d);
	for (int i = 1, u, v, c; i <= m; i ++)
		scanf("%d %d %d", &u, &v, &c), addEdge(u, v, c), addEdge(v, u, c);
	dfs1(1, 0, 0); for (int i = 1; i <= n; i ++) dfs2(i, 0, 0);
	int ans = 0; for (int s = 0; s < (1 << d); s ++) {
		// cout << "s = " << s << '\n';
		int t0 = (s >> ((d >> 1) + (d & 1)));
		int t1 = (s - (t0 << ((d >> 1) + (d & 1)))), tmp = 0;
		for (int i = 1; i <= n; i ++) {
			// cout << i << ' ' << t0 << ' ' << f[i][t0] << ',' << t1 << ' ' << g[i][t1] << '\n';
			tmp |= (f[i][d >> 1][t0] & g[i][(d >> 1) + (d & 1)][t1]);
		} 
		// cout << "result: " << tmp << '\n';
		ans += tmp;
	} printf("%d\n", ans);
	return 0;
}

T4

维护一个长度为 $n$ 的序列 $a$ ，支持两种操作 $Q$ 次：

给定区间 $[l, r]$ ，对于所有 $i∈[l,r]i\in [l,r]$ ， $ai←ai2a_i\gets a_i^2$ ；
给定区间 $[l, r]$ ，求 $∑i=lrai\sum_{i=l}^r a_i$ 。

$1≤n,q≤2×1051\le n,q\le 2\times 10^5$ ，结果对 $p = 998244353$ 取模。

原题有一档 $O (n Q)$ 的小数据分和两档特殊性质，分别是单点修改和单点询问。单点修改拿个树状数组维护一下即可。单点询问用一个差分树状数组维护每个点被平方了几次，假设 $x$ 被平方了 $k$ 次，那么它现在的值就是：
$x^{2^k}\bmod p$
用一下扩展欧拉定理进行降幂，原式变为：
$x^{(2^k\bmod\varphi(p))+\varphi(p)}\bmod p$
做两次快速幂即可。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
bool MemoryST;
const int N = 2e5 + 5, P = 998244353;
int n, q, a[N];
struct Queries { int op, l, r; } Q[N];
namespace Subtask0 {
	void work() {
		for (int qq = 1; qq <= q; qq ++) {
			int op = Q[qq].op, l = Q[qq].l, r = Q[qq].r;
			if (op == 1) 
				for (int i = l; i <= r; i ++)
					a[i] = 1ll * a[i] * a[i] % P;
			else {
				int sum = 0;
				for (int i = l; i <= r; i ++)
					sum = (sum + a[i]) % P;
				printf("%d\n", sum);
			}
		}
	}
}
namespace Subtask1 {
	const int maxn = 2e5 + 5;
	namespace BIT {
		int b[maxn];
		#define lowbit(x) ((x) & (-(x)))
		void add(int i, int x) {
			for (; i <= n; i += lowbit(i))
				b[i] = (b[i] + x) % P;
		}
		int query(int i) {
			int ans = 0;
			for (; i; i -= lowbit(i)) ans = (b[i] + ans) % P;
			return ans;
		}
	} using namespace BIT;
	void work() {
		for (int i = 1; i <= n; i ++) add(i, a[i]);
		for (int qq = 1; qq <= q; qq ++) {
			int op = Q[qq].op, l = Q[qq].l, r = Q[qq].r;
			if (op == 1) add(l, 1ll * a[l] * ((a[l] + P - 1) % P) % P), a[l] = 1ll * a[l] * a[l] % P;
			else printf("%d\n", (query(r) - query(l - 1) + P) % P);
		}
	}
}
namespace Subtask2 {
	const int maxn = 2e5 + 5, P0 = 998244352;
	namespace BIT {
		int b[maxn];
		#define lowbit(x) ((x) & (-(x)))
		void add(int i, int x) {
			for (; i <= n; i += lowbit(i))
				b[i] += x;
		}
		int query(int i) {
			int ans = 0;
			for (; i; i -= lowbit(i)) ans += b[i];
			return ans;
		}
	} using namespace BIT;
	int qp(int x, int y, int p) {
		int res = 1;
		for (; y; y >>= 1, x = (1ll * x * x) % p)
			if (y & 1) res = 1ll * res * x % p;
		return res;
	}
	void work() {
		// for (int i = 1; i <= n; i ++) add(i, a[i]);
		for (int qq = 1; qq <= q; qq ++) {
			int op = Q[qq].op, l = Q[qq].l, r = Q[qq].r;
			if (op == 1)
				add(l, 1), add(r + 1, -1);
			else {
				int tot = query(l), tmp = qp(2, tot, P0) + P0;
				printf("%d\n", qp(a[l], tmp, P));
			}
		}
	}
}
bool MemoryED;
int main() {
	scanf("%d %d", &n, &q);
	for (int i = 1; i <= n; i ++) scanf("%d", &a[i]);
	bool stag1 = 1, stag2 = 1;
	for (int i = 1; i <= q; i ++) {
		scanf("%d %d %d", &Q[i].op, &Q[i].l, &Q[i].r);
		if (Q[i].op == 1 && Q[i].l != Q[i].r) stag1 = 0;
		if (Q[i].op == 2 && Q[i].l != Q[i].r) stag2 = 0;
	} if (stag1) return Subtask1::work(), 0;
	if (stag2) return Subtask2::work(), 0;
	Subtask0::work();
	cerr << fixed << setprecision(6) << (&MemoryED - &MemoryST) / 1024.0 << "KB\n";
	cerr << 1e3 * clock() / CLOCKS_PER_SEC << "ms\n";
	return 0;
}

正解是观察到 $φ(p)=998244352=223×119\varphi(p)=998244352=2^{23}\times 119$ 会出现循环节，然后就可以用线段树维护了，循环节长度可以打表发现是 $24$ 。时间复杂度就是 $O(nlog⁡n)O(n\log n)$ 带 $24$ 的常数，用来处理循环节。线段树上每个点记录一下是否进入循环节和循环节的数组即可。