• Amazing round:
• Good round:
• Average round:
• Bad round:
• Horrible round:

If one team got a score of $$$x$$$ in the first half, what is the maximum score the other team could get?

We can consider the first half and the second half separately. The dream might come true if and only if the scores in both halves are possible. In the second half, the RiOI team scored $$$(c - a)$$$ goals, while the KDOI team scored $$$(d - b)$$$ goals.

Suppose the RiOI team scored $$$x$$$ goals in some half. Denoting the score of the KDOI team as $$$y$$$, one can see that the maximal value of $$$y$$$ is $$$2\cdot x + 2$$$, under the goal order $$$\tt{\color{red}K\color{red}K\color{black}RK\color{red}K\color{black}R...RK\color{red}K\color{black}RK\color{red}K}$$$. When $$$y \geq x$$$, all scores in the range $$$[x, 2\cdot x+2]$$$ can be achieved by deleting several $$$\tt K$$$-s colored red.

Therefore, the scores $$$x: y$$$ in a single half are possible, if and only if $$$\max(x, y) \leq 2\cdot \min(x, y) + 2$$$.

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int T, a, b, c, d;

int main() {
	for (scanf("%d", &T); T--; ) {
		scanf("%d%d%d%d", &a, &b, &c, &d), c -= a, d -= b;
		if (a > b) swap(a, b); if (c > d) swap(c, d);
		puts((a + 1 << 1) >= b && (c + 1 << 1) >= d ? "YES" : "NO");
	}
}

import sys
input=sys.stdin.readline
 
t=int(input())
for _ in range(t):
    a,b,c,d=map(int,input().split())
    if(max(a,b)>2*min(a,b)+2):
        print("NO")
    elif(max(c-a,d-b)>2*min(c-a,d-b)+2):
        print("NO")
    else:
        print("YES")

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

When shall we output $$$\tt{NO}$$$?

We can put larger numbers on indices with $$$s_i = \tt{0}$$$, and smaller numbers on indices with $$$s_i = \tt{1}$$$.

Note that if there is an interval $$$p_l, \ldots, p_r$$$ such that $$$r - l + 1 \geq k$$$, and $$$s_l = s_{l+1} = \ldots = s_r = \tt{1}$$$, then it's impossible to satisfy all the requirements, since by iterating $$$i$$$ over $$$l$$$ to $$$r$$$, there must be some $$$i$$$ such that $$$p_i = \max(p_l, \ldots, p_r)$$$.

Otherwise, denote $$$c$$$ as the number of occurrences of $$$\tt{1}$$$ in the string $$$s$$$. We can always construct the permutation by filling the indices $$$i$$$ of $$$s_i = \tt{1}$$$ with $$$1$$$ to $$$c$$$ respectively, and indices of $$$s_i = \tt{0}$$$ with $$$(c + 1)$$$ to $$$n$$$ respectively. It works because for every interval $$$[l, r]$$$ such that $$$r - l + 1 \geq k$$$, there is at least one index $$$l \leq i \leq r$$$ such that $$$s_i = \tt{0}$$$, and it will be greater than all the indices of $$$s_i = \tt{1}$$$.

Time complexity: $$$\mathcal O(n)$$$ per test case.

#include <bits/stdc++.h>
 
void solve() {
	int n, k; std::cin >> n >> k;
	std::string s; std::cin >> s, s = " " + s;
	for (int i = 1, j = 1; i <= n; i = ++j) if (s[i] == '1') {
		while (j < n && s[j + 1] == '1') j++;
		if (j - i + 1 >= k) return (void)puts("NO");
	}
	puts("YES");
	int c1 = 0, c2 = std::count_if(s.begin(), s.end(), [&](char ch) -> bool { return ch == '1'; });
	for (int i = 1; i <= n; ++i) 
		std::cout << (s[i] == '1' ? ++c1 : ++c2) << " \n"[i == n];
}
 
int main() { int t; std::cin >> t; while (t--) solve(); return 0; }

import sys
input=lambda:sys.stdin.readline().rstrip()
for _ in range(int(input())):
  n,k=map(int,input().split())
  s=input()
  if "1"*k in s: # YES YOU WILL NOT BELIEVE THAT THIS IS O(N)
    print("No")
  else:
    print("Yes")
    a=sorted(range(0,n),key=lambda i:s[i],reverse=True)
    ans=[0]*n
    for i in range(n):
      ans[a[i]]=i+1
    print(*ans)

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

DP is needed for this problem.

If you force some index to be in the subsequence, there is only one optimal transition.

