【CodeForces】CodeForces Round #406 (Div. 1) 题解

最新推荐文章于 2022-12-19 16:26:42 发布
最新推荐文章于 2022-12-19 16:26:42 发布
阅读量368 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 【OJ】CodeForces 【类型】做题记录 【比赛】CodeForces 【算法】博弈论 【算法】拓扑排序 【算法】最短路 【数据结构】线段树 【数据结构】树状数组 【算法】复杂度分析 【算法】倍增与二分 【算法】贪心 【算法】点分治 【算法】字符串哈希 【算法】常数优化 【算法】最大权闭合子图 【算法】最大流 【算法】最大流最小割定理 【算法】线性规划与网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39972971/article/details/82871203
本文深入探讨了博弈论在图算法中的应用，包括Berzerk、Legacy等经典问题的解决思路，涵盖游戏图构建、单源最短路径计算、贪心算法优化及树状数组维护等关键技巧。

【比赛链接】

【题解链接】

**【A】**Berzerk

【思路要点】

  • 博弈搜索，将状态按先后手拆点，建出游戏图。
  • 若一个点存在出边指向必败态，则该点为必胜态。
  • 若一个点所有出边指向必胜态，则该点为必败态。
  • 不满足上述两点的点为平局态。
  • 用一个类似拓扑排序的过程实现即可。
  • 时间复杂度 O ( N 2 ) O(N^2) O(N2) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e4 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, tot, point[MAXN][2], d[MAXN];
bool vis[MAXN], win[MAXN];
vector <int> s, t, a[MAXN];
int main() {
	read(n);
	int k; read(k);
	while (k--) {
		int x; read(x);
		s.push_back(x);
	}
	read(k);
	while (k--) {
		int x; read(x);
		t.push_back(x);
	}
	for (int i = 1; i <= n; i++) {
		point[i][0] = ++tot;
		d[tot] = s.size();
		point[i][1] = ++tot;
		d[tot] = t.size();
	}
	int l = 0, r = 1;
	static int q[MAXN];
	q[0] = point[1][0], q[1] = point[1][1];
	vis[q[0]] = vis[q[1]] = true;
	win[q[0]] = win[q[1]] = false;
	while (l <= r) {
		int tmp = q[l++], type = tmp % 2;
		int pos = (tmp + 1) / 2;
		if (win[tmp]) {
			if (type) {
				for (unsigned i = 0; i < t.size(); i++) {
					int tnp = point[(pos - t[i] + n - 1) % n + 1][1];
					if (!vis[tnp] && --d[tnp] == 0) {
						vis[tnp] = true;
						win[tnp] = false;
						q[++r] = tnp;
					}
				}
			} else {
				for (unsigned i = 0; i < s.size(); i++) {
					int tnp = point[(pos - s[i] + n - 1) % n + 1][0];
 					if (!vis[tnp] && --d[tnp] == 0) {
						vis[tnp] = true;
						win[tnp] = false;
						q[++r] = tnp;
					}
				}
			}
		} else {
			if (type) {
				for (unsigned i = 0; i < t.size(); i++) {
					int tnp = point[(pos - t[i] + n - 1) % n + 1][1];
					if (!vis[tnp]) {
						vis[tnp] = true;
						win[tnp] = true;
						q[++r] = tnp;
					}
				}
			} else {
				for (unsigned i = 0; i < s.size(); i++) {
					int tnp = point[(pos - s[i] + n - 1) % n + 1][0];
					if (!vis[tnp]) {
						vis[tnp] = true;
						win[tnp] = true;
						q[++r] = tnp;
					}
				}
			}
		}
	}
	for (int i = 2; i <= n; i++)
		if (vis[point[i][0]]) {
			if (win[point[i][0]]) printf("Win ");
			else printf("Lose ");
		} else printf("Loop ");
	printf("\n");
	for (int i = 2; i <= n; i++)
		if (vis[point[i][1]]) {
			if (win[point[i][1]]) printf("Win ");
			else printf("Lose ");
		} else printf("Loop ");
	printf("\n");
	return 0;
}

**【B】**Legacy

【思路要点】

  • 线段树建图，跑单源最短路。
  • 时间复杂度 O ( N L o g N + Q L o g 2 N ) O(NLogN+QLog^2N) O(NLogN+QLog2N) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
