For any non-decreasing sequence $$$(b_1, b_2, \ldots, b_m)$$$, $$$b_1$$$ $$$|$$$ $$$b_2$$$ $$$|$$$ $$$b_3$$$ $$$|$$$ $$$\cdots$$$ $$$|$$$ $$$b_m$$$ $$$\ge$$$ $$$b_1$$$.

So, it is always better to consider subsequences of length $$$1$$$. Out of these, we can simply choose the smallest element and this is always optimal.

Time Complexity: $$$O(n)$$$.

#include<bits/stdc++.h>
using namespace std;
 
int main(){
 
    int t;
    cin >> t;
 
    while(t--){
        
        int n;
        cin >> n;

        vector<int> a(n);
        for(int i = 0; i < n; i++) cin >> a[i];

        cout << *min_element(a.begin(), a.end()) << '\n';

    }
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

We can observe that $$$f(i,1)=0$$$ for $$$i \ge 1$$$ and $$$f(1,i)$$$ for $$$i \ge 2$$$.

Thus, "1 n-1" is always a valid answer.

// By Auchenai01
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 998244353;
const ll MAXX = 1e16;
const int INF = 1e9 + 7;
void solve() {
    int n;
    cin >> n;
    cout << 1 << " " << n - 1 << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

If $$$m=1$$$, the answer is "YES".

Otherwise, to make $$$f(x,i)=1$$$ for all $$$2 \le i \le n$$$, the valuse of $$$x$$$ must be at least $$$\operatorname{lcm}(2,3,\ldots,n)+1$$$. We can see it will exceed $$$10^{18}$$$ when $$$n$$$ is larger than $$$30$$$.

Thus, the solution is: When $$$m=1$$$, output "YES". Otherwise, run bruteforce when $$$n \le 30$$$ and output "NO" when $$$n \gt 30$$$,

// By Auchenai01
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 998244353;
const ll MAXX = 1e16;
const int INF = 1e9 + 7;
void solve() {
    int n, m;
    cin >> n >> m;
    if (n <= 30) {
    	for (int i = 2; i <= n; i++) {
    		if (m % i != 1) {
    			cout << "NO" << endl;
    			return;
    		}
    	}
    	cout << "YES" << endl;
    	return;
    }
    cout << (m == 1 ? "Yes" : "no") << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Let's assume $$$\operatorname{mex}(a_1, a3, \ldots, a{n-1}) = p$$$ and $$$\operatorname{mex}(a_2, a4, \ldots, a{n}) = q$$$. Now the condition becomes $$$\operatorname{mex}(p, q) = \operatorname{mex}(a_1, a_2, a_3, \ldots, a_n)$$$.

We can see that the inequality $$$\operatorname{mex}(p, q) \le 2$$$ holds for any value of $$$p$$$ and $$$q$$$. So, we can simply check the three possible cases:

Case I: $$$\operatorname{mex}(p, q) = 0$$$

Here, we should have $$$p \gt 0$$$ and $$$q \gt 0$$$, and this implies that there are at least two 0's in the array $$$a$$$. Then, we have $$$\operatorname{mex}(a_1, a_2, a_3, \ldots, a_n) \gt 0 = \operatorname{mex}(p, q)$$$.

So, the array is not good in this case.

Case II: $$$\operatorname{mex}(p, q) = 1$$$

Here, we should have $$$p = 0$$$ and $$$q \ne 1$$$, or $$$p \ne 1$$$ and $$$q = 0$$$. In any case, $$$\operatorname{mex}(a_1, a_2, a_3, \ldots, a_n) \ne 1 = \operatorname{mex}(p, q)$$$.

So, the array is not good in this case.

Case III: $$$\operatorname{mex}(p, q) = 2$$$

Here, we should have $$$p = 0$$$ and $$$q = 1$$$, or $$$p = 1$$$ and $$$q = 0$$$. For the array to be good, we should also have $$$\operatorname{mex}(a_1, a_2, a_3, \ldots, a_n) = 2$$$.

Thus, an array is good if it's $$$\operatorname{mex} = 2$$$ and $$$\operatorname{mex}$$$ of even and odd indexed values are $$$0$$$ and $$$1$$$.

So, any array of length $$$n$$$ can be rearranged into a good array if all the following conditions are satisfied:

• $$$\operatorname{mex}$$$ of array is $$$2$$$.

• number of 0's in the array $$$\le \frac{n}{2}$$$.

• number of 1's in the array $$$\le \frac{n}{2}$$$.

Time Complexity: $$$O(n)$$$.

// By Auchenai01
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 998244353;
const ll MAXX = 1e16;
const int INF = 1e9 + 7;
void solve() {
    int n;
    cin >> n;
    vi a(n);
    vi cnt(n + 1);
    for (int i = 0; i < n; i++) {
    	cin >> a[i];
    	cnt[a[i]]++;
    }
    if (cnt[0] == 0) {
    	cout << "NO" << endl;
    	return;
    }
    if (cnt[1] == 0) {
    	cout << "NO" << endl;
    	return;
    }
    if (cnt[2] > 0) {
    	cout << "NO" << endl;
    	return;
    }
    if (cnt[0] > n / 2 || cnt[1] > n / 2) {
    	cout << "NO" << endl;
    } else {
    	cout << "YES" << endl;
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Let $$$pre_i=\max_{1 \le j \le i}(a_j+a_{j+1}+\ldots+a_i)$$$, and $$$suf_i=\max_{i \le j \le n}(a_i+a_{i+1}+\ldots+a_j)$$$.

The answer is $$$\max_{1 \le j \le i \le}(pre_i+suf_j)$$$.

#include<bits/stdc++.h> 

using namespace std;  

typedef long double ld;
typedef long long ll;
#define all(x) x.begin(), x.end()
#define int long long
#define C(x) ((x) * ((x) - 1) / 2)

void solve()
{
  int n;
  cin >> n;
  int a[n];
  for(int i = 0; i < n; i ++)
    cin >> a[i];

  ll ans = 0, suf = 0, sm = 0;
  ll pref[n + 1] = {};
  pref[0] = 0;
  for(int i = 0; i < n; i ++)
    {
      sm += a[i];
      sm = max(0ll, sm);
      ans = max(ans, sm);
      pref[i + 1] = ans;
    }
  ans = pref[n - 1];
  sm = 0;
  for(int i = n - 1; i > 0; i--)
    {
      sm += a[i];
      sm = max(0ll, sm);
      suf = max(suf, sm);
      ans = max(pref[i - 1] + suf, ans);
    }   

  cout << ans << endl;
  
}
// if i % 2 == 1, i + 2, else i - 2
signed main()
{  
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  
  int t = 1;
  cin >> t;
  while(t--)
    solve();
  return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Observe that $$$x \oplus (x + 1) = 1$$$ when $$$x$$$ is even. This expression can be used to reduce $$$f(x)$$$.

Now, consider an array $$$b$$$ of length $$$m$$$. Let the number of odd values in the array be $$$p$$$. Let's check for the conditions which make the array good.

Case I: $$$p$$$ is even

Now, the total sum is even. So, $$$f(b_1 + b_2 + \cdots + b_m) = b_1 + b_2 + \cdots + b_m - 2$$$.

For array $$$b$$$ to be good, $$$(#\text{even}) - (#\text{odd}) = 1$$$.

Case II: $$$p$$$ is odd

Now, the total sum is odd. So, $$$f(b_1 + b_2 + \cdots + b_m) = b_1 + b_2 + \cdots + b_m + 2$$$.

For array $$$b$$$ to be good, $$$(#\text{even}) - (#\text{odd}) = -1$$$.

We can count subarrays of these two types using map and prefix sums.

Time Complexity: $$$O(n\text{log}n)$$$.

// By Auchenai01
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 998244353;
const ll MAXX = 1e16;
const int INF = 1e9 + 7;
void solve() {
    int n;
    cin >> n;
    vi a(n);
    for (int i = 0; i < n; i++) {
    	cin >> a[i];
    }
    vvi cnt(4, vi(2 * n + 1));
    cnt[3][n] = 1;
    int cur = n;
    ll ans = 0;
    for (int i = 0; i < n; i++) {
    	cur += ((a[i] % 2) ? 1 : -1);
    	cnt[i % 4][cur]++;
    	if (cur) ans += cnt[(i + 3) % 4][cur-1];
    	if (cur < 2 * n) ans += cnt[(i + 3) % 4][cur+1];
    }
    cout << ans << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Several important observations: - If a node $$$x$$$ is the last node traversed by a node $$$i$$$, ($$$a_i = x$$$), then $$$a_x = x$$$.

• No other node, apart from the root node, can have the root node as the last traversed node, i.e., if $$$a_i = r$$$, then $$$i = r$$$.

• $$$a_i$$$ appears later than $$$i$$$ in the inorder traversal of the full binary tree.

• $$$a_r$$$ (where $$$r$$$ is the root) should be the last node in the inorder traversal of the full binary tree.

This gives us a simple solution -

• First check whether $$$a_{a_i} = a_i$$$ $$$\forall$$$ $$$i, 1 \leq i \leq n$$$.

• Then check if $$$a_i = r$$$ for $$$i \neq r$$$.

• After doing these checks, a traversal can be constructed as follows-

  • For a node $$$x$$$, map all those nodes $$$y$$$ such that $$$a_y = x$$$.
  • Mark a special node $$$last$$$ such that $$$a_r = last$$$.
  • Run a greedy solution over all nodes except the special node and first add those nodes to the traversal which are in the map and then that node itself.
  • Then finally add the root and the nodes in map of special node and then the special node itself.

Also look at the code for more clarification.

BONUS: can you implement the checker?

// By Auchenai01
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 998244353;
const ll MAXX = 1e16;
const int INF = 1e9 + 7;
class DSU {
public:
    vector<int> parent, size;
    DSU(int n) {
        parent.resize(n);
        size.resize(n, 1);
        for (int i = 0; i < n; ++i) {
            parent[i] = i; 
        }
    }
    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]); 
        }
        return parent[x];
    }
     void unite(int a, int b) {
        a = find(a), b = find(b);
        if (a != b) {
            if (size[a] < size[b]) swap(a, b);
            parent[b] = a;
            size[a] += size[b];
        }
    }
};
void solve() {
    int n, r;
    cin >> n >> r;
    r--;
    DSU D(n);
    vi a(n);
    for (int i = 0; i < n; i++) {
    	int x;
    	cin >> x;
    	x--;
    	D.unite(x, i);
    	a[i] = x;
    }
    for (int i = 0; i < n; i++) {
    	if (a[i] == r && i != r) {
    		cout << -1 << endl;
    		return;
    	}
    }
    vi P(n, -1);
    vvi V(n);
    int mark = -1;
    for (int i = 0; i < n; i++) {
    	int y = D.find(i);
    	if (P[y] == -1) {
    		P[y] = a[i];
    	} else if (P[y] != a[i]) {
    		cout << -1 << endl;
    		return;
    	}
    	V[a[i]].push_back(i);
    	if (i == r) {
    		mark = a[i];
    	}
    }
    vi ans;
    for (int i = 0; i < n; i++) {
    	if (i != mark) {
    		for (int v : V[i]) {
    			if (v != i) ans.push_back(v);
    		}
    		if (V[i].size()) ans.push_back(i);
    	}
    }
    ans.push_back(r);
    for (int v : V[mark]) {
    	if (v != mark && v != r) ans.push_back(v);
    }
    if (mark != r && V[mark].size()) ans.push_back(mark);
    assert(ans.size() == n);
    for (int i = 0; i < n; i++) {
    	cout << ans[i] + 1 << " ";
    }
    cout << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Let's find the minimum value first.

We can see there exists a sequence of operations where the last operation is the G-operation and obtains the minimum value. Since $$$\operatorname{lcm}(x,y) \ge \operatorname{gcd}(x,y)$$$, all sequences where the last operation is an L-operation have a value greater than or equal to the value of sequences where the last operation is a G-operation.

When we fix using $$$s_n='G'$$$, we only care about the gcd value of the current value and $$$a_n$$$. Thus, we have $$$dp_{i,j,k= 0/1}$$$ ~--- the number if schemes in the first $$$i$$$ operations, where the gcd value of the current value and $$$a_n$$$ is $$$j$$$ and the last operation is $$$k$$$.

In this way, we can obtain the number of valid operation sequences when $$$s_n='G'$$$. Now lets consier a operation sequences like $$$s=" \ldots GLL \ldots L"$$$. We can see $$$s_j=s_{j+1}=\ldots=s_{n}='L'$$$ is valid only if $$$\operatorname{gcd}(a_j,a_{j+1},\ldots,a_n)=a_n$$$. For such $$$j$$$, we can update the answer with the original dp value.

Then we sill need to find the maximum index $$$mx$$$ such that $$$\operatorname{gcd}(a_j,a_{j+1},\ldots,a_n) \neq a_n$$$. We can see the $$$mx$$$-th operation must be a $$$G$$$-operation. We need to do the above dp again, but this time, we only care about the gcd value of the current value and $$$a_{mx}$$$.

Time Complexity: $$$O(n \cdot \operatorname{divisors}(A) \cdot \log(A))$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=998244353;
const ll  INF=2147483647;
int T;
ll n,x;
ll a[N];
map<ll,ll> dp[N][2];

/*
 * stuff you should look for
 * [Before Submission]
 * array bounds, initialization, int overflow, special cases (like n=1), typo
 * [Still WA]
 * check typo carefully
 * casework mistake
 * special bug
 * stress test
 */

//-------------------------------------------------

vector<ll> divs[N];

void init_divs()
{
	for(int i=1;i<N;i++)
		for(int j=1;j*i<N;j++)
            divs[j*i].push_back(i);
}

//-------------------------------------------------

ll gcd(ll a,ll b)
{
    return b?gcd(b,a%b):a;
}

ll lcm(ll a,ll b)
{
    return a*b/gcd(a,b);
}

void init()
{
    cin>>n>>x;
    for(int i=1;i<=n;i++)
        cin>>a[i];
}

void DP(ll k)
{
    //
    //printf("DP\n");
    //
    for(int i=1;i<=n;i++)
        for(int j=0;j<=1;j++)
            dp[i][j].clear();
    queue<tuple<ll,ll,ll> > Q;
    dp[1][0][gcd(k,gcd(x,a[1]))]=1;
    dp[1][1][gcd(k,lcm(x,a[1]))]=1;
    Q.push({1,0,gcd(k,gcd(x,a[1]))});
    Q.push({1,1,gcd(k,lcm(x,a[1]))});
    while(!Q.empty())
    {
        tuple<ll,ll,ll> t=Q.front();
        ll i=get<0>(t),ty=get<1>(t),val=get<2>(t);
        Q.pop();
        //
       // printf("i=%lld ty=%lld val=%lld dp=%lld\n",i,ty,val,dp[i][ty][val]);
        //
        if(i==n) continue;
        if(ty)
        {
            ll vg=gcd(k,gcd(val,a[i+1])),vl=gcd(k,lcm(val,a[i+1]));
            if(!dp[i+1][0][vg]) Q.push({i+1,0,vg});
            dp[i+1][0][vg]+=dp[i][1][val],dp[i+1][0][vg]%=TMD;
            if(!dp[i+1][1][vl]) Q.push({i+1,1,vl});
            dp[i+1][1][vl]+=dp[i][1][val],dp[i+1][1][vl]%=TMD;
        }
        else
        {
            ll vl=gcd(k,lcm(val,a[i+1]));
            if(!dp[i+1][1][vl]) Q.push({i+1,1,vl});
            dp[i+1][1][vl]+=dp[i][0][val],dp[i+1][1][vl]%=TMD;
        }
    }
}

void solve()
{
    //
    //printf("solve\n");
    //
    ll mn=x,ans=0;
    for(int i=1;i<=n;i++)
    {
        if((i&1)==(n&1)) mn=gcd(mn,a[i]);
        else mn=lcm(mn,a[i]);
    }
    DP(a[n]);
    if(mn!=a[n])
    {
        cout<<mn<<" "<<dp[n][0][mn]<<"\n";
        return ;
    }
    //
     //
    //printf("solve2 mn=%lld\n",mn);
    //
    ans=dp[n][0][mn];
    for(int i=n-1;i;i--)
    {
        if(a[n]%a[i])
        {
            //
            //printf("before i=%d ans=%lld\n",i,ans);
            //
            DP(a[i]);
            for(auto &j:dp[i][0])
                if(!(a[n]%j.first)) ans+=j.second,ans%=TMD;
            //
            //printf("after i=%d ans=%lld\n",i,ans);
            //
            break;
        }
        else
        {
            for(auto &j:dp[i][0])
                ans+=j.second,ans%=TMD;
        }
    }
    ans++;      //LLL...L
    ans%=TMD;
    a[0]=x;
    for(int i=0;i<=n;i++)
    {
        if(a[n]%a[i])
        {
            ans+=TMD-1;
            ans%=TMD;
            break;
        }
    }
    //
    cout<<mn<<" "<<ans<<"\n";
}

//-------------------------------------------------------

void gen_data()
{
    srand(time(NULL));
}

int bruteforce()
{
    return 0;
}

//-------------------------------------------------------

int main()
{
    fastio;

    init_divs();
    cin>>T;
	while(T--)
	{
		init();
		solve();

		/*

		//Stress Test

		gen_data();
		auto ans1=solve(),ans2=bruteforce();
		if(ans1==ans2) printf("OK!\n");
		else
		{
			//Output Data
 		}

		*/
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

• The statement.

• What is a directed graph.

• What is an $$$x$$$-base number.

• Important definition $$$k$$$: in the constructed scheme, the length (number of edges) of the path with the same color must smaller than $$$k$$$.

1

2

3

4

5

• The statement.

• What is a regular (balanced) bracket sequence.

• Important definition $$$s$$$: the given binary string in the statement.

• Important definition $$$n$$$: the length of $$$s$$$ (which is a bit different from the original statement).

• Important definition $$$ans_i$$$: Several regular bracket strings of length $$$n$$$, as your output answer.

2

3

4

5

6

7

• The statement.

• What is a regular (balanced) bracket sequence.

• Important definition $$$s$$$: the given bracket string in the statement.

• Important definition $$$n$$$: the length of $$$s$$$.

• Important definition $$$f(s)$$$: The string obtained by flipping the brackets in even indices $$$s$$$ (and keeping the brackets in odd indices unchanged).

• Important definition $$$ans$$$: A regular bracket string of length $$$n$$$ — your output answer.

• All strings we are talking about are $$$1$$$-indexed.

Vedio Editorial

The key observation is that the parity of the distance between Alice and Bob always changes after one move. Therefore, if $$$|x - y|$$$ is even, Alice can always move closer to Bob and corner him to win. Otherwise, Bob will win.

#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 <typename T>
using os = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using oms = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define mod  1000000007
#define mod2 998244353
#define ll long long
#define bl __int128_t
#define pb push_back
#define all(v) v.begin(),v.end()
#define bs binary_search
#define rall(v) v.rbegin(),v.rend()
#define lb lower_bound
#define ub upper_bound
#define pl pair<ll,ll>
#define f(i,n) for(ll i=0;i<n;i++)
#define inp(a,n) vector<ll> a(n); f(i,n) cin>>a[i]
#define pyes cout<<"YES\n"
#define pno cout<<"NO\n"
using Mat = array<array<ll,2>,2>;

#pragma GCC optimize("unroll-loops")
#pragma gcc optimize("Ofast")
#pragma GCC optimization("Ofast")
#pragma optimize(Ofast)
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("popcnt")

ll power(ll x,ll y,ll z=LLONG_MAX){
    ll res=1;
    while(y>0){
        if(y%2) res=(res*x)%z;
        y/=2;
        if(y) x=(x*x)%z;
    }return res%z;
}

ll gcd(ll a,ll b,ll& x,ll& y){
    x=1,y=0;
    ll x1=0,y1=1,a1=a,b1=b;
    while(b1){
        ll q=a1/b1;
        tie(x,x1)=make_tuple(x1,x-q*x1);
        tie(y,y1)=make_tuple(y1,y-q*y1);
        tie(a1,b1)=make_tuple(b1,a1-q*b1);
    }return a1;
}



int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    ll t=1,i,j,n,m,z=1e9+7,z2=998244353,k,x,y,q;
    // sieve(); // for SPF
    cin>>t;
    ll tt=t;
    string s,s2;
    while(tt--){
        ll n, x, y;
        cin >> n >> x >> y;
        if((x + y) % 2) pno;
        else pyes;
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Add as many segments with $$$1$$$ as one endpoint as possible. The answer is $$$n - 3$$$, which reaches the upper limit of the triangulation number.

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

int main() {

    int t;
    cin>>t;

    while(t--)
    {
        int n;
        cin>>n;
        if(t==0) cout<<n-3;
        else cout<<n-3<<"\n";
    }

    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Assume $$$x$$$ is the optimal solution, and $$$gcd(n, x) = y$$$. Then, $$$x$$$ must be equal to $$$y$$$; otherwise, $$$y$$$ would be a smaller solution. Therefore, we only need to factorize $$$n$$$ and find the smallest factor of $$$n$$$ in the range $$$[l, r]$$$.

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

int main() {
    long long t;
    cin>>t;

    while(t--)
    {
        long long n,l,r;
        cin>>n>>l>>r;

        if(n<l) cout<<"-1\n";
        else
        {
            long long ans=1e9+1;
            for(long long i=1;i*i<=n;i++)
            {
                if(n%i==0)
                {
                    long long A=i;
                    long long B=n/i;
                    if(A>=l && A<=r)
                    {
                        ans=min(ans,A);
                    }
                    if(B>=l && B<=r)
                    {
                        ans=min(ans,B);
                    }
                }
            }
            if(ans>n) cout<<"-1\n";
            else cout<<ans<<"\n";
        }
    }
    
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Greedily replace all '?' with 'L' or replace all '?' with 'R'. Then, check if the robot will explode.

#include <bits/stdc++.h>
using namespace std;
int n,m;
int solve(string s){
    map<int,int> mp;
    int x=0;
    for(int i=0;i<m;i++) 
    {
        if(s[i]=='L') x++;
        else x--;
        mp[x]=1;
    }

    mp.erase(0);
    return mp.size()>=n;

}

int main() {

    int t;
    cin>>t;

    while(t--)
    {
        cin>>n>>m;
        string s;
        cin>>s;

        string T=s;
        for(int i=0;i<m;i++) if(s[i]=='?') T[i]='L';

        if(solve(T)) cout<<"YES\n"<<T<<"\n";
        else 
        {
            for(int i=0;i<m;i++) if(s[i]=='?') T[i]='R';
            if(solve(T)) cout<<"YES\n"<<T<<"\n";
            else cout<<"NO\n";
        }

    }

    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

If $$$k$$$ is chosen for the first time, we can recalculate the answer using brute force. Otherwise, the answer can be updated in $$$O(1)$$$. Since all values on the diagonal are already the same, the update operation will only increase the answer by (new_value — old_value).

Time complexity: $$$O(n^3)$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1010;
const int LOGN=28;
const ll  TMD=1000000007;
const ll  INF=2147483647;
int T,n,q;
ll  ans;
ll  a[N][N],dp[N][N];

ll DP()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            dp[i][j]=max(dp[i-1][j],dp[i][j-1])+a[i][j];
    return dp[n][n];
}

void init()
{
    cin>>n>>q;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            cin>>a[i][j];
    ans=DP();
}

void modify(int k,int v)
{
    ll delta;
    for(int i=min(k-1,n),j=k-i;i>=1&&j<=n;i--,j++)
    {
        delta=v-a[i][j];
        a[i][j]=v;
    }
    ans+=delta;
}

void solve()
{
    vector<int> tag(2*n);
    for(int i=1;i<=q;i++)
    {
        int k,v;
        cin>>k>>v;
        modify(k,v);
        if(!tag[k])
        {
            tag[k]=1;
            ans=DP();
        }
        cout<<ans<<'\n';
    }
}

//-------------------------------------------------------

void gen_data()
{
    srand(time(NULL));
}

int bruteforce()
{
    return 0;
}

//-------------------------------------------------------

int main()
{
    fastio;

	cin>>T;
	while(T--)
	{
		init();
		solve();

		/*

		//Stress Test

		gen_data();
		auto ans1=solve(),ans2=bruteforce();
		if(ans1==ans2) printf("OK!\n");
		else
		{
			//Output Data
 		}

		*/
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Note: $$$'('$$$ is $$$1$$$ and $$$')'$$$ is $$$-1$$$, with $$$S$$$ as the current sum.

If $$$a \geq 2b$$$, Alice always wins.

The strategy is: $$$S = b \xrightarrow{\text{Bob}} 0 \leq S \leq 2b \xrightarrow{\text{Alice}} S = b \xrightarrow{\text{Bob}} 0 \leq S \leq 2b \xrightarrow{\text{Alice}} \dots \xrightarrow{\text{Bob}} 0 \leq S \leq 2b \xrightarrow{\text{Alice}} S = 0$$$.

Otherwise, Bob always wins.

The strategy is: $$$S \geq b \xrightarrow{\text{Bob}} S \geq 2b \xrightarrow{\text{Alice}} S \geq b \xrightarrow{\text{Bob}} S \geq 2b \xrightarrow{\text{Alice}} \dots \xrightarrow{\text{Bob}} S \geq 2b \xrightarrow{\text{Alice}} S \gt 0$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=0;
const ll  INF=2147483647;
int T;
int n,a,b;

/*
 * stuff you should look for
 * [Before Submission]
 * array bounds, initialization, int overflow, special cases (like n=1), typo
 * [Still WA]
 * check typo carefully
 * casework mistake
 * special bug
 * stress test
 */

void init()
{
    cin>>n>>a>>b;
}

int cal(string s)
{
    int sum=0;
    for(int i=0;i<s.length();i++)
        sum+=(s[i]=='('?1:-1);
    return sum;
}

void solve()
{
    string s;
    if(a>=2*b)
    {
        cout<<1<<'\n'<<flush;
        for(int i=1;i<=n;i+=2)
        {
            int cur=cal(s)-a;
            string t,tt;
            if(i==n)
            {
                for(int j=1;j<=a;j++)
                {
                    if(cur<0) cur+=2,t+='(';
                    else t+=')';
                }
                cout<<t<<'\n'<<flush;
                s+=t;
            }
            else
            {
                for(int j=1;j<=a;j++)
                {
                    if(cur<b) cur+=2,t+='(';
                    else t+=')';
                }
                cout<<t<<'\n'<<flush;
                s+=t;
                cin>>tt;
                s+=tt;
            }
        }
    }
    else
    {
        cout<<0<<'\n'<<flush;
        for(int i=1;i<=n;i+=2)
        {
            string t,tt;
            cin>>t;
            s+=t;
            if(i==n) break;
            if(cal(s)<b)
            {
                for(int j=1;j<=b;j++) tt+=')';
                cout<<tt<<'\n'<<flush;
            }
            else
            {
               for(int j=1;j<=b;j++) tt+='(';
                cout<<tt<<'\n'<<flush;
            }
            s+=tt;
        }
    }
}

//-------------------------------------------------------

void gen_data()
{
    srand(time(NULL));
}

int bruteforce()
{
    return 0;
}

//-------------------------------------------------------

int main()
{
    fastio;

    cin>>T;
	while(T--)
	{
		init();
		solve();

		/*

		//Stress Test

		gen_data();
		auto ans1=solve(),ans2=bruteforce();
		if(ans1==ans2) printf("OK!\n");
		else
		{
			//Output Data
 		}

		*/
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

For fixed $$$m$$$, we can construct intervals for $$$n \in [mL, mR]$$$. Let $$$m = \left\lfloor \frac{n}{L} \right\rfloor$$$. If $$$n \gt mR$$$, output $$$-1$$$; otherwise, we can always construct a valid solution.

Now, let's consider constructing a solution with the minimum $$$\gcd$$$. Let $$$minlen$$$ be the minimum length of all intervals. We can observe that all scores $$$(l[i] \cdot (l[i] + 1) \cdots \cdot r[i])$$$ in the intervals are multiples of $$$(minlen!)$$$.

Let's prove it in one line:
$$$\frac{r \cdot (r-1) \cdots (r-minlen+1)}{minlen!} = \frac{r!}{(r-minlen)! minlen!} = C(r, minlen)$$$.

Thus, we can simply choose $$$[1, minlen]$$$ to minimize the gcd. For construction, we choose the scheme that minimizes the value of $$$minlen$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=998244353;
const ll  INF=2147483647;
ll T,n,L,R;
ll fac[N];

/*
 * stuff you should look for
 * [Before Submission]
 * array bounds, initialization, int overflow, special cases (like n=1), typo
 * [Still WA]
 * check typo carefully
 * casework mistake
 * special bug
 * stress test
 */

void init_fac()
{
	fac[0]=1;
	for(int i=1;i<N;i++) fac[i]=(fac[i-1]*i)%TMD;
}

void init()
{
    cin>>n>>L>>R;
}

void solve()
{
    ll mn=INF,m=0;
    for(int i=1;i<=n;i++)
    {
        if(i*L<=n&&n<=i*R)
        {
            ll res=max(0LL,n-(L+R*(i-1)));
            if(L+res<mn) mn=L+res,m=i;
        }
    }
    if(!m)
    {
        cout<<"-1\n";
        return ;
    }
    vector<ll> len(m+4);
    for(int i=1;i<=m;i++) len[i]=L;
    n-=m*L;
    for(int i=m;i;i--)
        len[i]+=min(R-L,n),n-=min(R-L,n);
    cout<<m<<' '<<fac[mn]<<'\n';
    for(int i=1,cur=1;i<=m;i++)
    {
        cout<<cur<<' '<<cur+len[i]-1<<'\n';
        cur+=len[i];
    }
}

//-------------------------------------------------------

void gen_data()
{
    srand(time(NULL));
}

int bruteforce()
{
    return 0;
}

//-------------------------------------------------------

int main()
{
    fastio;

    init_fac();
	cin>>T;
	while(T--)
	{
		init();
		solve();

		/*

		//Stress Test

		gen_data();
		auto ans1=solve(),ans2=bruteforce();
		if(ans1==ans2) printf("OK!\n");
		else
		{
			//Output Data
 		}

		*/
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

One key observation is that only the last operation of type $$$2$$$ matters.

The answer is $$$x + \max(b[j] + a[j+1:r[i]])$$$. There are two other cases: $$$x$$$ and $$$x + \sum(a[l[i]:r[i]])$$$. To simplify, let’s define $$$c[i] = b[i] + a[i+1:]$$$, and then build a sparse table on $$$c$$$ to maintain the answer.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
using namespace std;
typedef double db; 
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=0;
const ll  INF=2147483647;
int T,n,q;
int a[N],b[N];
ll  presum[N];

//-------------------------------------------------
int lg2[N];
ll  mx[N][LOGN];

void init()
{
	for(int i=1;i<=n;i++) lg2[i]=(int)log2(i);
	for(int i=1;i<=n;i++) mx[i][0]=b[i]-presum[i];
	for(int i=1;i<LOGN;i++)
	{
		for(int j=1;j<=n;j++)
		{
			int p=j+(1<<(i-1));
			if(p>n) 
			{
				mx[j][i]=mx[j][i-1];
			}
			else    
			{
				mx[j][i]=max(mx[j][i-1],mx[p][i-1]);
			}
		}
	}
}

ll getmax(int L,int R)
{
	int t=lg2[R-L+1];
	return max(mx[L][t],mx[R-(1<<t)+1][t]);
}

//-------------------------------------------------

int main()
{
	scanf("%d",&T);
	while(T--)
	{
	    scanf("%d%d",&n,&q);
	    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	    for(int i=1;i<=n;i++) scanf("%d",&b[i]);
	    for(int i=1;i<=n;i++) a[i]=max(0,a[i]);
	    for(int i=1;i<=n;i++) presum[i]=presum[i-1]+a[i];
	    init();
	    for(int i=1;i<=q;i++)
	    {
    		int k,l,r;
    		//ll  ans;
    		scanf("%d%d%d",&k,&l,&r);
    		printf("%I64d\n",max(k+presum[r]-presum[l-1],presum[r]+getmax(l,r)));
    		//ans=presum[r]-presum[l-1];
    	}
	}
	
	//fclose(stdin);
	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

• Great:
• Good:
• Average:
• Bad:
• Trash:

• D2A:
• D2B:
• D1A:
• D1B:
• D1C1:
• D1C2:
• D1C3:
• D1D:
• D1E:
• D1F1:
• D1F2:

• D2A:
• D2B:
• D1A:
• D1B:
• D1C1:
• D1C2:
• D1C3:
• D1D:
• D1E:
• D1F1:
• D1F2:

Do you know the source of the title?

Assuming that choosing $$$\text{mex(S')}$$$ is optimal, what conditions does $$$S'$$$ need to satisfy?

Are there duplicate numbers in $$$S'$$$? Is there a number greater than $$$\text{mex(S')}$$$ in $$$S'$$$?

Assuming that choosing $$$\text{mex(S')}$$$ is optimal, there are no duplicate numbers in $$$S'$$$. And thers is not a number greater than $$$\text{mex(S')}$$$. Otherwise, we can easily construct a better answer.

Consider $$$\text{S={0,1,...,x}}$$$. We can see $$$\text{mex(S')} \gt \text{max(S')}$$$ when $$$x$$$ is $$$0$$$ or $$$1$$$. And $$$\text{mex({0,1})}=\text{mex({0})}+\text{sum({1})}$$$. Thus, we only use $$$\text{mex}$$$ operation for each single $$$0$$$.

The answer is $$$\text{sum(S)}$$$ add the number of $$$0$$$ in $$$S$$$.

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

void solve(){
    int n, tmp, ans = 0;
    cin >> n;
    for(int i=0; i<n; i++){cin >> tmp; ans += tmp + (tmp == 0);}
    cout << ans << '\n';
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin >> t;
    while(t--) solve();
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Casework. Consider two easy cases first: $$$\Sigma a \gt s$$$ and $$$\Sigma a=s$$$.

What if there is an index $$$i$$$ such that $$$a_i+a_{i+1}=1$$$?

To "block" $$$a_i+a_{i+1}=1$$$, what should Bob do?

Consider cases of $$$\Sigma a=s+1$$$ and $$$\Sigma a \gt s+1$$$.

The minimum path sum is the sum of the simple path from $$$1$$$ to $$$n$$$ (i.e., $$$1 \rightarrow 2 \rightarrow \dots \rightarrow n$$$), denoted as $$$\text{base_sum} = \sum_{i=1}^{n} a_i$$$.

The path can include back-and-forth movements (e.g., from $$$i$$$ to $$$i+1$$$ and back to $$$i$$$), which increases the path length and the path sum. Specifically, each back-and-forth movement between adjacent positions $$$(i, i+1)$$$ adds $$$a_i + a_{i+1}$$$ to the path sum.

Thus, the total path sum can be expressed as $$$\text{base_sum} + d$$$, where $$$d$$$ is the additional sum contributed by zero or more back-and-forth movements. Here, $$$d$$$ can be represented as a non-negative integer linear combination of the sums of adjacent pairs.

Casework:

• If $$$s \lt \text{base_sum}$$$, no path sum can equal $$$s$$$ (since the base sum already exceeds $$$k$$$, and any additional movements will further increase the sum).

• If $$$s = \text{base_sum}$$$, the simple path ($$$1 \rightarrow 2 \rightarrow \dots \rightarrow n$$$) already satisfies the condition, so Alice cannot be stopped.

• If $$$s \gt \text{base_sum}$$$, let $$$d = s - \text{base_sum}$$$:

  • If $$$d = 1$$$, we can rearrange the array to avoid adjacent pairs summing to $$$1$$$ (i.e., avoid $$$0$$$ and $$$1$$$ being adjacent). Specifically, place all $$$0$$$s first, followed by all $$$2$$$s, and then all $$$1$$$s (e.g., $$$[0, 0, \dots, 0, 2, 2, \dots, 2, 1, 1, \dots, 1]$$$). This ensures no adjacent pair sums to $$$1$$$, making $$$d = 1$$$ unachievable.
  • If $$$d \neq 1$$$, no rearrangement can prevent Alice from achieving the path sum $$$s$$$ (since sums of adjacent pairs can cover all $$$T \geq 2$$$ through linear combinations).

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

void solve(){
    int n, k, tmp;
    cin >> n >> k;
    vector<int> a(3);
    for(int i=0; i<n; i++){cin >> tmp; a[tmp]++;}
    if(k == a[1] + 2*a[2] || k >= a[1] + 2*a[2] + 2){cout << -1 << '\n'; return;}
    for(int i=0; i<a[0]; i++) cout << 0 << ' ';
    for(int i=0; i<a[2]; i++) cout << 2 << ' ';
    for(int i=0; i<a[1]; i++) cout << 1 << ' ';
    cout << '\n';
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin >> t;
    while(t--) solve();
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Assuming that choosing $$$S$$$ is optimal, what is the value of $$$g(S)$$$?

In the case of $$$g(S)=0$$$, make $$$f(S)$$$ the length of the union of the entire set.

Assuming that choosing $$$S$$$ is optimal, $$$g(S)$$$ must be $$$0$$$ because removing an edge on the cycle will not change $$$f(S)$$$.

In the case of $$$g(S)=0$$$, we need to make $$$f(S)$$$ the length of the union of the entire set. There are many approaches.

An easiest $$$O(n^2)$$$ approach is to remove all segments contained by other segments. Afterwards, it can be proven that there are no cycles with a length greater than or equal to $$$3$$$ in the graph. If there is a cycle, note it as $$$x_1 \rightarrow x_2 \rightarrow x_3 \rightarrow ... \rightarrow x_1$$$, we can always find $$$x_{i-1} \lt x_i \gt x_{i+1}$$$, where either $$$[x_{i-1},x_i] \subseteq [x_i,x_{i+1}]$$$ or $$$[x_i,x_{i+1}] \subseteq [x_{i-1},x_i]$$$. At this point, we have deduced the contradiction, so there are no cycles with a length greater than or equal to $$$3$$$ in the graph.

Another approach is to use DSU to maintain the generate forest.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
int T,n;
int a[N],b[N];

void init()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i]>>b[i];
}

void solve()
{
    vector<int> tag(n+4,1),ans;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j) continue;
            if(a[j]<=a[i]&&b[i]<=b[j]) tag[i]=0;
        }
        if(tag[i]) ans.push_back(i);
    }
    cout<<ans.size()<<"\n";
    for(int i=0;i<ans.size();i++)
        cout<<ans[i]<<(i+1==ans.size()?"\n":" ");
}

int main()
{
    fastio;

    cin>>T;
	while(T--)
	{
		init();
		solve();
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Consider $$$p_i=1$$$. If $$$a_i=1$$$, what are inversions containing $$$i$$$? If $$$a_i=2n-1$$$, what are inversions containing $$$i$$$?

Attempt to generalize the conclusion to any pair $$$(i, j)$$$.

Consider $$$p_i=1$$$ and inversions containing $$$i$$$. If $$$a_i=1$$$, it is the minimum value, and the inversions containing $$$i$$$ are $$$(1, i), (2, i),... (i-1, i)$$$; If $$$a_i=2n-1$$$, it is the maximum value, and the inversions containing $$$i$$$ are $$$(i, i+1),... (i, n)$$$. The key observation is the number of inversions containing $$$i$$$ is only related to $$$a_i$$$, and completely unrelated to other elements.

At this point, the problem has actually been solved. We can greedily choose $$$\min(i-1,n-i)$$$ and remove $$$1$$$ from $$$p$$$, and the remaining part is a completely identical subproblem with a size of $$$n-1$$$.

It can be implemented as follows: for each index $$$i$$$, calculate the number of elements to the left that are bigger than $$$p_i$$$ (note it as $$$lbigger$$$), and the number of elements to the right that are bigger than $$$p_i$$$ (note it as $$$rbigger$$$). Then greedily add $$$\min(lbigger,rbigger)$$$ to the answer.

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

void solve(){
    int n, ans = 0;
    cin >> n;
    vector<int> p(n);
    for(int i=0; i<n; i++) cin >> p[i];
    for(int i=0; i<n; i++){
        int left = 0, right = 0;
        for(int j=0; j<i; j++) if(p[j] > p[i]) left++;
        for(int j=i+1; j<n; j++) if(p[j] > p[i]) right++;
        ans += min(left, right);
    }
    cout << ans << '\n';
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin >> t;
    while(t--) solve();
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Try to Perform binary search to find a $$$\texttt{'('}$$$ and a $$$\texttt{')'}$$$ using $$$O(\log n)$$$ queries. It is best to complete it within $$$10$$$ operations (to pass the hard version).

Consider the easy version. Constraint implies that we use one query to determine $$$2$$$ characters.

Construct a string $$$x$$$, insert $$$s_i$$$ and $$$s_j$$$ into certain positions of $$$x$$$ to obtain string $$$y$$$, so that $$$f(y)$$$ can produce $$$4$$$ different values.

Consider the medium version. Effectively utilizing the conditions of $$$k \le 1000$$$.

Consider binary code.

Consider the hard version. The number of substrings in a string of length $$$l$$$ is $$$O(l ^ 2)$$$. How to utilize this?

At first, we need to find $$$s_x=\texttt{’(’}$$$ and $$$s_y=\texttt{’)’}$$$. Do binary search to find the smallest $$$i$$$ such that $$$f(s_1s_2...s_i) \gt 0$$$. Then we get $$$s_{i-1}=\texttt{’(’}$$$ and $$$s_i=\texttt{’)’}$$$. A corner case is $$$f(s)=0$$$. In this case, $$$s_n=\texttt{’(’}$$$ and $$$s_1=\texttt{’)’}$$$.

Ask $$$f(\texttt{"s1)s2)()"})$$$:

• If $$$f(\texttt{"s1)s2)()"})=6$$$, $$$s_1=$$$ $$$\texttt{'('}$$$ and $$$s_2=$$$ $$$\texttt{'('}$$$.

• If $$$f(\texttt{"s1)s2)()"})=2$$$, $$$s_1=$$$ $$$\texttt{'('}$$$ and $$$s_2=$$$ $$$\texttt{')'}$$$.

• If $$$f(\texttt{"s1)s2)()"})=3$$$, $$$s_1=$$$ $$$\texttt{')'}$$$ and $$$s_2=$$$ $$$\texttt{'('}$$$.

• If $$$f(\texttt{"s1)s2)()"})=1$$$, $$$s_1=$$$ $$$\texttt{')'}$$$ and $$$s_2=$$$ $$$\texttt{')'}$$$.

In this way, we can determine two characters with one query.

Read the tutorial in easy version first.

Note $$$f_0$$$ as the $$$f$$$ value of the following string:

$$$\underbrace{()()\ldots()}_{128 pairs}$$$ $$$)$$$ $$$\underbrace{()()\ldots()}_{64 pairs}$$$ $$$)$$$ $$$\dots$$$ $$$)()$$$

Then ask for the $$$f$$$ value of the following string (note it as $$$f_1$$$):

$$$\underbrace{s_8)()\ldots()}_{128 pairs}$$$ $$$)$$$ $$$\underbrace{s_7)()\ldots()}_{64 pairs}$$$ $$$)$$$ $$$\dots$$$ $$$)s_1)$$$

By checking the binary bits of $$$f_0-f_1$$$, we can determine $$$8$$$ positions with one query. For example, if $$$f_0-f_1=(10000101)_2$$$, we can get $$$s_1=s_3=s_8=')'$$$.

Read the tutorial of the medium version first.

We can optimize

$$$\underbrace{s_i)()\ldots()}_{2^k pairs}$$$

to

$$$\underbrace{()()\ldots()}_{2^{\lfloor \frac{k}{2} \rfloor}-1\ pairs}$$$ $$$s_i)$$$ $$$\underbrace{()()\ldots()}_{2^{\lceil \frac{k}{2} \rceil}-1\ pairs}$$$

With this optimization, we can determine $$$12$$$ locations in one query.

Another construction also works:

$$$\underbrace{s_1)s_1)\ldots s_1)}_{g(1)\ pairs}$$$ $$$)$$$ $$$\underbrace{s_2)s_2)\ldots s_2)}_{g(2)\ pairs}$$$ $$$)$$$ $$$\underbrace{s_3)s_3)\ldots s_3)}_{g(3)\ pairs}$$$ $$$)$$$ $$$\ldots$$$ $$$\underbrace{s_{12})s_{12})\ldots s_{12})}_{g(12)\ pairs}$$$

