Thanks for participation!
#include<bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int tests;
cin >> tests;
while (tests--) {
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
for (auto &i: a) {
for (auto &j: i) cin >> j;
}
if (n * m == 1) cout << "-1\n";
else {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << a[(i + 1) % n][(j + 1) % m] << ' ';
}
cout << '\n';
}
}
}
}
#include<bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size() && s[i] == '0'; ++i) {
if (t[i] != '0') {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int tests;
cin >> tests;
while (tests--) {
int n;
ll x;
cin >> n >> x;
vector<ll> a(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i];
partial_sum(a.begin() + 1, a.end(), a.begin() + 1);
vector<int> dp(n + 2);
for (int i = n - 1; i >= 0; --i) {
int q = upper_bound(a.begin(), a.end(), a[i] + x) - a.begin();
dp[i] = dp[q] + q - i - 1;
}
cout << accumulate(dp.begin(), dp.end(), 0ll) << '\n';
}
}
Pigeonhole principle
#include<bits/stdc++.h>
using namespace std;
int main() {
int tests;
cin >> tests;
while (tests--) {
int n;
cin >> n;
vector<int> a(n);
for (auto& i : a) cin >> i;
vector<int> pos(n);
iota(pos.begin(), pos.end(), 0);
vector<pair<int, int>> ans;
for (int i = n — 1; i; --i) {
vector<int> occ(i, -1);
for (auto j : pos) {
if (occ[a[j] % i] != -1) {
ans.emplace_back(j, occ[a[j] % i]);
pos.erase(find(pos.begin(), pos.end(), j));
break;
}
occ[a[j] % i] = j;
}
}
reverse(ans.begin(), ans.end());
cout << "YES\n";
for (auto [x, y] : ans) cout << x + 1 << ' ' << y + 1 << '\n';
}
}
Solve for one tree
Answer is size of tree
Let sizes of deleted subtrees be $$$a_1, a_2, \ldots a_m$$$. We know that $$$a_1 + a_2 + \ldots + a_m = n$$$. Then we know that $$$a_1 | a_2 \ldots a_m \leq n$$$. To proof that lets see bits separately. It will add $$$1$$$ to result, if one of bits is $$$1$$$, $$$0$$$ otherwise, but this is not more than their sum.
~~~~~
include<bits/stdc++.h>
using namespace std;
void solve() { int k; cin >> k; vector a(k); for (int i = 0; i < k; ++i) { cin >> a[i]; for (int j = 0; j < a[i] — 1; ++j) { int trash; cin >> trash; } } sort(a.begin(), a.end(), greater<>()); int ans = 0; for (auto x : a) { for (int h = 23; h >= 0; --h) { int ca = ans >> h & 1, cx = x >> h & 1; if (cx == 0) continue; if (ca == 0) ans |= 1 << h; else { ans |= (1 << h) — 1; break; } } } cout << ans << '\n'; }
int main() { int t; cin >> t; while (t--) solve(); } ~~~~~
~~~~~
include<bits/stdc++.h>
using namespace std;
int main() { cin.tie(nullptr)->sync_with_stdio(false);
int tests; cin >> tests; while (tests--) { int n, m; cin >> n >> m; vector<vector<int>> black(n); vector<int> edg(m); vector<vector<int>> g(n); for (int i = 0; i < m; ++i) { int x, y, c; cin >> x >> y >> c; --x, --y; edg[i] = x ^ y; g[x].push_back(i); g[y].push_back(i); if (c == 0) { black[x].push_back(i); black[y].push_back(i); } } vector<int> deg(n); for (int i = 0; i < n; ++i) deg[i] = g[i].size() & 1; vector<bool> del(m, false), used(n, false); auto dfs = [&](auto dfs, int u) -> void { used[u] = true; for (auto id : black[u]) { int to = edg[id] ^ u; if (used[to]) continue; dfs(dfs, to); if (deg[to]) { del[id] = true; deg[to] ^= 1; deg[u] ^= 1; } } }; bool ok = true; for (int i = 0; i < n; ++i) { if (used[i]) continue; dfs(dfs, i); ok &= !deg[i]; } if (!ok) { cout << "NO\n"; continue; } auto euler = [&](auto euler, int u) -> void { while (!g[u].empty()) { int id = g[u].back(); g[u].pop_back(); int to = edg[id] ^ u; if (del[id]) continue; del[id] = true; euler(euler, to); } cout << u + 1 << ' '; }; cout << "YES\n"; cout << m - accumulate(del.begin(), del.end(), 0) << '\n'; euler(euler, 0); cout << '\n'; }
} ~~~~~
Think of the most stupid solution you can do
Do memorization and some cuts
Done!
~~~~~
include <bits/stdc++.h>
using namespace std;
int n, k; vector<vector> memo; string res; vector cnt; string s;
bool rec(int i, int cur) { if (i == k) { if (cur == 0) { return true; } return false; } if (memo[i][cur]) return false; memo[i][cur] = true; for (int c = 0; c < 2; ++c) { int q = cur; if (c == 0) q += cnt[i]; else q += n — cnt[i]; if ((q & 1) == s[i] — '0') { if (rec(i + 1, q / 2)) { res += char(c + '0'); return true; } } } return false; }
int main() { cin.tie(nullptr)->sync_with_stdio(false);
int tests; cin >> tests; while (tests--) { cin >> n >> k; cin >> s; reverse(s.begin(), s.end()); cnt = vector<int>(k); for (int i = 0; i < n; ++i) { string t; cin >> t; reverse(t.begin(), t.end()); for (int j = 0; j < k; ++j) cnt[j] += t[j] - '0'; } memo = vector<vector<bool>>(k, vector<bool>(n, false)); res = ""; rec(0, 0); if (res.empty()) cout << "-1\n"; else cout << res << '\n'; }
} ~~~~~
~~~~~
include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() { cout << "? aa" << endl; int p, v[10]; cin >> p; p--; cout << "? zzzzzzzzzz" << endl; int hsh, hsho; ll nom = 0, cnt = 1; cin >> hsh; hsho = hsh; hsh++; for (int i = 0; i < 10; i++) { nom += 26 * cnt; cnt *= p; v[i] = 26 — (hsh % p); hsh /= p; } string s; cnt = 1; ll ch = 0; for (int i = 0; i < 10; i++) { if (v[i] < 1) { v[i] = 26; v[i + 1]--; } ch += cnt * v[i]; cnt *= p; s += 'a' + (v[i] — 1); } cout << "? " << s << endl; int ans; cin >> ans; cout << "! " << p << ' ' << ans + nom — ch — hsho << endl; }
int32_t main() { int t; cin >> t; while (t--) { solve(); } } ~~~~~