namespace ShortestPath {
	const ll INF = 1e18;
	const int MAXP = 1e6;
	struct edge {int dest, len; };
	int n; ll dist[MAXP];
	vector <edge> a[MAXP];
	set <pair <ll, int> > st;
	void addedge(int x, int y, int z) {
		a[x].push_back((edge) {y, z});
	}
	void init(int x) {
		n = x; st.clear();
		for (int i = 1; i <= n; i++) {
			dist[i] = INF;
			a[i].clear();
		}
	}
	void work(int s) {
		dist[s] = 0;
		st.insert(make_pair(0, s));
		while (!st.empty()) {
			pair <ll, int> tmp = *st.begin();
			st.erase(tmp);
			for (unsigned i = 0; i < a[tmp.second].size(); i++) {
				int dest = a[tmp.second][i].dest;
				ll newlen = tmp.first + a[tmp.second][i].len;
				if (newlen < dist[dest]) {
					st.erase(make_pair(dist[dest], dest));
					dist[dest] = newlen;
					st.insert(make_pair(dist[dest], dest));
				}
			}
		}
	}
}
int tot, n, q, s, totp, root;
int lc[MAXN], rc[MAXN], point[MAXN][2];
void build(int &root, int l, int r) {
	root = ++totp;
	point[root][0] = ++tot;
	point[root][1] = ++tot;
	if (l == r) return;
	int mid = (l + r) / 2;
	build(lc[root], l, mid);
	build(rc[root], mid + 1, r);
}
void query(int from, int root, int l, int r, int ql, int qr, int len, int type) {
	if (l == ql && r == qr) {
		if (type == 0) ShortestPath :: addedge(from, point[root][0], len);
		else ShortestPath :: addedge(point[root][1], from, len);
		return;
	}
	int mid = (l + r) / 2;
	if (mid >= ql) query(from, lc[root], l, mid, ql, min(mid, qr), len, type);
	if (mid + 1 <= qr) query(from, rc[root], mid + 1, r, max(mid + 1, ql), qr, len, type);
}
int main() {
	read(n), read(q), read(s), tot = n;
	build(root, 1, n);
	ShortestPath :: init(tot);
	for (int i = 1, j = 0; i <= totp; i++) {
		if (lc[i]) {
			ShortestPath :: addedge(point[i][0], point[lc[i]][0], 0);
			ShortestPath :: addedge(point[i][0], point[rc[i]][0], 0);
			ShortestPath :: addedge(point[lc[i]][1], point[i][1], 0);
			ShortestPath :: addedge(point[rc[i]][1], point[i][1], 0);
		} else {
			j++;
			ShortestPath :: addedge(point[i][0], j, 0);
			ShortestPath :: addedge(j, point[i][1], 0);
		}
	}
	for (int i = 1; i <= q; i++) {
		int opt; read(opt);
		if (opt == 1) {
			int x, y, z;
			read(x), read(y), read(z);
			ShortestPath :: addedge(x, y, z);
		}
		if (opt == 2) {
			int x, l, r, z;
			read(x), read(l), read(r), read(z);
			query(x, root, 1, n, l, r, z, 0);
		}
		if (opt == 3) {
			int x, l, r, z;
			read(x), read(l), read(r), read(z);
			query(x, root, 1, n, l, r, z, 1);
		}
	}
	ShortestPath :: work(s);
	for (int i = 1; i <= n; i++) {
		ll tmp = ShortestPath :: dist[i];
		if (tmp == 1e18) printf("-1 ");
		else write(tmp), putchar(' ');
	}
	return 0;
}

**【C】**Till I Collapse

