this post is completely a joke. Original post. Inspired by the server overheat on 24. July 2025

Hello, CodeForces!

Today, I would like to discuss about an issue of Codeforces server rooms.

As you know, Codeforces Server Room is one of the hottest Servers in the world. For example, the mean daily maximum temperature in August is 95 °C, and if you turn on the radiator, it can even get up to a whopping 102 °C. Therefore, heat exhaustion can be a big concern. I think that even the following things can happen:

• 5% of the CPUs will instantly die
• 15% of the CPUs collapsed when compiling the code
• 30% of the CPUs collapsed during running of the code
• The remaining 50% were barely able to run the code, and returned TLE and RE verdicts.
• Only 10% were able to run the code correctly.

If I were a CPU in Codeforces, I have a strong confidence that I could not even get to the server because I often suffer extreme discomfort at 98 °C (real).

Are there any tips or any ways of practice to get used to high heat?

UPD: temperatures are now more realistic. Photo credit: some QQ group, sender unknown.

Wrong answer on test 4.

There is (probably) a much better solution, but I can't figure out what is wrong with this. (only main part of the code)

int n, q, dfn[200001], low[200001], a[200001],
	w[200001], an[21][200001], dep[200001], tot = 0, rt = 1;
vector<int> gv[200001];

inline void add_edge(int u, int v){
	gv[u].push_back(v);
	gv[v].push_back(u);
}
void dfs(int u, int fa){
	an[0][u] = fa;
	dfn[u] = low[u] = ++tot;
	for(int i = 1; i <= 20; i++)
		an[i][u] = an[i - 1][an[i - 1][u]];
	for(auto v : gv[u]){
		if(v == fa) continue;
		dep[v] = dep[u] + 1;
		dfs(v, u);
		low[u] = max(low[u], low[v]);
	}
}
int lca(int u, int v){
	if(dep[u] < dep[v]) swap(u, v);
	for(int i = 20; i >= 0; i--)
		if(dep[an[i][u]] >= dep[v]) u = an[i][u];
	if(u == v) return u;
	for(int i = 20; i >= 0; i--)
		if(an[i][u] != an[i][v])
			u = an[i][u], v = an[i][v];
	return an[0][u];
}
int approach(int u, int v){
	if(dep[u] < dep[v]) swap(u, v);
	for(int i = 20; i >= 0; i--)
		if(dep[an[i][u]] > dep[v]) u = an[i][u];
	return u;
}

// SGT
struct node{
	int l, r, val, lazy;
	node(){
		l = 0, r = 0, val = 0, lazy = 0;
	}
	node operator+(const node &b) const{
		node c; c.l = l, c.r = b.r;
		c.val = val + b.val;
		c.lazy = 0;
		return c;
	}
}tree[200001 << 2];

void build(int l, int r, int p){
	tree[p].l = l, tree[p].r = r;
	if(l == r){
		tree[p].val = a[l];
		tree[p].lazy = 0;
		return;
	}
	int mid = (l + r) / 2;
	build(l, mid, p * 2);
	build(mid + 1, r, p * 2 + 1);
	tree[p] = tree[p * 2] + tree[p * 2 + 1];
}
void mark(int p, int x){
	tree[p].val += x * (tree[p].r - tree[p].l + 1);
	tree[p].lazy += x;
}
void tag(int p){
	if(tree[p].lazy != 0)
		mark(p * 2, tree[p].lazy), mark(p * 2 + 1, tree[p].lazy);
	tree[p].lazy = 0;
}
void add(int l, int r, int x, int p){
	if(l > r) return;
	if(l <= tree[p].l && tree[p].r <= r){
		mark(p, x); return;
	}
	tag(p);
	int mid = (tree[p].l + tree[p].r) / 2;
	if(l <= mid) add(l, r, x, p * 2);
	if(mid < r) add(l, r, x, p * 2 + 1);
	tree[p] = tree[p * 2] + tree[p * 2 + 1];
}
int query(int l, int r, int p){
	if(l > r) return 0;
	if(l <= tree[p].l && tree[p].r <= r)
		return tree[p].val;
	tag(p);
	int mid = (tree[p].l + tree[p].r) / 2;
	if(l <= mid && mid < r)
		return query(l, r, p * 2) + query(l, r, p * 2 + 1);
	else if(l <= mid)
		return query(l, r, p * 2);
	else
		return query(l, r, p * 2 + 1);
}

void init_vars(){
	// type your initiating code...
}

