feat(cf): 894

codeforces/891/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

codeforces/891/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

codeforces/891/a.cc

@@ -0,0 +1,101 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  ve<int> a(n);
+  for (auto &e : a)
+    cin >> e;
+  sort(all(a));
+
+  ll total = 0;
+  for (int i = 1; i < n; ++i) {
+    total += a[i];
+  }
+  (a[0] & 1) == (total & 1) ? YES() : NO();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/891/a.in

@@ -0,0 +1,15 @@
+7
+8
+1 2 4 3 2 3 5 4
+2
+4 7
+3
+3 9 8
+2
+1 7
+5
+5 4 3 2 1
+4
+4 3 4 5
+2
+50 48

codeforces/891/a.out

@@ -0,0 +1,10 @@
+YES
+NO
+YES
+YES
+NO
+YES
+YES
+
+[code]: 0
+[time]: 12.9125 ms

codeforces/891/b.cc

@@ -0,0 +1,108 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  string s;
+  cin >> s;
+
+  bool carry = false;
+  int leftmost = sz<int>(s);
+
+  for (int i = sz<int>(s) - 1; i >= 0; --i) {
+    int d = s[i] - '0' + int(carry);
+    if (d < 5)
+      s[i] += carry;
+    if (carry = d >= 5)
+      leftmost = i;
+  }
+
+  if (carry)
+    pr("1");
+  for (int i = 0; i < sz<int>(s); ++i)
+    pr("{}", (i < leftmost) ? '0' : s[i]);
+  prln();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/891/b.in

@@ -0,0 +1,11 @@
+10
+1
+5
+99
+913
+1980
+20444
+20445
+60947
+419860
+40862016542130810467

codeforces/891/b.out

@@ -0,0 +1,13 @@
+0
+15
+199
+1913
+0980
+00000
+00445
+161947
+009860
+00862026542131811467
+
+[code]: 0
+[time]: 6.30426 ms

codeforces/891/c.cc