【思路要点】

  • 显然所有答案的总和不超过 N + N 2 + N 3 + . . . = O ( N L o g N ) N+\frac{N}{2}+\frac{N}{3}+...=O(NLogN) N+2N​+3N​+...=O(NLogN) 。
  • 从左到右考虑所有左端点，用树状数组维护右端点对应的区间内不同数的个数，二分最远点实现贪心。
  • 时间复杂度 O ( N L o g 2 N ) O(NLog^2N) O(NLog2N) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct BinaryIndexTree {
	int n, a[MAXN];
	void init(int x) {
		n = x;
		memset(a, 0, sizeof(a));
	}
	void modify(int x, int d) {
		for (int i = x; i <= n; i += i & -i)
			a[i] += d;
	}
	int query(int x) {
		int ans = 0;
		for (int i = 20; i >= 0; i--) {
			int tmp = 1 << i;
			if (ans + tmp <= n && a[ans + tmp] <= x) {
				x -= a[ans + tmp];
				ans += tmp;
			}
		}
		return ans;
	}
} BIT;
int n, val[MAXN], last[MAXN], ans[MAXN];
vector <int> a[MAXN], home[MAXN];
int main() {
	read(n);
	for (int i = 1; i <= n; i++) {
		read(val[i]);
		a[last[val[i]]].push_back(i);
		last[val[i]] = i;
	}
	for (int i = 1; i <= n; i++)
		home[1].push_back(i);
	BIT.init(n);
	for (int i = 1; i <= n; i++) {
		if (i != 1) BIT.modify(i - 1, -1);
		for (unsigned j = 0; j < a[i - 1].size(); j++)
			BIT.modify(a[i - 1][j], 1);
		for (unsigned j = 0; j < home[i].size(); j++) {
			int tmp = home[i][j];
			ans[tmp]++, home[BIT.query(tmp) + 1].push_back(tmp);
		}
	}
	for (int i = 1; i <= n; i++)
		write(ans[i]), putchar(' ');
	return 0;
}

**【D】**Rap God

【思路要点】

  • 标算是点分治。
  • 我们用树上倍增 + + + 哈希实现快速比较字符串。
  • 运用点分治，我们将问题转化到了询问 ( x , y ) (x,y) (x,y) 中的 x x x 在分治重心的情况。
  • 将 x x x 所在分治子树的字符串通过哈希比较排序，询问时二分即可。
  • 时间复杂度 O ( N L o g 3 N + Q L o g 3 N ) O(NLog^3N+QLog^3N) O(NLog3N+QLog3N) 。
  • 但上面的做法比较难写，下面笔者的代码是暴力的精细实现，时间复杂度 O ( N 2 ) O(N^2) O(N2) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
char from[MAXN];
int n, m, father[MAXN], ans[MAXN];
vector <pair <int, int> > q[MAXN];
vector <pair <int, char> > a[MAXN];
void dfs(int pos, int fa) {
	for (unsigned i = 0; i < a[pos].size(); i++)
		if (a[pos][i].first != fa) {
			father[a[pos][i].first] = pos;
			from[a[pos][i].first] = a[pos][i].second;
			dfs(a[pos][i].first, pos);
		}
}
int solve(int pos, int to) {
	static int vis[MAXN], depth[MAXN], tag = 0;
	static char val[MAXN]; static int cmp[MAXN]; tag++;
	int tmp = n, ans = -1;
	for (int now = to; now != pos; now = father[now], tmp--) {
		val[tmp] = from[now];
		depth[now] = tmp;
		vis[now] = tag;
		cmp[now] = 1;
		ans++;
	}
	vis[pos] = tag, cmp[pos] = 1, depth[pos] = tmp;
	for (int i = 1; i <= n; i++)
		if (vis[i] != tag) {
			int top = 0, now = i;
			static int st[MAXN];
			while (vis[now] != tag) st[top++] = now, now = father[now];
			for (int j = top - 1; j >= 0; j--) {
				int now = st[j];
				depth[now] = depth[father[now]] + 1;
				vis[now] = tag;
				if (cmp[father[now]] != 1) cmp[now] = cmp[father[now]];
				else if (val[depth[now]] > from[now]) cmp[now] = 0;
				else if (val[depth[now]] == from[now]) cmp[now] = 1;
				else cmp[now] = 2;
				ans += (cmp[now] == 0) || (cmp[now] == 1 && depth[now] < n);
			}
		}
	return ans;
}
void work(int pos, int fa) {
	for (unsigned i = 0; i < q[pos].size(); i++)
		ans[q[pos][i].second] = solve(pos, q[pos][i].first);
	for (unsigned i = 0; i < a[pos].size(); i++)
		if (a[pos][i].first != fa) {
			int dest = a[pos][i].first;
			father[pos] = dest;
			father[dest] = 0;
			from[pos] = a[pos][i].second;
			work(dest, pos);
			father[dest] = pos;
			father[pos] = 0;
			from[dest] = a[pos][i].second;
		}
}
int main() {
	read(n), read(m);
	for (int i = 1; i <= n - 1; i++) {
		int x, y; char c;
		scanf("%d%d %c", &x, &y, &c);
		a[x].push_back(make_pair(y, c));
		a[y].push_back(make_pair(x, c));
	}
	dfs(1, 0);
	for (int i = 1; i <= m; i++) {
		int x, y; read(x), read(y);
		q[x].push_back(make_pair(y, i));
	}
	work(1, 0);
	for (int i = 1; i <= m; i++)
		writeln(ans[i]);
	return 0;
}