void solve(int testcase, ...){
	init_vars();
	cin >> n >> q;
	for(int i = 1; i <= n; i++)
		cin >> w[i];
	for(int i = 1; i < n; i++){
		int u, v; cin >> u >> v;
		add_edge(u, v);
	}
	dfs(1, 1);
	for(int i = 1; i <= n; i++)
		a[dfn[i]] = w[i];
	build(1, n, 1);
	for(int i = 1; i <= q; i++){
		int op, u, v, x; cin >> op;
		if(op == 1) cin >> u, rt = u;
		else if(op == 2){
			cin >> u >> v >> x;
			if(lca(u, v) == rt || (lca(u, rt) == rt) + (lca(v, rt) == rt) == 1 || u == rt || v == rt)
				add(1, n, x, 1);
			else if(lca(u, rt) != lca(u, v) && lca(u, rt) != u && lca(u, rt) != rt && lca(lca(u, v), rt) == lca(u, v))
				add(1, dfn[approach(lca(u, rt), rt)] - 1, x, 1), add(low[approach(lca(u, rt), rt)] + 1, n, x, 1);
			else if(lca(v, rt) != lca(u, v) && lca(v, rt) != v && lca(v, rt) != rt && lca(lca(u, v), rt) == lca(u, v))
				add(1, dfn[approach(lca(v, rt), rt)] - 1, x, 1), add(low[approach(lca(v, rt), rt)] + 1, n, x, 1);
			else if(lca(u, rt) != u && lca(u, rt) != rt && lca(v, rt) != v && lca(v, rt) != rt && lca(u, v) != u && lca(u, v) != v)
				add(1, dfn[approach(lca(u, v), rt)] - 1, x, 1), add(low[approach(lca(u, v), rt)] + 1, n, x, 1);
			else if((lca(u, rt) == u) + (lca(v, rt) == v) == 1){
				if(lca(u, rt) == u) add(1, dfn[approach(u, rt)] - 1, x, 1), add(low[approach(u, rt)] + 1, n, x, 1);
				else add(1, dfn[approach(v, rt)] - 1, x, 1), add(low[approach(v, rt)] + 1, n, x, 1);
			}
			else if(lca(u, rt) == u && lca(v, rt) == v){
				if(lca(u, v) == u) add(1, dfn[approach(rt, v)] - 1, x, 1), add(low[approach(rt, v)] + 1, n, x, 1);
				else add(1, dfn[approach(rt, u)] - 1, x, 1), add(low[approach(rt, u)] + 1, n, x, 1);
			}
			else
				add(dfn[lca(u, v)], low[lca(u, v)], x, 1);
		}
		else{
			cin >> v;
			if(v == rt) cout << query(1, n, 1) << endl;
			else if(lca(v, rt) != v) cout << query(dfn[v], low[v], 1) << endl;
			else cout << query(1, dfn[approach(v, rt)] - 1, 1) + query(low[approach(v, rt)] + 1, n, 1) << endl;
		}
	}
}

Is the difficulty calculated by the server or is it set manually by some high-rated people?

I find the difficulties quite similar to those on the website clist.by, so are they calculated using similar algorithms?

Last contest, the solution of problem E has a complexity of $$$O(n2^m)$$$, which costs about $$$10^8$$$ calculations. On many programming platforms, that is really risky.

For example, in a chinese contest 'THUWC', a solution with a bottleneck at unordered_map and a data size of $$$5\times 10^5$$$ can lead to TLE (the time limit is 1s, and the language is C++17).

Then how many plus/minus operations can Codeforces' server perform in a second?

Link to problem, it is not that hard to find the solution, but I can't quite understand why the operation done by the players can always be sorted into one of the three types of the following when the root is unknown:

• The first player sets the root in the first turn;
• The first player sets one of the leaves in the first turn, while the second player sets the root (That is only valid when at least 1 leaf is unknown);
• The first player sets one of the other nodes in the first turn, while the second player sets the root (That is only valid when the number of available nodes that is neither the root nor the leaf odd).

What I don't understand is that why can't one player choose the root or something else midgame, and why the condition for the third thing exists?

I am now facing a difficult situation, the problems I find are either too easy or too hard, there are not many problems which I find interesting and a little difficult to solve.

Please help!

This problem has only Japanese editorials and Youtube videos.

People in mainland China are not allowed to visit youtube (VPN or similar is illegal) and I'm not studying Japanese (the translation is terrible), so can anyone translate or just post the written editorial here?

I'm a student studying German and I'm interested about CP in Germany.

If you're from Germany, Austria or Switzerland, how's CP there and how the government (or any national organization) is maintaining it? Write what you know pls :)

Hi, everyone!

I've just checked my rating graph and saw this.

Is it a normal codeforces bug or a browser bug or else?

Also, I found other rating graphs strange (someone taking part in a contest recently but had its rating graph updated until last year).

Many people may be worried about homework when participating in CF contests on weekdays, and Chinese users don't have a chance to compete. So, I think it is better to set the time of the contests to weekends.

Jerrlee was my classmate and he is struggling with Atcoder ABC C-D Problems. However, in last contest, he amazingly made to the 94-th! What's he doing and most importantly, is he cheating?

It's normal people won't like this, but I'm so confused that a person like this will do such a performance.