@@ -0,0 +1,215 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace __gnu_pbds;
+
+// https://mirror.codeforces.com/blog/entry/124683
+
+namespace hashing {
+using i64 = std::int64_t;
+using u64 = std::uint64_t;
+static const u64 FIXED_RANDOM =
+    std::chrono::steady_clock::now().time_since_epoch().count();
+
+#if USE_AES
+std::mt19937 rd(FIXED_RANDOM);
+const __m128i KEY1{(i64)rd(), (i64)rd()};
+const __m128i KEY2{(i64)rd(), (i64)rd()};
+#endif
+
+template <class T, class D = void>
+struct custom_hash {};
+
+template <class T>
+inline void hash_combine(u64 &seed, T const &v) {
+  custom_hash<T> hasher;
+  seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4);
+};
+
+template <class T>
+struct custom_hash<T,
+                   typename std::enable_if<std::is_integral<T>::value>::type> {
+  u64 operator()(T _x) const {
+    u64 x = _x;
+#if USE_AES
+    __m128i m{i64(u64(x) * 0xbf58476d1ce4e5b9u64), (i64)FIXED_RANDOM};
+    __m128i y = _mm_aesenc_si128(m, KEY1);
+    __m128i z = _mm_aesenc_si128(y, KEY2);
+    return z[0];
+#else
+    x += 0x9e3779b97f4a7c15 + FIXED_RANDOM;
+    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+    return x ^ (x >> 31);
+#endif
+  }
+};
+
+template <class T>
+struct custom_hash<T, std::void_t<decltype(std::begin(std::declval<T>()))>> {
+  u64 operator()(T const &a) const {
+    u64 value = FIXED_RANDOM;
+    for (auto &x : a)
+      hash_combine(value, x);
+    return value;
+  }
+};
+
+template <class... T>
+struct custom_hash<std::tuple<T...>> {
+  u64 operator()(const std::tuple<T...> &a) const {
+    u64 value = FIXED_RANDOM;
+    std::apply(
+        [&value](T const &...args) {
+          (hash_combine(value, args), ...);
+        },
+        a);
+    return value;
+  }
+};
+
+template <class T, class U>
+struct custom_hash<std::pair<T, U>> {
+  u64 operator()(std::pair<T, U> const &a) const {
+    u64 value = FIXED_RANDOM;
+    hash_combine(value, a.first);
+    hash_combine(value, a.second);
+    return value;
+  }
+};
+};  // namespace hashing
+
+#ifdef PB_DS_ASSOC_CNTNR_HPP
+template <class Key, class Value = null_type>
+using hashtable = gp_hash_table<
+    Key, Value, hashing::custom_hash<Key>, std::equal_to<Key>,
+    direct_mask_range_hashing<>, linear_probe_fn<>,
+    hash_standard_resize_policy<hash_exponential_size_policy<>,
+                                hash_load_check_resize_trigger<>, true>>;
+
+#endif
+#ifdef PB_DS_TREE_POLICY_HPP
+template <typename T>
+using multitree = tree<T, null_type, std::less_equal<T>, rb_tree_tag,
+                       tree_order_statistics_node_update>;
+template <class Key, class Value = null_type>
+using rbtree = tree<Key, Value, std::less<Key>, rb_tree_tag,
+                    tree_order_statistics_node_update>;
+#endif
+
+void solve() {
+  ll n;
+  cin >> n;
+  ve<ll> b(n * (n - 1) / 2);
+
+  hashtable<int, int> m;
+  for (auto &e : b) {
+    cin >> e;
+    ++m[e];
+  }
+  sort(all(b));
+  b.erase(unique(all(b)), b.end());
+
+  ve<int> ans(n);
+
+  int write = n - 1;
+  int count = 0;
+  for (int i = sz<int>(b) - 1; i >= 0; --i) {
+    while (m[b[i]]) {
+      ans[write--] = b[i];
+      m[b[i]] -= count;
+      ++count;
+    }
+  }
+
+  for (auto &e : ans)
+    pr("{} ", e);
+  prln();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/891/c.in

@@ -0,0 +1,3 @@
+1
+3
+1 3 1

codeforces/891/c.out

@@ -0,0 +1,4 @@
+1 3 3 
+
+[code]: 0
+[time]: 13.2291 ms

codeforces/891/compile_flags.txt

@@ -0,0 +1,6 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL
+-std=c++23

codeforces/891/d.cc

@@ -0,0 +1,113 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  ve<ll> a(n), b(n);
+  for (auto& e : a)
+    cin >> e;
+  for (auto& e : b)
+    cin >> e;
+
+  ll best_diff = MIN<ll>();
+  ve<ll> ans;
+  for (int i = 0; i < n; ++i) {
+    auto diff = a[i] - b[i];
+    if (diff > best_diff) {
+      best_diff = diff;
+      ans = {i};
+    } else if (diff == best_diff) {
+      ans.eb(i);
+    }
+  }
+
+  prln("{}", ans.size());
+  for (auto& e : ans)
+    pr("{} ", e + 1);
+  prln();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/891/d.in

@@ -0,0 +1,16 @@
+5
+4
+3 1 2 4
+4 3 2 1
+5
+1 2 4 1 2
+5 2 3 3 1
+2
+1 2
+2 1
+3
+0 2 1
+1 3 2
+3
+5 7 4
+-2 -3 -6

codeforces/891/d.out

@@ -0,0 +1,13 @@
+1
+4 
+2
+3 5 
+1
+2 
+3
+1 2 3 
+2
+2 3 
+
+[code]: 0
+[time]: 14.0336 ms

codeforces/891/e.cc

@@ -0,0 +1,155 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  ve<pa<ll, int>> a(n);
+  for (int i = 0; i < n; ++i) {
+    cin >> a[i].ff;
+    a[i].ss = i;
+  }
+  sort(all(a));
+  ve<ll> prefix(n + 1, 0), postfix(n + 2, 0);
+  for (int i = 0; i < n; ++i) {
+    prefix[i + 1] = prefix[i] + a[i].ff;
+  }
+  for (int i = n - 1; i >= 0; --i) {
+    postfix[i + 1] = postfix[i + 2] + a[i].ff;
+  }
+
+  ve<ll> ans(n);
+  for (int i = 0; i < n; ++i) {
+    ll x = n + a[i].ff * (i + 1) - prefix[i + 1];
+    x += postfix[i + 2] - a[i].ff * (n - i - 1);
+    ans[a[i].ss] = x;
+  }
+
+  for (auto& e : ans)
+    pr("{} ", e);
+  prln();
+  /*
+     1 3 4
+
+     3 + 0 +
+
+     to query @ i, want to get info related to
+     a[i] - a[0], a[i] - a[1], ....
+
+     prefix differences + postfix differences for each index
+
+     n + a[i] - a[0] + a[i] - a[1] + ... + a[i] - a[i] + a[j] - a[i] + a[j + 1]
+    - a[i]
+
+     = n + a[i] * (i + 1) - prefix[i] (inclusive) + postfix[i] (exclusive) -
+    a[i] * ``
+
+     n * a[i] - sum of prefix before i + sum of postfix after i
+
+     sum a[i] - a[j] + 1 for j in range(i + 1)
+     count how manny points before us? * a[i]
+     remove prefix sum up to j
+      - and postfix! <- note this
+
+     *-**
+     -
+     ---
+     ----
+
+     ---
+       -
+       --
+
+     ----
+       --
+        -
+
+    really, we're just adding the inclusive distance between ALL pairs
+
+
+   */
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/891/e.in

@@ -0,0 +1,7 @@
+3
+3
+1 4 3
+5
+1 2 5 7 1
+4
+1 10 100 1000

codeforces/891/e.out

@@ -0,0 +1,6 @@
+8 7 6 
+16 15 18 24 16 
+1111 1093 1093 2893 
+
+[code]: 0
+[time]: 13.531 ms

codeforces/891/f.cc

@@ -0,0 +1,223 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace __gnu_pbds;
+
+// https://mirror.codeforces.com/blog/entry/124683
+
+namespace hashing {
+using i64 = std::int64_t;
+using u64 = std::uint64_t;
+static const u64 FIXED_RANDOM =
+    std::chrono::steady_clock::now().time_since_epoch().count();
+
+#if USE_AES
+std::mt19937 rd(FIXED_RANDOM);
+const __m128i KEY1{(i64)rd(), (i64)rd()};
+const __m128i KEY2{(i64)rd(), (i64)rd()};
+#endif
+
+template <class T, class D = void>
+struct custom_hash {};
+
+template <class T>
+inline void hash_combine(u64 &seed, T const &v) {
+  custom_hash<T> hasher;
+  seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4);
+};
+
+template <class T>
+struct custom_hash<T,
+                   typename std::enable_if<std::is_integral<T>::value>::type> {
+  u64 operator()(T _x) const {
+    u64 x = _x;
+#if USE_AES
+    __m128i m{i64(u64(x) * 0xbf58476d1ce4e5b9u64), (i64)FIXED_RANDOM};
+    __m128i y = _mm_aesenc_si128(m, KEY1);
+    __m128i z = _mm_aesenc_si128(y, KEY2);
+    return z[0];
+#else
+    x += 0x9e3779b97f4a7c15 + FIXED_RANDOM;
+    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+    return x ^ (x >> 31);
+#endif
+  }
+};
+
+template <class T>
+struct custom_hash<T, std::void_t<decltype(std::begin(std::declval<T>()))>> {
+  u64 operator()(T const &a) const {
+    u64 value = FIXED_RANDOM;
+    for (auto &x : a)
+      hash_combine(value, x);
+    return value;
+  }
+};
+
+template <class... T>
+struct custom_hash<std::tuple<T...>> {
+  u64 operator()(const std::tuple<T...> &a) const {
+    u64 value = FIXED_RANDOM;
+    std::apply(
+        [&value](T const &...args) {
+          (hash_combine(value, args), ...);
+        },
+        a);
+    return value;
+  }
+};
+
+template <class T, class U>
+struct custom_hash<std::pair<T, U>> {
+  u64 operator()(std::pair<T, U> const &a) const {
+    u64 value = FIXED_RANDOM;
+    hash_combine(value, a.first);
+    hash_combine(value, a.second);
+    return value;
+  }
+};
+};  // namespace hashing
+
+#ifdef PB_DS_ASSOC_CNTNR_HPP
+template <class Key, class Value = null_type>
+using hashtable = gp_hash_table<
+    Key, Value, hashing::custom_hash<Key>, std::equal_to<Key>,
+    direct_mask_range_hashing<>, linear_probe_fn<>,
+    hash_standard_resize_policy<hash_exponential_size_policy<>,
+                                hash_load_check_resize_trigger<>, true>>;
+
+#endif
+#ifdef PB_DS_TREE_POLICY_HPP
+template <typename T>
+using multitree = tree<T, null_type, std::less_equal<T>, rb_tree_tag,
+                       tree_order_statistics_node_update>;
+template <class Key, class Value = null_type>
+using rbtree = tree<Key, Value, std::less<Key>, rb_tree_tag,
+                    tree_order_statistics_node_update>;
+#endif
+
+void solve() {
+  int n;
+  cin >> n;
+  ve<ll> a(n);
+  hashtable<ll, ll> freq;
+  for (auto &e : a) {
+    cin >> e;
+    ++freq[e];
+  }
+  int q;
+  cin >> q;
+  while (q--) {
+    ll x, y;
+    cin >> x >> y;
+
+    if (x * x < 4 * y) {
+      pr("0 ");
+      continue;
+    }
+
+    ll root = sqrtl(powl(x, 2) - 4 * y);
+
+    ll r0 = (x + root) / 2;
+    ll r1 = (x - root) / 2;
+
+    if (r0 + r1 != x || r0 * r1 != y) {
+      pr("0 ");
+      continue;
+    }
+
+    if (r0 == r1) {
+      pr("{} ", (freq[r0] - 1) * freq[r0] / 2);
+    } else
+      pr("{} ", freq[r0] * freq[r1]);
+  }
+  prln();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/891/f.in

@@ -0,0 +1,18 @@
+3
+3
+1 3 2
+4
+3 2
+5 6
+3 1
+5 5
+4
+1 1 1 1
+1
+2 1
+6
+1 4 -2 3 3 3
+3
+2 -8
+-1 -2
+7 12

codeforces/891/f.out

@@ -0,0 +1,6 @@
+1 1 0 0 
+6 
+1 1 3 
+
+[code]: 0
+[time]: 12.9466 ms

codeforces/894/.clang-format

@@ -0,0 +1,9 @@
+BasedOnStyle: Google
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

codeforces/894/.clangd

@@ -0,0 +1,8 @@
+CompileFlags:
+	Add:
+		- -Wall
+		- -Wextra
+		- -Wpedantic
+		- -Wshadow
+		- -DLOCAL
+		- -Wno-unknown-pragmas

codeforces/894/a.cc

@@ -0,0 +1,103 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n, m;
+  cin >> n >> m;
+
+  vector<string> grid(n);
+  for (auto &s : grid)
+    cin >> s;
+  string letters = "vika";
+  int i = 0;
+
+  for (int col = 0; col < m; ++col) {
+    for (int row = 0; row < n; ++row) {
+      if (grid[row][col] == letters[i]) {
+        if (++i == 4) {
+          cout << "YES\n";
+          return;
+        }
+        break;
+      }
+    }
+  }
+
+  cout << "NO" << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/a.in

@@ -0,0 +1,3 @@
+1
+1 1
+v

codeforces/894/a.out

@@ -0,0 +1,4 @@
+NO
+
+[code]: 0
+[time]: 14.0724 ms

codeforces/894/b.cc

@@ -0,0 +1,98 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n;
+  cin >> n;
+  ve<ll> b(n);
+  for (auto& e : b)
+    cin >> e;
+
+  ve<ll> ans{b[0]};
+  for (int i = 1; i < n; ++i) {
+    if (ans.back() > b[i]) {
+      ans.eb(b[i]);
+    }
+    ans.eb(b[i]);
+  }
+  cout << ans.size() << endl;
+  for (auto& e : ans)
+    cout << e << ' ';
+  cout << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/b.in

@@ -0,0 +1,13 @@
+6
+3
+4 6 3
+3
+1 2 3
+5
+1 7 9 5 7
+1
+144
+2
+1 1
+5
+1 2 2 1 1

codeforces/894/b.out

@@ -0,0 +1,15 @@
+4
+4 6 3 3 
+3
+1 2 3 
+6
+1 7 9 5 5 7 
+1
+144 
+2
+1 1 
+6
+1 2 2 1 1 1 
+
+[code]: 0
+[time]: 14.2317 ms

codeforces/894/c.cc

@@ -0,0 +1,131 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+inline static void NO() {
+  prln("NO");
+}
+inline static void YES() {
+  prln("YES");
+}
+
+void solve() {
+  int n;
+  cin >> n;
+  ve<int> a(n);
+  for (auto& e : a)
+    cin >> e;
+
+  ve<int> b(n, 0);
+  int write = n - 1;
+
+  int y = 0;
+  int i = 0;
+  while (i < n) {
+    ++y;
+    while (i + 1 < n && a[i] == a[i + 1]) {
+      ++y;
+      ++i;
+    }
+    if ((b[write] = y) != a[write]) {
+      NO();
+      return;
+    };
+    --write;
+    if (i + 1 < n) {
+      for (int j = 0; j < a[i] - a[i + 1] - 1; ++j) {
+        if ((b[write] = y) != a[write]) {
+          NO();
+          return;
+        }
+        --write;
+      }
+    }
+    ++i;
+  }
+
+  while (write >= 0) {
+    if ((b[write] = y) != a[write]) {
+      NO();
+      return;
+    }
+    --write;
+  }
+
+  YES();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/c.in

@@ -0,0 +1,15 @@
+7
+5
+5 4 3 2 1
+3
+3 1 1
+3
+4 2 1
+1
+2
+5
+5 3 3 1 1
+5
+5 5 5 3 3
+2
+6 1

codeforces/894/c.out

@@ -0,0 +1,10 @@
+YES
+YES
+NO
+NO
+YES
+YES
+NO
+
+[code]: 0
+[time]: 12.7897 ms

codeforces/894/compile_flags.txt

@@ -0,0 +1,6 @@
+-Wall
+-Wextra
+-Wpedantic
+-Wshadow
+-DLOCAL
+-std=c++23

codeforces/894/d.cc

@@ -0,0 +1,94 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  ll n;
+  cin >> n;
+  ll l = 1, r = sqrt(2 * n) + 1;
+
+  while (l <= r) {
+    ll m = l + (r - l) / 2;
+    if (m * (m - 1) / 2 <= n) {
+      l = m + 1;
+    } else
+      r = m - 1;
+  }
+
+  cout << r + n - r * (r - 1) / 2 << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/d.in

@@ -0,0 +1,6 @@
+5
+1
+3
+6
+179
+1000000000000000000

codeforces/894/d.out

@@ -0,0 +1,8 @@
+2
+3
+4
+27
+2648956421
+
+[code]: 0
+[time]: 12.2623 ms

codeforces/894/e.cc

@@ -0,0 +1,103 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+ll n, m, d;
+void solve() {
+  cin >> n >> m >> d;
+
+  ll ans = 0;
+  ll sum = 0;
+  multiset<ll> tree;
+  ll x;
+  for (int i = 0; i < n; ++i) {
+    cin >> x;
+    if (x > 0) {
+      sum += x;
+      tree.insert(x);
+    }
+    if (sz<int>(tree) > m) {
+      sum -= *tree.begin();
+      tree.erase(tree.begin());
+    }
+
+    ans = max(ans, sum - d * (i + 1));
+  }
+
+  prln("{}", ans);
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/e.in

@@ -0,0 +1,13 @@
+6
+5 2 2
+3 2 5 4 6
+4 3 2
+1 1 1 1
+6 6 6
+-82 45 1 -77 39 11
+5 2 2
+3 2 5 4 8
+2 1 1
+-1 2
+6 3 2
+-8 8 -2 -1 9 0

codeforces/894/e.out

@@ -0,0 +1,9 @@
+2
+0
+60
+3
+0
+7
+
+[code]: 0
+[time]: 12.3913 ms

codeforces/894/f.cc

@@ -0,0 +1,117 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+ll w, f;
+void solve() {
+  cin >> w >> f;
+  int n;
+  cin >> n;
+  ll total = 0;
+
+  ve<int> strengths(n);
+  for (int i = 0; i < n; ++i) {
+    cin >> strengths[i];
+    total += strengths[i];
+  }
+
+  ve<ll> dp(total + 1, false);
+  dp[0] = true;
+  for (int i = 0; i < n; ++i) {
+    for (int j = total; j >= strengths[i]; --j) {
+      dp[j] = dp[j] || dp[j - strengths[i]];
+    }
+  }
+
+  ll ans = MAX<ll>();
+  for (int i = 0; i <= total; ++i) {
+    if (dp[i]) {
+      ans = min(ans, max((i + w - 1) / w, (total - i + f - 1) / f));
+    }
+  }
+
+  cout << ans << endl;
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/f.in

@@ -0,0 +1,13 @@
+4
+2 3
+3
+2 6 7
+37 58
+1
+93
+190 90
+2
+23 97
+13 4
+4
+10 10 2 45

codeforces/894/f.out

@@ -0,0 +1,7 @@
+3
+2
+1
+5
+
+[code]: 0
+[time]: 7.07388 ms

codeforces/894/g.cc

@@ -0,0 +1,232 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto &&x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto &&x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+inline static void NO() {
+  prln("NO");
+}
+
+inline static void YES() {
+  prln("YES");
+}
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+template <typename... Ts>
+using tu = std::tuple<Ts...>;
+template <typename... Ts>
+using dq = std::deque<Ts...>;
+template <typename... Ts>
+using qu = std::queue<Ts...>;
+template <typename... Ts>
+using pq = std::priority_queue<Ts...>;
+template <typename... Ts>
+using st = std::stack<Ts...>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace __gnu_pbds;
+
+// https://mirror.codeforces.com/blog/entry/124683
+
+namespace hashing {
+using i64 = std::int64_t;
+using u64 = std::uint64_t;
+static const u64 FIXED_RANDOM =
+    std::chrono::steady_clock::now().time_since_epoch().count();
+
+#if USE_AES
+std::mt19937 rd(FIXED_RANDOM);
+const __m128i KEY1{(i64)rd(), (i64)rd()};
+const __m128i KEY2{(i64)rd(), (i64)rd()};
+#endif
+
+template <class T, class D = void>
+struct custom_hash {};
+
+template <class T>
+inline void hash_combine(u64 &seed, T const &v) {
+  custom_hash<T> hasher;
+  seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4);
+};
+
+template <class T>
+struct custom_hash<T,
+                   typename std::enable_if<std::is_integral<T>::value>::type> {
+  u64 operator()(T _x) const {
+    u64 x = _x;
+#if USE_AES
+    __m128i m{i64(u64(x) * 0xbf58476d1ce4e5b9u64), (i64)FIXED_RANDOM};
+    __m128i y = _mm_aesenc_si128(m, KEY1);
+    __m128i z = _mm_aesenc_si128(y, KEY2);
+    return z[0];
+#else
+    x += 0x9e3779b97f4a7c15 + FIXED_RANDOM;
+    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
+    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
+    return x ^ (x >> 31);
+#endif
+  }
+};
+
+template <class T>
+struct custom_hash<T, std::void_t<decltype(std::begin(std::declval<T>()))>> {
+  u64 operator()(T const &a) const {
+    u64 value = FIXED_RANDOM;
+    for (auto &x : a)
+      hash_combine(value, x);
+    return value;
+  }
+};
+
+template <class... T>
+struct custom_hash<std::tuple<T...>> {
+  u64 operator()(const std::tuple<T...> &a) const {
+    u64 value = FIXED_RANDOM;
+    std::apply(
+        [&value](T const &...args) {
+          (hash_combine(value, args), ...);
+        },
+        a);
+    return value;
+  }
+};
+
+template <class T, class U>
+struct custom_hash<std::pair<T, U>> {
+  u64 operator()(std::pair<T, U> const &a) const {
+    u64 value = FIXED_RANDOM;
+    hash_combine(value, a.first);
+    hash_combine(value, a.second);
+    return value;
+  }
+};
+};  // namespace hashing
+
+#ifdef PB_DS_ASSOC_CNTNR_HPP
+template <class Key, class Value = null_type>
+using hashtable = gp_hash_table<
+    Key, Value, hashing::custom_hash<Key>, std::equal_to<Key>,
+    direct_mask_range_hashing<>, linear_probe_fn<>,
+    hash_standard_resize_policy<hash_exponential_size_policy<>,
+                                hash_load_check_resize_trigger<>, true>>;
+
+#endif
+#ifdef PB_DS_TREE_POLICY_HPP
+template <typename T>
+using multitree = tree<T, null_type, std::less_equal<T>, rb_tree_tag,
+                       tree_order_statistics_node_update>;
+template <class Key, class Value = null_type>
+using rbtree = tree<Key, Value, std::less<Key>, rb_tree_tag,
+                    tree_order_statistics_node_update>;
+#endif
+
+int n, q;
+void solve() {
+  cin >> n;
+  ve<int> a(n);
+  multitree<int> values;
+
+  for (auto &e : a) {
+    cin >> e;
+    values.insert(e);
+  }
+
+  multitree<int> tree;
+  for (auto it = next(values.begin()); it != values.end(); ++it) {
+    tree.insert(*it - *prev(it));
+  }
+
+  int i, x;
+  cin >> q;
+  while (q--) {
+    cin >> i >> x;
+    --i;
+    // NOTE: this is not removing the exact right value among duplicates
+    dbgln("update: i={}, x={}", i, x);
+    if (i) {
+    auto it = values.find(a[i]);
+      dbgln("removing {}", *it - *prev(it));
+      tree.erase(*it - *prev(it));
+      dbgln("adding diff {}", abs(*prev(it) - x));
+      tree.insert(abs(*prev(it) - x));
+    }
+    if (i != n - 1) {
+      dbgln("removing {}", *it - *next(it));
+      tree.erase(*it - *next(it));
+      dbgln("adding {}", abs(*next(it) - x));
+      tree.insert(abs(*next(it) - x));
+    }
+    values.erase(a[i]);
+    a[i] = x;
+
+    int ans = *--values.end();
+    if (!tree.empty())
+      ans += *--tree.end();
+    pr("{} ", ans);
+  }
+  prln();
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/894/g.in

@@ -0,0 +1,34 @@
+4
+3
+2 4 8
+3
+1 6
+2 10
+3 1
+5
+1 2 2 2 2
+1
+5 3
+2
+5 6
+7
+1 2
+1 7
+1 7
+2 5
+1 2
+2 7
+2 2
+5
+2 5 1 10 6
+10
+1 7
+4 8
+2 5
+1 4
+2 8
+3 4
+1 9
+3 7
+3 4
+3 1

codeforces/894/g.out

@@ -0,0 +1,86 @@
+update: i=0, x=6
+removing -2
+adding 4
+12 update: i=1, x=10
+removing -8
+adding diff 2
+removing -2
+adding 8
+16 update: i=2, x=1
+removing -8
+adding diff 7
+16 
+update: i=4, x=3
+removing -2
+adding diff 1
+3 
+update: i=0, x=2
+removing -4
+adding 3
+9 update: i=0, x=7
+removing -4
+adding 2
+9 update: i=0, x=7
+removing -4
+adding 2
+9 update: i=1, x=5
+removing -5
+adding diff 1
+9 update: i=0, x=2
+removing -4
+adding 3
+9 update: i=1, x=7
+removing -5
+adding diff 1
+9 update: i=1, x=2
+removing -5
+adding diff 4
+10 
+update: i=0, x=7
+removing 2
+adding 6
+16 update: i=3, x=8
+removing -7
+adding diff 2
+removing 2
+adding 7
+17 update: i=1, x=5
+removing -7
+adding diff 5
+removing 2
+adding 4
+17 update: i=0, x=4
+removing 2
+adding 3
+17 update: i=1, x=8
+removing -7
+adding diff 2
+removing 2
+adding 7
+17 update: i=2, x=4
+removing -7
+adding diff 6
+removing 2
+adding 3
+17 update: i=0, x=9
+removing 2
+adding 8
+18 update: i=2, x=7
+removing -7
+adding diff 3
+removing 2
+adding 6
+18 update: i=2, x=4
+removing -7
+adding diff 6
+removing 2
+adding 3
+18 update: i=2, x=1
+removing -7
+adding diff 9
+removing 2
+adding 0
+19 
+
+[code]: 0
+[time]: 14.2844 ms

codeforces/974/e.cc

@@ -0,0 +1,124 @@
+#include <bits/stdc++.h>  // {{{
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+template <typename T>
+[[nodiscard]] static T MIN() {
+  return std::numeric_limits<T>::min();
+}
+
+template <typename T>
+[[nodiscard]] static T MAX() {
+  return std::numeric_limits<T>::max();
+}
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+
+#define prln(...) std::println(__VA_ARGS__)
+#define pr(...) std::print(__VA_ARGS__)
+
+#ifdef LOCAL
+#define dbgln(...) std::println(__VA_ARGS__)
+#define dbg(...) std::print(__VA_ARGS__)
+#endif
+
+using ll = long long;
+using ld = long double;
+template <typename T>
+using ve = std::vector<T>;
+template <typename T, size_t N>
+using ar = std::array<T, N>;
+template <typename T1, typename T2>
+using pa = std::pair<T1, T2>;
+
+#define ff first
+#define ss second
+#define eb emplace_back
+#define pb push_back
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+//  }}}
+
+void solve() {
+  int n, m, h;
+  cin >> n >> m >> h;
+  unordered_set<int> horses;
+
+  int horse;
+  for (int i = 0; i < h; ++i) {
+    cin >> horse;
+    horses.insert(horse);
+  }
+
+  ve<ve<pa<int, ll>>> graph(n + 1);
+  for (int i = 0; i < m; ++i) {
+    int u, v;
+    ll w;
+    cin >> u >> v >> w;
+    graph[u].eb(v, w);
+    graph[v].eb(u, w);
+  }
+
+  ve<ll> marian(n + 1, MAX<ll>()), robin(n + 1, MAX<ll>());
+
+  auto djikstra = [&](int start, ve<ll>& delta) {
+    priority_queue<tuple<ll, int, bool>, ve<tuple<ll, int, bool>>, greater<>>
+        pq;
+    delta[start] = 0;
+    pq.emplace(delta[start], start, horses.contains(start));
+    unordered_set<int> seen;
+
+    while (!pq.empty()) {
+      auto [d0, u, took] = pq.top();
+      pq.pop();
+      if (d0 > delta[u] && !took) continue;
+      if (took) seen.insert(u);
+      for (auto [v, w] : graph[u]) {
+        ll d1 = d0 + (took ? w / 2 : w);
+        bool take = took || horses.contains(v);
+        if (d1 < delta[v]) {
+          delta[v] = d1;
+          pq.emplace(d1, v, take);
+        }
+      }
+    }
+  };
+
+  djikstra(1, marian);
+  djikstra(n, robin);
+
+  ll ans = MAX<ll>();
+  for (int node = 1; node <= n; ++node) {
+    ans = min(ans, max(marian[node], robin[node]));
+  }
+
+  prln("{}", ans == MAX<ll>() ? -1 : ans);
+}
+
+int main() {  // {{{
+  cin.tie(nullptr)->sync_with_stdio(false);
+  cin.exceptions(cin.failbit);
+
+  int t = 1;
+  cin >> t;
+
+  while (t--) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}

codeforces/974/e.in

@@ -0,0 +1,5 @@
+1
+3 2 1
+2
+1 2 4
+1 3 16

codeforces/974/e.out

@@ -0,0 +1,4 @@
+16
+
+[code]: 0
+[time]: 14.7145 ms