**【E】**ALT

【思路要点】

  • 最大权闭合子图 + + + 树上倍增建图。
  • 时间复杂度 O ( D i n i c ( N + Q , N + Q L o g N ) ) O(Dinic(N+Q,N+QLogN)) O(Dinic(N+Q,N+QLogN)) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXP = 4e5 + 5;
const int MAXN = 2e4 + 5;
const int MAXLOG = 16;
const int INF = 2e9;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct edge {int dest, flow; unsigned pos; };
vector <edge> a[MAXP];
int n, m, s, t, dist[MAXP];
unsigned curr[MAXP];
vector <int> b[MAXN], home[MAXN];
int tot, point[MAXN][MAXLOG], pos[MAXN];
int depth[MAXN], father[MAXN][MAXLOG];
void addedge(int x, int y, int z) {
	a[x].push_back((edge) {y, z, a[y].size()});
	a[y].push_back((edge) {x, 0, a[x].size() - 1});
}
int dinic(int pos, int limit) {
	if (pos == t) return limit;
	int used = 0, tmp;
	for (unsigned &i = curr[pos]; i < a[pos].size(); i++)
		if (a[pos][i].flow != 0 && dist[pos] + 1 == dist[a[pos][i].dest] && (tmp = dinic(a[pos][i].dest, min(limit - used, a[pos][i].flow)))) {
			used += tmp;
			a[pos][i].flow -= tmp;
			a[a[pos][i].dest][a[pos][i].pos].flow += tmp;
			if (used == limit) return used;
		}
	return used;
}
bool bfs() {
	static int q[MAXP];
	int l = 0, r = 0;
	memset(dist, 0, sizeof(dist));
	dist[s] = 1, q[0] = s;
	while (l <= r) {
		int tmp = q[l];
		for (unsigned i = 0; i < a[tmp].size(); i++)
			if (dist[a[tmp][i].dest] == 0 && a[tmp][i].flow != 0) {
				q[++r] = a[tmp][i].dest;
				dist[q[r]] = dist[tmp] + 1;
			}
		l++;
	}
	return dist[t] != 0;
}
void work(int pos, int fa) {
	depth[pos] = depth[fa] + 1;
	father[pos][0] = fa;
	for (int i = 1; i < MAXLOG; i++) {
		father[pos][i] = father[father[pos][i - 1]][i - 1];
		if (father[pos][i]) {
			point[pos][i] = ++tot;
			addedge(point[pos][i], point[pos][i - 1], INF);
			addedge(point[pos][i], point[father[pos][i - 1]][i - 1], INF);
		}
	}
	for (unsigned i = 0; i < b[pos].size(); i++)
		if (b[pos][i] != fa) {
			point[b[pos][i]][0] = home[pos][i];
			work(b[pos][i], pos);
		}
}
int lca(int x, int y) {
	if (depth[x] < depth[y]) swap(x, y);
	for (int i = MAXLOG - 1; i >= 0; i--)
		if (depth[father[x][i]] >= depth[y]) x = father[x][i];
	if (x == y) return x;
	for (int i = MAXLOG - 1; i >= 0; i--)
		if (father[x][i] != father[y][i]) {
			x = father[x][i];
			y = father[y][i];
		}
	return father[x][0];
}
int main() {
	read(n), read(m);
	for (int i = 1; i <= n - 1; i++) {
		int x, y; read(x), read(y);
		b[x].push_back(y);
		home[x].push_back(i);
		b[y].push_back(x);
		home[y].push_back(i);
	}
	s = 0, tot = n - 1;
	work(1, 0);
	for (int i = 1; i <= m; i++) {
		int x, y; read(x), read(y);
		int z = lca(x, y);
		pos[i] = ++tot;
		addedge(s, pos[i], 1);
		for (int j = MAXLOG - 1; j >= 0; j--)
			if (depth[father[x][j]] >= depth[z]) {
				addedge(pos[i], point[x][j], INF);
				x = father[x][j];
			}
		for (int j = MAXLOG - 1; j >= 0; j--)
			if (depth[father[y][j]] >= depth[z]) {
				addedge(pos[i], point[y][j], INF);
				y = father[y][j];
			}
	}
	t = ++tot;
	for (int i = 1; i <= n - 1; i++)
		addedge(i, t, 1);
	int ans = 0;
	while (bfs()) {
		memset(curr, 0, sizeof(curr));
		ans += dinic(s, INF);
	}
	printf("%d\n", ans);
	bfs(); int size = 0;
	for (int i = 1; i <= m; i++)
		if (dist[pos[i]] == 0) size++;
	printf("%d ", size);
	for (int i = 1; i <= m; i++)
		if (dist[pos[i]] == 0) printf("%d ", i);
	printf("\n");
	size = 0;
	for (int i = 1; i <= n - 1; i++)
		if (dist[i] != 0) size++;
	printf("%d ", size);
	for (int i = 1; i <= n - 1; i++)
		if (dist[i] != 0) printf("%d ", i);
	printf("\n");
	return 0;
}
Codeforces Round #838 (Div. 2)题解
Kicamon的博客
12-16 738
这场的状态不太好。
题解 Codeforces Round #814 (Div. 1/2)
im_zyINF的博客
08-17 498
Codeforces
Codeforces Round #406 (Div. 1)
weixin_30675967的博客
03-24 126
B题打错调了半天，C题想出来来不及打，还好没有挂题 AC:AB Rank:96 Rating:2125+66->2191 A.Berzerk 题目大意：有一个东东在长度为n的环上（环上点编号0~n-1），两个玩家，玩家1有a种操作可选，玩家2有b种操作可选，每种操作可以让这个东东向前走若干步，两个玩家轮流操作，谁先让东东走到0谁胜，求出双方都选最优操作的情况下，东东开始在1~n-...
Codeforces Round #406 (Div. 1) B. Legacy（线段树上优化建图）
xxxxxiao123的博客
02-15 222
题意： 题解： 如何处理从v往[l−r][l-r][l−r]每个点进行连边？ 如果暴力连边就有n2n^2n2条边，无法承受。 考虑如何优化区间建图。 线段树，它可以在区间询问/修改的时候，把一个区间分成O(logn)O(logn)O(logn)级别个子区间，分别对应线段树上这么多个点。 就像这样建图，相当于是建立了两颗线段树，因为线段树递归到叶子结点后，表示的就是单个结点了，那么我们用叶子结点直接表示点。 其他的点表示区间，线段树上边的权值为0. 比如说v向2-9的点进行连边。 我们只需要连接v与2、3、
codeforces#406 A (拓展欧几里得水题）
keep coding
03-24 485
A. The Monstertime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputA monster is chasing after Rick and Morty on another planet. They're so frightened th...
Codeforces Round #406 (Div. 2) C 博弈
新熊君的博客
05-02 408
题目链接此题类似于当初上ACM公选课博弈一节的某例题，考察了对于必胜点，必败点等基础知识的掌握。对于此题： 必败点(P点) :前一个选手(Previous player)将取胜的位置称为必败点。 必胜点(N点) :下一个选手(Next player)将取胜的位置称为必胜点。 对于必败点和必胜点，分别有以下性质： 必败点：无论怎么操作，从必败点下一步都只能进入必胜点。 必胜点：至
CodeForces Round #406 (Div. 2)
dezhen7015的博客
03-25 122
这一场打得真难受 A. The Monster 解个方程就好了。 但开个visit数组暴力判断也没问题。 可以看到这份代码实际上数组可能会越界，好在没人hack，也没有FST A B. Not Afraid 题意记不清了，反正差不多是道模拟。 开两个bool数组记录两个集合里的人出现过没有即可。 B C. Berzerk 博弈论 DP SG函数 ...
Codeforces Round #142 Div.2 题解
热门推荐
Fuko_Ibuki的博客
09-06 1万+
A B C D E A 打n条龙,龙的攻击力xi,打死每条龙攻击力加yi,你的初始攻击力是s. 如果你的攻击力小于或者等于某条龙的攻击力你就死了. 问你能不能活着回去. 每次贪心打攻击力最小的龙,将龙排序既可. #include&lt;bits/stdc++.h&gt; //Ithea Myse Valgulious using namespace std; co...
Codeforces Beta Round #87 (Div. 1 Only) A Party
weixin_62528401的博客
09-19 216
trees
Codeforces Round #839 (Div. 3)题解
Kicamon的博客
12-19 1353
我们可以将数分为三类，一类是只有先手想要染的（数量为a），第二类是只有后手想要染的（数量为b），第三类是两者都要染的（数量为c）。上述例子中，后手想要赢的话，只要将3、4、5都染成蓝色， 那么他就可以将这三个数从新排布得到降序的数组；而先手想要赢的话，就要将所有的都染成蓝色， 所以后手赢。这题的题意有点含糊，其大意是，两个操作，将一个红色染成蓝色， 或者将蓝色的位置之间任意排序。我是撒比，这题开始用二分答案来写，卡了一个半小时。此时可以选择3或者5将其染成蓝色，这里不做演示。，不足的在从大到小标记。
Codeforces Round #742 Div.2 （A~E）题解
m0_51145827的博客
09-15 582
比赛链接：点击这里传送 官方题解链接：点击这里传送 Codeforces 1567A 题目链接：点击这里传送 题意： 给出n个1 ×\times× 2大小的多米诺骨牌组成2×\times×n的矩形。现输入第一行的多米诺骨牌的方向，根据上图的格式输出排列方法。 思路： 上下左右四个方向都取其对立面输出就行。 #include<bits/stdc++.h> using namespace std; int t, n; string s; string ans; int main() { ios
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层...
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1303
Codeforces Round #787 (Div. 3)个人题解 Codeforces Round #787 (Div. 3) A. Food for Animals B. Make It Increasing C. Detective Task D. Vertical Paths E. Replace With the Previous, Minimize F. Vlad and Unfinished Business G. Sorting Pancakes
【CodeForces】CodeForces Round #477 (Div. 1 + Div. 2) 题解
cz_xuyixuan的博客
05-07 1708
【比赛链接】Div. 1Div. 2【题解链接】点击打开链接【Div.2 A】Mind the Gap【思路要点】从小到大枚举答案，检查合法性。时间复杂度\(O(Ans*N)\)。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 100005; template &lt;typename T&gt; vo...
【CodeForces】Codeforces Global Round 9
cz_xuyixuan的博客
07-10 1335
比赛链接 点击打开链接 官方题解 点击打开链接 Problem A. Sign Flipping 将奇数位的数取非正值，偶数位的数取非负值即可。 单组数据时间复杂度 O(N)O(N)O(N) 。 #include<bits/stdc++.h> using namespace std; const int MAXN = 3e5 + 5; typedef long long ll; template <typename T> void chkmax(T &x, T y) {x =
【CodeForces506E】Mr. Kitayuta's Gift
cz_xuyixuan的博客
11-22 1219
【题目链接】 点击打开链接 【思路要点】 首先有一个简单的 O(∣S∣3+N∗∣S∣2)O(|S|^3+N*|S|^2)O(∣S∣3+N∗∣S∣2) 的 dpdpdp 做法，即从结果串的两边向中间 dpdpdp 。 这个方法同样可以对于所有 M≤NM≤NM≤N 算出所有答案。 由数据范围，本题的正解很可能是矩阵乘法优化 dpdpdp ，不妨用上述 dpdpdp 计算较小范围的答案，然后...
【CodeForces】CodeForces Round #464 (Div. 2) 题解
cz_xuyixuan的博客
02-18 1161
【比赛链接】点击打开链接【题解链接】点击打开链接【A】Love Triangle【思路要点】按照题意寻找三角形即可。即若存在一个点\(i\)使得\(f[f[f[i]]]==i\)，答案为Yes，否则为No。时间复杂度\(O(N)\)。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 5005; templ...
【CodeForces】CodeForces Round #549 (Div. 1) 题解
cz_xuyixuan的博客
04-04 1004
【比赛链接】 点击打开连接 【题解链接】 点击打开链接 【A】 The Beatles 【思路要点】 任取一个合法的起始点，枚举所有可能的步长 lll ，计算步数 N×kgcd(Nk,l)\frac{N\times k}{gcd(Nk,l)}gcd(Nk,l)N×k​ ，取最优值即可。 时间复杂度 O(NLogV)O(NLogV)O(NLogV) 。 【代码】 #incl...
【CodeForces】Hello 2019 (Div. 1 + Div. 2) 题解
cz_xuyixuan的博客
01-09 973
【比赛链接】 点击打开连接 【题解链接】 点击打开链接 **【A】**Gennady and a Card Game 【思路要点】 按照题意模拟。 时间复杂度 O(1)O(1)O(1) 。 【代码】 #include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 2e5 + 5; typedef lo...
Codeforces Round 260 (Div. 1)
最新发布
01-12
### Codeforces Round 260 Div. 1 题目及题解 #### A. Vasya and Multisets 在这道题目中，Vasya有一个由n个整数组成的序列。目标是通过将这些数分成若干组，使得每组中的所有数都相同，并且尽可能减少分组的数量。 为了实现这一目的，可以利用贪心算法来解决这个问题。具体来说，在遍历输入数据的同时维护当前最大频率计数器，对于每一个新遇到的不同数值增加一个新的集合[^1]。 ```cpp #include <bits/stdc++..h> using namespace std; void solve() { int n; cin >> n; unordered_map<int, int> freq; for (int i = 0; i < n; ++i) { int x; cin >> x; freq[x]++; } int maxFreq = 0; for (auto& p : freq) { maxFreq = max(maxFreq, p.second); } cout << maxFreq << "\n"; } ``` #### B. Pashmak and Graph 此问题涉及图论领域的一个经典最短路径计算案例。给定一张带权无向图以及起点S和终点T，要求求出从S到T经过至少一条边后的最小花费总和。 Dijkstra算法适用于此类场景下的单源最短路径查询任务。初始化距离表dist[]为无穷大(INF)，仅设置起始节点的距离为零；随后借助优先队列选取未访问过的最近邻接顶点u更新其相邻结点v至目前为止所知的最佳到达成本min{dist[u]+w(u,v)}直至找到终止条件即抵达目的地t或处理完毕所有可达区域内的候选者为止。 ```cpp typedef pair<long long,int> pli; const long long INF = LLONG_MAX / 3; struct Edge { int to, cost; }; vector<Edge> G[MAX_V]; long long d[MAX_V]; bool dijkstra(int s, int t){ priority_queue<pli,vector<pl>,greater<pl>> que; fill(d,d+MAX_V,INF); d[s]=0; que.push(pli(0,s)); while(!que.empty()){ pli p=que.top();que.pop(); int v=p.second; if(d[v]<p.first) continue; for(auto e:G[v]){ if(d[e.to]>d[v]+e.cost){ d[e.to]=d[v]+e.cost; que.push(pli(d[e.to],e.to)); } } } return d[t]!=INF; } ``` #### C. DZY Loves Colors 这是一道关于颜色染色的问题。给出长度为N的一维网格，初始状态下每个格子都有一个默认的颜色编号。现在有M次操作机会改变某些位置上的色彩值，最终目的是统计整个条带上共有几种不同的色调存在。 采用离散化技术预处理原始输入并记录下各段连续同色区间的端点坐标范围，之后针对每一次修改请求动态调整受影响部分的信息结构体（如线段树），最后依据累积的结果得出答案。 ```cpp // 假设已经实现了上述提到的数据结构 SegmentTree 和 update 函数 SegmentTree st; for(int i=1;i<=m;++i){ int l,r,c; scanf("%d%d%d",&l,&r,&c); update(l,r,c); } printf("%lld\n",st.query()); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值