where $$$g(1)=1$$$ and $$$\frac{g(i+1) \cdot (g(i+1)+1)}{2} \gt \frac{g(1) \cdot (g(1)+1)}{2}+\frac{g(2) \cdot (g(2)+1)}{2}+\ldots+\frac{g(i) \cdot (g(i)+1)}{2}$$$.

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

typedef long long ll;

typedef long long       ll;
typedef long double     ld;
typedef pair<ll, ll>   pll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;

const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;

#define T(x, i) get<i>(x)
#define F first
#define S second
#define all(v) v.begin(), v.end()
#define forn(i, n) for (int i = 0; i < n; i++)

template<class T, class U> inline istream& operator>>(istream& str, pair<T, U> &p) { return str >> p.F >> p.S; }
template<class T, class U> inline ostream& operator<<(ostream& str, const pair<T, U> &p) { str << p.F << ' ' << p.S << ' '; return str; }
template<class T> inline istream& operator>>(istream& str, vector<T> &a) { for (auto &i : a) str >> i; return str; }
template<class T> inline ostream& operator<<(ostream& str, const vector<T> &a) { for (auto &i : a) str << i << ' '; return str; }

void flush() { cout << flush; }
void flushln() { cout << endl; }
template<class T> void read(T &x) { cin >> x; }
template<class T, class ...U> void read(T &x, U&... u) { read(x); read(u...); }
template<class T> void print(const T &x) { cout << x; }
template<class T, class ...U> void print(const T &x, const U&... u) { print(x); print(u...); }
template<class ...T> void println(const T&... u) { print(u..., '\n'); }
template<class T> void eprint(const T &x) { cerr << x; }
template<class T, class ...U> void eprint(const T &x, const U&... u) { eprint(x); eprint(u...); }
template<class ...T> void eprintln(const T&... u) { eprint(u..., '\n'); }

#ifdef DEBUG
	mt19937 rng(1033);
	#define var(x) cerr << #x << ": " << x << '\n';
	#define range(a, b) cerr << #a << ", " << #b << ": "; for (auto _it = a; _it != b; ++_it) cerr << *_it << ' '; cerr << '\n';
#else
	mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
	#define cerr if (false) cerr
	#define var(x)
	#define range(a, b)
	#define eprintln if(false)eprintln
	#define eprint if(false)eprint
#endif
int rnd(int mod) { return uniform_int_distribution<int>(0, mod - 1)(rng); }


int n;

map<vector<int>, int> mem;

int ask(vector<int> ind) {
	if (!mem.count(ind)) {
		cout << "? ";
		cout << ind.size() << ' ';
		for (auto i : ind)
			cout << i + 1 << ' ';
		cout << endl;

		int res;
		cin >> res;
		mem[ind] = res;
	}

	return mem[ind];
}


bool same(vector<int> ind) {
	if (ask(ind))
		return false;
	ind.push_back(ind[0]);
	ind.erase(ind.begin());
	if (ask(ind))
		return false;
	return true;
}

pii search(vector<int> ind) {
	if (ind.size() == 2) {
		if (ask(ind))
			return {ind[0], ind[1]};
		return {ind[1], ind[0]};
	}

	vector<int> inda, indb;
	int sz = (ind.size() + 1) / 2;
	for (int i = 0; i < sz; i++) {
		inda.push_back(ind[i]);
		indb.push_back(ind[ind.size() - 1 - i]);
	}

	if (!same(inda))
		return search(inda);
	if (!same(indb))
		return search(indb);
	inda.push_back(indb[0]);
	return search(inda);
}

pii find_reg2() {
	vector<int> ind(n);
	iota(all(ind), 0);
	shuffle(all(ind), rng);
	return search(ind);
}

void solve() {
	mem.clear();
	auto [po, pc] = find_reg2();

	vector<int> to_ask(n);
	iota(all(to_ask), 0);
	if (to_ask.size() & 1)
		to_ask.push_back(0);


	string ans = string(n, '.');
	ans[po] = '(';
	ans[pc] = ')';
		
	for (int i = 0; i < to_ask.size(); i += 2) {
		int a = to_ask[i], b = to_ask[i + 1];

		vector<int> q = {po, pc, po, a, b, pc};
		int res = ask(q);

		// ()(ab) - x ab
		// ()(()) - 4 ()
		// ()((() - 2 ((
		// ()())) - 3 ))
		// ()()() - 6 )(
		map<int, pair<char, char>> results = {
			{4, {'(', ')'}},
			{2, {'(', '('}},
			{3, {')', ')'}},
			{6, {')', '('}},
		};

		assert(results.count(res));
		auto [resa, resb] = results[res];
		ans[a] = resa;
		ans[b] = resb;
	}

	cout << "! " << ans << endl;
}

signed main() {
	#ifdef DEBUG
	// freopen("input.txt", "r", stdin);
	// freopen("output.txt", "w", stdout);
	#endif
	ios_base::sync_with_stdio(0); cin.tie(0);
	cout << fixed << setprecision(20);
	int t = 1;
	cin >> t;
	for (int i = 0; i < t; i++) {
		cin >> n;
		solve();
	}
	#ifdef DEBUG
		cerr << "Runtime is: " << clock() * 1.0 / CLOCKS_PER_SEC << endl;
	#endif
}


/*


()(ab)
()(()) - 4 ()
()((() - 2 ((
()())) - 3 ))
()()() - 6 )(

2
3
)((
2
()


*/

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <random>
#include <chrono>
 
using namespace std;
 
#define _int64 long long
#define mo 998244353

char tar[110000];
int cnt;

int doask(vector<int>& a)
{
	int i,ret;
	/*
	{
		int v,tmp,j;
		string ss;
		cnt++;
		ss="";
		for (i=0;i<a.size();i++)
		{
			ss.push_back(tar[a[i]]);
		}
		tmp=0;
		for (i=0;i<ss.length();i++)
		{
			v=0;
			for (j=i;j<ss.length();j++)
			{
				if (ss[j]=='(') v++;
				else v--;
				if (v<0) break;
				if (v==0) tmp++;
			}
		}
		return tmp;
	}
	*/
	
	printf("? %d",(int)a.size());
	for (i=0;i<a.size();i++)
		printf(" %d",a[i]+1);
	printf("\n");
	fflush(stdout);
	scanf("%d",&ret);
	return ret;
	
}

char ans[1100];

void doanswer()
{
	printf("! %s\n",ans);
	cerr<<"T "<<tar<<endl;
	cerr<<"cnt:"<<cnt<<endl;
	if (string(ans)==string(tar))
	{
		cerr<<"good"<<endl;
	}
	else cerr<<"bad"<<endl;
	fflush(stdout);
}

int main()
{
	int i,j,k,n,l,t,m,x,y,o,b1,indl,indr,ll,rr,mid,tmp,v,st;
	vector<int> a;
	scanf("%d",&t);
	for (l=0;l<t;l++)
	{
		scanf("%d",&n);
		for (i=0;i<n;i++)
		{
			x=rand()%2;
			if (x==0) tar[i]='(';
			else tar[i]=')';
		}
		tar[n]='\0';
		cnt=0;
		st=0;ans[n]='\0';
		indl=-1;
		indr=-1;
		// while (st<n)
		// {
			ll=st;rr=n;
			while (rr-ll>1)
			{
				mid=(ll+rr)/2;
				a.clear();
				for (i=st;i<=mid;i++)
					a.push_back(i);
				tmp=doask(a);
				if (tmp==0) ll=mid;
				else rr=mid;
			}
			if (rr==n)
			{
				indr=st;
				/*
				if ((indl==-1)&&(indr==-1))
				{
					indr=st;
				}
				ll=st-1;rr=n;
				while (rr-ll>1)
				{
					mid=(ll+rr)/2;
					a.clear();
					a.push_back(mid);
					a.push_back(indr);
					tmp=doask(a);
					if (tmp==0) ll=mid;
					else rr=mid;
				}
				for (i=st;i<=ll;i++)
					ans[i]=')';
				for (i=rr;i<n;i++)
					ans[i]='(';
				st=n;
				break;
				*/
			}
			else
			{
				indr=rr;
				/*
				v=rr;
				ans[v]=')';
				ll=st-1;rr=v-1;
				while (rr-ll>1)
				{
					mid=(ll+rr)/2;
					a.clear();
					a.push_back(mid);
					a.push_back(v);
					tmp=doask(a);
					if (tmp==0) ll=mid;
					else rr=mid;
				}
				for (i=st;i<=ll;i++)
					ans[i]=')';
				for (i=rr;i<v;i++)
					ans[i]='(';
				st=v+1;
				indl=v-1;
				indr=v;
				*/
			}
		// }
		//cerr<<"indr:"<<indr<<endl;
		for (i=0;i<n;i+=8)
		{
			a.clear();
			for (j=0;j<8;j++)
			{
				if (i+j>=n) break;
				for (k=0;k<(1<<j);k++)
				{
					a.push_back(i+j);
					a.push_back(indr);
					a.push_back(indr);
				}
			}
			tmp=doask(a);
			for (j=0;j<8;j++)
			{
				if (i+j>=n) break;
				if (((1<<j)&tmp)!=0) ans[i+j]='(';
				else ans[i+j]=')';
			}
		}

		doanswer();
	}
}

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <random>
#include <chrono>
 
using namespace std;
 
#define _int64 long long
#define mo 998244353

char tar[110000];
int cnt;

int doask(vector<int>& a)
{
	int i,ret;
	/*
	{
		int v,tmp,j;
		string ss;
		cnt++;
		ss="";
		for (i=0;i<a.size();i++)
		{
			ss.push_back(tar[a[i]]);
		}
		tmp=0;
		for (i=0;i<ss.length();i++)
		{
			v=0;
			for (j=i;j<ss.length();j++)
			{
				if (ss[j]=='(') v++;
				else v--;
				if (v<0) break;
				if (v==0) tmp++;
			}
		}
		return tmp;
	}
	*/
	
	printf("? %d",(int)a.size());
	for (i=0;i<a.size();i++)
		printf(" %d",a[i]+1);
	printf("\n");
	fflush(stdout);
	scanf("%d",&ret);
	return ret;
	
}

char ans[1100];

void doanswer()
{
	printf("! %s\n",ans);
	cerr<<"T "<<tar<<endl;
	cerr<<"cnt:"<<cnt<<endl;
	if (string(ans)==string(tar))
	{
		cerr<<"good"<<endl;
	}
	else cerr<<"bad"<<endl;
	fflush(stdout);
}

int main()
{
	int i,j,k,n,l,t,m,x,y,o,b1,indl,indr,ll,rr,mid,tmp,v,st,sum,len;
	vector<int> a;
	vector<int> p;
	sum=0;len=0;
	for (i=1;i<=130;i++)
	{
		tmp=i*(i+1)/2;
		if (tmp>sum)
		{
			p.push_back(i);
			//cerr<<"i:"<<i<<endl;
			sum+=tmp;
			len+=i+i;
		}
	}
	//cerr<<"p.sz:"<<p.size()<<" "<<len<<endl;
	scanf("%d",&t);
	for (l=0;l<t;l++)
	{
		scanf("%d",&n);
		for (i=0;i<n;i++)
		{
			x=rand()%2;
			if (x==0) tar[i]='(';
			else tar[i]=')';
		}
		tar[n]='\0';
		cnt=0;
		st=0;ans[n]='\0';
		indl=-1;
		indr=-1;
		// while (st<n)
		// {
			ll=st;rr=n;
			while (rr-ll>1)
			{
				mid=(ll+rr)/2;
				a.clear();
				for (i=st;i<=mid;i++)
					a.push_back(i);
				tmp=doask(a);
				if (tmp==0) ll=mid;
				else rr=mid;
			}
			if (rr==n)
			{
				indr=st;
				/*
				if ((indl==-1)&&(indr==-1))
				{
					indr=st;
				}
				ll=st-1;rr=n;
				while (rr-ll>1)
				{
					mid=(ll+rr)/2;
					a.clear();
					a.push_back(mid);
					a.push_back(indr);
					tmp=doask(a);
					if (tmp==0) ll=mid;
					else rr=mid;
				}
				for (i=st;i<=ll;i++)
					ans[i]=')';
				for (i=rr;i<n;i++)
					ans[i]='(';
				st=n;
				break;
				*/
			}
			else
			{
				indr=rr;
				/*
				v=rr;
				ans[v]=')';
				ll=st-1;rr=v-1;
				while (rr-ll>1)
				{
					mid=(ll+rr)/2;
					a.clear();
					a.push_back(mid);
					a.push_back(v);
					tmp=doask(a);
					if (tmp==0) ll=mid;
					else rr=mid;
				}
				for (i=st;i<=ll;i++)
					ans[i]=')';
				for (i=rr;i<v;i++)
					ans[i]='(';
				st=v+1;
				indl=v-1;
				indr=v;
				*/
			}
		// }
		//cerr<<"indr:"<<indr<<endl;
		for (i=0;i<n;i+=p.size())
		{
			a.clear();
			for (j=0;j<p.size();j++)
			{
				if (i+j>=n) break;
				for (k=0;k<p[j];k++)
				{
					a.push_back(i+j);
					a.push_back(indr);
				}
				a.push_back(indr);
			}
			tmp=doask(a);
			for (j=p.size()-1;j>=0;j--)
			{
				if (i+j>=n) continue;
				v=p[j]*(p[j]+1)/2;
				if (tmp>=v)
				{
					tmp-=v;ans[i+j]='(';
				}
				else ans[i+j]=')';
			}
		}

		doanswer();
	}
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Consider enumerating $$$p_i = 1$$$. After that, will the cells to the left of $$$p_i$$$ affect the cells to the right of $$$p_i$$$?

Consider range DP.

Can you find the upper bound of $$$s_i$$$?

Consider range DP.

Note $$$dp[l][r][x][y]$$$ as the number of scheme ensureing $$$s[l-1]+=x$$$ and $$$s[r+1]+=y$$$.

Transform:

For simplicity, this formula omits some edge cases. Readers are encouraged to fill in the details themselves.

The complexity seems high, but the problem can be solved with one key observation: the upper bound of $$$s_i$$$ is $$$O( \log n)$$$.

Proof: let's fix a position $$$i$$$ and only consider the cells $$$c_1, c_2, ..., c_k$$$ $$$(c_1 \lt c_2 \lt ... \lt c_k)$$$ to the left of $$$i$$$ that cause $$$s_i$$$ to increase. We can see that $$$i - c_j \gt 2(i - c_{j+1})$$$. Otherwise, $$$c_{j+1}$$$ would cause $$$s_{c_j}$$$ to increase by $$$1$$$ instead of $$$s_i$$$. Thus, We can get $$$k$$$ is $$$O( \log n)$$$.

Complexity: $$$O(n^3 \log^3n)$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=110;
const int LOGN=10;
const ll  TMD=998244353;
const ll  INF=2147483647;
int T,n;
ll s[N],fac[N],inv[N];
ll dp[N][N][LOGN][LOGN];

void init_C()
{
	fac[0]=1;
	for(int i=1;i<N;i++) fac[i]=(fac[i-1]*i)%TMD;
	inv[N-1]=pw(fac[N-1],TMD-2);
 	for(int i=N-2;i>=0;i--) inv[i]=(inv[i+1]*(i+1))%TMD;
}

ll C(int n,int m)
{
	if(n<m||n<0||m<0) return 0;
	return fac[n]*inv[m]%TMD*inv[n-m]%TMD;
}

void init()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>s[i];
    for(int i=1;i<=n+4;i++)
        for(int j=1;j<=n+4;j++)
            for(int ii=0;ii<LOGN;ii++)
                for(int jj=0;jj<LOGN;jj++)
                    dp[i][j][ii][jj]=0;
    dp[1][1][0][1]=(s[1]<1);
    for(int i=2;i<=n;i++)
        dp[i][i][1][0]=(s[i]<1);
    for(int i=1;i<=n;i++)   //auxiliary value
        dp[i][i-1][0][0]=dp[i+1][i][0][0]=1;
}

int ABS(int x)
{
    return x<0?-x:x;
}

void solve()
{
    for(int i=2;i<=n;i++)
    {
        for(int j=1;j+i-1<=n;j++)
        {
            for(int ii=0;ii<LOGN;ii++)
            {
                for(int jj=0;jj<LOGN;jj++)
                {
                     int l=j,r=j+i-1;
                     for(int k=l;k<=r;k++)
                     {
                         int tagl=0,tagr=0;
                         if(l==1&&r==n) tagl=tagr=0;
                         else if(l==1) tagr=1;
                         else if(r==n) tagl=1;
                         else
                         {
                             if(ABS(l-1-k)<=ABS(k-(r+1))) tagl=1;
                             else tagr=1;
                         }
                         if(ii-tagl<0||jj-tagr<0) continue;
                         if(s[k]==-1)
                         {
                             ll suml=0,sumr=0;
                             for(int kk=0;kk<LOGN;kk++) suml=(suml+dp[l][k-1][ii-tagl][kk])%TMD;
                             for(int kk=0;kk<LOGN;kk++) sumr=(sumr+dp[k+1][r][kk][jj-tagr])%TMD;
                            dp[l][r][ii][jj]=(dp[l][r][ii][jj]+suml*sumr%TMD*C(r-l,k-l))%TMD;
                        }
                         else
                         {
                             for(int kk=0;kk<LOGN;kk++)
                             {
                                 if(s[k]-kk<0||s[k]-kk>=LOGN) continue;
                                 dp[l][r][ii][jj]=(dp[l][r][ii][jj]+dp[l][k-1][ii-tagl][kk]*dp[k+1][r][s[k]-kk][jj-tagr]%TMD*C(r-l,k-l))%TMD;
                             }
                         }
                     }
                }
            }
        }
    }
    cout<<dp[1][n][0][0]<<'\n';
}