Let's go for DP. Denote $$$dp(i)$$$ as the length of the longest neat subsequence of prefix $$$[a_1, a_2, \ldots, a_i]$$$. It's obvious that $$$dp(0) \leq dp(1) \leq \ldots \leq dp(n)$$$.

Suppose we have calculated $$$dp(0), \ldots, dp(i-1)$$$. Let's try to calculate $$$dp(i)$$$:

1. If $$$a_i$$$ is not selected in the neat subsequence, we simply use $$$dp(i-1)$$$ to update $$$dp(i)$$$;
2. If $$$a_i$$$ is selected in the neat subsequence, the subsequence must end with $$$a_i$$$ elements equal to $$$a_i$$$. Since the $$$dp$$$ array is monotone, we should greedily find the $$$a_i$$$-th largest index $$$x$$$ in $$$[a_1, \ldots, a_i]$$$ where $$$a_x = a_i$$$, and use $$$dp(x-1) + a_i$$$ to update $$$dp(i)$$$.

The resulting $$$dp(i)$$$ is $$$\max(dp(i-1), dp(x-1) + a_i)$$$. Finding $$$x$$$ can be done efficiently by storing the occurrences of each different value.

Time complexity: $$$\mathcal O(n)$$$ per test case.

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int MAXN = 2e5 + 10;

int T, n, a[MAXN], dp[MAXN]; deque<int> q[MAXN];

int main() {
	for (scanf("%d", &T); T--; ) {
		scanf("%d", &n);
		for (int i = 1; i <= n; i++) q[i].clear();
		for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
		for (int i = 1; i <= n; i++) {
			dp[i] = dp[i - 1], q[a[i]].emplace_back(i);
			if (q[a[i]].size() > a[i]) q[a[i]].pop_front();
			if (q[a[i]].size() == a[i]) dp[i] = max(dp[i], dp[q[a[i]].front() - 1] + a[i]);
		}
		printf("%d\n", dp[n]);
	}
}

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

You may not know the given Manhattan distance is between you and which anchor point. Can you make some moves so that you can determine it?

The absolute value in $$$\lvert x_i-c \rvert + \lvert y_i-d \rvert$$$ is somehow annoying, because you don't know whether it's $$$(x_i - c)$$$ or $$$(c - x_i)$$$. Find a way to fix the sign of $$$(x_i - c)$$$ and $$$(y_i - d)$$$.

Read the hints.

Denote $$$V$$$ as $$$10^9$$$. Let's first use four operations $$$(\texttt{L}, V)$$$, $$$(\texttt{L}, V)$$$, $$$(\texttt{U}, V)$$$, and $$$(\texttt{U}, V)$$$. Since initially $$$-V \leq X, Y \leq V$$$, after the four operations, it's guaranteed that $$$X', Y' \leq -V$$$.

Thus, one can note that the current value received from the jury is exactly $$$\min\limits_{1 \leq i \leq n}(\lvert x_i - X'\rvert + \lvert y_i - Y'\rvert) = \min\limits_{1 \leq i \leq n}(X' - x_i + y_i - Y')$$$, which equals $$$\min\limits_{1 \leq i \leq n}(x_i - y_i) - X + Y + 4V$$$. This gives us the value of $$$X + Y$$$.

Similarly, if we move to the top-right corner (or the bottom-left one), we can know the value of $$$X - Y$$$. It would take $$$4$$$ extra steps of moving down or moving right (instead of $$$4 + 4$$$). By knowing $$$X + Y$$$ and $$$X - Y$$$, $$$X$$$ and $$$Y$$$ can be solved out.

Hence, we use only $$$8$$$ operations for each test case, which is sufficient to pass.

#include <bits/stdc++.h>
#define all(s) s.begin(), s.end()
using namespace std;
using ll = long long;
using ull = unsigned long long;

const int _N = 1e5 + 5;

int T;

void solve() {
	int n; cin >> n;
    ll mn1 = LLONG_MAX, mx2 = -LLONG_MAX;
    for (int i = 1; i <= n; i++) {
        ll x, y; cin >> x >> y;
        mn1 = min(mn1, y - x);
        mx2 = max(mx2, x + y);
    }
    ll res;
    cout << "? R 1000000000" << endl;
    cin >> res;
    cout << "? R 1000000000" << endl;
    cin >> res;
    cout << "? D 1000000000" << endl;
    cin >> res;
    cout << "? D 1000000000" << endl;
    cin >> res;
    ll res1 = mn1 - res + 4000000000ll;
    cout << "? U 1000000000" << endl;
    cin >> res;
    cout << "? U 1000000000" << endl;
    cin >> res;
    cout << "? U 1000000000" << endl;
    cin >> res;
    cout << "? U 1000000000" << endl;
    cin >> res;
    ll res2 = mx2 + res - 4000000000ll;
    cout << "! " << (res2 - res1) / 2 << ' ' << (res2 + res1) / 2 << endl;
	return;
}

