What happens when there are two equal elements?

#include <bits/stdc++.h>
using namespace std;
 
void solve() {
	int n;
	cin >> n;
	vector<int> a(n);
	for (auto &x : a)
		cin >> x;
		
	sort(a.rbegin(), a.rend());
	
	for (int i = 0; i < n-1; i++)
		if (a[i] == a[i+1]) {
			cout << "-1\n";
			return;
		}
	
	for (auto x : a)
		cout << x << " ";
	cout << "\n";
}
 
int main() {
	int T;
	cin >> T;
	while (T--)
		solve();
}

#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
 
int t, n, m;
 
int main() {
    
    int t; cin >> t;
    while(t--) {
        int n, m; cin >> n >> m;
        
        int c, cnt, mx = 1;
        
        for(int i = 0; i < n; i++) {
            int a; cin >> a;
            
            if (!i) {
                c = a;
                cnt = 1;
            }
            else if (a != c) {
                c = a;
                mx = max(mx, cnt);
                cnt = 1;
            }
            else {
                cnt++;
            }
        }
        
        mx = max(mx, cnt);
        
        if(mx < m) cout << "YES" << "\n";
        else cout << "NO" << "\n";
    }
    
    return 0;
}

If we have two consecutive $$$1$$$'s, the rabbits on the left and right of this block are independent. We can divide our problem into multiple subproblems.

If one of these subproblems mentioned in hint $$$1$$$ contains two consecutive 0's, can we solve this subproblem?

If we don't have consecutive $$$0$$$'s in these subproblems mentioned in hint $$$1$$$, the pattern looks like $$$10101 \dots 10101$$$, in which of these patterns can we place the rabbits?

#include <bits/stdc++.h>
using namespace std;
 
void solve() {
	int n; cin >> n;
	string s; cin >> s;
	bool ok = true;
	bool curr = (s[0] == '1');
	int cnt = 0;
	for (int i = 0; i < n; i++) {
		if (s[i] == '0')
			cnt++;
		if (i == 0)
			continue;
		if (s[i] == s[i-1] && s[i] == '0')
			curr = false;
		if (s[i] == s[i-1] && s[i] == '1') {
			if (curr && cnt % 2 == 1)
				ok = false;
			curr = true;
			cnt = 0;
		}
	}
	
	if (curr && cnt % 2 == 1 && s[n-1] == '1')
		ok = false;
		
	cout << (ok ? "YES" : "NO") << "\n";
}
 
int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int T; cin >> T;
	while (T--)
		solve();
}

Solve small cases.

What happens when every value is even?

How can we add exactly one odd number to the solution of hint 2?

339616059

The answer is bounded by $$$31$$$.

We will precalculate the minimum operations for each answer.

How will the bitwise or look like if we want to increase the popcount from the original by increasing the number of $$$1$$$'s.

We can show that it is better to fill the least significant $$$0$$$'s first.

What is the best way to fill a certain bit.

The solution is a greedy algorithm.

339616091

Solve the problem in $$$\mathcal{O}(n b + t b^2 + q \log (b))$$$.

Try to understand what are the SCCs.

They are a line. Given the sizes of the SCC, find a closed formula for the answer.

Think how to maintain the formula using data structures.

339616164

There was a lot of cheating on this problem, which is why there were many in-contest solves. Cheaters will be banned. We’re sorry if the high solve count during the contest misled anyone, but please understand that this isn’t something the authors, coordinators, or codeforces can control.

What happens when $$$n$$$ is big?

$$$b_n$$$ is $$$a^{a^N}$$$ for some big $$$N$$$.

Given $$$a$$$ and $$$m$$$ find a condition for $$$a$$$ to be $$$m$$$-tetrative.

The condition is $$$\forall p|ord_m(a), p|a$$$.

Fix the number of values of $$$a$$$ such that $$$ord_m(a) = k$$$ and get a formula.

If $$$m$$$ is an odd prime power, the number above for $$$k|\varphi(m)$$$ is $$$\varphi(k)$$$.

Manipulate the formula until it only depends on the prime divisors of $$$\varphi(m)$$$ that are not in $$$m$$$.

Factor it to calculate it in $$$O(\log m)$$$.

339616197

Think of min-cut instead of max-flow.

Can you think of a sufficient condition so that all the min-cuts between any pair of vertices are divisible by the same number?

In fact, the expected sufficient condition implies that all cuts of the graph (not just min-cuts) are divisible by the same number.

The minimum number of colors is always $$$1$$$ or $$$2$$$. You can check if the answer is $$$1$$$ by brute force.

It is possible to make all cuts even in each induced subgraph using just $$$2$$$ colors.

339616226

The expected is $$$n = mlogm - O(m)$$$ steps using harmonic sum.

Think of a solution in 2D (not needed but good intuition).

Put points as an almost regular polygon and keep doing circles around it jumping with step $$$1$$$, then $$$2$$$, then $$$3$$$...

Think how to project this solution to 1D

339616257

There is a $$$n = 2m-3$$$ solution that will be useful: given two groups of points in arithmetic progression far enough apart you can add two pivots in the middle to keep jumping from the left to the right group: ..... .. .....

The goal is to recursively construct a solution using smaller ones.

339616281