int main()
{
    fastio;

    init_C();

    cin>>T;
	while(T--)
	{
		init();
		solve();
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Come up with an O(n log^4 n) solution using a persistent multidimensional segment tree with Trie that supports rectangle update XOR.

Find the nature of the problem and recall the data structures and algorithms learned. What can we utilize?

Consider a standard Mo's algorithm. Why it doesn't work in this problem?

Recalling the Handshake Theorem: $$$\Sigma_{i=1}^n degree_i=2m$$$.

Consider a variation of Mo's algorithm.

How to find the $$$k$$$-th smallest value without $$$O( \log n)$$$ complexity?

We found that merging the $$$f$$$ values of two intervals is a bit difficult. However, if we want to add a single node to the graph, it is relatively easy to update the $$$f$$$ value using brute force. This inspires us to use the Mo's algorithm.

If we use the standard Mo's Algorithm, when expanding the interval from $$$[l, r]$$$ to $$$[l, r+1]$$$, we need to examine all edges connected to $$$r+1$$$ and update the node degrees accordingly. We define a cost array: $$$cost_i=degree_i+1$$$. The cost of update node $$$r+1$$$ is $$$cost_{r+1}$$$.

However, if a node has a high degree, repeatedly processing it in Mo's Algorithm could lead to big time complexity.

We leverage the Handshaking Lemma to use modified Mo's Algorithm to efficiently handle the queries.

Recall that the Mo's algorithm relatively evenly divides array indices into blocks according to array length and assigns block numbers. Here, our dividinging strategy is different: we "relatively evenly" divide the array into blocks based on the prefix sum value of the $$$cost$$$ array. Specifically, we calculate the prefix sum of the cost array $$$precost$$$, using $$$\frac{precost_i}{B}$$$ as the block number of node $$$i$$$, where $$$B$$$ is the block length parameter.

Assuming we have a data structure that can maintain the value of $$$k$$$-th smallest value in $$$O(1)$$$, using the same analysis method as standard Mo's algorithm, we can get the complexity is $$$O((n+m+q)\sqrt{n+m})$$$.

To find the $$$k$$$-th smallest value without $$$O( \log n)$$$ complexity, we only need to maintain two arrays $$$cnt$$$ and $$$sum$$$, where $$$cnt_i$$$ is the occurrence of value $$$i$$$, and $$$sum_i=\Sigma_{j=(i-1)B+1}^{iB}cnt_j$$$ ($$$B$$$ is the block length parameter). We can perform modification in $$$O(1)$$$ and query in $$$O(\sqrt{n})$$$. The complexity is $$$O((n+q)\sqrt{n})$$$.

Regarding implementation, you need to pay attention to two common pitfalls:

• If you use $$$cost_i=degree_i$$$ instead of $$$cost_i=degree_i+1$$$, the dividing algorithm doesn't work for the graph with many nodes with degree $$$0$$$.

• Similarly, you can not set $$$B=\sqrt{m}$$$.

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

#define all(a) a.begin(),a.end()
#define pb push_back
#define sz(a) ((int)a.size())

using ll=long long;
using u32=unsigned int;
using u64=unsigned long long;
using i128=__int128;
using u128=unsigned __int128;
using f128=__float128;

using pii=pair<int,int>;
using pll=pair<ll,ll>;

template<typename T> using vc=vector<T>;
template<typename T> using vvc=vc<vc<T>>;
template<typename T> using vvvc=vc<vvc<T>>;

using vi=vc<int>;
using vll=vc<ll>;
using vvi=vc<vi>;
using vvll=vc<vll>;

#define vv(type,name,n,...) \
    vector<vector<type>> name(n,vector<type>(__VA_ARGS__))
#define vvv(type,name,n,m,...) \
    vector<vector<vector<type>>> name(n,vector<vector<type>>(m,vector<type>(__VA_ARGS__)))

template<typename T> using min_heap=priority_queue<T,vector<T>,greater<T>>;
template<typename T> using max_heap=priority_queue<T>;

// https://trap.jp/post/1224/
#define rep1(n) for(ll i=0; i<(ll)(n); ++i)
#define rep2(i,n) for(ll i=0; i<(ll)(n); ++i)
#define rep3(i,a,b) for(ll i=(ll)(a); i<(ll)(b); ++i)
#define rep4(i,a,b,c) for(ll i=(ll)(a); i<(ll)(b); i+=(c))
#define cut4(a,b,c,d,e,...) e
#define rep(...) cut4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define per1(n) for(ll i=((ll)n)-1; i>=0; --i)
#define per2(i,n) for(ll i=((ll)n)-1; i>=0; --i)
#define per3(i,a,b) for(ll i=((ll)a)-1; i>=(ll)(b); --i)
#define per4(i,a,b,c) for(ll i=((ll)a)-1; i>=(ll)(b); i-=(c))
#define per(...) cut4(__VA_ARGS__,per4,per3,per2,per1)(__VA_ARGS__)
#define rep_subset(i,s) for(ll i=(s); i>=0; i=(i==0?-1:(i-1)&(s)))

template<typename T, typename S> constexpr T ifloor(const T a, const S b){return a/b-(a%b&&(a^b)<0);}
template<typename T, typename S> constexpr T iceil(const T a, const S b){return ifloor(a+b-1,b);}

template<typename T>
void sort_unique(vector<T> &vec){
    sort(vec.begin(),vec.end());
    vec.resize(unique(vec.begin(),vec.end())-vec.begin());
}

template<typename T, typename S> constexpr bool chmin(T &a, const S b){if(a>b) return a=b,true; return false;}
template<typename T, typename S> constexpr bool chmax(T &a, const S b){if(a<b) return a=b,true; return false;}

template<typename T, typename S> istream& operator >> (istream& i, pair<T,S> &p){return i >> p.first >> p.second;}
template<typename T, typename S> ostream& operator << (ostream& o, const pair<T,S> &p){return o << p.first << ' ' << p.second;}

#ifdef i_am_noob
#define bug(...) cerr << "#" << __LINE__ << ' ' << #__VA_ARGS__ << "- ", _do(__VA_ARGS__)
template<typename T> void _do(vector<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(unordered_set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(T && x) {cerr << x << endl;}
template<typename T, typename ...S> void _do(T && x, S&&...y) {cerr << x << ", "; _do(y...);}
#else
#define bug(...) 777771449
#endif

template<typename T> void print(vector<T> x){for(auto i: x) cout << i << ' ';cout << "\n";}
template<typename T> void print(set<T> x){for(auto i: x) cout << i << ' ';cout << "\n";}
template<typename T> void print(unordered_set<T> x){for(auto i: x) cout << i << ' ';cout << "\n";}
template<typename T> void print(T && x) {cout << x << "\n";}
template<typename T, typename... S> void print(T && x, S&&... y) {cout << x << ' ';print(y...);}

template<typename T> istream& operator >> (istream& i, vector<T> &vec){for(auto &x: vec) i >> x; return i;}

vvi read_graph(int n, int m, int base=1){
    vvi adj(n);
    for(int i=0,u,v; i<m; ++i){
        cin >> u >> v,u-=base,v-=base;
        adj[u].pb(v),adj[v].pb(u);
    }
    return adj;
}

vvi read_tree(int n, int base=1){return read_graph(n,n-1,base);}

template<typename T, typename S> pair<T,S> operator + (const pair<T,S> &a, const pair<T,S> &b){return {a.first+b.first,a.second+b.second};}

template<typename T> constexpr T inf=0;
template<> constexpr int inf<int> = 0x3f3f3f3f;
template<> constexpr ll inf<ll> = 0x3f3f3f3f3f3f3f3f;

template<typename T> vector<T> operator += (vector<T> &a, int val){for(auto &i: a) i+=val; return a;}

template<typename T> T isqrt(const T &x){T y=sqrt(x+2); while(y*y>x) y--; return y;}

#define ykh mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())

//#include<atcoder/all>
//using namespace atcoder;

//using mint=modint998244353;
//using mint=modint1000000007;

const int N=1<<18,K=1<<10;

struct DS{
    int big[N/K],small[N];
    void ins(int x){
        small[x]++;
        big[x>>10]++;
    }
    void del(int x){
        small[x]--;
        big[x>>10]--;
    }
    int kth(int k){
        k--;
        int cur=0;
        while(big[cur]<=k) k-=big[cur++];
        cur<<=10;
        while(small[cur]<=k) k-=small[cur++];
        return cur;
    }
}ds;

void ahcorz(){
    int n,m; cin >> n >> m;
    vvi adj=read_graph(n,m);
    vi block(n);
    int cur=0;
    rep(n){
        if(cur>=n) break;
        int tot=0;
        while(cur<n&&tot<K){
            tot+=sz(adj[cur])+1;
            block[cur++]=i;
        }
    }
    int q; cin >> q;
    vc<array<int,4>> qq(q);
    vi res(q);
    rep(q){
        int l,r,k; cin >> l >> r >> k; l--,r--;
        qq[i]={l,r,k,i};
    }
    sort(all(qq),[&](array<int,4> arr1, array<int,4> arr2){
        if(block[arr1[0]]!=block[arr2[0]]) return block[arr1[0]]<block[arr2[0]];
        if(block[arr1[0]]&1) return arr1[1]>arr2[1];
        else return arr1[1]<arr2[1];
    });
    vi val(n);
    int l=0,r=0;
    ds.ins(0);
    auto ins=[&](int i){
        for(auto j: adj[i]){
            if(j>=l&&j<=r){
                ds.del(val[j]);
                val[j]^=i+1,val[i]^=j+1;
                ds.ins(val[j]);
            }
        }
        ds.ins(val[i]);
    };
    auto del=[&](int i){
        ds.del(val[i]);
        for(auto j: adj[i]){
            if(j>=l&&j<=r){
                ds.del(val[j]);
                val[j]^=i+1,val[i]^=j+1;
                ds.ins(val[j]);
            }
        }
    };
    auto gogo=[&](int l2, int r2){
        while(l>l2){
            ins(l-1);
            l--;
        }
        while(r<r2){
            ins(r+1);
            r++;
        }
        while(l<l2){
            l++;
            del(l-1);
        }
        while(r>r2){
            r--;
            del(r+1);
        }
    };
    for(auto [l2,r2,k,i]: qq){
        gogo(l2,r2);
        res[i]=ds.kth(k);
    }
    rep(i,l,r+1) ds.del(val[i]);
    rep(q) print(res[i]);
}

signed main(){
    ios_base::sync_with_stdio(0),cin.tie(0);
    cout << fixed << setprecision(20);
    int t=1;
    cin >> t;
    while(t--) ahcorz();
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Did you notice the double meaning of the title?

Consider easy version. Try to use only operation $$$1$$$ and $$$3$$$ (Due to symmetry, using operation $$$2$$$ and $$$4$$$ is the same), and only use $$$m=30$$$ in operation $$$1$$$ and $$$m=300$$$ in operation $$$3$$$.

Let $$$S_i$$$ represent the set in which queries element $$$i$$$ is accessed. Make all $$$S_i$$$ different to distinguish all elements.

Greedily choose all $$$S_i$$$ such that $$$|S_i| \lt 3$$$. Afterwards, carefully construct a set of size $$$3$$$ to reach the upper bound.

Suppose there are $$$30$$$ numbers $$$1, 2, …, 30$$$, and each number can be used up to $$$30$$$ times. Can you construct $$$900$$$ distinct triplets?

Consider hard version. How to efficiently utilize the four operations, and the condition $$$m \gt k$$$?

Using operation $$$1$$$ and operation $$$4$$$ is enough. Due to symmetry, using operation $$$2$$$ and $$$3$$$ is the same.

Recall the bottleneck of the easy version. We used too many sets of size $$$3$$$. Let’s say it another way — too many elements were determined at the cost of $$$3$$$. How to optimize it?

Consider $$$S_i=S_j$$$. This actually provides an unordered pair. In other words, we know unordered pair $$$(p_i,p_j)=(x,y)$$$, but we can not determine whether $$$p_i=x$$$ or $$$p_j=x$$$. To determine it, we can add one of $$$x$$$ or $$$y$$$ to the query of type $$$4$$$.

Suppose there are $$$300$$$ unordered pairs $$$(x_1, y_1), (x_2, y_2), …, (x_{300}, y_{300})$$$. We can add one element of $$$(x_i, y_i)$$$ into query $$$4$$$, then query to determine all unordered pairs. However, the average cost is still near to $$$3$$$, which is no better than the easy version.

Try to determine $$$435$$$ unordered pairs using single query $$$4$$$.

Use only operation $$$1$$$ and $$$3$$$, with $$$m=30$$$ in operation $$$1$$$ and $$$m=300$$$ in operation $$$3$$$.

Let $$$S_i$$$ represent the set accessed by query element $$$i$$$. To distinguish all elements, we need to ensure that all $$$S_i$$$ ($$$1 \le i \le n$$$) are distinct.

After selecting all $$$S_i$$$ such that $$$|S_i| \lt 3$$$, we must also construct a set of size $$$3$$$ to reach the upper bound.

Another way to phrase this: We have $$$30$$$ numbers $$$1, 2, \ldots, 30$$$, where $$$1$$$ through $$$29$$$ can each be used $$$30$$$ times, and $$$30$$$ can be used $$$270$$$ times. The goal is to construct as many distinct triplets as possible to maximize the count.

A natural approach is to prioritize consuming the usage count of $$$30$$$. Since $$$29$$$ is prime, the sequence $$$x = [1, k \mod 29 + 1, 2k \mod 29 + 1, \ldots, 28k \mod 29 + 1]$$$ ensures all elements are distinct. For $$$1 \le k \le 9$$$, we can construct triplets $$$(x_1, x_2, 30), (x_2, x_3, 30), \ldots, (x_{29}, x_1, 30)$$$.

After this, $$$1$$$ through $$$29$$$ will each have $$$12$$$ remaining uses, and $$$30$$$ will have $$$9$$$ remaining uses. This distribution is not ideal. Instead, we can use $$$(1, 2, 3)$$$ and $$$(4, 5, 6)$$$ in place of $$$(1, 2, 30), (3, 4, 30),$$$ and $$$(5, 6, 30)$$$. This adjustment ensures that $$$1$$$ through $$$30$$$ each have $$$12$$$ remaining uses.

Define a perfect set $$$S_x$$$ as a set of triplets where each number from $$$1$$$ to $$$x$$$ appears exactly once.

For numbers $$$1, 2, \ldots, 3l$$$, define:

• $$$al = [1, 2, \ldots, l]$$$,

• $$$am = [l+1, l+2, \ldots, 2l]$$$,

• $$$ar = [2l+1, 2l+2, \ldots, 3l]$$$.

Let $$$\text{lshift}(a, i) = [a_{1+i}, a_{2+i}, \ldots, a_{(n+i-1) \mod n + 1}]$$$. Then, define:

We can generate $$$l^2$$$ distinct perfect sets of the form $$$S_l(al, \text{lshift}(am, i), \text{lshift}(ar, j))$$$ for $$$0 \le i, j \le l$$$.

Now that all numbers have equal remaining usage counts, we can apply the above construction.

Using the above construction, there are many different approaches.

Overall, we can construct a total of $$$846$$$ distinct sets, which is sufficient to pass the easy version.

The hard version differs significantly from the easy version in its approach, particularly in utilizing the concept of distinguishing elements through $$$S_i$$$.

We need to efficiently utilize the four operations, and the condition $$$m \gt k$$$.

In this solution, use operation $$$2$$$ $$$29$$$ times and operation $$$3$$$ once.

Consider all sets $$$S_i$$$ with $$$|S_i| \lt 3$$$ and elements in $$$[1,29]$$$, assigning each to exactly two indices, yielding $$$2×(1+29+\frac{29×28}{2})=872$$$ sets forming 436 unordered pairs where $$$S_i=S_j$$$, where we cannot initially determine whether $$$pos_i = x$$$ or $$$pos_j = x$$$.

Consider $$$S_i = S_j$$$. This actually provides an unordered pair $$$(pos_i, pos_j) = (x, y)$$$, where we know the pair of positions but cannot determine whether $$$pos_i = x$$$ and $$$pos_j = y$$$, or $$$pos_i = y$$$ and $$$pos_j = x$$$.

Let these $$$\frac{872}{2} = 436$$$ pairs be denoted as $$$(pos_1, pos_n), (pos_2, pos_{n-1}), \ldots, (pos_{436}, pos_{n-435})$$$ (for convenience, we assume $$$n = 890$$$). Then, randomly select exactly one $$$pos$$$ from each of these pairs, and query the maximum value (considering only one maximum for now) among $$$p[pos_1 \text{ or } pos_n], p[pos_2 \text{ or } pos_{n-1}], \ldots$$$.

Let us analyze what will happen:

We can see ehe expected number of resolved pairs per query:

With an expectation value of $$$2$$$, we can estimate that performing $$$\text{max}$$$ query $$$300$$$ times yields a high probability $$$P \approx 1$$$ of determining all $$$436$$$ unordered pairs $$$(pos_i, pos_j)$$$. This implies that a single application of operation $$$3$$$ suffices to resolve all such pairs.

Through this methodology, we successfully determine $$$872$$$ elements of the permutation $$$p$$$. At this stage, $$$29$$$ query operations remain available (with exactly $$$2$$$ uses permitted), and the determination of all $$$n=890$$$ elements becomes computationally tractable.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1010;
int T,n;
vector<int> Sv[N],Sp[N];

void init()
{
    cin>>n;
    for(int i=1;i<N;i++)
        Sv[i].clear(),Sp[i].clear();
}

vector<int> ask(int ty,vector<int> &v)
{
    cout<<ty<<" "<<v.size();
    for(int i=0;i<v.size();i++)
        cout<<" "<<v[i];
    cout<<"\n"<<flush;
    int k;
    if(ty<3) k=min(60,(int)v.size());
    else k=min(300,(int)v.size());
    vector<int> res;
    for(int i=1;i<=k;i++)
    {
        int t;
        cin>>t;
        res.push_back(t);
    }
    return res;
}

void solve()
{
    int cnt=0;
    vector<int> p(n+4);
    for(int i=1;i<=30;i++)
        Sv[++cnt].push_back(i);
    for(int i=1;i<=30;i++)
    {
        for(int j=i+1;j<=30;j++)
        {
            cnt++;
            Sv[cnt].push_back(i),Sv[cnt].push_back(j);
        }
    }
    for(int i=1;i<=9;i++)
    {
        int cur=1;
        while(1)
        {
            int nxt=cur+i;
            if(nxt>29) nxt-=29;
            cnt++;
            Sv[cnt].push_back(30);
            Sv[cnt].push_back(cur);
            Sv[cnt].push_back(nxt);
            cur=nxt;
            if(nxt==1) break;
        }
    }
    vector<int> vl(11),vm(11),vr(11);
    for(int i=1;i<=10;i++)
        vl[i]=i,vm[i]=10+i,vr[i]=20+i;
    for(int i=1;i<=9;i++)
    {
        for(int j=1;j<=10;j++)
        {
            cnt++;
            Sv[cnt].push_back(vl[j]);
            Sv[cnt].push_back(vm[j]);
            Sv[cnt].push_back(vr[j]);
        }
        for(int j=0;j<10;j++)
            vr[j]=vr[j+1];
        vr[10]=vr[0];
    }
    for(int i=1,cur=1;i<=29;i++)
    {
        int x=cur,y=cur+1,z=cur+2;
        while(x>29) x-=29;
        while(y>29) y-=29;
        while(z>29) z-=29;
        cnt++;
        Sv[cnt].push_back(x);
        Sv[cnt].push_back(y);
        Sv[cnt].push_back(z);
        cur+=3;
    }
    for(int i=1;i<=30;i++)
    {
        vector<int> v,t;
        for(int j=1;j<=n;j++)
            if(find(Sv[j].begin(),Sv[j].end(),i)!=Sv[j].end())
                v.push_back(j);
        if(v.empty()) continue;
        if(i<30) t=ask(2,v);
        else t=ask(4,v);
        for(int j=0;j<t.size();j++)
            Sp[t[j]].push_back(i);
    }
    for(int i=1;i<=n;i++)
         sort(Sp[i].begin(),Sp[i].end()), sort(Sv[i].begin(),Sv[i].end());
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if((!Sp[i].empty())&&Sp[i]==Sv[j]) p[i]=j;
    cout<<"! ";
    for(int i=1;i<=n;i++)
        cout<<p[i]<<(i==n?'\n':' ');
    cout<<flush;
}

int main()
{
    fastio;

    cin>>T;
	while(T--)
	{
		init();
		solve();
	}

	return 0;
}

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1010;
int T,n;
vector<int> Sv[N],Sp[N],prv[N],prp[N];

void init()
{
    srand(time(0));
    cin>>n;
    for(int i=1;i<N;i++)
        Sv[i].clear(),Sp[i].clear(),prv[i].clear(),prp[i].clear();
}

vector<int> ask(int ty,vector<int> &v)
{
    cout<<ty<<" "<<v.size();
    for(int i=0;i<v.size();i++)
        cout<<" "<<v[i];
    cout<<"\n"<<flush;
    int k;
    if(ty<3) k=min(60,(int)v.size());
    else k=min(300,(int)v.size());
    vector<int> res;
    for(int i=1;i<=k;i++)
    {
        int t;
        cin>>t;
        res.push_back(t);
    }
    return res;
}

void solve()
{
    int cnt=0,cntr=871,cntpr=30;
    vector<int> p(n+4);
    for(int i=1;i<=29;i++)
    {
        cnt++;
        Sv[cnt].push_back(i);
        cntr--;
        Sv[cntr].push_back(i);
    }
    for(int i=1;i<=29;i++)
    {
        for(int j=i+1;j<=29;j++)
        {
            cnt++;
            Sv[cnt].push_back(i),Sv[cnt].push_back(j);
            cntr--;
            Sv[cntr].push_back(i),Sv[cntr].push_back(j);
        }
    }
    for(int i=871,hd=1;i<890;i++,hd+=3)
    {
        int x=hd,y=hd+1,z=hd+2;
        if(x>29) x-=29;
        if(y>29) y-=29;
        if(z>29) z-=29;
        Sv[i].push_back(x),Sv[i].push_back(y),Sv[i].push_back(z);
    }
    for(int i=1;i<=29;i++)
    {
        vector<int> v,t;
        for(int j=1;j<=n;j++)
            if(find(Sv[j].begin(),Sv[j].end(),i)!=Sv[j].end())
                v.push_back(j);
        if(v.empty()) continue;
        t=ask(2,v);
        for(int j=0;j<t.size();j++)
            Sp[t[j]].push_back(i);
    }
    for(int i=1;i<=n;i++)
         sort(Sp[i].begin(),Sp[i].end()), sort(Sv[i].begin(),Sv[i].end());
    for(int i=1;i<=n;i++)
    {
        for(int j=871;j<=n;j++)
            if(Sp[i]==Sv[j]) p[i]=j;
    }
    for(int i=1;i<=n;i++)
    {
        if(Sp[i].size()==1) prp[Sp[i][0]].push_back(i);
        else if(Sp[i].size()==2) prp[30*Sp[i][0]+Sp[i][1]].push_back(i);    //hash the set
        //|S|>2 and empty set are ignored
    }
    for(int i=1;i<=n;i++)
    {
        if(Sv[i].size()==1) prv[Sv[i][0]].push_back(i);
        else if(Sv[i].size()==2) prv[30*Sv[i][0]+Sv[i][1]].push_back(i);    //hash the set
    }
    //necessary shuffle
    for(int i=1;i<N;i++)
    {
        if(prp[i].size()<2) continue;
        if(rand()&1) swap(prp[i][0],prp[i][1]);
    }
    for(int i=1;i<=1;i++)
    {
        vector<int> v,t;
        for(int j=1;j<N;j++)
        {
            if(prp[j].empty()) continue;
            else if(prp[j].size()==1)
            {
                p[prp[j][0]]=prv[j][0];
                prp[j].clear();
                prv[j].clear();
                continue;
            }
            v.push_back(prp[j][0]);
        }
        if(v.empty()) continue;
        t=ask(3,v);
        for(int j=1;j<N;j++)
        {
            if(prp[j].empty()) continue;
            if(t.empty()) break;
            if(prv[j][1]==t.back())
            {
                t.pop_back();
                p[prp[j][0]]=prv[j][1];
                p[prp[j][1]]=prv[j][0];
            }
            else
            {
                p[prp[j][0]]=prv[j][0];
                p[prp[j][1]]=prv[j][1];
            }
            prp[j].clear();
            prv[j].clear();
        }
    }
    cout<<"! ";
    for(int i=1;i<=n;i++)
        cout<<p[i]<<(i==n?'\n':' ');
    cout<<flush;
}

int main()
{
    fastio;

    cin>>T;
	while(T--)
	{
		init();
		solve();
	}

	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

We can see if $$$x$$$ is a perfect square, $$$x^x$$$, $$$x^{(x^x)}$$$, $$$\ldots$$$ are also perfect square.

Proof: assume $$$x=y^2$$$, $$$x^z=(y^z) \cdot (y^z)$$$.

So the answer is the number of perfect squares not greater than $$$n$$$.

There are exactly $$$\lfloor \sqrt{n} \rfloor$$$ integers $$$x$$$ (with $$$1 \leq x \leq n$$$) such that $$$x$$$ is a mystic number.

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        cout << static_cast<int>(sqrt(n)) << '\n';
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

If $$$n \leq 3$$$, it's impossible to satisfy the conditions, so the answer is $$$-1$$$.

For $$$n \geq 4$$$, you can construct a valid permutation like $$$[n-1, n-2,. . ., 1, 3, 2, 4]$$$.

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        if(n <= 3)
        {
            cout<<"-1\n";
            continue;
        }
        while(n >= 5)
            cout<<n<<' ',--n;
       cout<<"1 3 2 4\n";
    }
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Let's break the possible values of m (the count of colorfull subarrays) into ranges:

Case 1: m == n

• We only need the n single-element subarrays, each trivially distinct.
• Output any array with all equal elements like [1, 1, 1, ..., 1].
• This ensures no subarray of length > 1 has all distinct elements.
• Total uniqueness value: n. (This is also the minimum m we can achieve)

Case 2: n < m < 2n

• We already get $$$n$$$ uniqueness from 1-element subarrays.
• We now need $$${m - n}$$$ more distinct subarrays of length 2.
• Example: $$$[1, 2, 1, 2]$$$
  Subarrays with indices: $$$[0,1]$$$, $$$[1,2]$$$, $$$[2,3]$$$ contribute 1 to the count → 3 subarrays of length 2 with distinct elements.
• In general, the maximum number of 2-length colorful subarrays we can form in an array of size n is n - 1.
• Hence, we can reach up to m = 2n - 1 using only 1 and 2, and we can alter some prefix/suffix of our array to get any m in this range.

Case 3: m ≥ 2n

• We introduce the third element 3 to push f(a) further.
• Similar construction: start with [1, 2, 3], then alternate like [1,2,3,1,2,...] to get more distinct subarrays.
• Try analyzing how many new colorful subarrays we get of lengths 2 and 3.
• (Try to prove this part yourself): The maximum uniqueness we can achieve is 3n - 3, and any value can be achieved in between. (This is the maximum m we can achieve)
• You can check the prove from the HARD VERSION

So, for m < n or m > 3n - 3 it is not possible!

We know that any array of length $$$n$$$ automatically contributes $$$n$$$ colorful subarrays and so $$$m_{\min}=n$$$ (the single-element ones).

Step 1: Maximum possible $$$m$$$

We want to construct the array to maximize the number of colorful subarrays.
Consider a repeating sequence:

repeated until the array length is $$$n$$$. The total length will be:

Now, examine all subarrays of length $$$p$$$ (a sliding window): - If $$$1 \leq p \leq k$$$: all elements can be distinct (no repetition within the window). - For each such $$$p$$$, there are $$$n - p + 1$$$ windows. - If $$$p \gt k$$$: by the Pigeonhole Principle, at least one element repeats.

Thus, the total number of colorful subarrays is:

Simplifying:

If $$$m \gt m_{\max}(k)$$$ for every $$$k \leq n$$$, it is impossible.

Step 2: Finding the right $$$k$$$

Define:

Find the smallest $$$k$$$ such that:

This means: - $$$k-1$$$ colors cannot reach $$$m$$$, - but $$$k$$$ colors can generate enough colorful subarrays.

Step 3: Constructing the array

Start with the repeating pattern,

This creates exactly $$$\text{bound}[k]$$$ colorful subarrays. If $$$m \lt \text{bound}[k]$$$, we modify the last few elements (by repeating some values smartly) to reduce the number of distinct subarrays until exactly $$$m$$$ remains.

#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 <typename T>
using os = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using oms = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define mod  1000000007
#define mod2 998244353
#define ll long long
#define bl __int128_t
#define pb push_back
#define all(v) v.begin(),v.end()
#define bs binary_search
#define rall(v) v.rbegin(),v.rend()
#define lb lower_bound
#define ub upper_bound
#define pl pair<ll,ll>
#define f(i,n) for(ll i=0;i<n;i++)
#define inp(a,n) vector<ll> a(n); f(i,n) cin>>a[i]
#define pyes cout<<"YES\n"
#define pno cout<<"NO\n"
using Mat = array<array<ll,2>,2>;

#pragma GCC optimize("unroll-loops")
#pragma gcc optimize("Ofast")
#pragma GCC optimization("Ofast")
#pragma optimize(Ofast)
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("popcnt")

ll power(ll x,ll y,ll z=LLONG_MAX){
    ll res=1;
    while(y>0){
        if(y%2) res=(res*x)%z;
        y/=2;
        if(y) x=(x*x)%z;
    }return res%z;
}

ll gcd(ll a,ll b,ll& x,ll& y){
    x=1,y=0;
    ll x1=0,y1=1,a1=a,b1=b;
    while(b1){
        ll q=a1/b1;
        tie(x,x1)=make_tuple(x1,x-q*x1);
        tie(y,y1)=make_tuple(y1,y-q*y1);
        tie(a1,b1)=make_tuple(b1,a1-q*b1);
    }return a1;
}



int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    ll t=1,i,j,n,m,z=1e9+7,z2=998244353,k,x,y,q;
    // sieve(); // for SPF
    cin>>t;
    ll tt=t;
    string s,s2;
    while(tt--){
        ll n, m, k;
        cin >> n >> m >> k;
        if(m < n || m > 3 * n){
            cout << -1 << '\n';
            continue;
        }
        m -= n;
        vector<ll> v;
        v.pb(2);
        v.pb(1);
        for(i = 1; i < n; i++){
            if(m == 0){
                v.pb(v.back());
            }
            else if(m == 1 || i == 1){
                v.pb(v[i - 1]);
                m--;
            }
            else{
                v.pb(v[i] ^ v[i - 1]);
                m -= 2;
            }
        }
        if(m > 0){
            cout << -1 << '\n';
            continue;
        }
        f(i, n) cout << v[i + 1] << ' ';
        cout << '\n';
    }
    return 0;
}

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

int a[1000100];
 
void solve() {
    int n, m, k, mxk = 0;
    cin >> n >> m >> k;
    
    for(int i=1;i<=n;i++)
        mxk+=min(i,k);
        
    if(m < n || m > mxk){
        cout << -1 << "\n";
        return;
    }
    
    if (n == m) {
        for (int i = 0; i < n; i++)
            cout << 1 << " ";
        cout << "\n";
        return;
    }
    auto bound = [&](int p){
        return n*p - p*(p-1)/2;
    };
    for(int i = 1; i < k; ++i){
        if(bound(i) < m && bound(i+1) >= m){
            int kup = i+1;
            int cnt = 1;
            for(int j = 0; j < kup; ++j) a[j] = j+1;
            int ext = m-bound(i);
            int put = kup;
            for(int iter = 0; iter < ext-1; ++iter){
                a[put] = 1+put%kup;
                put++;
            }
            while(put<n){
                a[put] = a[put-(kup-1)];
                put++;
            }
        }
    }
    for(int i = 0; i < n; ++i){
        cout << a[i] << " ";
    }
    cout << "\n";
}
 
int32_t main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    int tc = 1;
    cin >> tc;
    while(tc-- > 0) solve();
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Key Insight

For a given sum $$$s = a + b$$$:

• The condition $$$\gcd(a, b) = 1$$$ simplifies to $$$\gcd(a, s) = 1$$$ because $$$b = s - a$$$

• $$$b \geq 2$$$ implies $$$a \leq s - 2$$$

Thus, for each $$$s$$$, the number of valid integers $$$a$$$ in $$$[1, s-2]$$$ with $$$\gcd(a, s) = 1$$$ is given by Euler's totient function $$$\phi(s)$$$ minus $$$1$$$ (to exclude $$$a = s-1$$$ which would make $$$b=1$$$).

Algorithm Selection

Precompute Euler's Totient Function: Compute $$$\phi(s)$$$ for all $$$s \leq 10^6$$$ using sieve method.

Prefix Sum Array: Build array $$$P$$$ where $$$P[s] = P[s-1] + (\phi(s) - 1)$$$ for $$$s \geq 2$$$ ($$$P[1] = 0$$$).

Efficient Query Processing: Answer each query $$$(l, r)$$$ as $$$P[r] - P[l-1]$$$.

#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 <typename T>
using os = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using oms = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define mod  1000000007
#define mod2 998244353
#define ll long long
#define bl __int128_t
#define pb push_back
#define all(v) v.begin(),v.end()
#define bs binary_search
#define rall(v) v.rbegin(),v.rend()
#define lb lower_bound
#define ub upper_bound
#define pl pair<ll,ll>
#define f(i,n) for(ll i=0;i<n;i++)
#define inp(a,n) vector<ll> a(n); f(i,n) cin>>a[i]
#define pyes cout<<"YES\n"
#define pno cout<<"NO\n"
using Mat = array<array<ll,2>,2>;

#pragma GCC optimize("unroll-loops")
#pragma gcc optimize("Ofast")
#pragma GCC optimization("Ofast")
#pragma optimize(Ofast)
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("popcnt")

ll power(ll x,ll y,ll z=LLONG_MAX){
    ll res=1;
    while(y>0){
        if(y%2) res=(res*x)%z;
        y/=2;
        if(y) x=(x*x)%z;
    }return res%z;
}

ll gcd(ll a,ll b,ll& x,ll& y){
    x=1,y=0;
    ll x1=0,y1=1,a1=a,b1=b;
    while(b1){
        ll q=a1/b1;
        tie(x,x1)=make_tuple(x1,x-q*x1);
        tie(y,y1)=make_tuple(y1,y-q*y1);
        tie(a1,b1)=make_tuple(b1,a1-q*b1);
    }return a1;
}

#define MX 1e6+6
vector<ll> spf(MX+2,1);
vector<ll> gpf(MX+2,0);
void sieve(){
    spf[0]=0;
    for(ll i=2;i<3;i++){
        if(spf[i]==1){
            for(ll j=i;j<MX+1;j+=i) if(spf[j]==1) spf[j]=i;
        }
    }for(ll i=3;i<MX+1;i+=2){
        if(spf[i]==1){
            for(ll j=i;j<MX+1;j+=i) if(spf[j]==1) spf[j]=i;
        }
    }for(ll i=2;i<=MX;i++) if(gpf[i]==0) for(ll j=i;j<=MX;j+=i) gpf[j]=i;
    return; 
}

vector<ll> dp(MX, 0);

void func(){
    dp[3] = 1;
    for(ll i = 4; i < MX; i++){
        vector<ll> pr;
        ll x = i;
        while(x > 1){
            ll y = spf[x];
            while(x % y == 0) x /= y;
            pr.pb(y);
        }
        ll val = i - 2, sz = pr.size();
        ll ans = 0;
        f(j, (1ll << sz)){
            ll pro = 1, cnt = 0;
            f(k, sz) if((1ll << k) & j) pro *= pr[k], cnt++;
            if(cnt % 2) ans -= (val / pro);
            else ans += (val / pro);
        }
        dp[i] = dp[i - 1] + ans;
    }
}

int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    ll t=1,i,j,n,m,z=1e9+7,z2=998244353,k,x,y,q;
    sieve(); // for SPF
    func();
    cin>>t;
    ll tt=t;
    string s,s2;
    while(tt--){
        ll l, r;
        cin >> l >> r;
        cout << dp[r] - dp[l - 1] << '\n';
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

We define a leaf node as a node with only one incident edge (degree 1).

Algorithm Steps:

1. If any node has >2 leaves， the answer is impossible (-1), because at least one leaf will remain undeleted.
2. If any node has exactly 2 leaves (l₁ and l₂)，**delete the path between l₁ and l₂**.
3. Repeat steps 1–2 until no more changes occur.
4. If all remaining nodes have ≤1 leaves, remove one leaf along with its neighbor, then go back to step 1.

Why is this algorithm correct? Let's analyze: we define the connectivity component of "fine" as having no node has>2 leaves, and at most one node has 2 leaves. We will execute step 1 on a "fine" connected component, which remains a "fine" connected component. We define a "good" connectivity component as having no node has>1 leaves. We will execute step 4 on a "good" connected component, which becomes a "good" or "fine" connected component. Through induction, we can prove it. After the first execution of steps 1 and 2, if no node has>2 leaves, then there must be a solution, because after that, all connected components are "fine".

#include <iostream>
#include <vector>
#include <queue>
#include <set>
using namespace std;

vector<vector<int>> g;
vector<int> deg;
vector<bool> deleted;
vector<pair<int, int>> operations;
int n;

bool checkImpossible() {
    for (int u = 1; u <= n; ++u) {
        int leaf_neighbors = 0;
        for (int v : g[u]) {
            if (deg[v] == 1) {
                leaf_neighbors++;
            }
        }
        if (leaf_neighbors > 2) {
            return true;
        }
    }
    return false;
}

void deleteTwoLeaves() {
    while (true) {
        bool found = false;
        for (int u = 1; u <= n; ++u) {
            if (deleted[u]) continue;
            int leaf_neighbors = 0;
            vector<int> leaves;
            for (int v : g[u]) {
                if (!deleted[v] && deg[v] == 1) {
                    leaf_neighbors++;
                    leaves.push_back(v);
                }
            }
            if (leaf_neighbors == 2) {
                operations.push_back({leaves[0], leaves[1]});
                deleted[leaves[0]] = deleted[leaves[1]] = deleted[u] = true;
                for (int v : g[u]) {
                    if (!deleted[v]) {
                        deg[v]--;
                    }
                }
                found = true;
                break;
            }
        }
        if (!found) break;
    }
}

bool checkRemainingNodes() {
    for (int u = 1; u <= n; ++u) {
        if (!deleted[u] && deg[u] == 0) {
            return true;
        }
    }
    for (int u = 1; u <= n; ++u) {
        if (deleted[u]) continue;
        int leaf_neighbors = 0;
        for (int v : g[u]) {
            if (!deleted[v] && deg[v] == 1) {
                leaf_neighbors++;
            }
        }
        if (leaf_neighbors > 2) {
            return true;
        }
    }
    return false;
}

void deleteRemainingNodes() {
    while (true) {
        bool all_deleted = true;
        for (int u = 1; u <= n; ++u) {
            if (!deleted[u]) {
                all_deleted = false;
                break;
            }
        }
        if (all_deleted) break;

        bool found = false;
        for (int u = 1; u <= n; ++u) {
            if (deleted[u]) continue;
            int leaf_neighbors = 0;
            vector<int> leaves;
            for (int v : g[u]) {
                if (!deleted[v] && deg[v] == 1) {
                    leaf_neighbors++;
                    leaves.push_back(v);
                }
            }
            if (leaf_neighbors == 2) {
                operations.push_back({leaves[0], leaves[1]});
                deleted[leaves[0]] = deleted[leaves[1]] = deleted[u] = true;
                for (int v : g[u]) {
                    if (!deleted[v]) {
                        deg[v]--;
                    }
                }
                found = true;
                break;
            }
        }
        if (found) continue;

        for (int u = 1; u <= n; ++u) {
            if (!deleted[u] && deg[u] == 1) {
                for (int v : g[u]) {
                    if (!deleted[v]) {
                        operations.push_back({u, v});
                        deleted[u] = deleted[v] = true;
                        for (int w : g[v]) {
                            if (!deleted[w]) {
                                deg[w]--;
                            }
                        }
                        found = true;
                        break;
                    }
                }
                if (found) break;
            }
        }
        if (!found) {
            cout << -1 << endl;
            return;
        }
    }
}

void solve() {
    cin >> n;
    g.assign(n + 1, vector<int>());
    deg.assign(n + 1, 0);
    deleted.assign(n + 1, false);
    operations.clear();

    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
        deg[u]++;
        deg[v]++;
    }

    if (checkImpossible()) {
        cout << -1 <<endl;
        return;
    }

    deleteTwoLeaves();

    if (checkRemainingNodes()) {
        cout << -1 <<endl;
        return;
    }

    deleteRemainingNodes();

    cout << operations.size() << endl;
    for (auto op : operations) {
        cout << op.first << " " << op.second << endl;
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

1. Observation

The product of:
— Number of non-leaf nodes, and
— Minimum degree among non-leaf nodes
is $$$O(n)$$$.

2. Dynamic Programming (DP) State Definition

• State: dp[v][j][k][m] where:
• v: Current node.
• j: Sum of values for all nodes in the subtree rooted at v.
• k: Binary weight of node v (0 or 1).
• m: Binary weight of v's parent (0 or 1).

• Recurrence Relation:

with the constraint $$$\sum t_x = j - k - m$$$ over all children $$$\text{son}_x$$$.

3. Critical Optimization

• Leaf Node Skipping:
  Direct computation of this DP would lead to TLE. Instead:
• Skip leaf nodes during DP traversal.
• This reduces redundant calculations by exploiting tree sparsity.

4. Final Complexity

• Optimized runtime: $$$O(n \sqrt{n})$$$

Thanks Ming_Xu for this solution.

TheForces #43: F (Equal Node Sum)

Note that the sum of all degrees in a tree is exactly $$$2 \cdot (n - 1) = 2n - 2$$$.

Observation 1: Observe that "For each non-leaf node, its sum value is equal to the sum value of every other non-leaf node." means that all non-leaf vertices must have the same sum value. The maximum sum value of a vertex is the degree of the vertex (which is maximized if all incident edges have weight $$$1$$$).

Let $$$\mathcal X := { v \in V \; \vert \; v\text{ is not a leaf } }$$$ (all non-leaf vertices) and let $$$\alpha := \min_{u \in \mathcal X} \mathrm{deg}(u)$$$ (min degree among all non-leaf vertices). Clearly, the maximum possible sum value must be less than or equal to $$$\alpha$$$ by Observation 1. Additionally, $$$|\mathcal X| \cdot \alpha \le 2n - 2$$$, since $$$|\mathcal X| \cdot \alpha$$$ counts a subset of all "degrees".

So the idea is as follows:

For all $$$k \in [0; \alpha]$$$, we calculate the number of different assignments where the sum value of all non-leaf vertices is equal to $$$k$$$.

The answer for $$$k = 0$$$ is trivial (set everything to $$$0$$$ — that's the only assignment), so let's fix $$$k \in [1; \alpha]$$$. Let $$$f(u, a)$$$ be the number of ways to assign weights to edges within the subtree of u such that all non-leaf descendants of $$$u$$$ have a sum value of $$$k$$$, and the sum of weights on edges from $$$u$$$ to its children is $$$a$$$. This means that if $$$a = k$$$, we don't need to set the edge weight to the parent of $$$u$$$ to $$$1$$$. Conversely, if $$$a = k - 1$$$, we would still need to set the weight of the edge to the parent to $$$1$$$. Let's call the number of such assignments $$$f(u, a)$$$.

For now, let's pretend that $$$f(u, a) = 1$$$ for all leaves (there's one (empty) assignment of the (empty) subtree of the leaf where we don't need to set the weight of the edge to the parent of $$$u$$$ to $$$1$$$ and there's also one assignment where we set the weight to $$$1$$$). Let $$$\mathcal C_u$$$ be the (direct) children of $$$u$$$. Assume that we knew $$$f(v, a)$$$ for all children $$$v \in \mathcal C_u$$$ — we could then calculate $$$f(u, a)$$$:

If we "take" a child which currently only has a sum value of $$$k - 1$$$, then we will set the weight to $$$1$$$ of the edge from that child to $$$u$$$, i.e. also increasing the sum value of $$$u$$$ by one. In total, we need to do this $$$a$$$ times to have a sum value of $$$a$$$. Doing this for all subsets (with size $$$a$$$) of $$$\mathcal C_u$$$ is too slow — instead, we can use a $$$\mathcal O(|\mathcal C_u| \cdot (k + 1))$$$ DP to calculate $$$f(u, k - 1)$$$ and $$$f(u, k)$$$ (simultaneously):

Let $$$d(i, j)$$$ denote the number of different assignments among the first $$$i$$$ children, such that the first $$$i$$$ children have a sum value of $$$k$$$ (or are leaves) and such that the current sum value of $$$u$$$ is $$$j$$$ (i.e. we set the weight of $$$j$$$ edges, to the first $$$i$$$ children, to $$$1$$$). The base case is $$$d(0, 0) = 1$$$. For $$$i \gt 0$$$, we have:

Unfortunately, this will be too slow. Observe that we essentially want to compute the following:

This can be easily seen from the DP transitions. Using divide-and-conquer and truncating the polynomials to the first $$$k + 1$$$ coefficients in intermediate steps, we can calculate $$$f(u, a)$$$ for $$$a \in [k - 1, k]$$$ in $$$\mathcal O(|\mathcal C_u| \log^2 |\mathcal C_u|)$$$ (keep in mind that $$$k \in \mathcal O(|\mathcal C_u|)$$$, so $$$k$$$ won't show up here).

If we naïvely implement such a DFS, we won't be able to use the fact that $$$|\mathcal X| \cdot \alpha \le 2n - 2$$$, since we will visit all leaf vertices in the worst case (e.g. consider the star graph; here, $$$\alpha \in [1; n - 1]$$$, but we would visit every vertex $$$\mathcal O(n)$$$ times!).

To circumvent this, we perform two small optimizations:

1) Simply delete all leaf vertices, but remember how many children were leafs for every non-leaf vertex. Let's call this number $$$L_u$$$.

2) Now we need to fix our calculation of $$$f(u, a)$$$, since we are not allowed to directly use the polynomials of the leaf vertices anymore. Let $$$\mathcal P$$$ denote the product of the polynomials that are non-leaf vertices. Then, remember that for leaf vertices, our polynomial was $$$1 + x$$$, so the product of the polynomials of all leaf vertices is $$$\mathcal Q = (1 + x)^{L_u} = \sum_{i = 0}^{L_u} \binom{L_u}{i} x^i$$$. Since $$$f(u, a) = [x^a](P \cdot Q)$$$, we need to find the coefficients of $$$x^a$$$ in $$$P \cdot Q$$$. Luckily, a simple for-loop is enough here (since we only need two coefficients).

Let's analyze the time complexity:

1) Preprocessing can be done in $$$\mathcal O(n)$$$ time 2) To find the number of different assignments for a fixed $$$k$$$, we only need to consider non-leaf vertices:

Since $$$|\mathcal C_u| \ge \alpha \ge k$$$, we know that $$$k = \mathcal O(|\mathcal C_u|)$$$:

Now, summing over all $$$k \in [1; \alpha]$$$:

Thus, the final time complexity is $$$\mathcal O(n \log^2 n)$$$.

$$$(1)$$$: We iterate over all coefficients of $$$\mathcal P$$$ of $$$x^i$$$ for $$$i \le k$$$ and calculate its contribution to $$$x^a$$$. This only involves multiplying that coefficient with the unique coefficient $$$[x^{a - i}] \mathcal Q$$$, which is a binomial coefficient. Thus, this contribution for a fixed coefficient of $$$\mathcal P$$$ is found in (amortized) $$$\mathcal O(1)$$$ time. Calculating $$$[x^a] (\mathcal P \cdot \mathcal Q)$$$ thus takes $$$\mathcal O(\min { k, |\mathcal C_u \cap \mathcal X| }) = \mathcal O(|\mathcal C_u \cap \mathcal X|)$$$ time.

$$$(2)$$$: Note that $$$\sum_{x \in \mathcal X} |\mathcal C_u \cap \mathcal X|$$$ is equivalent to the degree count between two non-leaf vertices, i.e. is two times the number of edges between non-leaf vertices. Since the non-leaf vertices form a tree, $$$\sum_{x \in \mathcal X} |\mathcal C_u \cap \mathcal X| = 2|\mathcal X| - 2 \le \mathcal O(|\mathcal X|)$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
using namespace std;
typedef double db; 
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=998244353;
const ll  INF=2147483647;
int T,n,min_deg;
vector<int> G[N];
vector<ll>  dp[N][2];

//-------------------------------------------------
ll fac[N],inv[N];

ll pw(ll x,ll p)
{
	if(!p) return 1;
	ll y=pw(x,p>>1);
	y=(y*y)%TMD;
	if(p&1) y=(y*(x%TMD))%TMD;
	return y;
}

void init()
{
	fac[0]=1;
	for(int i=1;i<N;i++) fac[i]=(fac[i-1]*i)%TMD;
	inv[N-1]=pw(fac[N-1],TMD-2);
 	for(int i=N-2;i>=0;i--) inv[i]=(inv[i+1]*(i+1))%TMD;
}

ll C(int n,int m)
{
	if(n<m||n<0||m<0) return 0;
	return fac[n]*inv[m]%TMD*inv[n-m]%TMD; 
}

ll A(int n,int m)
{
	if(n<m||n<0||m<0) return 0;
	return fac[n]*inv[n-m]%TMD; 
}

ll INV(ll x)
{
    return pw(x,TMD-2);
}

//-------------------------------------------------

void DP(int x,int fa)
{
	if(x!=1&&G[x].size()==1) return ;
	for(int i=0;i<=1;i++)
	{
		dp[x][i].clear();
		dp[x][i].resize(min_deg+1);
	}
	int cl=0;
	vector<int> nl;
	for(int i=0;i<G[x].size();i++)
	{
		int y=G[x][i];
		if(y==fa) continue;
		DP(y,x);
		if(G[y].size()==1) cl++;
		else               nl.push_back(y);
	}
	for(int sum=0;sum<=min_deg;sum++)
	{
		for(int b=0;b<=1;b++)
		{
			//int cl=0,cnl=0;
			vector<ll> dps(min((int)nl.size(),min_deg)+2),tmp(min((int)nl.size(),min_deg)+2);
			dps[b]=1;
		for(int i=0;i<nl.size();i++)
    	{
    		int y=nl[i];
			    tmp[0]=dps[0]*dp[y][0][sum]%TMD;
			    for(int j=1;j<=min(i+1,min_deg)+1;j++)
				    tmp[j]=(dps[j-1]*dp[y][1][sum]+dps[j]*dp[y][0][sum])%TMD;
			    for(int j=0;j<=min(i+1,min_deg)+1;j++) dps[j]=tmp[j];
    	}
    	for(int j=0;j<=min((int)nl.size(),min_deg)+1;j++)
		    dp[x][b][sum]=(dp[x][b][sum]+dps[j]*C(cl,sum-j))%TMD;
    	//
    	//for(int j=0;j<=min(cnl+1,min_deg);j++)
    	//    printf("dp[%d][%d][%d]=%I64d\n",x,b,sum,dp[x][b][sum]);
    	//
		}
	}
}

int main()
{
	//freopen("test.in","r",stdin);
	
	init();
	scanf("%d",&T);
	while(T--)
	{
        scanf("%d",&n);
        for(int i=1;i<=n;i++) G[i].clear();
        for(int i=1;i<n;i++)
        {
        	int u,v;
        	scanf("%d%d",&u,&v);
        	G[u].push_back(v);
        	G[v].push_back(u);
        }
        min_deg=G[1].size();
        for(int i=2;i<=n;i++)
		    if(G[i].size()!=1) min_deg=min(min_deg,(int)G[i].size());
        DP(1,0); 
        ll  ans=0;
        for(int i=0;i<dp[1][0].size();i++) ans=(ans+dp[1][0][i])%TMD;
        printf("%I64d\n",ans);
	}
	
	//fclose(stdin);
	return 0;
}

fn main() {
    let _io = io();
    for _ in 0..r!(U) {
        let n = r!(U);
        let mut edges = vec![vec![]; n];
        for _ in 1..n {
            let (u, v) = r!(usize, usize);
            edges[u - 1].push(v - 1);
            edges[v - 1].push(u - 1);
        }
        for u in 0..n {
            edges[u].sort_unstable();
        }
        fn dfs1(u: U, p: U, edges: &mut Vec<Vec<U>>, leafs: &mut Vec<U>) -> U {
            if edges[u].len() == 1 && edges[u][0] == p {
                return U::MAX;
            }
            let mut mn = U::MAX;
            let mut tbr = vec![];
            for &v in &edges[u].clone() {
                if v != p {
                    let x = dfs1(v, u, edges, leafs);
                    if x == U::MAX {
                        tbr.push(v)
                    }
                    mn = mn.min(x);
                }
            }
            leafs[u] = tbr.len();
            tbr.push(U::MAX);
            let mut new = vec![];
            let mut i = 0;
            let mut j = 0;
            while i < edges[u].len() {
                if edges[u][i] == tbr[j] {
                    i += 1;
                    j += 1;
                } else if edges[u][i] < tbr[j] {
                    new.push(edges[u][i]);
                    i += 1;
                } else {
                    j += 1;
                }
            }
            edges[u] = new;
            mn.min(edges[u].len() + leafs[u])
        }
        let mut leafs = vec![0; n];
        let mx = dfs1(0, 0, &mut edges, &mut leafs);
        fn dfs2(u: U, p: U, edges: &Vec<Vec<U>>, leafs: &Vec<U>, k: U) -> (N, N) {
            // (s == k, s == k - 1)
            let mut polys = vec![vec![N::ONE]];
            for &v in &edges[u] {
                if v != p {
                    let (a, b) = dfs2(v, u, edges, leafs, k);
                    polys.push(vec![a, b]);
                }
            }
            fn work(mut polys: Vec<Vec<N>>, k: U) -> Vec<N> {
                if polys.is_empty() {
                    vec![]
                } else if polys.len() == 1 {
                    polys.remove(0)
                } else {
                    let m = polys.len() >> 1;
                    let new = polys.split_off(m);
                    let r1 = work(polys, k);
                    let r2 = work(new, k);
                    let mut res = multiply(r1, r2);
                    res.truncate(k + 2);
                    res
                }
            }
            let mut n1 = N::ZERO;
            let mut n0 = N::ZERO;
            let leafs = leafs[u];
            for (i, r) in work(polys, k).into_iter().enumerate() {
                for (j, nn) in [(k, &mut n0), (k - 1, &mut n1)] {
                    if i > j {
                        continue;
                    }
                    let d = j - i;
                    *nn += r * leafs.choose(d);
                }
            }
            (n0, n1)
        }
        let mut ans = N::ONE;
        for k in 1..=mx {
            ans += dfs2(0, 0, &edges, &leafs, k).0;
        }
        w!(ans);
    }
}

static mut SEEN: Vec<(N, N)> = Vec::new();

#[allow(static_mut_refs)]
fn get_seen() -> &'static mut Vec<(N, N)> {
    unsafe { &mut SEEN }
}

/// use `init_seen` to get initial "dp" memoization table, doubles size on miss (why not)
pub trait Combinatorics {
    fn choose(self, k: usize) -> N;
    fn fact(self) -> N;
    fn inv_fact(self) -> N;
}
impl Combinatorics for usize {
    fn choose(self, k: usize) -> N {
        if self < k {
            N::ZERO
        } else {
            self.fact() * (self - k).inv_fact() * k.inv_fact()
        }
    }
    fn fact(self) -> N {
        let seen = get_seen();
        while self >= seen.len() {
            init_seen(seen);
        }
        seen[self].0
    }
    fn inv_fact(self) -> N {
        let seen = get_seen();
        while self >= seen.len() {
            init_seen(seen);
        }
        seen[self].1
    }
}
fn init_seen(seen: &mut Vec<(N, N)>) {
    if seen.is_empty() {
        seen.push((N::ONE, N::ONE));
    }
    let mut cur = seen.l().0;
    let mut cur_inv = seen.l().1;
    for i in seen.len()..seen.len() * 2 {
        cur *= N::new(i);
        cur_inv /= N::new(i);
        seen.push((cur, cur_inv));
    }
}

// require mod_int

// to find primitive roots: https://www.wolframalpha.com/input/?i=PrimitiveRoots%5B%5B%2F%2Fnumber%3A998244353%2F%2F%5D%5D
const C: usize = 119;
const ROOT_PW: usize = 1 << 23;
const G: M = M::new(3);
const ROOT: M = G.pow(C);
const ROOT_1: M = ROOT.inv();
type M = Mod;

// from https://cp-algorithms.com/algebra/fft.html#number-theoretic-transform
pub fn fft(a: &mut Vec<M>, invert: bool) {
    let n = a.len();

    let mut j = 0;
    for i in 1..n {
        let mut bit = n >> 1;
        while j & bit != 0 {
            j ^= bit;
            bit >>= 1;
        }
        j ^= bit;
        if i < j {
            a.swap(i, j);
        }
    }

    let mut len = 2;
    while len <= n {
        let mut wlen = if invert { ROOT_1 } else { ROOT };
        let mut i = len;
        while i < ROOT_PW {
            wlen *= wlen;
            i <<= 1;
        }
        for i in (0..n).step_by(len) {
            let mut w = M::ONE;
            for j in 0..len / 2 {
                let u = a[i + j];
                let v = a[i + j + len / 2] * w;
                a[i + j] = u + v;
                a[i + j + len / 2] = u - v;
                w *= wlen;
            }
        }

        len <<= 1;
    }

    if invert {
        let n_1 = M::new(n).inv();
        for x in a {
            *x *= n_1;
        }
    }
}

pub fn multiply(mut fa: Vec<M>, mut fb: Vec<M>) -> Vec<M> {
    let n = (fa.len() + fb.len()).next_power_of_two();

    fa.resize(n, M::ZERO);
    fb.resize(n, M::ZERO);

    fft(&mut fa, false);
    fft(&mut fb, false);
    for (fai, fbi) in fa.iter_mut().zip(fb) {
        *fai *= fbi;
    }
    fft(&mut fa, true);

    fa
}

const MOD: usize = 998_244_353;
// const MOD: usize = 1_000_000_007;
type N = Mod;

use std::ops::*;

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
pub struct Mod(pub usize);
#[allow(unused)]
impl Mod {
    const ZERO: Self = Self::new(0);
    const NEG_ONE: Self = Self::newi(-1);
    const ONE: Self = Self::new(1);
    const TWO: Self = Self::new(2);
    const NEG_TWO: Self = Self::newi(-2);
    const INV_TWO: Self = Self::new(2).inv();

    pub const fn newi(x: isize) -> Self {
        Self::new(((x % MOD as isize) + MOD as isize) as usize)
    }

    fn new2(x: usize) -> Self {
        debug_assert!(x < MOD << 1);
        if x >= MOD { Self(x - MOD) } else { Self(x) }
    }

    pub const fn new(x: usize) -> Self {
        Self(x % MOD)
    }
    pub const fn pow(self, mut e: usize) -> Self {
        let mut res = Self(1);
        let mut cur = self;
        while e > 0 {
            if e & 1 == 1 {
                res = res.fast_mul(cur);
            }
            cur = cur.fast_mul(cur);
            e >>= 1;
        }
        res
    }
    pub const fn inv(self) -> Self {
        #[cfg(debug_assertions)]
        if self.0 == 0 {
            panic!("Division by `0`.");
        }
        self.pow(MOD - 2)
    }

    pub const fn fast_mul(self, rhs: Self) -> Self {
        if MOD < u32::MAX as usize {
            Self((self.0 * rhs.0) % MOD)
        } else {
            Self(((self.0 as u128 * rhs.0 as u128) % MOD as u128) as usize)
        }
    }
}
impl std::iter::Sum for Mod {
    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(Self::ZERO, |a, b| a + b)
    }
}
impl std::iter::Product for Mod {
    fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(Self::ONE, |a, b| a * b)
    }
}
impl std::fmt::Display for Mod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.pad_integral(true, "", &self.0.to_string())
    }
}
impl AsRef<usize> for Mod {
    fn as_ref(&self) -> &usize {
        &self.0
    }
}
impl AsMut<usize> for Mod {
    fn as_mut(&mut self) -> &mut usize {
        &mut self.0
    }
}
impl Add for Mod {
    type Output = Self;
    fn add(self, rhs: Self) -> Self {
        Self::new2(self.0 + rhs.0)
    }
}
impl Add<usize> for Mod {
    type Output = Self;
    fn add(self, rhs: usize) -> Self {
        self + Self::new(rhs)
    }
}
impl Sub for Mod {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self {
        Self::new2(self.0 + MOD - rhs.0)
    }
}
impl Sub<usize> for Mod {
    type Output = Self;
    fn sub(self, rhs: usize) -> Self {
        self - Self::new(rhs)
    }
}
impl Mul for Mod {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self {
        self.fast_mul(rhs)
    }
}
impl Mul<usize> for Mod {
    type Output = Self;
    fn mul(self, rhs: usize) -> Self {
        if MOD < u32::MAX as usize {
            Self((self.0 * rhs) % MOD)
        } else {
            Self(((self.0 as u128 * rhs as u128) % MOD as u128) as usize)
        }
    }
}
impl Div for Mod {
    type Output = Self;
    fn div(self, rhs: Self) -> Self {
        self * rhs.inv()
    }
}
impl Div<usize> for Mod {
    type Output = Self;
    fn div(self, rhs: usize) -> Self {
        self * Mod::new(rhs).inv()
    }
}
impl Neg for Mod {
    type Output = Self;