int main() {
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	cin >> T;
	while (T--) {
		solve();
	}
}

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

Consider the value of nodes on a cycle.

Consider the parity of the cycle's length.

The following are equivalent statements:

• "There is a cycle containing nodes $$$u, v$$$";
• "Nodes $$$u, v$$$ are in the same two-edge-connected component".

Two two-edge-connected components don't affect each other.

Read the hints.

First, focus on a simple cycle only. Denote its length as $$$l$$$. We can choose two arbitrary nodes $$$u$$$ and $$$v$$$ on the cycle, obtaining two different simple paths. The two paths have equal values for all pairs of $$$(u, v)$$$. This implies that, for each set of size $$$l-2$$$ containing only nodes on the cycle, the bitwise XOR of the weight of the nodes in the set should equal $$$0$$$.

Thus, all nodes on the cycle have equal weight, since when sets $$$S_0 \cup {v}$$$ and $$$S_0 \cup {u}$$$ have equal bitwise XOR of node weights, this leads to nodes $$$u$$$ and $$$v$$$ having equal weights. Additionally, if $$$l$$$ is odd, one can verify that the weight of nodes on the cycle must be equal to $$$0$$$ (otherwise, it can be an arbitrary integer in $$$[0, V)$$$).

By decomposing the graph into two-edge-connected components, one can easily determine whether two nodes share a cycle —— by checking whether they belong to the same component. The answer is independent in each component, so we can simply multiply them together.

How to calculate the answer for a two-edge-connected component? First of all, the weight of all nodes must be equal. Then, if there exists an odd cycle (which can be detected with 2-coloring), it should equal $$$0$$$. There are only three different possible answers: $$$0$$$, $$$1$$$, and $$$V$$$.

Thus, one can calculate the answer to the original problem efficiently.

Time Complexity: $$$\mathcal O(n + m)$$$ per test case.

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int MAXN = 2e5 + 10;
const int mod = 998244353;

vector<int> g[MAXN], dcc[MAXN];

int dfn[MAXN], low[MAXN], id;

int s[MAXN], tp, p[MAXN], cnt;

void tarjan(int u, int f = 0) {
	dfn[u] = low[u] = ++id, s[++tp] = u;
	for (int v : g[u]) {
		if (!dfn[v]) tarjan(v, u), low[u] = min(low[u], low[v]);
		else if (v != f) low[u] = min(low[u], dfn[v]);
	}
	if (dfn[u] == low[u]) {
		cnt++;
		for (int x = 0; x != u; ) {
			x = s[tp--], p[x] = cnt;
			dcc[cnt].emplace_back(x);
		}
	}
}

int col[MAXN];

bool check(int u, int f = 0) {
	if (~col[u]) return col[u] == f; col[u] = f;
	for (int v : g[u]) if (p[u] == p[v] && !check(v, f ^ 1)) return 0;
	return 1;
}

int T, n, m, V, a[MAXN], ans;

int main() {
	for (scanf("%d", &T); T--; ) {
		scanf("%d%d%d", &n, &m, &V), id = cnt = 0, ans = 1;
		for (int i = 1; i <= n; i++) dfn[i] = low[i] = p[i] = 0, col[i] = -1;
		for (int i = 1; i <= n; i++) g[i].clear(), dcc[i].clear();
		for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
		for (int i = 1, u, v; i <= m; i++) {
			scanf("%d%d", &u, &v);
			g[u].emplace_back(v), g[v].emplace_back(u);
		}
		for (int i = 1; i <= n; i++) if (!dfn[i]) tarjan(i);
		for (int i = 1; i <= cnt; i++) {
			int x = -1;
			for (int u : dcc[i]) {
				if (a[u] < 0) continue;
				if (x < 0) x = a[u];
				else if (x != a[u]) { ans = 0; break; }
			}
			if (!ans) break;
			bool f = check(dcc[i][0]);
			if (f) { if (x < 0) ans = (ll)ans * V % mod; }
			else if (x > 0) ans = 0;
			if (!ans) break;
		}
		printf("%d\n", ans);
	}
}

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

Try to input $$$10^5$$$ copies of $$$1$$$ in the first query. What can you get then?

After the first query, you can get $$$W\in [L, R]$$$. And $$$2\cdot L\ge R$$$ always holds. Now, can you construct the second query?

In the first query, we will input $$$10^5$$$ copies of $$$1$$$. And the result will be equal to $$$r_1 = \left\lceil\frac{10^5}{W}\right\rceil$$$. By solving the equation $$$\left\lceil\frac{10^5}{x}\right\rceil = r_1$$$, we can get

For example, if:

• $$$r_1 = 1$$$, then $$$W=100\,000$$$;
• $$$r_1 = 2$$$, then $$$W\in [50\,000, 99\,999]$$$;
• $$$r_1 = 3$$$, then $$$W\in [33\,334, 49\,999]$$$;
• ...

For each interval $$$[L, R]$$$ above, $$$2\cdot L \gt R$$$ always holds, which is because $$$\lfloor \frac{n}{2L} \rfloor = \lfloor \frac{\lfloor \frac{n}{L} \rfloor}{2} \rfloor \neq \lfloor \frac{n}{L} \rfloor$$$.

Thus, we can input the following article in the second query:

For each of the underlined group $$$(L, x)$$$:

• If $$$L + x \le W$$$, the two words in this group will be displayed in the same line;
• Otherwise, they will be displayed in different lines.

Note that $$$L + x + L \gt 2\cdot L \gt R \ge W$$$, so for each $$$1\le x \le W - L$$$, the group $$$(L, x)$$$ takes a single line, and for each $$$W - L \lt x \le R - L$$$, the group $$$(L, x)$$$ always take two lines. So the result of the query is $$$r_2 = (W - L) + 2\cdot (R - W)$$$. Hence, we get $$$W = 2\cdot R - L - r_2$$$. And we need to use $$$n = 2\cdot (R - L)\le 10^5$$$ words in this query.

Thus, we solved the problem in at most $$$2$$$ queries, which fits the constraints of the Easy Version.

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <class T>
using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define all(v) v.begin(), v.end()
#define logg(x) (31 - __builtin_clz(x))
#define llogg(x) (63 - __builtin_clzll(x))
#define mini(v) min_element(v.begin(), v.end())
#define maxi(v) max_element(v.begin(), v.end())
#define TIME cerr << double(clock() - st) / (double)CLOCKS_PER_SEC
#define sq(a) ((a)*(a))
#ifdef hocln
#include "deb.h"
#else
#define imie(...) ""
#define debug() cerr
#endif
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef long double ld;
typedef tuple<ll, ll, ll> triple;
typedef tuple<ll, ll, ll, ll, ll> five;
typedef unsigned long long ull;
const long long INF = 4e18;
const int inf = 2e9;
const int MN = 3e5 + 15;
const int MX = 2e6 + 15;
//const long long MOD = 1e9 + 7;
//const long long MOD = 998244353;
const long double PI = 3.141592653589793238462643383279502884197;
template<typename T, typename T2> bool chmax(T& a, const T2& b) { return a < b ? a = b, 1 : 0; }
template<typename T, typename T2> bool chmin(T& a, const T2& b) { return a > b ? a = b, 1 : 0; }
template<typename T> using vector2 = vector<vector<T>>;
const int dx[] = { 0, 0, 1, -1, 1, 1, -1, -1 };
const int dy[] = { 1, -1, 0, 0 , 1, -1, 1, -1};
std::random_device rd;
std::mt19937 gen(rd());
ll random(ll low, ll high) { uniform_int_distribution<> dist(low, high); return dist(gen); }
template<typename T1, typename T2> istream& operator>>(istream& is, pair<T1, T2>& p) {
    is >> p.first;
    return is >> p.second;
}
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) {
    for (auto &i: v) os << i << ' ';
    return os;
}
int tc = 0;

inline void get(int l, int r) {
	int len = r-l+1;
	cout << "? " << len * 2 << ' ';
	for(int i = 1;i <= len;i++) {
		cout << l << ' ' << i << ' ';
	}
	cout << endl;
	int x;
	cin >> x;
	cout << "! " << len * 2 - x + l << endl;
}

inline void solve_test() {
	int n=1e5;
	cout << "? ";
	cout << n << ' ';
	for(int i = 1;i <= n;i++) cout << "1 ";
	cout << endl;
	int x;
	cin >> x;
	if(x == 1) {
		cout << "! " << n << endl;
		return;
	}
	int l = -1, r = -1;
	for(int i = 1;i <= n;i++) {
		if((n + i - 1) / i == x && l == -1) l = i;
		if((n + i - 1) / i == x) r = i;
	}
	get(l,r);
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int tt = 1;
    cin >> tt;
    while(tt--) {
		++tc;
        solve_test();
    }
}

Can you do something better than $$$10^5~1~1~\ldots~1$$$ in the first query, so that the interval length will be reduced for the second query?