    fn neg(self) -> Self::Output {
        if self.0 == 0 {
            self
        } else {
            Self(MOD - self.0)
        }
    }
}
impl Neg for &Mod {
    type Output = Mod;

    fn neg(self) -> Self::Output {
        -*self
    }
}
macro_rules! impl_mod_rest {
    ($($trait:ident::$fn:ident:$trait_assign:ident::$fn_assign:ident;)*) => {
        $(
            impl $trait<&Mod> for Mod {
                type Output = Mod;

                fn $fn(self, rhs: &Mod) -> Self::Output {
                    $trait::$fn(self, *rhs)
                }
            }
            impl $trait<&Mod> for &Mod {
                type Output = Mod;

                fn $fn(self, rhs: &Mod) -> Self::Output {
                    $trait::$fn(*self, *rhs)
                }
            }
            impl $trait<Mod> for &Mod {
                type Output = Mod;

                fn $fn(self, rhs: Mod) -> Self::Output {
                    $trait::$fn(*self, rhs)
                }
            }
            impl $trait<&usize> for Mod {
                type Output = Mod;

                fn $fn(self, rhs: &usize) -> Self::Output {
                    $trait::$fn(self, *rhs)
                }
            }
            impl $trait<&usize> for &Mod {
                type Output = Mod;

                fn $fn(self, rhs: &usize) -> Self::Output {
                    $trait::$fn(*self, *rhs)
                }
            }
            impl $trait<usize> for &Mod {
                type Output = Mod;

                fn $fn(self, rhs: usize) -> Self::Output {
                    $trait::$fn(*self, rhs)
                }
            }
            impl $trait_assign for Mod {
                fn $fn_assign(&mut self, rhs: Mod) {
                    *self = $trait::$fn(*self, rhs);
                }
            }
            impl $trait_assign<&Mod> for Mod {
                fn $fn_assign(&mut self, rhs: &Mod) {
                    *self = $trait::$fn(*self, rhs);
                }
            }
            impl $trait_assign<usize> for Mod {
                fn $fn_assign(&mut self, rhs: usize) {
                    *self = $trait::$fn(*self, rhs);
                }
            }
            impl $trait_assign<&usize> for Mod {
                fn $fn_assign(&mut self, rhs: &usize) {
                    *self = $trait::$fn(*self, rhs);
                }
            }
        )*
    };
}
impl_mod_rest! {
    Add::add:AddAssign::add_assign;
    Sub::sub:SubAssign::sub_assign;
    Mul::mul:MulAssign::mul_assign;
    Div::div:DivAssign::div_assign;
}

pub fn lcm(u: U, v: U) -> U {
    u * v / gcd(u, v)
}
// gcd from wiki: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
pub fn gcd(mut u: U, mut v: U) -> U {
    if u == 0 {
        return v;
    } else if v == 0 {
        return u;
    }

    let i = u.trailing_zeros();
    u >>= i;
    let j = v.trailing_zeros();
    v >>= j;
    let k = std::cmp::min(i, j);
    loop {
        if u > v {
            std::mem::swap(&mut u, &mut v);
        }
        v -= u;
        if v == 0 {
            return u << k;
        }
        v >>= v.trailing_zeros();
    }
}
/// Slower but more robust RNG
pub mod rng2 {
    pub struct Rng {
        seed: u64,
    }
    impl Rng {
        pub fn new() -> Self {
            Self {
                seed: std::time::SystemTime::now()
                    .duration_since(std::time::SystemTime::UNIX_EPOCH)
                    .unwrap()
                    .as_nanos() as u64,
            }
        }

        pub fn next(&mut self) -> u64 {
            use std::num::Wrapping;
            let mut x = Wrapping(self.seed);
            x += Wrapping(0x9e3779b97f4a7c15);
            x = (x ^ (x >> 30)) * Wrapping(0xbf58476d1ce4e5b9);
            x = (x ^ (x >> 27)) * Wrapping(0x94d049bb133111eb);
            x ^= x >> 31;
            self.seed = x.0;
            return self.seed;
        }

        pub fn next_u64(&mut self) -> u64 {
            self.next()
        }

        pub fn next_u128(&mut self) -> u128 {
            let (l, u) = (self.next_u64(), self.next_u64());
            ((l as u128) << 64) | u as u128
        }

        pub fn next_u(&mut self) -> usize {
            self.next_u64() as usize
        }
    }
}
pub struct Rng {
    seed: u32,
}
impl Rng {
    pub fn new() -> Self {
        Self {
            seed: std::time::SystemTime::now()
                .duration_since(std::time::SystemTime::UNIX_EPOCH)
                .unwrap()
                .subsec_nanos(),
        }
    }

    pub fn next(&mut self) -> u32 {
        self.seed ^= self.seed << 13;
        self.seed ^= self.seed >> 17;
        self.seed ^= self.seed << 5;
        self.seed
    }

    pub fn next_u64(&mut self) -> u64 {
        let (l, u) = (self.next(), self.next());
        ((l as u64) << 32) | u as u64
    }

    pub fn next_u128(&mut self) -> u128 {
        let (l, u) = (self.next_u64(), self.next_u64());
        ((l as u128) << 64) | u as u128
    }

    pub fn next_u(&mut self) -> usize {
        self.next_u64() as usize
    }
}
pub trait IterExt<T> {
    fn n(&mut self) -> T;
    fn cv(self) -> Vec<T>;
}
impl<T, I: Iterator<Item = T>> IterExt<T> for I {
    fn cv(self) -> Vec<T> {
        self.collect()
    }

    fn n(&mut self) -> T {
        self.next().unwrap()
    }
}
pub trait IterExt2<T: PartialOrd> {
    fn mn(self) -> T;
    fn mx(self) -> T;
}

impl<T: PartialOrd, I: IntoIterator<Item = T>> IterExt2<T> for I {
    fn mn(self) -> T {
        self.into_iter()
            .min_by(|a, b| a.partial_cmp(b).unwrap())
            .unwrap()
    }
    fn mx(self) -> T {
        self.into_iter()
            .max_by(|a, b| a.partial_cmp(b).unwrap())
            .unwrap()
    }
}
pub trait IterExt3<T: ToString> {
    fn to_string(self, sep: &str) -> String;
}
impl<T: ToString, I: IntoIterator<Item = T>> IterExt3<T> for I {
    fn to_string(self, sep: &str) -> String {
        self.into_iter().map(|x| x.to_string()).cv().join(sep)
    }
}
pub trait IterExt4<T: Clone> {
    fn l(&self) -> T;
}
impl<T: Clone> IterExt4<T> for Vec<T> {
    fn l(&self) -> T {
        self[self.len() - 1].clone()
    }
}
impl<T: Clone> IterExt4<T> for &[T] {
    fn l(&self) -> T {
        self[self.len() - 1].clone()
    }
}
impl<T: Clone> IterExt4<T> for &mut [T] {
    fn l(&self) -> T {
        self[self.len() - 1].clone()
    }
}

pub use lib::*;
#[allow(unused)]
mod lib {
    pub type U = usize;
    pub type I = isize;
    pub type F = f64;

    pub use std::cmp::{Ordering, Reverse};
    pub use std::collections::*;
    pub use std::f64::consts::*;
    pub use std::fmt::Write;
    use std::io::*;
    use std::iter::Filter;
    use std::str::{Split, SplitWhitespace};
    pub struct Output(String);
    impl AsRef<String> for Output {
        fn as_ref(&self) -> &String {
            &self.0
        }
    }
    impl AsMut<String> for Output {
        fn as_mut(&mut self) -> &mut String {
            &mut self.0
        }
    }
    static mut OUTPUT: Output = Output(String::new());
    #[inline(always)]
    #[allow(static_mut_refs)]
    pub fn output() -> &'static mut Output {
        unsafe { &mut OUTPUT }
    }
    #[macro_export]
    macro_rules! w {
    () => {{
        let _ = writeln!(output().as_mut());
    }};
    ($t:expr) => {{
        let _ = writeln!(output().as_mut(), "{}", $t);
    }};
    ($$$start:expr $$$(,$$$t:expr)* $$$(,)?) => {{
        let o = output().as_mut();
        let _ = write!(o, "{}", $start);
        $(
            let _ = write!(o, " {}", $t);
        )*
        let _ = writeln!(o);
    }};
}
    type InputInner = (Split<'static, &'static [char]>, String);
    pub struct Input(InputInner); // must drop both at the same time (or the iterator first)
    impl Input {
        #[inline(always)]
        pub fn get_next(&mut self) -> &'static str {
            loop {
                if let Some(n) = self.0.0.next() {
                    if !n.is_empty() {
                        return n;
                    }
                } else {
                    self.0 = read_next_line();
                }
            }
        }
    }
    const SKIP_CHARS: [char; 5] = [' ', '\n', '\r', '\t', ','];
    fn read_next_line() -> InputInner {
        let mut s = String::new();
        stdin().read_line(&mut s).unwrap();
        let ss: &'static mut str = unsafe { std::mem::transmute(s.as_mut_str()) };
        (ss.split(&SKIP_CHARS), s)
    }
    static mut INPUT: Option<Input> = None;
    #[inline(always)]
    #[allow(static_mut_refs)]
    pub fn input() -> &'static mut Input {
        unsafe { INPUT.as_mut().unwrap_unchecked() }
    }
    pub trait Parse {
        type ParsesTo;

        #[inline(always)]
        fn parse(i: &mut Input) -> Self::ParsesTo;
    }
    pub struct IO;
    impl Drop for IO {
        fn drop(&mut self) {
            print!("{}", output().0);
        }
    }
    macro_rules! impl_parse {
    ($($t:tt),*) => {
        $(
        impl Parse for $t {
            type ParsesTo = Self;

            #[inline(always)]
            fn parse(i: &mut Input) -> Self::ParsesTo {
                <Self as std::str::FromStr>::from_str(&i.get_next()).unwrap()
            }
        }
        )*
    };
}

    impl_parse!(
        bool, u8, i8, char, u16, i16, u32, i32, f32, u64, i64, f64, usize, isize, u128, i128
    );
    impl Parse for String {
        type ParsesTo = Vec<char>;

        fn parse(i: &mut Input) -> Self::ParsesTo {
            i.get_next().chars().collect()
        }
    }
    impl<T: Parse<ParsesTo = U>, U> Parse for Vec<T> {
        type ParsesTo = Vec<U>;

        fn parse(i: &mut Input) -> Self::ParsesTo {
            let n = usize::parse(i);
            (0..n).map(|_| T::parse(i)).collect()
        }
    }
    #[inline(always)]
    pub fn lin<T: Parse<ParsesTo = U>, U, V: FromIterator<U>>(n: usize) -> V {
        let i = input();
        (0..n).map(|_| T::parse(i)).collect()
    }
    #[inline(always)]
    pub fn grid<T: Parse<ParsesTo = U>, U, V: FromIterator<U>, W: FromIterator<V>>(
        n: usize,
        m: usize,
    ) -> W {
        (0..n).map(|_| lin::<T, U, V>(m)).collect()
    }
    #[macro_export]
    macro_rules! rv {
        ($n:expr; $c:tt<$t:tt>) => {
            lin::<$t, _, $c<_>>($n)
        };
        ($n:expr, $m:expr; $c1:tt<$c2:tt<$t:tt>>) => {
            grid::<$t, _, $c2<_>, $c1<$c2<_>>>($n, $m)
        };
    }
    #[macro_export]
    macro_rules! r {
    (<p>Unable to parse markup [type=CF_MATHJAX]</p>(,)?) => {{
        let i = input();
        ($(<$t as Parse>::parse(i)),*)
    }};
}
    pub fn io() -> IO {
        let (mut i, mut o) = (Some(Input(read_next_line())), Output(String::new()));
        unsafe {
            INPUT = i;
            OUTPUT = o; // fairly useless, can be removed; currently only "resets" output string
            // (which should be a noop)
        }
        IO
    }
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

There are $$$n$$$ valid $$$x=n+k(0\le k \lt n)$$$. So the answer is $$$n$$$.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<pdd> vpdd;
typedef vector<vd> vvd;
#define yn(ans) printf("%s\n", (ans)?"Yes":"No");
#define YN(ans) printf("%s\n", (ans)?"YES":"NO");
template<class T> bool chmax(T &a, T b) {
	if (a >= b) return false;
	a = b; return true;
}
template<class T> bool chmin(T &a, T b) {
	if (a <= b) return false;
	a = b; return true;
}
#define FOR(i, s, e, t) for ((i) = (s); (i) < (e); (i) += (t)) 
#define REP(i, e) for (int i = 0; i < (e); ++i) 
#define REP1(i, s, e) for (int i = (s); i < (e); ++i)
#define RREP(i, e) for (int i = (e); i >= 0; --i)
#define RREP1(i, e, s) for (int i = (e); i >= (s); --i)
#define all(v) v.begin(), v.end()
#define pb push_back
#define qb pop_back
#define pf push_front
#define qf pop_front
#define maxe max_element
#define mine min_element
ll inf = 1e18;
#define DEBUG printf("%d\n", __LINE__); fflush(stdout);
template<class T> void print(vector<T> &v, bool withSize = false) {
	if (withSize) cout << v.size() << endl;
	REP(i, v.size()) cout << v[i] << " "; 
	cout << endl;
}
mt19937_64 rng((unsigned int) chrono::steady_clock::now().time_since_epoch().count());

int __FAST_IO__ = []() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	return 0;
}();

#define TESTS int t; cin >> t; while (t--)
#define TEST 
int main() {
    TESTS {
    	ll N;
    	cin >> N;
    	printf("%lld\n", N);
    }
    
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

We can rum the following greedy algorithm.

● Go as far as you can.

● Stop when you can’t pass. Then find the maximum $$$c$$$ ever seen and change it to zero.

● Maintain $$$c$$$’s in a set or priority queue, or just do bruteforce since $$$n$$$ is small enough.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<pdd> vpdd;
typedef vector<vd> vvd;
#define yn(ans) printf("%s\n", (ans)?"Yes":"No");
#define YN(ans) printf("%s\n", (ans)?"YES":"NO");
template<class T> bool chmax(T &a, T b) {
	if (a >= b) return false;
	a = b; return true;
}
template<class T> bool chmin(T &a, T b) {
	if (a <= b) return false;
	a = b; return true;
}
#define FOR(i, s, e, t) for ((i) = (s); (i) < (e); (i) += (t)) 
#define REP(i, e) for (int i = 0; i < (e); ++i) 
#define REP1(i, s, e) for (int i = (s); i < (e); ++i)
#define RREP(i, e) for (int i = (e); i >= 0; --i)
#define RREP1(i, e, s) for (int i = (e); i >= (s); --i)
#define all(v) v.begin(), v.end()
#define pb push_back
#define qb pop_back
#define pf push_front
#define qf pop_front
#define maxe max_element
#define mine min_element
ll inf = 1e18;
#define DEBUG printf("%d\n", __LINE__); fflush(stdout);
template<class T> void print(vector<T> &v, bool withSize = false) {
	if (withSize) cout << v.size() << endl;
	REP(i, v.size()) cout << v[i] << " "; 
	cout << endl;
}
mt19937_64 rng((unsigned int) chrono::steady_clock::now().time_since_epoch().count());

int __FAST_IO__ = []() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	return 0;
}();

#define TESTS int t; cin >> t; while (t--)
#define TEST 
int main() {
    TESTS {
    	int N, X;
    	cin >> N >> X;
    	vi C(N), A(N);
    	REP(i, N) cin >> C[i];
    	REP(i, N) cin >> A[i];
    	int ans = 0, left = X;
    	priority_queue<int> q;
    	REP(i, N) {
    		q.push(C[i]);
    		left -= C[i];
    		while (left < 0) {
    			left += q.top();
    			ans++;
    			q.pop();
    		}
    		left += A[i];
    	}
    	printf("%d\n", ans);
    }
    
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

According to the Binomial Theorem,

The general $$$(r+1)$$$-th term is:

A key observation for this problem is that if any term in the binomial expansion is constant, the power of $$$x$$$ in that term must be zero (since $$$x^0 = 1$$$).

If the $$$(r+1)$$$-th term is constant, then:

(because $$$\binom{n}{r} \gt 0$$$)

Solving for $$$r$$$:

This means a constant term exists if and only if $$$(1 + m)$$$ divides $$$n$$$ (i.e., $$$n \equiv 0 \pmod{1 + m}$$$).

Equivalently, $$$(1 + m) \mid n$$$ if and only if $$$(m - 1)$$$ is a divisor of $$$n$$$.

Thus, the answer to this problem is:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<pdd> vpdd;
typedef vector<vd> vvd;
#define yn(ans) printf("%s\n", (ans)?"Yes":"No");
#define YN(ans) printf("%s\n", (ans)?"YES":"NO");
template<class T> bool chmax(T &a, T b) {
	if (a >= b) return false;
	a = b; return true;
}
template<class T> bool chmin(T &a, T b) {
	if (a <= b) return false;
	a = b; return true;
}
#define FOR(i, s, e, t) for ((i) = (s); (i) < (e); (i) += (t)) 
#define REP(i, e) for (int i = 0; i < (e); ++i) 
#define REP1(i, s, e) for (int i = (s); i < (e); ++i)
#define RREP(i, e) for (int i = (e); i >= 0; --i)
#define RREP1(i, e, s) for (int i = (e); i >= (s); --i)
#define all(v) v.begin(), v.end()
#define pb push_back
#define qb pop_back
#define pf push_front
#define qf pop_front
#define maxe max_element
#define mine min_element
ll inf = 1e18;
#define DEBUG printf("%d\n", __LINE__); fflush(stdout);
template<class T> void print(vector<T> &v, bool withSize = false) {
	if (withSize) cout << v.size() << endl;
	REP(i, v.size()) cout << v[i] << " "; 
	cout << endl;
}
mt19937_64 rng((unsigned int) chrono::steady_clock::now().time_since_epoch().count());

int __FAST_IO__ = []() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	return 0;
}();

#define TESTS int t; cin >> t; while (t--)
#define TEST 
int main() {
    TESTS {
    	int N;
    	cin >> N;
    	ll ans = 0;
    	for (int i = 1; 1ll * i * i <= N; ++i) {
    		if (N % i == 0) {
    			if (i > 1) ans += i - 1;
    			if (1ll * i * i != N) ans += N / i - 1;
    		}
    	}
    	printf("%lld\n", ans);
    }
    
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

If $$$n$$$ is even, we can keep every element in the matrix equal to $$$3$$$. So the answer is $$$1$$$ in that case.

Now, if $$$n$$$ is odd, keeping every element equal to $$$3$$$ makes XOR of every row and column equal to $$$3$$$ and to balance out that, we may put $$$1$$$ and $$$2$$$ in every row and column.

So the final matrix will be having exactly one $$$1$$$ in each row and each column, exactly one $$$2$$$ in each row and each column and rest all elements equal to $$$3$$$. To place $$$1$$$s, we have $$$n!$$$ ways and to place $$$2$$$s, each row and column must have exactly one $$$2$$$, but they should not be placed where the $$$1$$$s are placed, so we have $$$D(n)$$$ ways (where $$$D(n)$$$ is the number of derangements).

Total number of ways when $$$n$$$ is odd $$$ = n! \times D(n) $$$.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<pdd> vpdd;
typedef vector<vd> vvd;
#define yn(ans) printf("%s\n", (ans)?"Yes":"No");
#define YN(ans) printf("%s\n", (ans)?"YES":"NO");
template<class T> bool chmax(T &a, T b) {
	if (a >= b) return false;
	a = b; return true;
}
template<class T> bool chmin(T &a, T b) {
	if (a <= b) return false;
	a = b; return true;
}
#define FOR(i, s, e, t) for ((i) = (s); (i) < (e); (i) += (t)) 
#define REP(i, e) for (int i = 0; i < (e); ++i) 
#define REP1(i, s, e) for (int i = (s); i < (e); ++i)
#define RREP(i, e) for (int i = (e); i >= 0; --i)
#define RREP1(i, e, s) for (int i = (e); i >= (s); --i)
#define all(v) v.begin(), v.end()
#define pb push_back
#define qb pop_back
#define pf push_front
#define qf pop_front
#define maxe max_element
#define mine min_element
ll inf = 1e18;
#define DEBUG printf("%d\n", __LINE__); fflush(stdout);
template<class T> void print(vector<T> &v, bool withSize = false) {
	if (withSize) cout << v.size() << endl;
	REP(i, v.size()) cout << v[i] << " "; 
	cout << endl;
}
mt19937_64 rng((unsigned int) chrono::steady_clock::now().time_since_epoch().count());

int __FAST_IO__ = []() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	return 0;
}();

namespace atcoder {

namespace internal {

#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value ||
                                  std::is_same<T, __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int128 =
    typename std::conditional<std::is_same<T, __uint128_t>::value ||
                                  std::is_same<T, unsigned __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using make_unsigned_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value,
                              __uint128_t,
                              unsigned __int128>;

template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
                                                  is_signed_int128<T>::value ||
                                                  is_unsigned_int128<T>::value,
                                              std::true_type,
                                              std::false_type>::type;

template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
                                                 std::is_signed<T>::value) ||
                                                    is_signed_int128<T>::value,
                                                std::true_type,
                                                std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<(is_integral<T>::value &&
                               std::is_unsigned<T>::value) ||
                                  is_unsigned_int128<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<
    is_signed_int128<T>::value,
    make_unsigned_int128<T>,
    typename std::conditional<std::is_signed<T>::value,
                              std::make_unsigned<T>,
                              std::common_type<T>>::type>::type;

#else

template <class T> using is_integral = typename std::is_integral<T>;

template <class T>
using is_signed_int =
    typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<is_integral<T>::value &&
                                  std::is_unsigned<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
                                              std::make_unsigned<T>,
                                              std::common_type<T>>::type;

#endif

template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;

template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;

template <class T> using to_unsigned_t = typename to_unsigned<T>::type;

}  // namespace internal

}  // namespace atcoder

namespace atcoder {

namespace internal {

// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
    x %= m;
    if (x < 0) x += m;
    return x;
}

// Fast modular multiplication by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
    unsigned int _m;
    unsigned long long im;

    // @param m `1 <= m`
    explicit barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}

    // @return m
    unsigned int umod() const { return _m; }

    // @param a `0 <= a < m`
    // @param b `0 <= b < m`
    // @return `a * b % m`
    unsigned int mul(unsigned int a, unsigned int b) const {
        // [1] m = 1
        // a = b = im = 0, so okay

        // [2] m >= 2
        // im = ceil(2^64 / m)
        // -> im * m = 2^64 + r (0 <= r < m)
        // let z = a*b = c*m + d (0 <= c, d < m)
        // a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
        // c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) < 2^64 * 2
        // ((ab * im) >> 64) == c or c + 1
        unsigned long long z = a;
        z *= b;
#ifdef _MSC_VER
        unsigned long long x;
        _umul128(z, im, &x);
#else
        unsigned long long x =
            (unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
        unsigned long long y = x * _m;
        return (unsigned int)(z - y + (z < y ? _m : 0));
    }
};

// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
    if (m == 1) return 0;
    unsigned int _m = (unsigned int)(m);
    unsigned long long r = 1;
    unsigned long long y = safe_mod(x, m);
    while (n) {
        if (n & 1) r = (r * y) % _m;
        y = (y * y) % _m;
        n >>= 1;
    }
    return r;
}

// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
    if (n <= 1) return false;
    if (n == 2 || n == 7 || n == 61) return true;
    if (n % 2 == 0) return false;
    long long d = n - 1;
    while (d % 2 == 0) d /= 2;
    constexpr long long bases[3] = {2, 7, 61};
    for (long long a : bases) {
        long long t = d;
        long long y = pow_mod_constexpr(a, t, n);
        while (t != n - 1 && y != 1 && y != n - 1) {
            y = y * y % n;
            t <<= 1;
        }
        if (y != n - 1 && t % 2 == 0) {
            return false;
        }
    }
    return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);

// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
    a = safe_mod(a, b);
    if (a == 0) return {b, 0};

    // Contracts:
    // [1] s - m0 * a = 0 (mod b)
    // [2] t - m1 * a = 0 (mod b)
    // [3] s * |m1| + t * |m0| <= b
    long long s = b, t = a;
    long long m0 = 0, m1 = 1;

    while (t) {
        long long u = s / t;
        s -= t * u;
        m0 -= m1 * u;  // |m1 * u| <= |m1| * s <= b

        // [3]:
        // (s - t * u) * |m1| + t * |m0 - m1 * u|
        // <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
        // = s * |m1| + t * |m0| <= b

        auto tmp = s;
        s = t;
        t = tmp;
        tmp = m0;
        m0 = m1;
        m1 = tmp;
    }
    // by [3]: |m0| <= b/g
    // by g != b: |m0| < b/g
    if (m0 < 0) m0 += b / s;
    return {s, m0};
}

// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
    if (m == 2) return 1;
    if (m == 167772161) return 3;
    if (m == 469762049) return 3;
    if (m == 754974721) return 11;
    if (m == 998244353) return 3;
    int divs[20] = {};
    divs[0] = 2;
    int cnt = 1;
    int x = (m - 1) / 2;
    while (x % 2 == 0) x /= 2;
    for (int i = 3; (long long)(i)*i <= x; i += 2) {
        if (x % i == 0) {
            divs[cnt++] = i;
            while (x % i == 0) {
                x /= i;
            }
        }
    }
    if (x > 1) {
        divs[cnt++] = x;
    }
    for (int g = 2;; g++) {
        bool ok = true;
        for (int i = 0; i < cnt; i++) {
            if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
                ok = false;
                break;
            }
        }
        if (ok) return g;
    }
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);

// @param n `n < 2^32`
// @param m `1 <= m < 2^32`
// @return sum_{i=0}^{n-1} floor((ai + b) / m) (mod 2^64)
unsigned long long floor_sum_unsigned(unsigned long long n,
                                      unsigned long long m,
                                      unsigned long long a,
                                      unsigned long long b) {
    unsigned long long ans = 0;
    while (true) {
        if (a >= m) {
            ans += n * (n - 1) / 2 * (a / m);
            a %= m;
        }
        if (b >= m) {
            ans += n * (b / m);
            b %= m;
        }

        unsigned long long y_max = a * n + b;
        if (y_max < m) break;
        // y_max < m * (n + 1)
        // floor(y_max / m) <= n
        n = (unsigned long long)(y_max / m);
        b = (unsigned long long)(y_max % m);
        std::swap(m, a);
    }
    return ans;
}

}  // namespace internal

}  // namespace atcoder

namespace atcoder {

namespace internal {

struct modint_base {};
struct static_modint_base : modint_base {};

template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;

}  // namespace internal

template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
    using mint = static_modint;

  public:
    static constexpr int mod() { return m; }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    static_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    static_modint(T v) {
        long long x = (long long)(v % (long long)(umod()));
        if (x < 0) x += umod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    static_modint(T v) {
        _v = (unsigned int)(v % umod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v -= rhs._v;
        if (_v >= umod()) _v += umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        unsigned long long z = _v;
        z *= rhs._v;
        _v = (unsigned int)(z % umod());
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        if (prime) {
            assert(_v);
            return pow(umod() - 2);
        } else {
            auto eg = internal::inv_gcd(_v, m);
            assert(eg.first == 1);
            return eg.second;
        }
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }
    friend ostream &operator<<(ostream &os, const mint& rhs) {
	os << rhs.val(); return os;	    
    }

  private:
    unsigned int _v;
    static constexpr unsigned int umod() { return m; }
    static constexpr bool prime = internal::is_prime<m>;
};

template <int id> struct dynamic_modint : internal::modint_base {
    using mint = dynamic_modint;

  public:
    static int mod() { return (int)(bt.umod()); }
    static void set_mod(int m) {
        assert(1 <= m);
        bt = internal::barrett(m);
    }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    dynamic_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        long long x = (long long)(v % (long long)(mod()));
        if (x < 0) x += mod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        _v = (unsigned int)(v % mod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v += mod() - rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        _v = bt.mul(_v, rhs._v);
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        auto eg = internal::inv_gcd(_v, mod());
        assert(eg.first == 1);
        return eg.second;
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }
    friend ostream &operator<<(ostream &os, const mint& rhs) {
	os << rhs.val(); return os;	    
    }

  private:
    unsigned int _v;
    static internal::barrett bt;
    static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);

using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;

namespace internal {

template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;

template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;

template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};

template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;

}  // namespace internal

}  // namespace atcoder

using Mint = atcoder::modint998244353;
using Mint2 = atcoder::modint1000000007;
typedef vector<Mint> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;

vector<Mint> fac, ifac;
void initFac(int N) {
	fac.resize(N + 1);
	ifac.resize(N + 1);
	fac[0] = ifac[0] = 1;
	REP1(i, 1, N + 1) {
		fac[i] = fac[i - 1] * i;
	}
	ifac[N] = 1 / fac[N];
	RREP1(i, N - 1, 1) {
		ifac[i] = (i + 1) * ifac[i + 1];
	}
}
 
Mint C(int m, int n) {
	if (m < n || n < 0) return 0;
	return fac[m] * ifac[n] * ifac[m - n]; 
}

Mint P(int m, int n) {
	if (m < n || n < 0) return 0;
	return fac[m] * ifac[m - n];
}

vector<vector<Mint>> fastmulti(vector<vector<Mint>> &a, vector<vector<Mint>> &b) {
	vector<vector<Mint>> ans(a.size(), vector<Mint>(b[0].size(), Mint(0)));
	REP(i, a.size()) {
		REP(j, a[0].size()) {
			REP(k, b[0].size()) {
				ans[i][k] += a[i][j] * b[j][k];
			}
		}
	}
	return ans;
}
 
vector<vector<Mint>> pow(vector<vector<Mint>> &a, ll k) {
	vector<vector<Mint>> res(a.size(), vector<Mint>(a.size(), 0)), y = a;
	REP(i, a.size()) res[i][i] = 1;
	while (k) {
		if (k & 1) res = fastmulti(y, res);
		y = fastmulti(y, y);
		k >>= 1;
	}
	return res;
}

template< typename Mint >
struct NumberTheoreticTransformFriendlyModInt {
 
  vector< Mint > dw, idw;
  int max_base;
  Mint root;
 
  NumberTheoreticTransformFriendlyModInt() {
    const unsigned mod = Mint::mod();
    assert(mod >= 3 && mod % 2 == 1);
    auto tmp = mod - 1;
    max_base = 0;
    while(tmp % 2 == 0) tmp >>= 1, max_base++;
    root = 2;
    while(root.pow((mod - 1) >> 1) == 1) root += 1;
    assert(root.pow(mod - 1) == 1);
    dw.resize(max_base);
    idw.resize(max_base);
    for(int i = 0; i < max_base; i++) {
      dw[i] = -root.pow((mod - 1) >> (i + 2));
      idw[i] = Mint(1) / dw[i];
    }
  }
  
  void ntt(vector< Mint > &a) {
    const int n = (int) a.size();
    assert((n & (n - 1)) == 0);
    assert(__builtin_ctz(n) <= max_base);
    for(int m = n; m >>= 1;) {
      Mint w = 1;
      for(int s = 0, k = 0; s < n; s += 2 * m) {
        for(int i = s, j = s + m; i < s + m; ++i, ++j) {
          auto x = a[i], y = a[j] * w;
          a[i] = x + y, a[j] = x - y;
        }
        w *= dw[__builtin_ctz(++k)];
      }
    }
  }
 
  void intt(vector< Mint > &a, bool f = true) {
    const int n = (int) a.size();
    assert((n & (n - 1)) == 0);
    assert(__builtin_ctz(n) <= max_base);
    for(int m = 1; m < n; m *= 2) {
      Mint w = 1;
      for(int s = 0, k = 0; s < n; s += 2 * m) {
        for(int i = s, j = s + m; i < s + m; ++i, ++j) {
          auto x = a[i], y = a[j];
          a[i] = x + y, a[j] = (x - y) * w;
        }
        w *= idw[__builtin_ctz(++k)];
      }
    }
    if(f) {
      Mint inv_sz = Mint(1) / n;
      for(int i = 0; i < n; i++) a[i] *= inv_sz;
    }
  }
 
  vector< Mint > multiply(vector< Mint > a, vector< Mint > b) {
    int need = a.size() + b.size() - 1;
    int nbase = 1;
    while((1 << nbase) < need) nbase++;
    int sz = 1 << nbase;
    a.resize(sz, 0);
    b.resize(sz, 0);
    ntt(a);
    ntt(b);
    Mint inv_sz = Mint(1) / sz;
    for(int i = 0; i < sz; i++) a[i] *= b[i] * inv_sz;
    intt(a, false);
    a.resize(need);
    return a;
  }
  void sq(vector<Mint> &a, vector<Mint> &b, bool mult) {
    int need = a.size() + b.size() - 1;
    int nbase = 1;
    while((1 << nbase) < need) nbase++;
    int sz = 1 << nbase;
    
    b.resize(sz, 0);
    ntt(b);
    Mint inv_sz = Mint(1) / sz;
    if (mult) {
        a.resize(sz, 0);
        ntt(a);
        for(int i = 0; i < sz; i++) a[i] *= b[i] * inv_sz;
        intt(a, false);
        a.resize(need);
    }
    for (int i = 0; i < sz; i++) b[i] *= b[i] * inv_sz;
    intt(b, false);
    b.resize(need);
  }
  
  void pow(vector<Mint> &a, vector<Mint> &b, int p) {
    int len = a.size();
    while (p) {
        sq(a, b, p & 1);
        a.resize(len);
        b.resize(len);
        p >>= 1;
    }
  }
}; 

NumberTheoreticTransformFriendlyModInt<Mint> ntt;

#define TESTS int t; cin >> t; while (t--)
#define TEST 
int main() {
	int mx = 1e6;
	initFac(mx);
	
	vm dp2(mx + 1, 0), pre2(mx + 1, 0);
	dp2[0] = 1; dp2[1] = 0;
	pre2[0] = dp2[0] * ifac[0] * ifac[0], pre2[1] = dp2[1] * ifac[1] * ifac[1] + pre2[0];
	REP1(i, 2, mx + 1) {
		dp2[i] = fac[i] * fac[i - 1] * pre2[i - 2];
		pre2[i] = pre2[i - 1] + dp2[i] * ifac[i] * ifac[i];
	}

    TESTS {
    	int N;
    	cin >> N;
    	Mint ans = 0;
    	if (N % 2 == 0) ans = 1;
    	else if (N > 1) {
    		ans = dp2[N];
    	}
    	printf("%d\n", ans.val());
    }
    
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

As we know that $$$a_i \le 20$$$, we can represent every $$$a_i$$$ in its prime factorisation and as there are only $$$8$$$ primes which are $$$\le 20$$$, we can store the prime powers for every $$$a_i$$$ in a vector.

Now lets consider an array $$$b$$$ where $$$b_i$$$ is a vector containing the prime powers of $$$a_i$$$. Let $$$pre$$$ be another array where $$$pre_i = b_1 + b_2 + \cdots b_i$$$. Consider the subarray $$$a[l:r]$$$ and we can say that $$$f(al \times a{l + 1} \cdots a_r) = (prer[1] - pre{l - 1}[1] + 1) \times (prer[2] - pre{l - 1}[2] + 1) \cdots$$$.

To evaluate the required answer, we iterate from $$$i = 1$$$ to $$$n$$$ and at each step we fix $$$i$$$ and calculate $$$(prei[1] - pre{j - 1}[1] + 1) \times (prei[2] - pre{j - 1}[2] + 1) \cdots$$$ over all $$$j \lt i$$$. This expression is a product of $$$8$$$ binomial terms and when expanded, it will have $$$2^8 = 256$$$ terms and we can store partial products of $$$pre_{j - 1}$$$s appearing over $$$256$$$ terms and evaluate the expression using bit-masking.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<pdd> vpdd;
typedef vector<vd> vvd;
#define yn(ans) printf("%s\n", (ans)?"Yes":"No");
#define YN(ans) printf("%s\n", (ans)?"YES":"NO");
template<class T> bool chmax(T &a, T b) {
	if (a >= b) return false;
	a = b; return true;
}
template<class T> bool chmin(T &a, T b) {
	if (a <= b) return false;
	a = b; return true;
}
#define FOR(i, s, e, t) for ((i) = (s); (i) < (e); (i) += (t)) 
#define REP(i, e) for (int i = 0; i < (e); ++i) 
#define REP1(i, s, e) for (int i = (s); i < (e); ++i)
#define RREP(i, e) for (int i = (e); i >= 0; --i)
#define RREP1(i, e, s) for (int i = (e); i >= (s); --i)
#define all(v) v.begin(), v.end()
#define pb push_back
#define qb pop_back
#define pf push_front
#define qf pop_front
#define maxe max_element
#define mine min_element
ll inf = 1e18;
#define DEBUG printf("%d\n", __LINE__); fflush(stdout);
template<class T> void print(vector<T> &v, bool withSize = false) {
	if (withSize) cout << v.size() << endl;
	REP(i, v.size()) cout << v[i] << " "; 
	cout << endl;
}
mt19937_64 rng((unsigned int) chrono::steady_clock::now().time_since_epoch().count());

int __FAST_IO__ = []() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	return 0;
}();

namespace atcoder {

namespace internal {

#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value ||
                                  std::is_same<T, __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int128 =
    typename std::conditional<std::is_same<T, __uint128_t>::value ||
                                  std::is_same<T, unsigned __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using make_unsigned_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value,
                              __uint128_t,
                              unsigned __int128>;

template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
                                                  is_signed_int128<T>::value ||
                                                  is_unsigned_int128<T>::value,
                                              std::true_type,
                                              std::false_type>::type;

template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
                                                 std::is_signed<T>::value) ||
                                                    is_signed_int128<T>::value,
                                                std::true_type,
                                                std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<(is_integral<T>::value &&
                               std::is_unsigned<T>::value) ||
                                  is_unsigned_int128<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<
    is_signed_int128<T>::value,
    make_unsigned_int128<T>,
    typename std::conditional<std::is_signed<T>::value,
                              std::make_unsigned<T>,
                              std::common_type<T>>::type>::type;

#else

template <class T> using is_integral = typename std::is_integral<T>;

template <class T>
using is_signed_int =
    typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<is_integral<T>::value &&
                                  std::is_unsigned<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
                                              std::make_unsigned<T>,
                                              std::common_type<T>>::type;

#endif

template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;

template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;

template <class T> using to_unsigned_t = typename to_unsigned<T>::type;

}  // namespace internal

}  // namespace atcoder

namespace atcoder {

namespace internal {

// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
    x %= m;
    if (x < 0) x += m;
    return x;
}

// Fast modular multiplication by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
    unsigned int _m;
    unsigned long long im;

    // @param m `1 <= m`
    explicit barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}

    // @return m
    unsigned int umod() const { return _m; }

    // @param a `0 <= a < m`
    // @param b `0 <= b < m`
    // @return `a * b % m`
    unsigned int mul(unsigned int a, unsigned int b) const {
        // [1] m = 1
        // a = b = im = 0, so okay

        // [2] m >= 2
        // im = ceil(2^64 / m)
        // -> im * m = 2^64 + r (0 <= r < m)
        // let z = a*b = c*m + d (0 <= c, d < m)
        // a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
        // c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) < 2^64 * 2
        // ((ab * im) >> 64) == c or c + 1
        unsigned long long z = a;
        z *= b;
#ifdef _MSC_VER
        unsigned long long x;
        _umul128(z, im, &x);
#else
        unsigned long long x =
            (unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
        unsigned long long y = x * _m;
        return (unsigned int)(z - y + (z < y ? _m : 0));
    }
};

// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
    if (m == 1) return 0;
    unsigned int _m = (unsigned int)(m);
    unsigned long long r = 1;
    unsigned long long y = safe_mod(x, m);
    while (n) {
        if (n & 1) r = (r * y) % _m;
        y = (y * y) % _m;
        n >>= 1;
    }
    return r;
}

// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
    if (n <= 1) return false;
    if (n == 2 || n == 7 || n == 61) return true;
    if (n % 2 == 0) return false;
    long long d = n - 1;
    while (d % 2 == 0) d /= 2;
    constexpr long long bases[3] = {2, 7, 61};
    for (long long a : bases) {
        long long t = d;
        long long y = pow_mod_constexpr(a, t, n);
        while (t != n - 1 && y != 1 && y != n - 1) {
            y = y * y % n;
            t <<= 1;
        }
        if (y != n - 1 && t % 2 == 0) {
            return false;
        }
    }
    return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);

// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
    a = safe_mod(a, b);
    if (a == 0) return {b, 0};

    // Contracts:
    // [1] s - m0 * a = 0 (mod b)
    // [2] t - m1 * a = 0 (mod b)
    // [3] s * |m1| + t * |m0| <= b
    long long s = b, t = a;
    long long m0 = 0, m1 = 1;

    while (t) {
        long long u = s / t;
        s -= t * u;
        m0 -= m1 * u;  // |m1 * u| <= |m1| * s <= b

        // [3]:
        // (s - t * u) * |m1| + t * |m0 - m1 * u|
        // <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
        // = s * |m1| + t * |m0| <= b

        auto tmp = s;
        s = t;
        t = tmp;
        tmp = m0;
        m0 = m1;
        m1 = tmp;
    }
    // by [3]: |m0| <= b/g
    // by g != b: |m0| < b/g
    if (m0 < 0) m0 += b / s;
    return {s, m0};
}

// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
    if (m == 2) return 1;
    if (m == 167772161) return 3;
    if (m == 469762049) return 3;
    if (m == 754974721) return 11;
    if (m == 998244353) return 3;
    int divs[20] = {};
    divs[0] = 2;
    int cnt = 1;
    int x = (m - 1) / 2;
    while (x % 2 == 0) x /= 2;
    for (int i = 3; (long long)(i)*i <= x; i += 2) {
        if (x % i == 0) {
            divs[cnt++] = i;
            while (x % i == 0) {
                x /= i;
            }
        }
    }
    if (x > 1) {
        divs[cnt++] = x;
    }
    for (int g = 2;; g++) {
        bool ok = true;
        for (int i = 0; i < cnt; i++) {
            if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
                ok = false;
                break;
            }
        }
        if (ok) return g;
    }
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);

// @param n `n < 2^32`
// @param m `1 <= m < 2^32`
// @return sum_{i=0}^{n-1} floor((ai + b) / m) (mod 2^64)
unsigned long long floor_sum_unsigned(unsigned long long n,
                                      unsigned long long m,
                                      unsigned long long a,
                                      unsigned long long b) {
    unsigned long long ans = 0;
    while (true) {
        if (a >= m) {
            ans += n * (n - 1) / 2 * (a / m);
            a %= m;
        }
        if (b >= m) {
            ans += n * (b / m);
            b %= m;
        }

        unsigned long long y_max = a * n + b;
        if (y_max < m) break;
        // y_max < m * (n + 1)
        // floor(y_max / m) <= n
        n = (unsigned long long)(y_max / m);
        b = (unsigned long long)(y_max % m);
        std::swap(m, a);
    }
    return ans;
}

}  // namespace internal

}  // namespace atcoder

namespace atcoder {

namespace internal {

struct modint_base {};
struct static_modint_base : modint_base {};

template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;

}  // namespace internal

template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
    using mint = static_modint;

  public:
    static constexpr int mod() { return m; }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    static_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    static_modint(T v) {
        long long x = (long long)(v % (long long)(umod()));
        if (x < 0) x += umod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    static_modint(T v) {
        _v = (unsigned int)(v % umod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v -= rhs._v;
        if (_v >= umod()) _v += umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        unsigned long long z = _v;
        z *= rhs._v;
        _v = (unsigned int)(z % umod());
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        if (prime) {
            assert(_v);
            return pow(umod() - 2);
        } else {
            auto eg = internal::inv_gcd(_v, m);
            assert(eg.first == 1);
            return eg.second;
        }
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }
    friend ostream &operator<<(ostream &os, const mint& rhs) {
	os << rhs.val(); return os;	    
    }

  private:
    unsigned int _v;
    static constexpr unsigned int umod() { return m; }
    static constexpr bool prime = internal::is_prime<m>;
};

template <int id> struct dynamic_modint : internal::modint_base {
    using mint = dynamic_modint;

  public:
    static int mod() { return (int)(bt.umod()); }
    static void set_mod(int m) {
        assert(1 <= m);
        bt = internal::barrett(m);
    }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    dynamic_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        long long x = (long long)(v % (long long)(mod()));
        if (x < 0) x += mod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        _v = (unsigned int)(v % mod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v += mod() - rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        _v = bt.mul(_v, rhs._v);
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        auto eg = internal::inv_gcd(_v, mod());
        assert(eg.first == 1);
        return eg.second;
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }
    friend ostream &operator<<(ostream &os, const mint& rhs) {
	os << rhs.val(); return os;	    
    }

  private:
    unsigned int _v;
    static internal::barrett bt;
    static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);

using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;

namespace internal {

template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;

template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;

template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};

template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;

}  // namespace internal

}  // namespace atcoder

using Mint2 = atcoder::modint998244353;
using Mint = atcoder::modint1000000007;
typedef vector<Mint> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;

vector<Mint> fac, ifac;
void initFac(int N) {
	fac.resize(N + 1);
	ifac.resize(N + 1);
	fac[0] = ifac[0] = 1;
	REP1(i, 1, N + 1) {
		fac[i] = fac[i - 1] * i;
	}
	ifac[N] = 1 / fac[N];
	RREP1(i, N - 1, 1) {
		ifac[i] = (i + 1) * ifac[i + 1];
	}
}
 
Mint C(int m, int n) {
	if (m < n || n < 0) return 0;
	return fac[m] * ifac[n] * ifac[m - n]; 
}

Mint P(int m, int n) {
	if (m < n || n < 0) return 0;
	return fac[m] * ifac[m - n];
}

vector<vector<Mint>> fastmulti(vector<vector<Mint>> &a, vector<vector<Mint>> &b) {
	vector<vector<Mint>> ans(a.size(), vector<Mint>(b[0].size(), Mint(0)));
	REP(i, a.size()) {
		REP(j, a[0].size()) {
			REP(k, b[0].size()) {
				ans[i][k] += a[i][j] * b[j][k];
			}
		}
	}
	return ans;
}
 
vector<vector<Mint>> pow(vector<vector<Mint>> &a, ll k) {
	vector<vector<Mint>> res(a.size(), vector<Mint>(a.size(), 0)), y = a;
	REP(i, a.size()) res[i][i] = 1;
	while (k) {
		if (k & 1) res = fastmulti(y, res);
		y = fastmulti(y, y);
		k >>= 1;
	}
	return res;
}

template< typename Mint >
struct NumberTheoreticTransformFriendlyModInt {
 
  vector< Mint > dw, idw;
  int max_base;
  Mint root;
 
  NumberTheoreticTransformFriendlyModInt() {
    const unsigned mod = Mint::mod();
    assert(mod >= 3 && mod % 2 == 1);
    auto tmp = mod - 1;
    max_base = 0;
    while(tmp % 2 == 0) tmp >>= 1, max_base++;
    root = 2;
    while(root.pow((mod - 1) >> 1) == 1) root += 1;
    assert(root.pow(mod - 1) == 1);
    dw.resize(max_base);
    idw.resize(max_base);
    for(int i = 0; i < max_base; i++) {
      dw[i] = -root.pow((mod - 1) >> (i + 2));
      idw[i] = Mint(1) / dw[i];
    }
  }
  
  void ntt(vector< Mint > &a) {
    const int n = (int) a.size();
    assert((n & (n - 1)) == 0);
    assert(__builtin_ctz(n) <= max_base);
    for(int m = n; m >>= 1;) {
      Mint w = 1;
      for(int s = 0, k = 0; s < n; s += 2 * m) {
        for(int i = s, j = s + m; i < s + m; ++i, ++j) {
          auto x = a[i], y = a[j] * w;
          a[i] = x + y, a[j] = x - y;
        }
        w *= dw[__builtin_ctz(++k)];
      }
    }
  }
 
  void intt(vector< Mint > &a, bool f = true) {
    const int n = (int) a.size();
    assert((n & (n - 1)) == 0);
    assert(__builtin_ctz(n) <= max_base);
    for(int m = 1; m < n; m *= 2) {
      Mint w = 1;
      for(int s = 0, k = 0; s < n; s += 2 * m) {
        for(int i = s, j = s + m; i < s + m; ++i, ++j) {
          auto x = a[i], y = a[j];
          a[i] = x + y, a[j] = (x - y) * w;
        }
        w *= idw[__builtin_ctz(++k)];
      }
    }
    if(f) {
      Mint inv_sz = Mint(1) / n;
      for(int i = 0; i < n; i++) a[i] *= inv_sz;
    }
  }
 
  vector< Mint > multiply(vector< Mint > a, vector< Mint > b) {
    int need = a.size() + b.size() - 1;
    int nbase = 1;
    while((1 << nbase) < need) nbase++;
    int sz = 1 << nbase;
    a.resize(sz, 0);
    b.resize(sz, 0);
    ntt(a);
    ntt(b);
    Mint inv_sz = Mint(1) / sz;
    for(int i = 0; i < sz; i++) a[i] *= b[i] * inv_sz;
    intt(a, false);
    a.resize(need);
    return a;
  }
  void sq(vector<Mint> &a, vector<Mint> &b, bool mult) {
    int need = a.size() + b.size() - 1;
    int nbase = 1;
    while((1 << nbase) < need) nbase++;
    int sz = 1 << nbase;
    
    b.resize(sz, 0);
    ntt(b);
    Mint inv_sz = Mint(1) / sz;
    if (mult) {
        a.resize(sz, 0);
        ntt(a);
        for(int i = 0; i < sz; i++) a[i] *= b[i] * inv_sz;
        intt(a, false);
        a.resize(need);
    }
    for (int i = 0; i < sz; i++) b[i] *= b[i] * inv_sz;
    intt(b, false);
    b.resize(need);
  }
  
  void pow(vector<Mint> &a, vector<Mint> &b, int p) {
    int len = a.size();
    while (p) {
        sq(a, b, p & 1);
        a.resize(len);
        b.resize(len);
        p >>= 1;
    }
  }
}; 

NumberTheoreticTransformFriendlyModInt<Mint> ntt;

#define TESTS int t; cin >> t; while (t--)
#define TEST 
int main() {
	vvi p(21, vi(8, 0));
	vi pr = {2,3,5,7,11,13,17,19};
	REP1(i, 1, 21) {
		REP(j, 8) {
			int k = i;
			while (k % pr[j] == 0) k /= pr[j], p[i][j]++; 
		}
	}
	
    TESTS {
    	int N;
    	cin >> N;
    	vi A(N);
    	REP(i, N) cin >> A[i];
    	
    	vi cnt(8, 0);
    	vm pre(1 << 8, 0);
    	pre[0] = 1;
    	Mint ans = 0;
    	REP(i, N) {
    		REP(j, 8) cnt[j] += p[A[i]][j];
    		
    		REP(j, 1 << 8) {
    			int x = __builtin_popcount(j);
    			Mint prod = 1;
    			REP(k, 8) {
    				if (!(j >> k & 1)) prod *= cnt[k] + 1;
    			}
    			prod *= pre[j];
    			ans += (x % 2 == 0 ? 1 : -1) * prod;
    		}
    		
    		REP(j, 1 << 8) {
    			Mint prod = 1;
    			REP(k, 8) {
    				if (j >> k & 1) prod *= cnt[k];
    			}
    			pre[j] += prod;
    		}
    	}
    	printf("%d\n", ans.val());
    }
    
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Key Observations:

• Max MADDES (MAD) for Arrays:
• Array [n, n, ..., n] (length n) has MAD = n * n * (n - 1) / 2
• Array [n, n, ..., n, 0] (length n) has MAD = n * n * (n - 1) / 2 - n
• Feasible Range:
• Solutions exist for all m in [0, n * n * (n - 1) / 2 - n]

Construction Strategy:

For small m (0 ≤ m ≤ n):
Use the array [m, 0, ..., 0, m] where the MAD comes from subarrays [m,0,...,0] and [0,...,0,m].

For larger m (m > n):
Start with [n, 0, ..., 0] and iteratively: - Shift ns right (producing arrays like [n, ..., 0, n], [n, ..., n, 0], etc.) - Each shift increases MAD by n - When close to target (delta = m - current_MAD), adjust: [n, ..., n, delta/2, 0, ..., 0, delta/2]

The subarrays [n, ..., n, delta/2] and [delta/2, 0, ..., 0] each contribute delta/2.

Edge Cases:

• Maximum MAD arrays ([n,...,n] and [n,...,n,0]) cannot be adjusted further
• No solution exists when:
• delta is odd
• delta exceeds 2n

Final Notes:

• This strategy covers all feasible m values
• Time Complexity: O(n) per test case

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
using namespace std;
typedef double db; 
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=0;
const ll  INF=2147483647;
int T,n;
ll  m;

int sample()
{
	if(n==4&&m==10) 
	{
		printf("4 2 2 4\n");
		return 1;
	}
	if(n==8&&m==40)
	{
		printf("5 2 1 2 1 5 2 1\n");
		return 1;
	}
	return 0;
}

int main()
{
	//freopen("test.in","r",stdin);
	
	scanf("%d",&T);
	while(T--)
	{
	    scanf("%d%I64d",&n,&m);
	    if(sample()) continue;
	    if(m<=n)
	    {
    		printf("%d",(int)m);
    		for(int i=2;i<n;i++) printf(" 0");
    		printf(" %d\n",(int)m);
    	    continue;
		}
	    else if((ll)n*n*(n-1)/2-n+1<=m&&m<=(ll)n*n*(n-1)/2-1)
	    {
    		printf("-1\n");
    		continue;
    	}
    	int p=n;
    	ll  delta=m-n;
    	vector<int> ans(n+1);
    	ans[1]=ans[n]=n;
    	//
    	while(delta>=n)
    	{
    		delta-=n;
	    	if(ans[p-1]) p=n,ans[n]=n;
	    	else p--,swap(ans[p],ans[p+1]);
	    }
	    if(ans[n]==n)
	    {
	    	if(delta)
	    	{
    		    delta+=n;
    		    ans[n]=delta/2;
    		    for(int i=1;i<n;i++)
    		    {
    		    	if(ans[i]==n&&ans[i+1]==0)
    		    	{
	    		    	ans[i+1]=delta/2;
	    		    	break;
	    		    }
    		    }
	    	}
    	}
    	else
    	{
	    	int p1=0,p2=0;
   	        for(int i=1;i<n;i++)
		    {
    		   	if(ans[i]==n&&ans[i+1]==0)
    		   	{
	    	    	p1=i+1;
	    	    	break;
	    	    }
    		}
    		for(int i=1;i<n;i++)
		    {
    		   	if(ans[i]==0&&ans[i+1]==n)
    		   	{
	    	    	p2=i+1;
	    	    	break;
	    	    }
    		}
    		if(p2) ans[p1]=ans[n]=delta;
    		else   ans[p1]=ans[n]=delta/2;
	    }
    	//
    	for(int i=1;i<=n;i++) printf("%d%c",ans[i],i==n?'\n':' ');
	}
	
	//fclose(stdin);
	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

Let $$$x = n \times k + r$$$, where $$$r$$$ is the remainder when $$$x$$$ is divided by $$$n$$$ ($$$r \lt n$$$).

$$$x + $$$ $$$(x$$$ $$$mod$$$ $$$n)$$$ $$$= n \times k + r + r = n \times k + 2 \times r = n$$$

First case: $$$k = 0$$$

$$$2 \times r = n$$$, $$$r$$$ must be an integer, so we have $$$+1$$$ solution if $$$n$$$ is even.

Second case: $$$k = 1$$$

$$$n + 2 \times r = n$$$, $$$\Rightarrow r = 0$$$, here we have $$$+1$$$ solution for every $$$n$$$.

In general:

If $$$n$$$ is even, we have $$$2$$$ solutions.

If $$$n$$$ is odd, we have only $$$1$$$ solution.

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);

int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        if(n%2) cout<<"1\n";
        else cout<<"2\n";
    }   
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Let $$$n$$$ in canonical form be $$${a_1} ^ {b_1} \times {a_2} ^ {b_2} \times {a_3} ^ {b_3} ...$$$, where $$$a_{i}$$$ is the $$$i-$$$th prime number and $$$b_{i}$$$ is its power. For example: $$$2025 = 2 ^ 0 \times 3 ^ 4 \times 5 ^ 2 \times 7 ^ 0 \times 11 ^ 0 ...$$$.

Let $$$E$$$ be an even square number. That means $$$E = e ^ 2$$$. $$$E$$$ is even, when $$$e$$$ is even too $$$\Rightarrow$$$ $$$E = e ^ 2 = (2 \times k) ^ 2 = 4 \times k^2$$$. We can see that $$$E$$$ is divisible by $$$2^2$$$. $$$E$$$ is square number $$$\Rightarrow$$$ every power is even. So we can represent $$$E = {c_1} ^ {d_1} \times {c_2} ^ {d_2} \times {c_3} ^ {d_3} ...$$$ where $$$c_{i}$$$ is the $$$i-$$$th prime number, $$$d_{i}$$$ is its power, $$$d_{i}$$$ is always even, and we know that $$$2^2$$$ divides $$$O$$$, so $$$d_{1} \ge 2$$$. $$$(*)$$$

Let $$$O$$$ be an odd square number. In analogical way: $$$O = {x_1} ^ {y_1} \times {x_2} ^ {y_2} \times {x_3} ^ {y_3} ...$$$ where $$$x_{i}$$$ is the $$$i-$$$th prime number and $$$y_{i}$$$ is its power. $$$O$$$ is not even, so we know for sure that $$$y_{1} = 0$$$. And $$$O$$$ is square number $$$\Rightarrow$$$ all $$$y$$$ are even numbers. $$$(**)$$$

Now we can calculate $$$f(n)$$$ and $$$g(n)$$$. We know that $$$n = {a_1} ^ {b_1} \times {a_2} ^ {b_2} \times {a_3} ^ {b_3} ...$$$.

From $$$(*)$$$: $$$f(n) = (\lfloor \frac{b_{1}}{2} \rfloor) \times (\lfloor \frac{b_{2}}{2} \rfloor + 1) \times (\lfloor \frac{b_{3}}{2} \rfloor + 1) ...$$$

From $$$(**):$$$ $$$g(n) = (\lfloor \frac{b_{2}}{2} \rfloor + 1) \times (\lfloor \frac{b_{3}}{2} \rfloor + 1) \times (\lfloor \frac{b_{4}}{2} \rfloor + 1) ...$$$

$$$\frac{f(n)}{g(n)} = \lfloor \frac{b_{1}}{2} \rfloor$$$. We know $$$a_{1} = 2$$$, so we must find the largest power of $$$2$$$, which divides $$$n$$$, and the final answer is this power divided by $$$2$$$.

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);

int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        if(n%2) cout<<"0\n";
        else{
            ll cnt=0;
            while(n%2==0){
                n/=2;
                cnt++;
            }
            cout<<(cnt/2)<<"\n";
        }
    }   
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Notice that, we can always swap two odd value and two even values, becuase their sum will always will be a even number greater than 2. Now, In the sorted permutation, all the odd values will be at odd and same for the even values. So, if the all the odd values are at odd indices and even values are at even indices, then we can always sort the permuation (by the first observation).

Now, only case left is when there are odd values which are at even indices and even values are at odd indices. for this case we only need to find a pair such that we can swap the odd value with even value,one such smallest pair is (4, 5). let say we want to swap $$$od$$$ with $$$ev$$$, so just swap the $$$od$$$ with 5 and $$$ev$$$ with 4. then we can swap (5, 4) and again we will swap 5 with $$$od$$$ and $$$ev$$$ with 4.

So, whenever the size of permutation >= 5, it is always possible, and for size <= 4, we can check it with brute force.

For more clear understanding please check this example:

so the final answer is just print "Yes" when the size of permutation >= 5. and for the lower values we can just do brute force.

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);

int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> a(n);
        for(ll i=0;i<n;i++) cin>>a[i];
        if(n>=5) cout<<"YES\n";
        else{
            bool ok=true;
            for(ll i=0;i<n;i++){
                if(a[i]%2!=(i+1)%2) ok=false;
            }
            if(ok) cout<<"YES\n";
            else cout<<"NO\n";
        }
    }   
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

An important observation is that for an $$$i$$$, its contribution for inversions is only related to the type of operation, and not to the arrangement of the numbers before $$$i$$$.

Note:

• $$$left[i]$$$: number of inversions made by $$$a[i]$$$ if we insert it to front.

• $$$right[i]$$$: number of inversions made by $$$a[i]$$$ if we insert it to back.

We can calculate $$$left[i]$$$ and $$$right[i]$$$ for each $$$i$$$ independently using Fenwick tree.

To find the answer for each $$$j$$$, we can sort $$$(left[i],right[i])$$$ by the value of $$$(left[i]-right[i])$$$. Then run the greedy algorithm.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
using namespace std;
typedef double db; 
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=0;
const ll  INF=2147483647;
int T,n;
int a[N],BIT[N],op1[N],op2[N],d[N];

void add(int p,int x)
{
	for(int i=p;i<=n;i+=(i&-i)) BIT[i]+=x;
}

int getsum(int p)
{
	int sum=0;
	for(int i=p;i;i-=(i&-i)) sum+=BIT[i];
	return sum;
}

int main()
{
	scanf("%d",&T);
	while(T--)
	{
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        for(int i=1;i<=n;i++) BIT[i]=0;
        for(int i=1;i<=n;i++)
        {
        	op1[i]=getsum(a[i]-1);
        	op2[i]=getsum(n)-getsum(a[i]);
        	d[i]=op1[i]-op2[i];
        	add(a[i],1);
        }
        ll cur=0;
        for(int i=1;i<=n;i++) cur+=op2[i];
        printf("%I64d ",cur);
        sort(d+1,d+n+1);
        for(int i=1;i<=n;i++)
        {
        	cur+=d[i]; 
        	printf("%I64d%c",cur,i==n?'\n':' ');
        }
	}
	
	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Let's say we have already found the positions of the numbers $$$0$$$, $$$1$$$, $$$\ldots$$$, $$$k-1$$$ and want to find the position where the number $$$k$$$ is hidden. We will add positions of the numbers $$$0$$$, $$$1$$$, $$$\ldots$$$, $$$k-1$$$ to each query and binary search on the remaining positions that are not yet occupied.

Number of queries made is $$$\Sigma_{i=0}^{n-1} \log(n-i) \le 9n+1$$$.

First, let's identify the positions of $$$0$$$ and $$$1$$$. Then we will find that this method is applicable to any $$$x$$$ and $$$x+1$$$.

Let $$$S_0$$$ and $$$S_1$$$ be the sets of possible positions for $$$0$$$ and $$$1$$$, respectively. Initially, $$$S_0 = S_1 = {0, 1, ..., n-1 } $$$.

Case $$$1$$$: $$$S_0 = S_1$$$.

Let $$$lhalf$$$ be a half of $$$S_0$$$, and $$$rhalf = S_0 - lhalf$$$. Consider querying $$$lhalf$$$:

• If the answer is $$$1$$$, we immediately know that $$$0$$$ is in $$$lhalf$$$ and $$$1$$$ is in $$$rhalf$$$.

• If the answer is $$$ \gt 1$$$, we immediately know that both $$$0$$$ and $$$1$$$ are in $$$lhalf$$$.

• If the answer is $$$0$$$, we need to query rhalf once more to determine the distribution of $$$0$$$ and $$$1$$$.

Through this operation, we reduce the size of both $$$S_0$$$ and $$$S_1$$$ by half. If randomization is used, the expected number of queries needed is $$$\frac{3}{2}$$$.

Case 2: $$$S_0$$$ and $$$S_1$$$ are disjoint.

Similarly, we randomly select half of $$$S_0$$$, $$$lhalf_0$$$, and half of $$$S_1$$$, $$$lhalf_1$$$. Consider querying $$$lhalf_0 ∪ lhalf_1$$$:

• If the answer is $$$1$$$ or $$$ \gt 1$$$, we can reduce the size of both $$$S_0$$$ and $$$S_1$$$ by half with just one query.

• Otherwise, we need to spend an additional query on $$$rhalf_0 ∪ lhalf_1$$$.

The total (expected) number of queries is $$$\frac{3}{4}$$$ of the easy version (i.e. $$$\frac{3}{4}\ \cdot 9n=6.75n$$$ ).

What is the probability that the number of queries exceeds $$$7n$$$? After transformation, this problem is equivalent to tossing a uniform coin $$$5000$$$ times, with a probability of facing up more than $$$3000$$$ times. This is a binomial distribution. We approximate it using a normal distribution, calculate the Z-value, and query the table. We can know that the probability is less than $$$10^{-9}$$$, which is small enough.

#include <bits/stdc++.h>
#define endl '\n'

using ll = long long;
using namespace std;

const ll MOD = 1e9 + 7;

int perm[1026];
int id[1026];

void solve()
{
    int n;

    cin >> n;

    set <int> st;

    for (int i = 0; i < n; i++)
    {
        perm[i] = id[i] = 0;
        st.insert(i);
    }

    for (int i = 0; i < n; i++)
    {
        int l = 0, r = st.size() - 1;
        int mid, pos = *(st.rbegin());

        while (l < r)
        {
            mid = l + r >> 1;

            vector <int> query;

            for (int q = 0; q < i; q++)
            {
                query.push_back(id[q]);
            }

            int curr = -1;
            int last = 0;

            for (auto it : st)
            {
                curr++;
                query.push_back(it);

                if (curr == mid)
                {
                    last = it;

                    break;
                }
            }

            cout << "? " << query.size();

            for (auto it : query)
            {
                cout << " " << it;
            }

            cout << endl;
            cout.flush();

            int mex;

            cin >> mex;

            if (mex > i)
            {
                r = mid;
                pos = last;
            }
            else
            {
                l = mid + 1;
            }
        }

        perm[pos] = i;
        st.erase(pos);
        id[i] = pos;

        cout << "! " << pos << " " << i << endl;
        cout.flush();
    }
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t;

    cin >> t;

    while (t--)
    {
        solve();
    }

    return 0;
}

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

#define all(x) x.begin(),x.end()

const int N = 2000;
int n, ans[N];

vector<int> f; // position of already found nums

int ask(vector<int> &v) { // asking funciton for case 1
    cout << "? " << (int)v.size() + (int)f.size(); 
    for(int &x : f) cout << ' ' << x-1;
    for(int &x : v) cout << ' ' << x-1;
    cout << endl;

    int mex;
    cin >> mex;
    return mex;
}

int ask(vector<int> &v, vector<int> &u) { // asking function for case 2
    cout << "? " << (int)v.size() + (int)u.size() + (int)f.size();
    for(int &x : f) cout << ' ' << x-1;
    for(int &x : v) cout << ' ' << x-1;
    for(int &x : u) cout << ' ' << x-1;
    cout << endl;

    int mex;
    cin >> mex;
    return mex;
}

void answer(int i,int v)
{
    cout<<"! "<<i<<' '<<v<<endl;
    cout<<flush;
}

void rand_shuffle(vector<int> &v, vector<int> &q1, vector<int> &q2) {
    int sz = v.size();
    for(int i = 0; i < sz; ++i) { // random shuffle
        int j = rand() % (i + 1);
        swap(v[i], v[j]);
    }
    for(int i = 0; i < sz; ++i) {
        if(i + i < sz) {
            q1.push_back(v[i]);
        } else {
            q2.push_back(v[i]);
        }
    }
}

void solve() {
    cin >> n;

    set<int> pos;
    for(int i = 1; i <= n; ++i) pos.insert(i);

    for(int cur = 1; cur < n; cur += 2) {
        vector<int> A(all(pos)), B(all(pos));

        while(A.size() > 1 || B.size() > 1) {

            bool ok = (A[0] == B[0]); // To check for case 1 or 2
            vector<int> q1, q2, q3, q4;

            rand_shuffle(A, q1, q2); // shuffle and split the set S0
            
            if(ok) { // Case 1 : S0 == S1

                int mex = ask(q1);
                if(mex > cur) {  
                    A = q1;
                    B = q1;
                } else if(mex == cur) {
                    A = q1;
                    B = q2;
                } else {
                    mex = ask(q2);
                    if(mex > cur) {
                        A = q2;
                        B = q2;
                    } else {
                        A = q2;
                        B = q1;
                    }
                }

            } else { // Case 2 : S0 != S1

                rand_shuffle(B, q3, q4); // shuffle and split the set S1

                int mex = ask(q1, q3);
                if(mex > cur) {
                    A = q1;
                    B = q3;
                } else if(mex == cur) {
                    A = q1;
                    B = q4;
                } else {
                    mex = ask(q2, q3);
                    if(mex > cur) {
                        A = q2;
                        B = q3;
                    } else {
                        A = q2;
                        B = q4;
                    }
                }
            }
        }

        //
        answer(A[0]-1,cur-1);
        answer(B[0]-1,cur);
        //

        ans[A[0]] = cur - 1; // fill the answer
        ans[B[0]] = cur;

        pos.erase(A[0]); // erase the already used positions 
        pos.erase(B[0]);

        f.push_back(A[0]); // add used positions for all future queries
        f.push_back(B[0]);
    }

    if(n & 1) {
        answer(*pos.begin()-1,n-1);
        
        ans[*pos.begin()] = n - 1;
    }

    /*
    cout << "!";
    for(int i = 1; i <= n; ++i) cout << ' ' << ans[i];
    cout << endl; 
    */

    f.clear();
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    srand(chrono::steady_clock::now().time_since_epoch().count());
    
    int tt = 1; 
    cin >> tt;
    while(tt--) {
        solve();
    }
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Note $$$b[i]$$$: Number of $$$j$$$'s with $$$a[j] \gt = i$$$.

Let's see what happens when a move happens.

$$$oldb[i]=(number\ of\ olda[j]=i)+(number\ of\ olda[j] \gt i)$$$.

For all $$$L \lt =i \lt R$$$, all $$$a[j]=i$$$ has been decreased by $$$1$$$ so $$$newb[i]=(number\ of\ olda[j] \gt i)=oldb[i+1]$$$. This is left shift $$$b[L...R]$$$.

What about $$$b[R]$$$? Since we can choose any $$$a[j]=R$$$, the value range of $$$newb[R]$$$ is $$$[oldb[R+1],oldb[R]]$$$.

Generally, doing an operation in $$$[L,R]$$$ is to set $$$b[L]:=\ a\ value\ in\ [b[R+1],b[R]]$$$, then left shift $$$b[L...R]$$$.

Consider different $$$R$$$ (including $$$+\infty$$$), the value range of $$$b[L]$$$ is $$$[0,b[L]-1]$$$, this corresponds to "taking any number ($$$ \gt 0$$$) of stones from the pile of stones in $$$b[L]$$$".

Conclusion: Assuming a player chooses the interval $$$[L, R]$$$ and reduces $$$x$$$ numbers by $$$1$$$. Observe the corresponding changes in the $$$b$$$ array, which corresponds to reducing $$$b[a[L]]$$$ by $$$x$$$ and reordering the array $$$b$$$.

Overall, the game is classical nim game on array $$$b$$$.

So we only need to calculate the xor sum of array $$$b$$$. If the xor sum is $$$0$$$, then the answer is "NO". Otherwise, the answer is "YES".

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
using namespace std;
typedef double db; 
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=0;
const ll  INF=2147483647;
int T,n;
int a[N],b[N];

int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++) scanf("%d",&a[i]);
		int NIM_SUM=0,cur=0;
		vector<int>  v;
		map<int,int> cnt;
		v.push_back(0);
		for(int i=1;i<=n;i++)
		{
			if(!cnt[a[i]]) v.push_back(a[i]);
			cnt[a[i]]++;
		}
		sort(v.begin(),v.end());
		for(int i=v.size()-1;i;i--)
		{
			cur+=cnt[v[i]];
			if((v[i]-v[i-1])&1) NIM_SUM^=cur;
		}
		printf("%s\n",NIM_SUM?"YES":"NO");
	}
	
	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

Problem Description

Since the constraints are small, you only need to simulate this process.

You are tasked with finding the minimum number of bandages required to defeat a dragon using a sword. The sword deals:

• 1 damage if the i-th attack is not divisible by 3.
• 2 damage if the i-th attack is divisible by 3.

If your health will becomes less than $$$0$$$ when the dragon attack you (in other words, your hp is less than $$$k$$$) , you must use a bandage.

void solve(){
    int h,k,n;cin>>h>>k>>n;
    int ans = 0, l = k, r = 1;
    while(h > 1){
        r++;
        k -= n;
        if(k <= 0){
            k = l - n;
            ans++;
        }
        if(r % 3 == 0){
            h-=2;
        }else{
            h--;
        }
    }
    cout<<ans<<endl;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Problem Statement

OwlBear is attacking a village. The village has n cannons, each dealing a_i damage. At the k-th second, the OwlBear is protected from the cannon at index (*k*-1) mod n. Given q queries, each with a damage threshold h, find the minimum number of seconds required to deal at least h damage.

Analysis

The key idea is to precompute the prefix sums of the damage dealt in each second, excluding the blocked cannon. Let sum be the total damage all cannons can deal in one second. Then, the damage dealt in the i-th second is sum - a[i % n]. We can create a prefix sum array p where p[i] stores the total damage dealt from second 1 to second i.

To answer a query with damage h, we can first calculate how many full cycles of n seconds are needed. This can be done by ans = h / p[n-1]. The remaining damage is h -= (ans * p[n-1]). Then, we multiply ans by n to get the number of seconds in full cycles. If there is still remaining damage (h > 0), we use binary search (specifically lower_bound) on the prefix sum array p to find the minimum number of additional seconds needed.

Solution

1. Read n and the damage array a.
2. Calculate the total damage sum and create the prefix sum array p where p[i] = sum - a[i] and accumulate the prefix sums.
3. For each query h:
   • Calculate the number of full cycles: ans = h / p[n-1].
   • Update the remaining damage: h -= (ans * p[n-1]).
   • Multiply ans by n.
   • If h > 0, use lower_bound on p to find the index of the first value greater than or equal to h. Add this index + 1 to ans to get the final answer.

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

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int tc;
    cin >> tc;
    while (tc--) {
        int n;
        cin >> n;
        vector<ll> a(n), p(n);
        for (int i = 0; i < n; i++) cin >> a[i];
        ll sum = 0;
        for (int i = 0; i < n; i++) sum += a[i];
        for (int i = 0; i < n; i++) p[i] = sum - a[i];
        for (int i = 1; i < n; i++) p[i] += p[i - 1];
        int q;
        cin >> q;
        while (q--) {
            ll h;
            cin >> h;
            ll ans = h / p[n - 1];
            h -= (ans * p[n - 1]);
            ans *= n;
            if (h) ans += lower_bound(p.begin(), p.end(), h) - p.begin()+1;
            cout << ans << '\n';
        }
    }
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

We can set $$$a_{i,j} = a_{j,i} = i + j$$$ for $$$i \neq j$$$, and set $$$a_{i,i} = 2$$$ for all $$$1 \le i \le n$$$.

Now, if $$$n$$$ is even, all conditions are met.

If $$$n$$$ is odd, the XOR of all elements is $$$2$$$. To balance out that $$$2$$$, we can add $$$2$$$ to $$$a_{3,1}$$$.

We set $$$a_{i,j}$$$ as the minimum prime factor of (i+j).

Now, if $$$n$$$ is even, all conditions are met.

If $$$n$$$ is odd, the XOR of all elements is $$$2$$$. There are $$$2$$$ cases:

• $$$n \le 17$$$. In this case we change $$$a_{1,1}$$$ to $$$4$$$ and $$$a_{2,2}$$$ to $$$6$$$.

• $$$n \gt 17$$$. In this case we change $$$a_{17,18}$$$ from $$$5$$$ to $$$7$$$.

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

int main(){

	ios_base::sync_with_stdio(false); cin.tie(NULL);

	int t;
	cin>>t;

	while(t--){

		int n;
		cin>>n;

		vector<vector<int>> a(n+1,vector<int>(n+1,0));

		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(i==j) a[i][j] = 2;
				else a[i][j] = i+j;
			}
		}

		if(n&1){
			a[3][1] = 6;
		}

		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++) cout << a[i][j] << ' ';
			cout << endl;
		}

	}
	
	return 0;
}

#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 <typename T>
using os = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using oms = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
 
#define mod  1000000007
#define mod2 998244353
#define ll long long
#define bl __int128_t
#define pb push_back
#define all(v) v.begin(),v.end()
#define bs binary_search
#define rall(v) v.rbegin(),v.rend()
#define lb lower_bound
#define ub upper_bound
#define pl pair<ll,ll>
#define f(i,n) for(ll i=0;i<n;i++)
#define inp(a,n) vector<ll> a(n); f(i,n) cin>>a[i]
#define pyes cout<<"YES\n"
#define pno cout<<"NO\n"
using Mat = array<array<ll,2>,2>;
 
#pragma GCC optimize("unroll-loops")
#pragma gcc optimize("Ofast")
#pragma GCC optimization("Ofast")
#pragma optimize(Ofast)
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("popcnt")
 
ll power(ll x,ll y,ll z=LLONG_MAX){
	ll res=1;
	while(y>0){
		if(y%2) res=(res*x)%z;
		y/=2;
		if(y) x=(x*x)%z;
	}return res%z;
}
 
ll gcd(ll a,ll b,ll& x,ll& y){
	x=1,y=0;
	ll x1=0,y1=1,a1=a,b1=b;
	while(b1){
		ll q=a1/b1;
		tie(x,x1)=make_tuple(x1,x-q*x1);
		tie(y,y1)=make_tuple(y1,y-q*y1);
		tie(a1,b1)=make_tuple(b1,a1-q*b1);
	}return a1;
}
 
#define MX 1e4
vector<ll> spf(MX+2,1);
vector<ll> gpf(MX+2,0);
void sieve(){
	spf[0]=0;
	for(ll i=2;i<3;i++){
		if(spf[i]==1){
			for(ll j=i;j<MX+1;j+=i) if(spf[j]==1) spf[j]=i;
		}
	}for(ll i=3;i<MX+1;i+=2){
		if(spf[i]==1){
			for(ll j=i;j<MX+1;j+=i) if(spf[j]==1) spf[j]=i;
		}
	}for(ll i=2;i<=MX;i++) if(gpf[i]==0) for(ll j=i;j<=MX;j+=i) gpf[j]=i;
	return; 
}
 
int main(){
	ios_base::sync_with_stdio(false); cin.tie(NULL);
	ll t=1,i,j,n,m,z=1e9+7,z2=998244353,k,x,y,q;
	sieve(); // for SPF
	cin>>t;
	ll tt=t;
	string s,s2;
	while(tt--){
		cin>>n;
		assert(n!=1ll);
		vector<vector<ll>> a(n+1ll,vector<ll>(n+1ll,0ll));
		f(i,n) f(j,n) a[i+1][j+1] = spf[i+j+2ll];
		if(n%2ll == 1ll){
			if(n>18){
				a[17][18] = 7;
			}
			else{
				a[2][2] = 4ll;
				a[3][3] = 6ll;
			}
		}
		f(i,n){
			f(j,n) cout<<a[i+1][j+1]<<' ';
			cout<<'\n';
		}
	}
	return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

There are only $$$n$$$ possible different shifts.Let's calculate cost for each of them in O(1).

Assume one-based indexing for array.
Let cost[i] represent the cost of the array after i shifts.

Initial cost:
cost[0] = 1*a1 + 2*a2 + ... + n*an

cost after first shift:

Rewriting cost[1] in terms of cost[0]

cost after second shift:

Rewriting cost[2] in terms of cost[1]

The generalized formula cost[i] from cost[i-1] terms :

Why the generalized formula is correct?

Using this formula, we can compute the cost for all shifts in O(1) per shift and take minimum among all, resulting in an overall complexity of O(n).

Let's take

$$$ cost_0 = 1 * a_1 + 2 * a_2 + ... + n * a_n $$$

$$$ sum = a_1 + a_2 + ... + a_n $$$

for now let's assume no updates on array ( i.e NO query 1 ( static array ) ). In easy version, we know for i>=1

$$$ cost_i = cost_{i-1} - sum + n * a_i $$$

$$$cost_i$$$ in terms of $$$cost_{i-2}$$$ :

If we continue this, we can express the cost at the i-th shift in terms of the 0-th shift:

Now, if there are updates in the array, the formula for the cost is modified. When an update occurs at inddex $$$ind$$$ , we modify the initial cost as follows:

let's say,

prev = $$$a_{ind}$$$ before update

curr = $$$a_{ind}$$$ after update

we modify the initial cost as follows:

The sum also changes:

To efficiently manage the updates and calculate the prefix sum, we can use Fenwick tree or segment tree (You can learn more about it https://www.hackerearth.com/practice/notes/binary-indexed-tree-or-fenwick-tree/ ).

Thus, the final formula after k shifts, considering updates, is:

Time Complexity: $$$ O((n+q)*logn) $$$

Space Complexity:$$$ O(n+q) $$$

#include<bits/stdc++.h>
using namespace std;
 
int main(){
 
    long long t;
    cin>>t;
 
    while(t--)
    {
        long long n;
        cin>>n;
        long long a[n];
        long long sum=0;
        long long ans=0;
        for(long long i=0;i<n;i++)
        {
            cin>>a[i];
            sum+=a[i];
            ans+=((i+1)*a[i]);
        }
 
        long long cost=ans;
        for(long long i=0;i<n;i++) 
        {
            cost=cost-sum+n*a[i];
            ans=min(ans,cost);
        }
        cout<<ans<<"\n";
    }
 
    return 0;
}

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

long long BIT[200000]={0}, a[200000]={0}, n;
void update(long long x, long long delta)
{
      for(; x <= n; x += x&-x)
        BIT[x] += delta;
}
long long query(long long x)
{
     long long sum = 0;
     for(; x > 0; x -= x&-x)
        sum += BIT[x];
     return sum;
}

int main() {

    long long t;
    cin>>t;
    while(t--) 
    {
        cin>>n;
        long long cost=0;
        long long sum=0;
        for(long long i=0;i<n;i++)
        {
            cin>>a[i];
            update(i+1,a[i]);
            cost+=((i+1)*a[i]);
            sum+=a[i];
        }

        long long q;
        cin>>q;

        while(q--)
        {
            long long ty;
            cin>>ty;
            if(ty==1)
            {
                long long ind,x;
                cin>>ind>>x;
                cost-=((ind)*(a[ind-1]));
                sum+=(x-a[ind-1]);
                update(ind,x-a[ind-1]);
                a[ind-1]=x;
                cost+=((ind)*(a[ind-1]));
            }
            else
            {
                long long k;
                cin>>k;
                k%=n;
                cout<<cost-(k)*(sum)+n*(query(k))<<"\n";
            }
        }

        for(int i = 0; i < n; i++) update(i + 1, -a[i]);
    }

    return 0;
}

#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 <typename T>
using os = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using oms = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
 
#define mod  1000000007
#define mod2 998244353
#define ll long long
#define bl __int128_t
#define pb push_back
#define all(v) v.begin(),v.end()
#define bs binary_search
#define rall(v) v.rbegin(),v.rend()
#define lb lower_bound
#define ub upper_bound
#define pl pair<ll,ll>
#define f(i,n) for(ll i=0;i<n;i++)
#define inp(a,n) vector<ll> a(n); f(i,n) cin>>a[i]
#define pyes cout<<"YES\n"
#define pno cout<<"NO\n"
using Mat = array<array<ll,2>,2>;
 
#pragma GCC optimize("unroll-loops")
#pragma gcc optimize("Ofast")
#pragma GCC optimization("Ofast")
#pragma optimize(Ofast)
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("popcnt")
 
ll power(ll x,ll y,ll z=LLONG_MAX){
    ll res=1;
    while(y>0){
        if(y%2) res=(res*x)%z;
        y/=2;
        if(y) x=(x*x)%z;
    }return res%z;
}
 
ll gcd(ll a,ll b,ll& x,ll& y){
    x=1,y=0;
    ll x1=0,y1=1,a1=a,b1=b;
    while(b1){
        ll q=a1/b1;
        tie(x,x1)=make_tuple(x1,x-q*x1);
        tie(y,y1)=make_tuple(y1,y-q*y1);
        tie(a1,b1)=make_tuple(b1,a1-q*b1);
    }return a1;
}
 
template<class T, class U>
// T -> node, U->update.
struct Lsegtree{
    vector<T>st;
    vector<U>lazy;
    ll n;
    T identity_element; // related to query
    U identity_update;  // related to update
    Lsegtree(ll n, T identity_element, U identity_update)
    {
        this->n = n;
        this->identity_element = identity_element;
        this->identity_update = identity_update;
        st.assign(4*n,identity_element);
        lazy.assign(4*n, identity_update);
    }
    T combine(T l, T r)
    {
        // change this function as required.
        // related to query
        T ans = l + r;
        return ans;
    }
    void buildUtil(ll v, ll tl, ll tr, vector<T>&a)
    {
        if(tl == tr)
        {
            st[v]=a[tl];
            return;
        }
        ll tm = (tl + tr)/2;
        buildUtil(2*v + 1, tl, tm,a);
        buildUtil(2*v + 2,tm+1,tr,a);
        st[v] = combine(st[2*v + 1], st[2*v + 2]);
    }
    // change the following 2 functions, and you're more or less done.
    T apply(T curr, U upd, ll tl, ll tr)
    {   
        // related to update and query
        T ans = (upd)*(tr-tl+1);
        return ans;
    }
    U combineUpdate(U old_upd, U new_upd, ll tl, ll tr)
    {   
        // related to update
        U ans = old_upd;
        ans=(new_upd);
        return ans;
    }  
    void push_down(ll v, ll tl, ll tr)
    {
        if(lazy[v] == identity_update)return;
        st[v] = apply(st[v], lazy[v], tl, tr);
        if(2*v + 2 < 4*n)
        {
            ll tm = (tl + tr)>>1;
            lazy[2*v + 1] = combineUpdate(lazy[2*v+1], lazy[v], tl, tm);
            lazy[2*v + 2] = combineUpdate(lazy[2*v+2], lazy[v], tm+1,tr);            
        }
        lazy[v] = identity_update;
    }
    T queryUtil(ll v, ll tl, ll tr, ll l, ll r)
    {
        push_down(v,tl,tr);
        if(l > r)return identity_element;
        if(tr < l or tl > r)
        {
            return identity_element;
        }
        if(l <= tl and r >= tr)
        {
            return st[v];
        }
        ll tm = (tl + tr)>>1;
        return combine(queryUtil(2*v+1,tl,tm,l,r), queryUtil(2*v+2,tm+1,tr,l,r));
    }
    void updateUtil(ll v, ll tl, ll tr, ll l, ll r, U upd)
    {
        push_down(v,tl,tr); 
        if(tr < l or tl > r)return;
        if(tl >=l and tr <=r)
        {
            lazy[v] = combineUpdate(lazy[v],upd,tl,tr);
            push_down(v,tl,tr);
        }
        else
        {
            ll tm = (tl + tr)/2;
            updateUtil(2*v+1,tl,tm,l,r,upd);
            updateUtil(2*v+2,tm+1,tr,l,r,upd);
            st[v] = combine(st[2*v + 1], st[2*v+2]);
        }
    }
    void build(vector<T>a)
    {
        assert(a.size() == n);
        buildUtil(0,0,n-1,a);
    }
    T query(ll l, ll r)
    {
        return queryUtil(0,0,n-1,l,r);
    }
    void update(ll l,ll r, U upd)
    {
        updateUtil(0,0,n-1,l,r,upd);
    }
    ll find_ind(ll v,ll tl,ll tr,ll x){
        // have to store maximums for this to work
        if(st[v]>x) return 0;
        if(tl==tr) return tl;
        ll tm=(tl+tr)/2;
        if(st[v+v+1]<=x) return find_ind(v+v+1,tl,tm,x);
        else return find_ind(v+v+2,tm+1,tr,x-st[v+v+1]);
    }
};
 
int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    ll t=1,i,j,n,m,z=1e9+7,z2=998244353,k,x,y,q;
    // sieve(); // for SPF
    cin>>t;
    ll tt=t;
    string s,s2;
    while(tt--){
        ll n;
        cin>>n;
        inp(a,n);
        ll sum = accumulate(all(a),0ll);
        ll val = 0ll;
        f(i,n) val += ((i+1)*a[i]);
        Lsegtree<ll,ll> sega(n,0ll,LLONG_MIN);
        sega.build(a);
 
        ll q;
        cin>>q; 
        while(q--){
            ll x;
            cin>>x;
            if(x==1ll){
                ll ind,p;
                cin>>ind>>p;
                ind--;
                sega.update(ind,ind,p);
                sum += (p-a[ind]);
                val += ((ind+1)*(p-a[ind]));
                a[ind] = p;
            }
            else{
                ll k;
                cin>>k;
                k %= n;
                ll ans = val;
                if(k>0ll){
                    ans += (n*sega.query(0ll,k-1ll));
                    ans -= (k*sum);
                }
                cout<<ans<<'\n';
            }
        }
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Solution 1:

This algorithm is a randomized algorithm.

We randomly select two fixed points $$$x$$$ and $$$y$$$, then for all $$$z \neq x, y$$$, query "? $$$x$$$ $$$y$$$ $$$z$$$". If the result is 0, it means $$$z$$$ and $$$x$$$ are on the same side of $$$y$$$; otherwise, $$$z$$$ and $$$x$$$ are on different sides of $$$y$$$.

Thus, we use $$$y$$$ as the pivot and partition the elements into the left and right halves. To determine which side is the actual left half, we need to perform type $$$1$$$ operation once, (this is only required in the first partitioning step. After determining the correct position of $$$y$$$, no more operations of this type are needed).

Once we know the correct position of $$$y$$$, we can recursively solve the left and right halves.

You might have already noticed that this is essentially the process of quick sort. Therefore, the complexity proof is identical to that of quicksort.

Solution 2:

This algorithm is a deterministic algorithm.

If we can determine the value of $$$p[1]$$$, then we can perform a comparison "? $$$p[1]$$$ $$$x$$$ $$$y$$$", where we compare two numbers.

The method to determine $$$p[1]$$$ is given by the following code:

int u = 1, v = 2;
for (int i = 3; i <= n; i++) {
    int res = ask(u, i, v);
    if (!res) {
        res = ask(u, v, i);
        if (res) v = i;
        else u = i;
    }
}
cout << "1 " << u << ' ' << v << endl;
int res;
cin >> res;
if (!res) swap(u, v);

After determining $$$p[1]$$$, you can solve the problem using any $$$O(n \log n)$$$ sorting algorithm.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=0;
const ll  INF=2147483647;
int T,n,keypos;
int p[N];
/*
 // 创建随机数生成器
std::random_device rd; // 获得随机种子
std::mt19937 g(rd());  // 使用Mersenne Twister引擎
*/

void init()
{
    srand(time(0));
    cin>>n;
    keypos=0;
}

int ask1(int x,int y)
{
    int t;
    cout<<"1 "<<x<<" "<<y<<"\n";
    cout.flush();
    cin>>t;
    return t;
}

int ask2(int x,int y,int z)
{
    int t;
    cout<<"2 "<<x<<" "<<y<<" "<<z<<"\n";
    cout.flush();
    cin>>t;
    return t;
}

void work(int L,int R,vector<int> &v)
{
    if(L>R) return ;
    if(L==R)
    {
        p[L]=v[0];
        return ;
    }
    if(L==R-1)
    {
        if(R<keypos)
        {
            if(!ask2(v[0],v[1],p[keypos])) swap(v[0],v[1]);
        }
        else
        {
            if(!ask2(v[1],v[0],p[keypos])) swap(v[0],v[1]);
        }
        p[L]=v[0];
        p[R]=v[1];
        return ;
    }
    // 使用std::shuffle打乱vector
    int midpos;
    vector<int> lhalf,rhalf;

    //shuffle(v.begin(), v.end(), g);
    random_shuffle(v.begin(), v.end());
    lhalf.push_back(v[0]);
    /*
    cout<<"L="<<L<<" R="<<R<<"\n shuffled v[]=";
    for(int i=0;i<v.size();i++) cout<<v[i]<<' ';
    cout<<"\n";
    //
    //
    cout<<"lhalf[]=";
    for(int i=0;i<lhalf.size();i++) cout<<lhalf[i]<<' ';
    cout<<"\n";
    */
    for(int i=2;i<v.size();i++)
    {
        if(ask2(v[0],v[1],v[i])) rhalf.push_back(v[i]);
        else lhalf.push_back(v[i]);

        /*
        cout<<"lhalf[]=";
        for(int i=0;i<lhalf.size();i++) cout<<lhalf[i]<<' ';
        cout<<"\n";
        */
    }
    if(!keypos)
    {
        if(!ask1(v[0],v[1])) swap(lhalf,rhalf);
        midpos=lhalf.size()+1;
        p[midpos]=v[1];
        keypos=midpos;
        //
        //printf("keypos=%d\n",keypos);
        //
    }
    else
    {
        if(R<keypos)
        {
            if(!ask2(v[0],v[1],p[keypos])) swap(lhalf,rhalf);
        }
        else
        {
            if(!ask2(v[1],v[0],p[keypos])) swap(lhalf,rhalf);
        }
        midpos=lhalf.size()+L;
        p[midpos]=v[1];
    }
    /*
    cout<<"lhalf[]=";
    for(int i=0;i<lhalf.size();i++) cout<<lhalf[i]<<' ';
    cout<<"\n";
    cout<<"rhalf[]=";
    for(int i=0;i<rhalf.size();i++) cout<<rhalf[i]<<' ';
    cout<<"\n";
    */
    work(L,midpos-1,lhalf);
    work(midpos+1,R,rhalf);
}

void solve()
{
    vector<int> v;
    for(int i=1;i<=n;i++) v.push_back(i);
    work(1,n,v);
    cout<<"! ";
    for(int i=1;i<=n;i++) cout<<p[i]<<(i==n?'\n':' ');
    cout.flush();
}

//-------------------------------------------------------

void gen_data()
{
    srand(time(NULL));
}

int bruteforce()
{
    return 0;
}

//-------------------------------------------------------

int main()
{
    //fastio;

	cin>>T;
	while(T--)
	{
		init();
		solve();

		/*

		//Stress Test

		gen_data();
		auto ans1=solve(),ans2=bruteforce();
		if(ans1==ans2) printf("OK!\n");
		else
		{
			//Output Data
 		}

		*/
	}

	return 0;
}

// Problem: G. Interactive is Fun
// Contest: Codeforces - TheForces Round #39 (DIV4-Forces)
// URL: https://mirror.codeforces.com/gym/105651/problem/G
// Memory Limit: 256 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#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;
	vector<int> p(n + 1);
	for (int i = 1; i <= n; i++) p[i] = i;
	auto ask = [&](int x, int y, int z) -> bool {
		cout << "2 " << x << ' ' << y << ' ' << z << endl;
		int res; cin >> res;
		return res;
	};
	int u = 1, v = 2;
	for (int i = 3; i <= n; i++) {
		int res = ask(u, i, v);
		if (!res) {
			res = ask(u, v, i);
			if (res) v = i;
			else u = i;
		}
	}
	cout << "1 " << u << ' ' << v << endl;
	int res; cin >> res;
	if (!res) swap(u, v);
	stable_sort(p.begin() + 1, p.end(), [&](int i, int j) {
		return ask(u, i, j);
	});
	cout << "! ";
	for (int i = 1; i <= n; i++) cout << p[i] << " ";
	cout << 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: Didn't solve:

Note that performing an operation is always optimal as it won't decrease the answer.

At first, lets find the number of good subarrays before applying the operation. For this, the condition is $$$a_l + a_{l+1} ... + a_r \gt = k*(r-l+1)$$$ which is $$$pre[r] - k*r \gt = pre[l-1] - k*(l-1)$$$. So we can make a new array $$$b$$$ where $$$b_i = pre[i] - k*i$$$ and the initial number of good subarrays is equal to the number of inversions in the array $$$b$$$.

Now, lets say we increment $$$a_i$$$ by $$$1$$$ for some $$$i$$$, then the additional good subarrays formed should have their left boundary to the left of $$$i$$$ or equal to $$$i$$$ and their right boundary to the right of $$$i$$$ or equal to $$$i$$$ $$$(i.e., l \le i \le r)$$$ and $$$b_r = b_{l-1} - 1$$$. If we have the number of additional good subarrays when the operation is performed at $$$i^{th}$$$ position, we can easily find the number of additional good subarrays when the operation is performed at $$$(i+1)^{th}$$$ position using a map.

Finally we take maximum over all positions and add it to the initial answer.

#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 <typename T>
using os = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using oms = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define ll long long

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin >> t;

    while (t--) {
        ll n, k;
        cin >> n >> k;

        vector<ll> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }

        vector<ll> b(n + 1, 0ll);
        for (int i = 0; i < n; i++) {
            b[i + 1] = b[i] + (a[i] - k);
        }

        ll ans = 0;

        oms<ll> inv;
        inv.insert(0);

        for (int i = 0; i < n; i++) {
            ans += inv.order_of_key(b[i + 1] + 1);
            inv.insert(b[i + 1]);
        }

        ll mx = 0;
        map<ll, ll> left, right;

        for (int i = 0; i < n; i++) {
            right[b[i + 1]]++;
        }

        left[0]++;
        ll val = 0;

        for (int i = 0; i < n; i++) {
            if (b[i + 1] == -1) {
                val++;
            }
        }

        mx = val;

        for (int i = 2; i <= n; i++) {
            val += right[b[i - 1] - 1];
            val -= left[b[i - 1] + 1];

            left[b[i - 1]]++;
            right[b[i - 1]]--;

            mx = max(mx, val);
        }

        ans += mx;
        cout << ans << '\n';
    }
    return 0;
}

Amazing problem:

Good problem:

Average problem:

Bad problem:

Didn't solve:

Assume that the number of colors $$$c$$$ is fixed. Let $$$mx[i][j]$$$ represent the length of the continuous path ending at node $$$i$$$ with color $$$j$$$. How do we construct $$$mx$$$?

Let's try some approaches. For the connected component formed by the first $$$k$$$ nodes, we can use color 1 for all of them. In this case, the $$$i$$$-th node's $$$mx$$$ array (for $$$1 \le i \le k$$$) would be:
$$$mx[i] = [ i-1 ,0, \dots, 0]$$$.

For the $$$(k+1)$$$-th node, we can use color 2 to connect the connected component formed by the first $$$k-1$$$ nodes. Thus, the $$$(k+1)$$$-th node's $$$mx$$$ array would be:
$$$mx[k+1] = [0, 1, 0, \dots, 0]$$$.

For the $$$(k+2)$$$-th node, we can use color 2 to connect the connected component formed by the first $$$k-1$$$ nodes and color 1 to connect node $$$k$$$. In this case, the $$$(k+2)$$$-th node's $$$mx$$$ array would be:
$$$mx[k+2] = [1, 1,0, \dots, 0]$$$.

At this point, you might realize: The $$$i$$$-th node's $$$mx$$$ array is exactly the $$$(i-1)$$$ in base $$$k$$$ as a mask!

Claim $$$1$$$: for two indices $$$i$$$ and $$$j(i \lt j)$$$, $$$mx[i] \neq mx[j]$$$.

Proof $$$1$$$: if we use color $$$k$$$ to connect node $$$i$$$ and $$$j$$$, $$$mx[i][k]+1=mx[j][k]$$$ must hold.

So we can assign values to each node's $$$mx$$$ array using a $$$k$$$-base mask from $$$0$$$ to $$$n-1$$$, which gives us a lower bound on the answer.

Claim $$$2$$$: we can always reach this lower bound.

Proof $$$2$$$: for two indices $$$i$$$ and $$$j(i \lt j)$$$, find $$$k$$$ such that $$$mx[i][k] \lt mx[j][k]$$$, then use color $$$k$$$ to connect node $$$i$$$ and $$$j$$$.

277722333

• $$$a[1][2]=a[2][1]=a[n-1][m]=a[n][m-1]='.'$$$ must hold.

• We can simply find the shortest path using BFS.

• Robot B can follow behind Robot A. That is, Return to $$$(1,1)$$$ in two steps, then "track" A. So the lower bound of our answer is the shortest path length+2.

• The only remaining problem is: how to find two disjoint shortest paths?

To to find two disjoint shortest paths, we have a classic idea: only walk along the edge of the shortest path tree.

That is, note $$$dis[x]$$$ as the distance from $$$s$$$ to $$$x$$$, we only remain edges $$$u \rightarrow v$$$ such that $$$dis[u]+1=dis[v]$$$.

Official editorial said:

Once all cells on the shortest path are known, sort them by their distance to $$$(1, 1)$$$, i.e., $$$d_1(x, y)$$$ values. Now, if there’s any “level” of the shortest path that contains exactly one cell, every shortest path much pass through this cell and two disjoint paths cannot exist. Otherwise, a valid pair of paths will always exist.

I am confused about how to prove this. After thinking, I came up with a rigorous proof using the maximum flow minimum cut theorem.

Since each node can be visited at most once, we need to split node $$$x$$$ into $$$x$$$ -> $$$x'$$$ when constructing the flow graph. Let's say $$$dis[x]=dis[x']$$$.

What I want to prove is that if the number of nodes at all "levels" is greater than $$$1$$$ (except for $$$s$$$ and $$$t$$$), then for all cuts, the number of cut edges is always greater than $$$1$$$.

Let $$$D[i]$$$ be the set of all nodes $$$x$$$ such that $$$dis[x] = i$$$.

Assume we can find a $$$D[i]$$$ satisfying there are two nodes $$$u,v∈D[i]$$$, such that $$$u∈S$$$ and $$$v∈T$$$ (let's call it "impure"). According to our assumption, there are at least two pairs of $$$x$$$->$$$x'$$$ in $$$D[i]$$$. We will discuss three cases.

• Case $$$1$$$: $$$x$$$ and $$$x'$$$ are from different $$$S/T$$$ sets. In this case, $$$x$$$->$$$x'$$$ is already a cut edge.

• Case $$$2$$$: $$$x$$$ and $$$x'$$$ are both from $$$S$$$. In this case, by following the successors of $$$x'$$$, we can always find a cut edge.

• Case $$$3$$$: $$$x$$$ and $$$x'$$$ are both from $$$T$$$. In this case, by following the predecessors of $$$x$$$, we can always find a cut edge.

In this way, we can always find at least two different cutting edges. Q.E.D.

If we can't find "impure" $$$D[i]$$$, this case is easier — we can find two cutting edges between some $$$D[i]$$$ and $$$D[i+1]$$$. The proof are left to you :)

Note $$$|D[i]|$$$ as the number of nodes of $$$D[i]$$$($$$s$$$ and $$$t$$$ are excluded). If $$$min(D[i])=k$$$, can we find $$$k$$$ disjoint shortest path for any $$$k$$$?

No. It only holds when $$$k=2$$$.

The following is the counter case for $$$k=3$$$:

After retaining only the edges on the shortest path tree, we can run a maximum flow algorithm to check if the maximum flow is $$$2$$$. Due to the special nature of the graph, the time complexity is equivalent to performing two BFS traversals on the graph.

We construct the Cartesian tree of the array, where $$$maxa$$$ is the root.

We can think of the process of merging numbers as one slime eating another slime.

If you are at slime $$$a[x]$$$, what would you do? First, you can definitely eat the subtree you are in. After that, you try to eat your parent. If you can do so ($$$subtreesum[x] \ge a[fa[x]]$$$), it is equivalent to being in the position of slime $$$fa[x]$$$. Otherwise, mark the edge $$$(x, fa[x])$$$ as a "blocking edge." We use DSU to link all non-blocking edges, and the size of the set containing the root is the answer.

Maintain the Tree with Data Structures.

We first construct the Cartesian tree for $$$a[1...n]$$$, using a segment tree to maintain its Euler sequence. Some arrays and DSU also needed. Afterward, we "clear" it—set all values in the segment tree to 0, and disconnect every point in the DSU. Then, we add the nodes one by one.

We can also use arrays $$$fa$$$, $$$lc$$$, and $$$rc$$$ to maintain the current parent-child relationships in the tree. When adding $$$a[i]$$$, we set the value at position $$$i$$$ in the segment tree to $$$a[i]$$$ and check whether the edge between $$$i$$$ and its child(at most two children) is a "blocking edge". If it is not, we use DSU to merge $$$i$$$ and $$$a[i]$$$. This step is not hard.

Additionally, all edges on the path from $$$a[i]$$$ to the root may change from being "blocking edges" to "non-blocking edges" (but "non-blocking edges" will never become "blocking edges"—think about why). We check all edges on the path from $$$a[i]$$$ to the root and update them using DSU.

In DSU, for the nodes in the same set, we can maintain the point with the smallest depth in that set. This allows us to quickly skip over many consecutive "non-blocking edges".

For a "blocking edge", it may be checked many times. If there are many "blocking edges" on a path to the root, and after checking they do not change, could we check $$$O(n^2)$$$ times?

No. For a path to the root, there can be at most $$$O(\log n)$$$ "blocking edges."

Why? Let's review: a "blocking edge" $$$(x, fa[x])$$$ is an edge that satisfies $$$subtreesum[x] \lt a[fa[x]]$$$. Each time we pass through a "blocking edge", the subtree sum at least doubles. Therefore, there can be at most $$$O(\log n)$$$ "blocking edges."

291785878

Consider a fixed interval $$$[l, r]$$$.

We find that if $$$a[r]$$$ is neither the maximum nor the minimum value, then performing $$$r--$$$ will increase the answer by $$$1$$$.

Thus, $$$a[r]$$$ must either be the maximum value or the minimum value; similarly, the same holds for $$$a[l]$$$.

We only need to calculate the answers where $$$a[r]$$$ is the maximum value and $$$a[l]$$$ is the minimum value. Afterward, we reverse the array $$$a$$$ and calculate again.

Consider a fixed $$$r$$$. We can separate the terms related to $$$r$$$ and those related to $$$l$$$, obtaining the following answer:

Maintaining "$$$a[l]$$$ is the minimum value in $$$a[l...r]$$$" seems difficult. Can we change it to "$$$1 \leq l \leq r$$$"? Yes, we can. Although this will count some "invalid" answers, these answers will never be the maximum value (think why).

Consider using a segment tree. If we have information for $$$[L, M]$$$ and $$$[M+1, R]$$$, how can we merge this information to obtain the information for $$$[L, R]$$$?

To find the answer that spans two intervals:

$$$\max_{r \in [M+1, R]} (a[r] - r) - \min_{l \in [L, M]} (a[l] - l)$$$

This can be maintained on a segment tree.

299719227

Since $$$m$$$ is small, we can enumerate $$$2^m$$$ cases and record their AND values.

Thus, we can easily obtain an array $$$mn[i][j]$$$: the minimum value of $$$a[i]$$$ after $$$j$$$ operations.

DP seems hard. How to solve this?

We observe that for a fixed $$$i$$$, $$$mn[i][j]$$$ is a convex function. In other words, $$$mn[i][j] - mn[i][j+1]$$$ is monotonically decreasing.

Thus, the problem is equivalent to a classic problem: choosing the top $$$k$$$ largest values from $$$n$$$ monotonically decreasing sequences. This part is the same as an old problem https://mirror.codeforces.com/contest/1428/problem/E.

We only need to focus on the highest changing bit. It is easy to see that, as $$$j$$$ increases, the highest changing bit decreases.

Formally, define

as the highest differing bit between x and y. We have:

Consider a proof by contradiction. Suppose:

Let

, and we can find an $x[k]$ such that the $$$b$$$-th bit of $$$x[k]$$$ is $$$0$$$.

We insert this $$$x[k]$$$ into the first $$$(j+1)$$$ operations, and the result will be strictly smaller than the current $$$mn[i][j+1]$$$. This contradicts the minimality of $$$mn[i][j+1]$$$.

302098411

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

In other exciting news:

• We've just launched our official Telegram channel! We invite you to join us there as well, so we can expand our community and conquer Telegram alongside Codeforces and Discord! 💪

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

The problemset has at least $$$1$$$ tree problem.

brute force dp math

If Bob is winning for given $$$n$$$ stones then Alice will win for $$$n + 2$$$ stones and $$$n + 3$$$ stones, because in $$$n + 2$$$ case Alice will remove $$$2$$$ stones and in $$$n + 3$$$ case Alice will remove $$$3$$$ stones resulting in $$$n$$$ stones where players switch their turns i.e., now Bob will play like first player for these $$$n$$$ stones, so obviously Alice will win.

From this information we can create $$$dp$$$ table, where $$$dp[x]$$$ refers who will win if pile contains $$$x$$$ stones. The base case is for $$$n = 1$$$ where Bob will win.

So from this $$$dp$$$ table , if Alice is already winning no need to add stones , otherwise we will iterate untill we reach the state where Alice will win.

If we observe the pattern, it will look like LWWWLLWWWLLWWWLLWWWLL... where $$$L$$$ means Alice loosing, $$$W$$$ means Alice winning. we can easily see from the pattern that if $$$n$$$ mod $$$5 \ge 2$$$ no need to add stones, Otherwise answer will be $$$2 - n$$$ mod $$$5$$$.

Time Complexity : $$$O(t)$$$

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);
 
int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        int r=(n%5);
        if(r==0) cout<<"2\n";
        else if(r==1) cout<<"1\n";
        else cout<<"0\n";
    }
}

Good problem! :
Average problem :
Bad problem... :

constructive algorithm implementation

The Upperbound value of $$$k$$$ for given $$$n$$$ is $$$⌈ \frac{n}{2} ⌉^2$$$, because the top-left square grid containing $$$⌈ \frac{n}{2} ⌉^2$$$ cells can have any characters which will mirror the other cells.

There are many ways to construct the grid, the below implementation is one of them.

Time Complexity : $$$O(n^2)$$$

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);
 
int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        int n,k;
        cin>>n>>k;
        int maxi=((n+1)/2)*((n+1)/2);
        if(k>maxi) cout<<"-1\n";
        else{
            vector<vector<int>> v(n,vector<int>(n));
            int val=0;
            for(int i=0;i<(n+1)/2;i++){
                for(int j=0;j<(n+1)/2;j++){
                    v[i][j]=val;
                    v[i][(n-j-1)]=val;
                    val=(val+1)%k;
                }
            }
            int x=1;
            if(n%2) x++;
            for(int i=(n+1)/2;i<n;i++){
                for(int j=0;j<n;j++){
                    v[i][j]=v[i-x][j];
                }
                x+=2;
            }
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    cout<<(char)('a'+v[i][j]);
                }
                cout<<"\n";
            }
        }
    }
}

Good problem! :
Average problem :
Bad problem... :

number theory math

General idea of the solution is to store the count of the factors of all $$$a_i(1 \le i \le n)$$$, in that the answer is the maximum factors whose count is greater than or equal to $$$n-2$$$, because we can change the remaining elements to this factor. But this solution is too slow. Infact we don't need to calculate all elements factors, it is sufficient to calculate any $$$3$$$ elements factors. Because if you are interested in any $$$4$$$-th element factors then if those factor is not included in the previous $$$3$$$ elements choosen then its not useful because we can only change upto maximum $$$2$$$ elements.

Note that we can actually also solve this problem by taking factors of only $$$1$$$ element, below implementation shows this.

Time Complexity : $$$O(nD(x)+t \sqrt{x})$$$, where $$$x$$$ is any element from $$$a$$$, $$$D(x)$$$ means number of factors of $$$x$$$.

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);
 
vector<ll> get(ll n){
    vector<ll> v;
    for(ll i=1;i*i<=n;i++){
        if(n%i==0){
            v.push_back(i);
            ll j=(n/i);
            if(j!=i) v.push_back(j);
        }
    }
    return v;
}
 
int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        vector<ll> a(n);
        ll ans=0;
        for(ll i=0;i<n;i++){
            cin>>a[i];
            ans=__gcd(ans,a[i]);
        }
        sort(a.begin(),a.end());
        vector<ll> v=get(a[0]);
        for(ll i=0;i<(ll)v.size();i++){
            ll cnt=0;
            for(ll j=0;j<n;j++) if(a[j]%v[i]==0) cnt++;
            if(cnt>=(n-2)) ans=max(ans,v[i]);
        }
        vector<ll> p,s;
        for(ll i=1;i<n;i++) p.push_back(a[i]);
        s=p;
        for(ll i=1;i<(ll)p.size();i++) p[i]=__gcd(p[i],p[i-1]);
        for(ll i=(ll)s.size()-2;i>=0;i--) s[i]=__gcd(s[i],s[i+1]);
        for(ll i=0;i<(ll)p.size();i++){
            ll val=0;
            if(i-1>=0) val=__gcd(val,p[i-1]);
            if(i+1<(ll)s.size()) val=__gcd(val,s[i+1]);
            ans=max(ans,val);
        }
        ll val=0;
        for(ll i=2;i<n;i++) val=__gcd(val,a[i]);
        ans=max(ans,val);
        cout<<ans<<"\n";
    }
}

can you solve the problem for $$$1 \le a_i \le 10^{18}$$$ ?

Good problem! :
Average problem :
Bad problem... :

data structure greedy

Let's first solve the problem for the entire array. Consider the prefix sum array $$$S$$$, where we want all $$$S[i] \gt 0$$$.

Consider how a swap operation would change the $$$S$$$ array. Clearly, we only pick $$$a[i] = -1$$$ and $$$a[j] = 1$$$. This makes $$$S[i, \dots, j-1]$$$ increase by 2.

Thus, we have a greedy strategy: each time, select the smallest $$$i$$$ and the largest $$$j$$$ such that $$$a[i] = -1$$$ and $$$a[j] = 1$$$. Let $$$\text{minS} = \min(S[1, \dots, n])$$$. With each operation, $$$\text{minS}$$$ increases by 2, so the required number of operations is easy to calculate.

Returning to the original problem, we can use a segment tree to maintain $$$S$$$. For operation 2, this is simply a range addition operation on the segment tree. For operation 1, we can easily find the $$$\text{minS}$$$ for each interval.

Time Complexity : $$$O(nlogn)$$$

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);

vector<ll> tree,lazy,v1;

void build(ll v, ll tl, ll tr){
    if(tl==tr) tree[v]=v1[tl];
    else{
        ll m=(tl+tr)/2;
        build(2*v+1,tl,m);
        build(2*v+2,m+1,tr);
        tree[v]=min(tree[2*v+1],tree[2*v+2]);
    }
}

void push(ll v){
    tree[2*v+1]+=lazy[v];
    tree[2*v+2]+=lazy[v];
    lazy[2*v+1]+=lazy[v];
    lazy[2*v+2]+=lazy[v];
    lazy[v]=0;
}

ll get(ll v, ll tl, ll tr, ll l, ll r){
    if(l>r) return 1e18;
    if(l==tl && r==tr) return tree[v];
    push(v);
    ll m=(tl+tr)/2;
    ll val1=get(2*v+1,tl,m,l,min(r,m));
    ll val2=get(2*v+2,m+1,tr,max(l,m+1),r);
    return min(val1,val2);
}

void update(ll v, ll tl, ll tr, ll l, ll r, ll x){
    if(l>r) return;
    if(l==tl && r==tr){
        tree[v]+=x;
        lazy[v]+=x;
    }
    else{
        push(v);
        ll m=(tl+tr)/2;
        update(2*v+1,tl,m,l,min(r,m),x);
        update(2*v+2,m+1,tr,max(l,m+1),r,x);
        tree[v]=min(tree[2*v+1],tree[2*v+2]);
    }
}
 
int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        ll n,q;
        cin>>n>>q;
        vector<ll> a(n);
        for(ll i=0;i<n;i++) cin>>a[i];
        v1.clear();
        v1=a;
        for(ll i=1;i<n;i++) v1[i]+=v1[i-1];
        tree.clear();
        tree.resize(4*n);
        lazy.clear();
        lazy.resize(4*n);
        build(0,0,n-1);
        while(q--){
            ll type;
            cin>>type;
            if(type==1){
                ll l,r;
                cin>>l>>r;
                l--;
                r--;
                ll sum=get(0,0,n-1,r,r);
                if(l-1>=0) sum-=get(0,0,n-1,l-1,l-1);
                if(sum<=0) cout<<"-1\n";
                else{
                    ll val=get(0,0,n-1,l,r);
                    if(l-1>=0) val-=get(0,0,n-1,l-1,l-1);
                    if(val>0) cout<<"0\n";
                    else{
                        val=-val;
                        cout<<(val+2)/2<<"\n";
                    }
                }
            }
            else{
                ll pos;
                cin>>pos;
                pos--;
                if(a[pos]==1) update(0,0,n-1,pos,n-1,-2);
                else update(0,0,n-1,pos,n-1,2);
                a[pos]*=-1;
            }
        }
    }
}

can you solve the problem for range update instead of point update ?

Good problem! :
Average problem :
Bad problem... :

constructive algorithm tree

There will be no tree if the grid $$$a$$$ doesn't satisfy atleast one of the following condition :

1. $$$a_{ij} = a_{ji}$$$
2. $$$a_{ii}=i$$$
3. $$$a_{ij} \le a_{(a_{ij})j}$$$

Otherwise we can construct the tree in many ways, one of the possible way is:

1. Lets create a parent array $$$par$$$ where $$$par[x]$$$ denotes the parent of node $$$x$$$, initially $$$par[i]=-1$$$ for every $$$i(1 \le i \le n)$$$.

2. we will iterate for $$$x = 1, 2, 3, \cdots , n$$$ in this order and for every $$$y(1 \le y \le n)$$$ we will update $$$par[y] = x$$$ if $$$a_{xy}=x$$$.

Time Complexity : $$$O(n^2)$$$.

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);
 
int main(){
    fast;
    ll t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        vector<vector<int>> v(n,vector<int>(n));
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cin>>v[i][j];
                v[i][j]--;
            }
        }
        bool ok=true;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==j && v[i][j]!=i) ok=false;
                if(v[i][j]!=v[j][i]) ok=false;
                if(v[i][j]>min(i,j)) ok=false;
                if(i<j){
                    if(v[i][j]!=v[v[i][j]][j]) ok=false;
                }
            }
        }
        if(ok){
            vector<int> par(n,0);
            par[0]=-1;
            for(int i=1;i<n;i++){
                for(int j=0;j<n;j++){
                    if(i!=j && v[i][j]==i) par[j]=i;
                }
            }
            for(int i=1;i<n;i++){
                cout<<par[i]+1<<" "<<i+1<<"\n";
            }
        }
        else cout<<"-1\n";
    }
}

Good problem! :
Average problem :
Bad problem... :

dp tree

We can solve this problem using Dynamic programming. Perform $$$DFS$$$(depth first search) and solve the problem from the leaves to root.

Let $$$dp_{ij}$$$ denotes the number of ways to use the nodes from the subtree of $$$i$$$ such that there are $$$j$$$ connected components. Before processing $$$i$$$ we need to combine the tables of $$$dp_k$$$, where $$$k$$$ is the set of childeren nodes of $$$i$$$. In this combining process every $$$j_1$$$ number of components in $$$dp_{i_{1}j_{1}}$$$ and every $$$j_2$$$ number of components in $$$dp_{i_{2}j_{2}}$$$ will contribute for new $$$dp$$$ states $$$j_1 + j_2$$$ number of components, where $$$i_1$$$ and $$$i_2$$$ belongs to set $$$k$$$.

Time Complexity : $$$O(n^2)$$$.

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast                       \
 ios_base::sync_with_stdio(0);      \
 cin.tie(0);                         \
 cout.tie(0);

ll mod=1e9+7;

long long power(long long a,long long b){
  long long x=1,y=a;
  while(b>0){
    if(b&1ll){
      x=(x*y)%mod;
    }
    y=(y*y)%mod;
    b>>=1;
  }
  return x%mod;
}
 
long long modular_inverse(long long n){
  return power(n,mod-2);
}

#define MAXN 2000005
 
long long factorial[MAXN];
long long invfact[MAXN];
 
void cfact(){
  long long i;
  factorial[0]=1;
  factorial[1]=1;
  for(i=2;i<MAXN;i++){
    factorial[i]=factorial[i-1]*i;
    factorial[i]%=mod;
  }
  invfact[MAXN-1]=modular_inverse(factorial[MAXN-1]);
  for(i=MAXN-2;i>=0;i--){
    invfact[i]=invfact[i+1]*(i+1);
    invfact[i]%=mod;
  }
}
 
long long calcnCr(long long n,long long k){
  if(k<0 || n<k){return 0;}
  return (factorial[n]*((invfact[k]*invfact[n-k])%mod))%mod;
}

vector<vector<ll>> adj,dp;
vector<ll> sz,dp1,v1;
ll xx,yy;

void dfs(ll x, ll p){
    dp[x][0]=1;
    for(auto i:adj[x]){
        if(i!=p){
            dfs(i,x);
            for(ll j=0;j<=sz[x]+sz[i];j++) dp1[j]=0;
            for(ll j=0;j<=sz[x];j++){
                for(ll k=1;k<=sz[i];k++){
                    dp1[j+k]=(dp1[j+k]+(((dp[x][j]*dp[i][k])%mod)*calcnCr(j+k-v1[x]-v1[i],j-v1[x]))%mod)%mod;
                }
            }
            sz[x]+=sz[i];
            v1[x]+=v1[i];
            for(ll j=0;j<=sz[x];j++){
                dp[x][j]=dp1[j];
            }
        }
    }
    sz[x]++;
    for(ll j=0;j<=sz[x];j++) dp1[j]=0;
    for(ll j=0;j<sz[x];j++){
        dp1[j+1]=(dp1[j+1]+(dp[x][j]*(j+1-v1[x]))%mod)%mod;
        dp1[j]=(dp1[j]+(dp[x][j+1]*j)%mod)%mod;
        dp1[j]=(dp1[j]+(dp[x][j]*(2*j-v1[x]))%mod)%mod;
    }
    for(ll j=0;j<=sz[x];j++){
        dp[x][j]=dp1[j];
    }
}
 
int main(){
    fast;
    cfact();
    ll t;
    cin>>t;
    while(t--){
        ll n;
        cin>>n;
        adj.clear();
        adj.resize(n);
        for(ll i=0;i<n-1;i++){
            ll u,v;
            cin>>u>>v;
            u--;
            v--;
            adj[u].push_back(v);
            adj[v].push_back(u);
        }
        dp.clear();
        dp.resize(n+2);
        for(ll i=0;i<n+2;i++) dp[i].resize(n+2);
        dp1.clear();
        dp1.resize(n+2);
        sz.clear();
        sz.resize(n+2);
        v1.clear();
        v1.resize(n+2);
        dfs(0,-1);
        cout<<dp[0][1]<<"\n";
    }
}

can you construnct any permutation which satisfies the condition for $$$n \le 10^6$$$ ?

Good problem! :
Average problem :
Bad problem... :

It will posted after the first solve or tomorrow

It will posted after the first solve or tomorrow

It will posted after the first solve or tomorrow

Good problem! :
Average problem :
Bad problem... :

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website

The problemset has at least $$$0$$$ bruteforce problem.

For odd values of $$$n$$$ we can re-express string $$$s$$$ as

Note that $$$s_1+s_2+...+s_{\lfloor \frac{n}{2} \rfloor}=s_{\lceil \frac{n}{2} \rceil+1}+....+s_n$$$ , so we can assume the sum as $$$f$$$.

And let's denote the median digit by $$$h$$$ , thus the sum is $$$2f+h$$$ , it can be shown that $$$h$$$ can be possibly any digit , thus we can construct all sums which lies between minimum and maximum inclusive .

Now Let's do the same for even values of $$$n$$$ we can re-express $$$s$$$ as

Using the symmetric property we can see $$$s_{\lfloor \frac{n}{2} \rfloor}=s_{\lfloor \frac{n}{2} \rfloor+1}$$$ , if we denote one digit by $$$h$$$ thus the sum of medians is $$$2h$$$ and if we denote the left and right segments by $$$f$$$ as we did for odd $$$n$$$ then we have $$$m=2f+2h=2(f+h)$$$ thus for even $$$n$$$ we have an additional condition that sum must be even

Thus Total Complexity for each test case is $$$\mathcal{O}(1)$$$ time .

for _ in range(int(input())): 
  n,m= map(int, input().split())
  if(m >= n and m <= 9 * n and (n % 2 != 0 or m % 2 == 0)):
    print("YES")
  else:
    print("NO")

If $$$x \lt z$$$, the answer is obviously $$$-1$$$. We only consider the case of $$$x \ge z$$$.

Maximum number of interviews per day can happen is the number of distinct interviews can happen , which is the number of interviewers times the capacity of each interviewer integer divided by the needed interviewers in one interview , Formally

The construction is simple:

consider a sequence of length $$$x \cdot y$$$ — $$$[1,2,\ldots,x,1,2,\ldots,x,\ldots]$$$ , and simply output consecutive segments of length $$$z$$$ in order.

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <random>
#include <chrono>
 
using namespace std;
 
#define _int64 long long
#define mo 998244353


int main()
{
	int i,j,k,n,l,t,m,x,y,o,b1,z,ans,now;
	scanf("%d",&t);
	for (l=0;l<t;l++)
	{
		scanf("%d%d%d",&x,&y,&z);
		if (z>x)
		{
			printf("0\n");
			continue;
		}
		ans=x*y/z;
		printf("%d\n",ans);
		now=1;
		for (i=0;i<ans;i++)
		{
			for (j=0;j<z;j++)
			{
				printf("%d ",now);
				now++;
				if (now>x) now=1;
			}
			printf("\n");
		}
	}
}

Note $$$f_i=\Sigma_{j=1}^i a_j·...·a_i$$$. We can get $$$f_1=a_1$$$ and $$$f_i=a_i + a_i \cdot f_{i-1}$$$ for $$$2 \le i \le n$$$.

The answer is $$$\Sigma_{i=1}^n f_i$$$.

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <random>
#include <chrono>
 
using namespace std;
 
#define _int64 long long
#define mo 1000000007

int a[1100000];
_int64 d[1100000];

int main()
{
	int i,j,k,n,l,t,m,x,y,o,b1,qq,ll,rr;
	_int64 ans;
	scanf("%d",&t);
	for (l=0;l<t;l++)
	{
		scanf("%d%d",&n,&qq);
		for (i=0;i<n;i++)
			scanf("%d",&a[i]);
		for (o=0;o<qq;o++)
		{
			scanf("%d%d",&ll,&rr);
			ll--;rr--;
			d[ll]=a[ll];
			d[ll]%=mo;
			ans=d[ll];
			for (i=ll+1;i<=rr;i++)
			{
				d[i]=d[i-1]*a[i]+a[i];
				d[i]%=mo;
				ans+=d[i];
				ans%=mo;
			}
			printf("%lld\n",ans);
		}
	}
}

For $$$n,m \ge 4$$$, we have trival construct $$$p_i=i$$$ to make condition $$$1$$$ holds.

Then check all $$$a_i+a_{i+1}=0 (\mod m)$$$, we can just swap $$$a_i$$$ and $$$a_{i-1}$$$ to make condition $$$2$$$ holds.

For $$$n,m \lt 4$$$, we need to some case work. Be careful of $$$n=4,m=3$$$ case and $$$n=2$$$ case.

For $$$k=3$$$ generate cases separately (Exercise) , for $$$k=2$$$ the permutation $$$[1,2,3,...,n]$$$ always works .

we need to see all cases (pairs) for which violates the condition , well let's see how we determine the number of pairs for only (odd numbers) since even $$$k$$$ can be solved with typical standard permutation .\ Using \textbf{Mod Array} this is how we can get the number of invalid pairs, $$$(0,0)$$$ is always invalid pair , then there are another pairs depending on $$$k$$$ , there are $$$\lfloor \frac{n}{2} \rfloor$$$ different pairs to do sum with, for example $$$k=3 \Rightarrow {(1,2),(2,1)}$$$ which can be counted $$$2 \lfloor \frac{n}{2} \rfloor=n-1$$$ for odd numbers and there's also base case yields $$$n$$$ invalid pairs, Now our mission is to construct a permutation without facing any pair of these. Let's analyze the situation , for all numbers in $$$[1,n]$$$ it has a specific value $$$\mod k$$$ , we want to calculate how many values $$$i$$$ such that : $$$1 \le i \le n$$$ satisfy \ $$$ i \mod k=x$$$ , let's construct a \textbf{Mini Mod Array} that will determine the \textbf{Final Mod Array} and depending on it we'll construct the permutation.

Again we separate 3 because it's an edge case and it's a triangular number of the second degree,Let's see how we can arrange the \textbf{Final Mod Array} , we want to count all the mods by $$$k$$$ for the numbers , it can be calculated as follows:- Considering $$$n \mod k=x$$$\ Every mod has at least $$$\lfloor \frac{n}{k} \rfloor$$$ values for mod in the array , and $$$\forall : 1 \le i \le x$$$ it'll increase by 1 , let's denote the number of mod values such $$$i \textbf{ mod } k =z$$$ appears on the \textbf{Final Mod Array} as $$$c_{z}$$$ , so we obtain the following fact:-

Using The Past Fact , we can construct a valid permutation for all odd $$$k$$$ except $$$3$$$ , let the \textbf{Final Mod Array} be expanded like this :-

Now we let's reflect what we made in the expanded mod array , the sum of each pair can be \textbf{even} because 2 numbers has the same mod and of course won't be divisible by $$$k$$$ , or some number $$$b$$$ will collide with the next so the new number making $$$(2b+1) \mod k$$$ , so since $$$2b+1$$$ is always odd we make sure that $$$2b+1$$$ is not equal to $$$k$$$ by \textit{swap}$$$(\lfloor \frac{k}{2} \rfloor , \lfloor \frac{k}{2} \rfloor -1$$$),Finally still to distribute $$$0$$$'s so that no pair is equal to (0,0) , since

then we can distribute pairs : $$$(k-1,0)$$$ so if $$$c_{k-1}=c_0$$$ we can distribute it like this

and if $$$c_{k-1}=c_0+1$$$ then it can be distributed like this:-

so we make sure that no (0,0) pair is in the expanded mod array. Let's work an example to finish the explanation $$$(n,k)=(20,9)$$$:-

$$$20 \mod 9=2 \Rightarrow c_1=c_2=\lfloor \frac{n}{k} \rfloor+1=3$$$ and $$$c_3=c_4=..=c_8=c_0=2$$$ so the final mod array

Finally generate numbers W.R.T mods , one valid permutation is:-

\textbf{Note: In practice we'll put $$$0$$$ as $$$k$$$ for generating correct answers but mathematically it's just $$$0$$$}\ We used $$$\mathtt{map}$$$ Structure ($$$\mathtt{dict}$$$ in $$$\mathtt{python}$$$) to optimize the storing operation in average $$$\mathcal{O}(1)$$$ time, and constructing operation takes $$$\mathcal{O}(n)$$$ time , since time for storing values in $$$\mathtt{map}$$$ structure we consider the worst case of $$$\mathtt{map}$$$ , so complexity (worst case) is $$$\mathcal{O}(n+k)$$$ because the $$$\mathtt{dict}$$$ structure in $$$\mathtt{python}$$$ .

~~~~~

This problem can be solved by classical DDP (https://en.oi-wiki.org/dp/dynamic/) in $$$O(n \log n)$$$. So we ask for $$$O(n)$$$ solution.

Note $$$f_i=\Sigma_{j=1}^i a_j·...·a_i$$$. We can get $$$f_1=a_1$$$ and $$$f_i=a_i + a_i \cdot f_{i-1}$$$ for $$$2 \le i \le n$$$. And $$$g_i=\Sigma_{j=1}^i f_i$$$.

For query $$$l,r$$$, consider $$$ans=g_r-g_l$$$. We have not done. We still need to substract $$$ans$$$ by $$$ \Sigma_{1 \le j \le l, l+1 \le k \le r} a_j·...·a_k$$$.

Nore $$$P_i=a_1·...·a_i$$$, and $$$IP_i=P_i^{-1}$$$

In fact, $$$ \Sigma_{1 \le j \le l, l+1 \le k \le r} a_j·...·a_k$$$ is equal to $$$(IP_0+IP_1+...+IP_{l-1})·(P_{l+1}+P_{l+2}+...+P_r)$$$

All this formula can be calculated in $$$O(n)$$$.

Complexity: $$$O(n+q)$$$.

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
const int N=1000010;
const int LOGN=28;
const ll  TMD=998244353;
const ll  INF=2147483647;
int T,n,q;
ll  a[N],dp[N],P[N],SP[N],IP[N],SIP[N];

ll pw(ll x,ll p)
{
	if(!p) return 1;
	ll y=pw(x,p>>1);
	y=(y*y)%TMD;
	if(p&1) y=(y*(x%TMD))%TMD;	
	return y;
}

ll INV(ll x)
{
    return pw(x,TMD-2);
}

void init()
{
    cin>>n>>q;
    for(int i=1;i<=n;i++) cin>>a[i];
}

void solve()
{
    dp[1]=a[1];
    for(int i=2;i<=n;i++)
        dp[i]=(dp[i-1]+a[i]+a[i]*(dp[i-1]-dp[i-2]))%TMD;
    P[0]=SP[0]=IP[0]=SIP[0]=1;
    for(int i=1;i<=n;i++)
        P[i]=(P[i-1]*a[i])%TMD;
    IP[n]=INV(P[n]);
    for(int i=n-1;i;i--) IP[i]=IP[i+1]*a[i+1]%TMD;
    for(int i=1;i<=n;i++)
    {
        SP[i]=(SP[i-1]+P[i])%TMD;
        SIP[i]=(SIP[i-1]+IP[i])%TMD;
    }
    for(int i=1;i<=q;i++)
    {
        int l,r;
        ll  ans;
        cin>>l>>r;
        ans=(dp[r]-dp[l-1]+TMD)%TMD;
        if(l>1) ans=(ans-(SP[r]-SP[l-1])*(SIP[l-2])+TMD*TMD)%TMD;
        cout<<ans<<'\n';
    }
}

int main()
{
    fastio;

	cin>>T;
	while(T--)
	{
		init();
		solve();
	}

	return 0;
}

We found that the probability of taking a certain number is only related to its rank. Let $$$P[i][j]$$$ represent the probability that, out of a total of $$$i$$$ numbers, Alice selects the $$$j$$$-th smallest number.

When the coin is on the obverse side, Alice's probability of picking it up is $$$\frac{1}{2} \cdot \frac{j}{1 + \dots + i}$$$. When a coin is reversed, consider two situations:

• The number with rank smaller than $$$j$$$ have been taken. If so Alice's probability of picking it up is $$$\frac{1 + \dots + (j-1)}{1 + \dots + i} P[i-1][j-1]$$$;

• The number with rank greater than $$$j$$$ has been taken. If so Alice's probability of picking it up is $$$\frac{(j+1) + \dots + i}{1 + \dots + i} P[i-1][j]$$$.

So the recurrence relation for $$$P[i][j]$$$ is given by:

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <unordered_map>
using namespace std;
typedef double db; 
typedef long long ll;
typedef unsigned long long ull;
const int N=2010;
const int LOGN=28;
const ll  TMD=998244353;
const ll  INF=2147483647;
int T,n;
int a[N];
ll  P[N][N];

ll pw(ll x,ll p)
{
	if(!p) return 1;
	ll y=pw(x,p>>1);
	y=(y*y)%TMD;
	if(p&1) y=(y*(x%TMD))%TMD;
	return y;
}

ll INV(ll x)
{
    return pw(x,TMD-2);
}

ll SUM(ll x)
{
	return x*(x+1)/2;
}

ll SUM(ll L,ll R)
{
	if(L>R) return 0;
	return SUM(R)-SUM(L-1);
}

void init_P()
{
	P[1][1]=INV(2);
	for(int i=2;i<N;i++)
	{
		for(int j=1;j<=i;j++)
		{
			P[i][j]=INV(2)*j%TMD*INV(SUM(1,i))%TMD;
			P[i][j]=(P[i][j]+INV(2)*SUM(j+1,i)%TMD*INV(SUM(1,i))%TMD*P[i-1][j])%TMD;
			P[i][j]=(P[i][j]+INV(2)*SUM(1,j-1)%TMD*INV(SUM(1,i))%TMD*P[i-1][j-1])%TMD;
		}
	}
}

void init()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
}

void solve()
{
	ll ans=0;
	sort(a+1,a+n+1);
	for(int i=1;i<=n;i++) ans=(ans+P[n][i]*a[i])%TMD;
	printf("%I64d\n",ans);
}

int main()
{
	init_P();
	scanf("%d",&T);
	while(T--)
	{
		init();
		solve();
	}
	
	return 0;
}

Note $$$X$$$ as set of $$$a_i$$$.

Note that $$$f(N)$$$ is defined only when $$$N \lt \text{lcm}(X)$$$.

How do we find $$$f(N)$$$ greedily? In each step, it's sufficient to keep track of the smallest achievable element in that step.

Let's build $$$f$$$ manually, where for every $$$0 \leq i \leq m$$$, $$$f[i] = \min(f[i - i \% y]) + 1$$$ for all $$$y \in X$$$. This is doable in $$$O(m \times |X|)$$$, which is too slow to pass the time limit.

Firstly, let's prove that $$$f$$$ is a non-decreasing function. For all $$$i$$$, it can be shown that $$$f(i) \leq f(i+1)$$$, because for any integer $$$y$$$, $$$(i + 1) - (i + 1) \% y \geq i - i \% y$$$.

It can also be proven that for any $$$i$$$, one of the following is true: $$$f(i) = f(i+1)$$$ or $$$f(i) + 1 = f(i + 1)$$$.

Now, we can use binary search to find the lengths of each value's occurrences. Let the current index be $$$i$$$. We can find the rightmost index (let it be $$$j$$$), for which $$$f(j) = f(i) + 1$$$. In each iteration, we add $$$(j - i) \times f(j)$$$.

This works in $$$O(|X| \times f(m) \times \log(m))$$$ time. This is sufficient because it can be proven that $$$|X| \times f(m) \leq 2 \times m$$$.

Let $$$mx = \max(X)$$$. In each step, we choose $$$mx$$$ if the number is not divisible by $$$mx$$$ ($$$m \to m - m \% mx$$$), otherwise we choose any other element, which decreases $$$m$$$ by at least $$$1$$$. Then, it's clear that for every $$$2$$$ steps, the current value decreases by at least $$$mx$$$, where $$$mx \geq |X|$$$. Thus, $$$|X| \times f(m) \leq mx \times 2 \times (m / mx) \leq 2 \times m$$$.

Overall time complexity is $$$O(|X| \times f(m) \times \log(m))$$$ or $$$O(|X| \times f(m))$$$, depending on the implementation.

Bonus: Try to prove that $$$|X| \times f(m) \leq m + 1$$$, for any given input values.

Conclusion:

• $$$f$$$ is sorted

• $$$f(n)$$$ is defined only when $$$n \lt \text{lcm}(X)$$$

• $$$f(m) \times |X| = O(m)$$$

• $$$f(i) = f(i-1) + 1$$$ or $$$f(i) = f(i-1)$$$ for any $$$i$$$

For greedy computation of $$$f(m)$$$, we can choose the smallest value achievable from one operation in each step.

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

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        int n, m;
        cin >> n >> m;
        vector<int> X(n);
        for (auto &i : X)
            cin >> i;
        int ans = 0;
        int cur = 0;
        int i = 0;
        while (i < m)
        {
            int mx = i + 1;
            for (auto &j : X)
                mx = max(mx, (i) / j * j + j - 1);
            mx = min(mx, m);
            cur++;
            ans += cur * (mx - i);
            i = mx;
        }
        cout << ans << '\n';
    }
    return 0;
}

TheForces is a project uniting individuals with a shared interest in competitive programming contests. You can join our discord server with more than $$$2500$$$ members to communicate with founders and members of TheForces.

In the other words TheForces rounds are series of educational contests for beginners to masters which are created by a group of CP lovers in the CF community, It's where anyone can propose and prepare his own interesting problems and receive money!

Not to mention that we've already created two official codeforces Div($$$1 + 2$$$) rounds before ;) So join us now!

Discord link

TheForces website