Change the first query to $$$N$$$ copies of $$$B$$$, where $$$N$$$ and $$$B$$$ are both undetermined constants.

Brute force to find the optimal value of $$$N$$$ and $$$B$$$.

We want to cut down the total length of articles. So here comes a new strategy for the first query: $$$N$$$ copies of $$$B$$$, where $$$N$$$ and $$$B$$$ are both undetermined constants.

Now, the result for the first query is $$$r_1 = \displaystyle\left\lceil \frac{N}{\left \lfloor\frac{W}{B}\right\rfloor} \right\rceil$$$.

If $$$W\in [1, B - 1]$$$, the editor will be unable to display the article, and unfortunately our original strategy for the second query will not work in this case. But we can still use the strategy in the first query! Now we can query $$$B^2$$$ copies of $$$1$$$, and it's easy to show that the results for each $$$W=1,2,\ldots,B - 1$$$ will be distinct.

Otherwise, $$$W\in [B, 10^5]$$$, similar to the easy version, we will get an interval $$$[L, R]$$$, where $$$2\cdot L\ge R$$$ always holds. Then, we can use the same strategy as the second query in the easy version and get a solution with $$$2\cdot(R - L)$$$ queries. To calculate $$$L$$$ and $$$R$$$, you can simply use binary search, or do some math work to get

There is also a fact that the rightmost interval will be cut off by the upper bound of $$$10^5$$$.

We can use brute force to find suitable values for $$$N$$$ and $$$B$$$. In the main correct solution, we choose $$$N = 11\,343$$$ and $$$B = 116$$$, and the maximal interval length is $$$6\,263$$$. Thus, the total length of articles won't exceed $$$11\,343 + \max(2\cdot 6\,263, 116^2) = 24\,799\le 25\,000$$$.

By some further optimization we can reduce $$$116^2$$$ a little to $$$\le 12\, 526$$$, so the total length of articles can be reduced to $$$23\,869$$$, but that's not needed.

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

const int MAXW = 100'000;
const int MAXSUM = 25'000;
const int B = 116;
const int K = 11343;

int t;

inline int ask(vector<int> v) {
  cout << "? " << v.size();
  for (int i : v) {
    cout << ' ' << i;
  }
  cout << endl;
  int x;
  cin >> x;
  if (x == -1) {
    exit(0);
  }
  return x;
}
inline void answer(int x) { cout << "! " << x << endl; }

int main() {
  cin >> t;
  while (t--) {
    vector<int> v_qry1(K, B);
    int res_qry1 = ask(v_qry1);
    if (res_qry1 == 0) {
      // W < B
      vector<int> v_qry2(B * B, 1);
      int res_qry2 = ask(v_qry2);
      int w = (B * B - 1) / (res_qry2 - 1);
      answer(w);
    } else {
      // W >= B
      int min_w = ((K - 1) / res_qry1 + 1) * B,
          max_w = ((K - 1) / (res_qry1 - 1) + 1) * B - 1;
      max_w = min(max_w, MAXW);
      for (int w = B; w <= MAXW; w++) {
        int h = (K - 1) / (w / B) + 1;
        if (h == res_qry1) {
          assert(min_w <= w);
          assert(w <= max_w);
        } else {
          assert(w < min_w || w > max_w);
        }
      }

      if (min_w == max_w) {
        answer(min_w);
      } else {
        vector<int> v_qry2;
        for (int i = min_w + 2; i <= max_w; i++) {
          v_qry2.push_back(min_w + 1);
          v_qry2.push_back(i - min_w - 1);
        }
        if (v_qry2.empty()) {
          v_qry2.push_back(min_w + 1);
        }
        int res_qry2 = ask(v_qry2);

        if (res_qry2 == 0) {
          answer(min_w);
        } else {
          answer(min_w + 1 + ((int)v_qry2.size() - res_qry2));
        }
      }
    }
  }
}

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

Replace $$$\tt 0$$$ with $$$1$$$ and $$$\tt 1$$$ with $$$-1$$$. Try to find a sufficient and necessary condition of $$$s$$$ almost-palindrome.

Denote the $$$\pm 1$$$-s you get in Hint 1 as array $$$a$$$, and $$$b_i = \sum_{j=1}^n a_j$$$. ($$$s$$$ is almost-palindrome) $$$\Longleftrightarrow$$$ ($$$\min b_i + \max b_i = b_n$$$),

You will need to solve the following subproblem:

You are on an infinite 2D plane, initially at $$$(0, 0)$$$. You can only move up/right by $$$1$$$ unit in one step. Also, you cannot touch the line $$$y=x + l$$$ or $$$y = x+ r$$$ during your move. Count the number of ways to travel to $$$(n, m)$$$.

We can solve the subproblem by a technique called "reflection inclusion-exclusion" in $$$\mathcal{O}\left(\frac{n}{|l - r|}\right)$$$ time complexity. You can view more details in problem E1 part of this blog: https://codeforces.me/blog/entry/129027

Or here is a detailed explanation in Chinese: https://www.cnblogs.com/Hanghang007/p/18159154

Try to compress sums by processing all $$$\max b_i - \min b_i = k$$$ together.

Read the hints first.

Recall the answer for the subproblem in Hint 3 as $$$f(n, m, l, r)$$$, we have

Suppose $$$\min b_i = l$$$ and $$$\max b_i = r$$$, the number of $$$b$$$-s is the number of ways to travel from $$$(0, 0)$$$ to $$$(n, m)$$$, "exactly" touching $$$y=x+l$$$ and $$$y=x+r$$$, that is,

Now we can compress the sums by processing all $$$\max b_i - \min b_i = k$$$ together. Let's enumerate on $$$k$$$, and note that the upper index of binomials is always $$$\frac{n-(l+r)}{2}+\frac{n+(l+r)}{2}=n$$$, and the lower index moves contiguously with the same $$$k$$$.

Thus, we have solved the problem in $$$\mathcal{O}(n\log n)$$$.

#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
 
const int MAXN = 1e6 + 10;
const int mod = 998244353;
 
inline int add(int x, int y) { return x += y, x < mod ? x : x - mod; }
inline int sub(int x, int y) { return x -= y, x < 0 ? x + mod : x; }
inline void cadd(int &x, int y) { x += y, x < mod || (x -= mod); }
inline void csub(int &x, int y) { x -= y, x < 0 && (x += mod); }
 
int inv[MAXN], a[MAXN], s[MAXN];
 
inline 
void init(int n) {
	inv[1] = 1;
	for (int i = 2; i <= n; i++) inv[i] = (ll)(mod - mod / i) * inv[mod % i] % mod;
}
 
int n;
 
inline 
int ask(int l, int r) {
	l = max(l, 0), r = min(r, n);
	return l ? sub(s[r], s[l - 1]) : s[r];
}
 
inline 
int calc(int k, int t) {
	int sum = 0;
	for (int p = 0; (n + k >> 1) - p * (k + 2 - t) >= 0; p++) {
		cadd(sum, ask((n - k >> 1) - p * (k + 2 - t), (n + k >> 1) - t - p * (k + 2 - t)));
	}
	for (int p = 0; (n - k >> 1) - 1 - p * (k + 2 - t) >= 0; p++) {
		csub(sum, (ll)(k + 1 - t) * a[(n - k >> 1) - 1 - p * (k + 2 - t)] % mod);
	}
	for (int p = 1; (n - k >> 1) + p * (k + 2 - t) <= n; p++) {
		cadd(sum, ask((n - k >> 1) + p * (k + 2 - t), (n + k >> 1) - t + p * (k + 2 - t)));
	}
	for (int p = 0; (n + k >> 1) + 1 - t + p * (k + 2 - t) <= n; p++) {
		csub(sum, (ll)(k + 1 - t) * a[(n + k >> 1) + 1 - t + p * (k + 2 - t)] % mod);
	}
	return sum;
}
 
int T, ans;
 
int main() {
	for (scanf("%d", &T), init(1e6 + 1); T--; ) {
		scanf("%d", &n), *a = *s = 1, ans = 0;
		for (int i = 1, x = 1; i <= n; i++) {
			a[i] = (ll)a[i - 1] * inv[i] % mod * (n - i + 1) % mod;
			s[i] = add(s[i - 1], a[i]);
		}
		for (int i = 1, x = 0, y = 0; i <= n; i++) {
			if (n + i & 1) continue;
			cadd(ans, x), cadd(ans, x = calc(i, 0));
			y = calc(i, 1), csub(ans, add(y, y));
		}
		printf("%d\n", ans);
	}
}

List out the coefficients of all $$${n\choose m}$$$.

Try linear sieve.

Read the hints and E1 editorial first. We'll try to speed up in a different way.

Let's consider $$$f\left(\frac{n-(l+r)}{2},\frac{n+(l+r)}{2},l,r\right)$$$ first. Let $$$k=r-l$$$. For each $$$k=1,2,\ldots,n$$$, we have

$$$\displaystyle\sum_{-k\le l\le 0}f\left(\frac{n-(l+r)}{2},\frac{n+(l+r)}{2},l,r\right)$$$

$$$=\displaystyle\sum_{-k\le l\le 0}\sum_{z\in\mathbb Z} {n\choose (n-(2z+1)\cdot k) / 2-l}-{n\choose (n-(2z-1)\cdot k) / 2}$$$

$$$=\displaystyle\sum_{-k+1\le l\le 0}\sum_{z\in\mathbb Z} {\color{red}{n\choose (n-(2z+1)\cdot k) / 2-l}}-{\color{blue}{n\choose (n-(2z-1)\cdot k) / 2}}$$$

$$$={\color{red}2^{\color{red}n}}-\displaystyle k\cdot { \sum_{z\in\mathbb Z}\color{blue}{n\choose (n-(2z-1)\cdot k) / 2}}$$$

We will consider the coefficient of $$${n\choose m}$$$ in the blue part. Note that $$$(n-(2z-1)\cdot k) / 2 = m\Longleftrightarrow k=(n-2m)/(2z-1)$$$. Define $$$g(n)=\sum_{d\mid n,2\nmid(n/d)} d$$$, then the coefficient of $$${n\choose m}$$$ is $$$g(|n-2m|)$$$.

The other 3 parts are similar.

Summing all, we got the final answer is

And we can use linear sieve to precalculate $$$g(n)$$$. Thus, the whole problem is solved in $$$\mathcal{O}(n)$$$.

#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
 
const int MAXN = 2e7 + 10;
const int mod = 998244353;
 
inline int add(int x, int y) { return x += y, x < mod ? x : x - mod; }
inline int sub(int x, int y) { return x -= y, x < 0 ? x + mod : x; }
inline void cadd(int &x, int y) { x += y, x < mod || (x -= mod); }
inline void csub(int &x, int y) { x -= y, x < 0 && (x += mod); }
 
inline 
int qpow(int b, int p) {
	int res = 1;
	for (; p; b = (ll)b * b % mod, p >>= 1) if (p & 1) res = (ll)res * b % mod;
	return res;
}
 
int f[MAXN], g[MAXN], p[MAXN], tot;
 
int fac[MAXN], ifac[MAXN];
 
inline 
void init(int n) {
	f[1] = 1;
	for (int i = 2; i <= n; i++) {
		if (!f[i]) p[++tot] = i, f[i] = g[i] = i + (i > 2);
		for (int j = 1; j <= tot; j++) {
			if (i * p[j] > n) break;
			if (i % p[j] == 0) {
				g[i * p[j]] = g[i] * p[j] + (j > 1);
				f[i * p[j]] = f[i] / g[i] * g[i * p[j]];
				break;
			}
			f[i * p[j]] = f[i] * (p[j] + (j > 1));
			g[i * p[j]] = p[j] + (j > 1);
		}
	}
	*fac = 1;
	for (int i = 1; i <= n; i++) fac[i] = (ll)fac[i - 1] * i % mod;
	ifac[n] = qpow(fac[n], mod - 2);
	for (int i = n; i; i--) ifac[i - 1] = (ll)ifac[i] * i % mod;
}
 
int T, n, ans;
 
int main() {
	for (scanf("%d", &T), init(2e7 + 1); T--; ) {
		scanf("%d", &n), ans = 0;
		for (int i = 0; i <= n; i++) {
			ans = (ans + (ll)ifac[i] * ifac[n - i] % mod * sub(f[abs(n - i * 2 - 1)], f[abs(n - i * 2)])) % mod;
		}
		ans = (ll)ans * fac[n] % mod;
		cadd(ans, ans), (n & 1 ? cadd : csub)(ans, qpow(2, n));
		printf("%d\n", ans);
	}
}

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem:

How to compare two $$$f$$$ values? Since this function grows extremely fast, try to compare $$$\ln f$$$, $$$\ln \ln f$$$ and so on.

You only need to compare lexicographical order.

How to quickly compare lexicographical order? Try using hashing.

Use a data structure to maintain the hash value for each point.

Consider performing a topological sort on the tree from the bottom up. Then, when a node needs to be inserted into another tree, its ranking is already determined. A segment tree can be used instead of a balanced tree.

First, define the concept of a $$$\textbf{power tower}$$$. $$$X$$$ is a power tower if and only if one of the following holds:

• $$$X = x$$$.
• $$$X = x^{X_1X_2\cdots X_m}$$$, where $$$m$$$ is a constant independent of $$$x$$$, and $$$X_1, X_2, \cdots, X_m$$$ are all power towers.

Clearly, for power towers $$$X$$$ and $$$Y$$$, $$$X^Y$$$ is also a power tower. Therefore, in this problem, any $$$f_u(x)$$$ is a power tower.

First, consider how to compare two power towers $$$X$$$ and $$$Y$$$. The steps are as follows:

• If $$$X = x$$$ or $$$Y = x$$$, directly return their magnitudes.
• Otherwise, let $$$X = x^{X_1X_2\cdots X_p}$$$, $$$Y = x^{Y_1Y_2\cdots Y_q}$$$, where the quantities in the exponents are power towers.
  • Sort $$$X_1, X_2, \cdots, X_p$$$ and $$$Y_1, Y_2, \cdots, Y_q$$$ in descending order.
  • Compare their lexicographical order. If the lexicographical orders are equal, return that $$$X$$$ and $$$Y$$$ are equal; otherwise, return that the power tower with the larger lexicographical order is greater than the one with the smaller lexicographical order.

This gives a solution that can determine the relative sizes of two power towers in polynomial complexity. However, this is far from sufficient.

To optimize the complexity, when comparing $$$X$$$ and $$$Y$$$, we at least need to know the sorted order of $$$X_1, X_2, \cdots, X_p$$$ and $$$Y_1, Y_2, \cdots, Y_q$$$. This is equivalent to knowing the size relationships among them.

A key property of the tree can be easily observed: Let $$$fa_u$$$ be the father of $$$u$$$ in the tree. Then, it must hold that $$$f_u(x) \prec f_{fa_u}(x)$$$. Consider performing a topological sort on the original tree and using a heap to maintain the current queue. Each time, the smallest node is taken out to update the others. For any node $$$u$$$ in the queue, the corresponding power tower $$$X = f_u(x)$$$ already has known rankings for $$$X_1, X_2, \cdots, X_p$$$. A persistent segment tree can then be used to maintain prefix-sum hashes. When comparing two power towers, binary search can be performed on the segment tree to quickly find the first position where their exponent power towers differ, achieving a fast comparison in $$$\mathcal{O}(\log n)$$$ time per operation.

Time complexity: $$$\mathcal{O}(n\log^2 n)$$$ per test case.

#include <bits/stdc++.h>
 
using namespace std;
 
typedef unsigned long long ull;
 
const int MAXN = 4e5 + 10;
 
ull A = mt19937_64(time(0))();
 
inline ull shift(ull x) {
	return x ^= A, x ^= x << 13, x ^= x >> 7, x ^= x << 11, x ^= A;
}
 
struct node {
	int l, r, num; ull val;
} t[MAXN * 20]; int cnt, rt[MAXN];
 
void add(int &p, int pre, int l, int r, int k, ull x) {
	t[p = ++cnt] = t[pre], t[p].val += x, t[p].num++;
	if (l == r) return ; int mid = l + r >> 1;
	if (k <= mid) add(t[p].l, t[pre].l, l, mid, k, x);
	else add(t[p].r, t[pre].r, mid + 1, r, k, x);
}
 
bool find(int p, int pre, int l, int r) {
	if (l == r) return t[p].num > t[pre].num; int mid = l + r >> 1;
	if (t[t[p].r].val == t[t[pre].r].val) return find(t[p].l, t[pre].l, l, mid);
	else return find(t[p].r, t[pre].r, mid + 1, r);
}
 
int n, l[MAXN], r[MAXN], fa[MAXN], d[MAXN];
 
int rk[MAXN], tot, lst; ull h[MAXN];
 
struct cmp {
	bool operator () (int x, int y) {
		return h[x] == h[y] ? x > y : find(rt[x], rt[y], 1, n);
	}
}; priority_queue<int, vector<int>, cmp> q;
 
 
inline 
void upd(int u) {
	h[u] = h[l[u]] + shift(h[r[u]]);
	add(rt[u], rt[l[u]], 1, n, rk[r[u]], shift(h[r[u]]));
}
 
int T;
 
int main() {
	for (scanf("%d", &T); T--; ) {
		scanf("%d", &n), cnt = lst = tot = 0;
		for (int i = 1; i <= n; i++) rt[i] = 0; 
		for (int i = 1; i <= n; i++) {
			scanf("%d%d", &l[i], &r[i]);
			d[i] = (l[i] && r[i] ? 2 : 0), fa[l[i]] = fa[r[i]] = i;
		}
		for (int i = 1; i <= n; i++) if (!d[i]) h[i] = 1, q.emplace(i);
		for (int u; !q.empty(); ) {
			printf("%d ", u = q.top()), q.pop();
			if (h[u] != h[lst]) tot++; lst = u, rk[u] = tot;
			if (!--d[fa[u]]) upd(fa[u]), q.push(fa[u]);
		}
		puts("");
	}
}

• Amazing problem:
• Good problem:
• Average problem:
• Bad problem:
• Horrible problem: