From 742bf851a9f9d2b7b8a3b260ddf58c92dd0cfafc Mon Sep 17 00:00:00 2001 From: Barrett Ruth Date: Thu, 30 Jan 2025 17:06:38 -0500 Subject: [PATCH] more code --- codeforces/431/.clang-format | 9 + codeforces/431/.null-ls_210584_c.cc | 1 + codeforces/431/.null-ls_213694_c.cc | 139 +++++++++++++++ codeforces/431/.null-ls_271044_c.cc | 193 ++++++++++++++++++++ codeforces/431/.null-ls_427011_c.cc | 193 ++++++++++++++++++++ codeforces/431/.null-ls_433724_c.cc | 139 +++++++++++++++ codeforces/431/.null-ls_441630_c.cc | 1 + codeforces/431/.null-ls_544573_c.cc | 193 ++++++++++++++++++++ codeforces/431/c.cc | 193 ++++++++++++++++++++ codeforces/431/c.debug | Bin 0 -> 79744 bytes codeforces/431/c.in | 1 + codeforces/431/c.out | 1 + codeforces/431/compile_flags.txt | 5 + codeforces/431/d.cc | 109 +++++++++++ codeforces/431/d.debug | Bin 0 -> 24256 bytes codeforces/431/d.in | 0 codeforces/431/d.out | 0 codeforces/431/e.cc | 109 +++++++++++ codeforces/431/e.debug | Bin 0 -> 24256 bytes codeforces/431/e.in | 0 codeforces/431/e.out | 0 codeforces/640/.clang-format | 2 + codeforces/640/a.cc | 126 +++++++++++++ codeforces/640/a.in | 6 + codeforces/640/a.out | 10 ++ codeforces/640/b.cc | 134 ++++++++++++++ codeforces/640/b.in | 9 + codeforces/640/b.out | 13 ++ codeforces/640/c.cc | 124 +++++++++++++ codeforces/640/c.in | 7 + codeforces/640/c.out | 6 + codeforces/640/compile_flags.txt | 5 + codeforces/640/d.cc | 139 +++++++++++++++ codeforces/640/d.in | 15 ++ codeforces/640/d.out | 7 + codeforces/640/e.cc | 231 ++++++++++++++++++++++++ codeforces/640/e.in | 11 ++ codeforces/640/e.out | 5 + codeforces/640/f.cc | 124 +++++++++++++ codeforces/640/f.in | 9 + codeforces/640/f.out | 8 + codeforces/640/g.cc | 174 ++++++++++++++++++ codeforces/640/g.in | 8 + codeforces/640/g.out | 7 + codeforces/923/.clang-format | 2 + codeforces/923/a.cc | 120 +++++++++++++ codeforces/923/a.in | 17 ++ codeforces/923/a.out | 24 +++ codeforces/923/b.cc | 231 ++++++++++++++++++++++++ codeforces/923/b.in | 11 ++ codeforces/923/b.out | 5 + codeforces/923/c.cc | 150 ++++++++++++++++ codeforces/923/c.in | 19 ++ codeforces/923/c.out | 6 + codeforces/923/compile_flags.txt | 5 + codeforces/923/d.cc | 136 ++++++++++++++ codeforces/923/d.in | 40 +++++ codeforces/923/d.out | 24 +++ codeforces/923/exe | Bin 0 -> 319016 bytes codeforces/923/j.cc | 110 ++++++++++++ codeforces/923/j.in | 0 codeforces/923/j.out | 8 + codeforces/923/k.cc | 86 +++++++++ codeforces/923/k.in | 0 codeforces/923/k.out | 0 codeforces/974/.clang-format | 2 + codeforces/974/a.cc | 67 +++++++ codeforces/974/a.debug | Bin 0 -> 27120 bytes codeforces/974/a.in | 9 + codeforces/974/a.out | 4 + codeforces/974/b.cc | 112 ++++++++++++ codeforces/974/b.debug | Bin 0 -> 22960 bytes codeforces/974/b.in | 6 + codeforces/974/b.out | 5 + codeforces/974/c.cc | 114 ++++++++++++ codeforces/974/c.in | 13 ++ codeforces/974/c.out | 6 + codeforces/974/compile_flags.txt | 5 + codeforces/974/d.cc | 130 ++++++++++++++ codeforces/974/d.in | 20 +++ codeforces/974/d.out | 6 + codeforces/974/h.cc | 229 ++++++++++++++++++++++++ codeforces/974/h.in | 11 ++ codeforces/974/h.out | 6 + codeforces/984/a.cc | 45 +++++ codeforces/984/a.in | 17 ++ codeforces/984/b.cc | 54 ++++++ codeforces/984/b.in | 14 ++ codeforces/984/b.out | 0 codeforces/984/c.cc | 76 ++++++++ codeforces/984/c.in | 24 +++ codeforces/984/c.out | 15 ++ codeforces/984/d.cc | 93 ++++++++++ codeforces/984/d.in | 31 ++++ codeforces/984/d.out | 0 codeforces/984/e.cc | 64 +++++++ codeforces/984/e.in | 16 ++ codeforces/984/e.out | 4 + codeforces/991/.null-ls_940867_d.cc | 188 +++++++++++++++++++ codeforces/991/buf | 29 +++ codeforces/991/compile_flags.txt | 1 + codeforces/991/d.cc | 188 +++++++++++++++++++ codeforces/991/d.in | 7 + codeforces/991/d.out | 6 + codeforces/991/e.cc | 50 ++++++ codeforces/991/e.in | 22 +++ codeforces/991/e.out | 0 codeforces/991/f.cc | 219 +++++++++++++++++++++++ codeforces/991/f.in | 18 ++ codeforces/991/f.out | 4 + codeforces/991/g.cc | 82 +++++++++ codeforces/991/g.in | 29 +++ codeforces/991/g.out | 6 + codeforces/991/x.out | 0 codeforces/993/.clang-format | 9 + codeforces/993/a.cc | 95 ++++++++++ codeforces/993/a.in | 4 + codeforces/993/b.cc | 104 +++++++++++ codeforces/993/b.in | 6 + codeforces/993/b.out | 5 + codeforces/993/c.cc | 98 ++++++++++ codeforces/993/c.in | 6 + codeforces/993/c.out | 5 + codeforces/993/compile_flags.txt | 5 + codeforces/993/d.cc | 121 +++++++++++++ codeforces/993/d.in | 9 + codeforces/993/d.out | 4 + codeforces/993/e.cc | 125 +++++++++++++ codeforces/993/e.in | 6 + codeforces/993/e.out | 5 + codeforces/993/e.run | Bin 0 -> 38216 bytes codeforces/993/exe | Bin 0 -> 247168 bytes codeforces/993/f.cc | 220 +++++++++++++++++++++++ codeforces/993/f.in | 9 + codeforces/993/g1.cc | 94 ++++++++++ codeforces/993/g1.in | 0 codeforces/993/g1.out | 0 codeforces/993/h.cc | 137 ++++++++++++++ codeforces/993/h.in | 16 ++ codeforces/993/h.out | 2 + codeforces/993/h.run | Bin 0 -> 55320 bytes leetcode/.clang-format | 2 + leetcode/a.cc | 268 ++++++++++++++++++++++++++++ leetcode/a.in | 7 + leetcode/a.out | 81 +++++++++ leetcode/b.cc | 110 ++++++++++++ leetcode/b.in | 0 leetcode/b.out | 0 leetcode/compile_flags.txt | 5 + 149 files changed, 7065 insertions(+) create mode 100644 codeforces/431/.clang-format create mode 100644 codeforces/431/.null-ls_210584_c.cc create mode 100644 codeforces/431/.null-ls_213694_c.cc create mode 100644 codeforces/431/.null-ls_271044_c.cc create mode 100644 codeforces/431/.null-ls_427011_c.cc create mode 100644 codeforces/431/.null-ls_433724_c.cc create mode 100644 codeforces/431/.null-ls_441630_c.cc create mode 100644 codeforces/431/.null-ls_544573_c.cc create mode 100644 codeforces/431/c.cc create mode 100755 codeforces/431/c.debug create mode 100644 codeforces/431/c.in create mode 100644 codeforces/431/c.out create mode 100644 codeforces/431/compile_flags.txt create mode 100644 codeforces/431/d.cc create mode 100755 codeforces/431/d.debug create mode 100644 codeforces/431/d.in create mode 100644 codeforces/431/d.out create mode 100644 codeforces/431/e.cc create mode 100755 codeforces/431/e.debug create mode 100644 codeforces/431/e.in create mode 100644 codeforces/431/e.out create mode 100644 codeforces/640/.clang-format create mode 100644 codeforces/640/a.cc create mode 100644 codeforces/640/a.in create mode 100644 codeforces/640/a.out create mode 100644 codeforces/640/b.cc create mode 100644 codeforces/640/b.in create mode 100644 codeforces/640/b.out create mode 100644 codeforces/640/c.cc create mode 100644 codeforces/640/c.in create mode 100644 codeforces/640/c.out create mode 100644 codeforces/640/compile_flags.txt create mode 100644 codeforces/640/d.cc create mode 100644 codeforces/640/d.in create mode 100644 codeforces/640/d.out create mode 100644 codeforces/640/e.cc create mode 100644 codeforces/640/e.in create mode 100644 codeforces/640/e.out create mode 100644 codeforces/640/f.cc create mode 100644 codeforces/640/f.in create mode 100644 codeforces/640/f.out create mode 100644 codeforces/640/g.cc create mode 100644 codeforces/640/g.in create mode 100644 codeforces/640/g.out create mode 100644 codeforces/923/.clang-format create mode 100644 codeforces/923/a.cc create mode 100644 codeforces/923/a.in create mode 100644 codeforces/923/a.out create mode 100644 codeforces/923/b.cc create mode 100644 codeforces/923/b.in create mode 100644 codeforces/923/b.out create mode 100644 codeforces/923/c.cc create mode 100644 codeforces/923/c.in create mode 100644 codeforces/923/c.out create mode 100644 codeforces/923/compile_flags.txt create mode 100644 codeforces/923/d.cc create mode 100644 codeforces/923/d.in create mode 100644 codeforces/923/d.out create mode 100755 codeforces/923/exe create mode 100644 codeforces/923/j.cc create mode 100644 codeforces/923/j.in create mode 100644 codeforces/923/j.out create mode 100644 codeforces/923/k.cc create mode 100644 codeforces/923/k.in create mode 100644 codeforces/923/k.out create mode 100644 codeforces/974/.clang-format create mode 100644 codeforces/974/a.cc create mode 100755 codeforces/974/a.debug create mode 100644 codeforces/974/a.in create mode 100644 codeforces/974/a.out create mode 100644 codeforces/974/b.cc create mode 100755 codeforces/974/b.debug create mode 100644 codeforces/974/b.in create mode 100644 codeforces/974/b.out create mode 100644 codeforces/974/c.cc create mode 100644 codeforces/974/c.in create mode 100644 codeforces/974/c.out create mode 100644 codeforces/974/compile_flags.txt create mode 100644 codeforces/974/d.cc create mode 100644 codeforces/974/d.in create mode 100644 codeforces/974/d.out create mode 100644 codeforces/974/h.cc create mode 100644 codeforces/974/h.in create mode 100644 codeforces/974/h.out create mode 100644 codeforces/984/a.cc create mode 100644 codeforces/984/a.in create mode 100644 codeforces/984/b.cc create mode 100644 codeforces/984/b.in create mode 100644 codeforces/984/b.out create mode 100644 codeforces/984/c.cc create mode 100644 codeforces/984/c.in create mode 100644 codeforces/984/c.out create mode 100644 codeforces/984/d.cc create mode 100644 codeforces/984/d.in create mode 100644 codeforces/984/d.out create mode 100644 codeforces/984/e.cc create mode 100644 codeforces/984/e.in create mode 100644 codeforces/984/e.out create mode 100644 codeforces/991/.null-ls_940867_d.cc create mode 100644 codeforces/991/buf create mode 100644 codeforces/991/compile_flags.txt create mode 100644 codeforces/991/d.cc create mode 100644 codeforces/991/d.in create mode 100644 codeforces/991/d.out create mode 100644 codeforces/991/e.cc create mode 100644 codeforces/991/e.in create mode 100644 codeforces/991/e.out create mode 100644 codeforces/991/f.cc create mode 100644 codeforces/991/f.in create mode 100644 codeforces/991/f.out create mode 100644 codeforces/991/g.cc create mode 100644 codeforces/991/g.in create mode 100644 codeforces/991/g.out create mode 100644 codeforces/991/x.out create mode 100644 codeforces/993/.clang-format create mode 100644 codeforces/993/a.cc create mode 100644 codeforces/993/a.in create mode 100644 codeforces/993/b.cc create mode 100644 codeforces/993/b.in create mode 100644 codeforces/993/b.out create mode 100644 codeforces/993/c.cc create mode 100644 codeforces/993/c.in create mode 100644 codeforces/993/c.out create mode 100644 codeforces/993/compile_flags.txt create mode 100644 codeforces/993/d.cc create mode 100644 codeforces/993/d.in create mode 100644 codeforces/993/d.out create mode 100644 codeforces/993/e.cc create mode 100644 codeforces/993/e.in create mode 100644 codeforces/993/e.out create mode 100755 codeforces/993/e.run create mode 100755 codeforces/993/exe create mode 100644 codeforces/993/f.cc create mode 100644 codeforces/993/f.in create mode 100644 codeforces/993/g1.cc create mode 100644 codeforces/993/g1.in create mode 100644 codeforces/993/g1.out create mode 100644 codeforces/993/h.cc create mode 100644 codeforces/993/h.in create mode 100644 codeforces/993/h.out create mode 100755 codeforces/993/h.run create mode 100644 leetcode/.clang-format create mode 100644 leetcode/a.cc create mode 100644 leetcode/a.in create mode 100644 leetcode/a.out create mode 100644 leetcode/b.cc create mode 100644 leetcode/b.in create mode 100644 leetcode/b.out create mode 100644 leetcode/compile_flags.txt diff --git a/codeforces/431/.clang-format b/codeforces/431/.clang-format new file mode 100644 index 0000000..e7350c4 --- /dev/null +++ b/codeforces/431/.clang-format @@ -0,0 +1,9 @@ +BasedOnStyle: Google +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortCompoundRequirementOnASingleLine: false +AllowShortEnumsOnASingleLine: false +AllowShortFunctionsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLambdasOnASingleLine: false +AllowShortLoopsOnASingleLine: false diff --git a/codeforces/431/.null-ls_210584_c.cc b/codeforces/431/.null-ls_210584_c.cc new file mode 100644 index 0000000..2462f22 --- /dev/null +++ b/codeforces/431/.null-ls_210584_c.cc @@ -0,0 +1 @@ +#include diff --git a/codeforces/431/.null-ls_213694_c.cc b/codeforces/431/.null-ls_213694_c.cc new file mode 100644 index 0000000..35605d1 --- /dev/null +++ b/codeforces/431/.null-ls_213694_c.cc @@ -0,0 +1,139 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +template void print(string const &str, Args &&...args) { + cout << vformat(str, make_format_args(forward(args)...)); +} + +template void print(T const &t) { cout << t; } + +template void print(T const &t) { + if constexpr (is_same_v || is_convertible_v) { + cout << t << '\n'; + } else { + for (const auto &e : t) { + cout << e << ' '; + } + cout << '\n'; + } +} + +template void println(string const &str, Args &&...args) { + print(str, fo diff --git a/codeforces/431/.null-ls_271044_c.cc b/codeforces/431/.null-ls_271044_c.cc new file mode 100644 index 0000000..aa8bdaa --- /dev/null +++ b/codeforces/431/.null-ls_271044_c.cc @@ -0,0 +1,193 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +template void print(string const &str, Args &&...args) { + cout << vformat(str, make_format_args(forward(args)...)); +} + +template void print(T const &t) { cout << t; } + +template void print(T const &t) { + if constexpr (is_same_v || is_convertible_v) { + cout << t << '\n'; + } else { + for (const auto &e : t) { + cout << e << ' '; + } + cout << '\n'; + } +} + +template void println(string const &str, Args &&...args) { + print(str, forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { + print(t); + cout << '\n'; +} + +void println() { cout << '\n'; } + +template T max() { return numeric_limits::max(); } + +template T min() { return numeric_limits::min(); } + +constexpr static int MOD = 1e9 + 7; + +void solve() { + int n, k, d; + cin >> n >> k >> d; + hashmap, int> memo; + + auto dp = [&](auto &self, int n, int d) -> int { + if (memo.find({n, d}) != memo.end()) + return memo[{n, d}]; + + if (n == 0) + return d == 0 ? 1 : 0; + + ll total = 0; + + FOR(i, 1, min(n + 1, k + 1)) { + total = (total + self(self, n - i, i < d ? d : 0)) % MOD; + } + + return memo[{n, d}] = total; + }; + + print(dp(dp, n, d)); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + // cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/431/.null-ls_427011_c.cc b/codeforces/431/.null-ls_427011_c.cc new file mode 100644 index 0000000..aa8bdaa --- /dev/null +++ b/codeforces/431/.null-ls_427011_c.cc @@ -0,0 +1,193 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +template void print(string const &str, Args &&...args) { + cout << vformat(str, make_format_args(forward(args)...)); +} + +template void print(T const &t) { cout << t; } + +template void print(T const &t) { + if constexpr (is_same_v || is_convertible_v) { + cout << t << '\n'; + } else { + for (const auto &e : t) { + cout << e << ' '; + } + cout << '\n'; + } +} + +template void println(string const &str, Args &&...args) { + print(str, forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { + print(t); + cout << '\n'; +} + +void println() { cout << '\n'; } + +template T max() { return numeric_limits::max(); } + +template T min() { return numeric_limits::min(); } + +constexpr static int MOD = 1e9 + 7; + +void solve() { + int n, k, d; + cin >> n >> k >> d; + hashmap, int> memo; + + auto dp = [&](auto &self, int n, int d) -> int { + if (memo.find({n, d}) != memo.end()) + return memo[{n, d}]; + + if (n == 0) + return d == 0 ? 1 : 0; + + ll total = 0; + + FOR(i, 1, min(n + 1, k + 1)) { + total = (total + self(self, n - i, i < d ? d : 0)) % MOD; + } + + return memo[{n, d}] = total; + }; + + print(dp(dp, n, d)); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + // cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/431/.null-ls_433724_c.cc b/codeforces/431/.null-ls_433724_c.cc new file mode 100644 index 0000000..35605d1 --- /dev/null +++ b/codeforces/431/.null-ls_433724_c.cc @@ -0,0 +1,139 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +template void print(string const &str, Args &&...args) { + cout << vformat(str, make_format_args(forward(args)...)); +} + +template void print(T const &t) { cout << t; } + +template void print(T const &t) { + if constexpr (is_same_v || is_convertible_v) { + cout << t << '\n'; + } else { + for (const auto &e : t) { + cout << e << ' '; + } + cout << '\n'; + } +} + +template void println(string const &str, Args &&...args) { + print(str, fo diff --git a/codeforces/431/.null-ls_441630_c.cc b/codeforces/431/.null-ls_441630_c.cc new file mode 100644 index 0000000..2462f22 --- /dev/null +++ b/codeforces/431/.null-ls_441630_c.cc @@ -0,0 +1 @@ +#include diff --git a/codeforces/431/.null-ls_544573_c.cc b/codeforces/431/.null-ls_544573_c.cc new file mode 100644 index 0000000..aa8bdaa --- /dev/null +++ b/codeforces/431/.null-ls_544573_c.cc @@ -0,0 +1,193 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +template void print(string const &str, Args &&...args) { + cout << vformat(str, make_format_args(forward(args)...)); +} + +template void print(T const &t) { cout << t; } + +template void print(T const &t) { + if constexpr (is_same_v || is_convertible_v) { + cout << t << '\n'; + } else { + for (const auto &e : t) { + cout << e << ' '; + } + cout << '\n'; + } +} + +template void println(string const &str, Args &&...args) { + print(str, forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { + print(t); + cout << '\n'; +} + +void println() { cout << '\n'; } + +template T max() { return numeric_limits::max(); } + +template T min() { return numeric_limits::min(); } + +constexpr static int MOD = 1e9 + 7; + +void solve() { + int n, k, d; + cin >> n >> k >> d; + hashmap, int> memo; + + auto dp = [&](auto &self, int n, int d) -> int { + if (memo.find({n, d}) != memo.end()) + return memo[{n, d}]; + + if (n == 0) + return d == 0 ? 1 : 0; + + ll total = 0; + + FOR(i, 1, min(n + 1, k + 1)) { + total = (total + self(self, n - i, i < d ? d : 0)) % MOD; + } + + return memo[{n, d}] = total; + }; + + print(dp(dp, n, d)); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + // cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/431/c.cc b/codeforces/431/c.cc new file mode 100644 index 0000000..c4c1066 --- /dev/null +++ b/codeforces/431/c.cc @@ -0,0 +1,193 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +template void print(string const &str, Args &&...args) { + cout << vformat(str, make_format_args(forward(args)...)); +} + +template void print(T const &t) { cout << t; } + +template void print(T const &t) { + if constexpr (is_same_v || is_convertible_v) { + cout << t << '\n'; + } else { + for (const auto &e : t) { + cout << e << ' '; + } + cout << '\n'; + } +} + +template void println(string const &str, Args &&...args) { + print(str, forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { + print(t); + cout << '\n'; +} + +void println() { cout << '\n'; } + +template T max() { return numeric_limits::max(); } + +template T min() { return numeric_limits::min(); } + +constexpr static int MOD = 1e9 + 7; + +void solve() { + int n, k, d; + cin >> n >> k >> d; + hashmap, int> memo; + + auto dp = [&](auto self, int n, int d) -> int { + if (memo.find({n, d}) != memo.end()) + return memo[{n, d}]; + + if (n == 0) + return d == 0 ? 1 : 0; + + ll total = 0; + + FOR(i, 1, min(n + 1, k + 1)) { + total = (total + self(self, n - i, i < d ? d : 0)) % MOD; + } + + return memo[{n, d}] = total; + }; + + print(dp(dp, n, d)); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + // cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/431/c.debug b/codeforces/431/c.debug new file mode 100755 index 0000000000000000000000000000000000000000..2d0767c40ab5c393c63381ae6346c68920e74a90 GIT binary patch literal 79744 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 + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/431/d.debug b/codeforces/431/d.debug new file mode 100755 index 0000000000000000000000000000000000000000..50f9758c9d595634ae3cea2c3ba9f4cd8ec05adf GIT binary patch literal 24256 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 + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/431/e.debug b/codeforces/431/e.debug new file mode 100755 index 0000000000000000000000000000000000000000..a16567f0fd8616b0c36b0ece725f46846ec64253 GIT binary patch literal 24256 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 + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n; + cin >> n; + + int k = 0; + vec summands; + int power = 0; + while (n) { + int digit = n % 10; + if (digit) { + ++k; + summands.push_back(static_cast(pow(10, power)) * digit); + } + ++power; + n /= 10; + } + cout << k << '\n'; + for (auto summand : summands) cout << summand << ' '; + cout << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/a.in b/codeforces/640/a.in new file mode 100644 index 0000000..3f448ef --- /dev/null +++ b/codeforces/640/a.in @@ -0,0 +1,6 @@ +5 +5009 +7 +9876 +10000 +10 diff --git a/codeforces/640/a.out b/codeforces/640/a.out new file mode 100644 index 0000000..d260f1f --- /dev/null +++ b/codeforces/640/a.out @@ -0,0 +1,10 @@ +2 +9 5000 +1 +7 +4 +6 70 800 9000 +1 +10000 +1 +10 diff --git a/codeforces/640/b.cc b/codeforces/640/b.cc new file mode 100644 index 0000000..1cb42af --- /dev/null +++ b/codeforces/640/b.cc @@ -0,0 +1,134 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + /* + n, k; SUM ai = n, same parity + + n odd: k even -> NO; k odd -> YES + n even: k even: odd #s -> NO, only even + */ + int n, k; + cin >> n >> k; + + if (k > n) { + NO(); + return; + } + + if ((n - 2 * (k - 1)) % 2 == 0 && (n - 2 * (k - 1)) > 0) { + YES(); + FOR(i, 1, k) + cout << 2 << ' '; + cout << n - 2 * (k - 1) << '\n'; + } else if ((n - k + 1) & 1) { + YES(); + FOR(i, 1, k) + cout << 1 << ' '; + cout << n - k + 1 << '\n'; + } else + NO(); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/b.in b/codeforces/640/b.in new file mode 100644 index 0000000..b87a5e7 --- /dev/null +++ b/codeforces/640/b.in @@ -0,0 +1,9 @@ +8 +10 3 +100 4 +8 7 +97 2 +8 8 +3 10 +5 3 +1000000000 9 diff --git a/codeforces/640/b.out b/codeforces/640/b.out new file mode 100644 index 0000000..4495de0 --- /dev/null +++ b/codeforces/640/b.out @@ -0,0 +1,13 @@ +YES +2 2 6 +YES +2 2 2 94 +NO +NO +YES +1 1 1 1 1 1 1 1 +NO +YES +1 1 3 +YES +2 2 2 2 2 2 2 2 999999984 diff --git a/codeforces/640/c.cc b/codeforces/640/c.cc new file mode 100644 index 0000000..b0d8cd3 --- /dev/null +++ b/codeforces/640/c.cc @@ -0,0 +1,124 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n, k; + + cin >> n >> k; + + /* + take n; + n divides n, 2n, 3n, 4n, ... + kth positive integer not divisible by n; + just count ^ : n - 1, n - 1 between each + + binary search on the right #; + */ + + ll x = k + k / (n - 1); + if (x % n == 0) --x; + println(x); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/c.in b/codeforces/640/c.in new file mode 100644 index 0000000..c1d0911 --- /dev/null +++ b/codeforces/640/c.in @@ -0,0 +1,7 @@ +6 +3 7 +4 12 +2 1000000000 +7 97 +1000000000 1000000000 +2 1 diff --git a/codeforces/640/c.out b/codeforces/640/c.out new file mode 100644 index 0000000..100793b --- /dev/null +++ b/codeforces/640/c.out @@ -0,0 +1,6 @@ +10 +15 +1999999999 +113 +1000000001 +1 diff --git a/codeforces/640/compile_flags.txt b/codeforces/640/compile_flags.txt new file mode 100644 index 0000000..ebd5be8 --- /dev/null +++ b/codeforces/640/compile_flags.txt @@ -0,0 +1,5 @@ +-std=c++20 +-Wall +-Wextra +-Wshadow +-DLOCAL diff --git a/codeforces/640/d.cc b/codeforces/640/d.cc new file mode 100644 index 0000000..2ab9035 --- /dev/null +++ b/codeforces/640/d.cc @@ -0,0 +1,139 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n; + cin >> n; + vec A(n); + for (auto &e : A) cin >> e; + + int moves = 1, i = 1, j = sz(A) - 1; + int a = A[0], b = 0; + int prev = a; + + while (i <= j) { + int cur = 0; + // bob + if (moves & 1) { + while (i <= j && cur <= prev) { + cur += A[j]; + --j; + } + b += cur; + prev = cur; + } else { // alice + while (i <= j && cur <= prev) { + cur += A[i]; + ++i; + } + a += cur; + prev = cur; + } + ++moves; + } + + println("{} {} {}", moves, a, b); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/d.in b/codeforces/640/d.in new file mode 100644 index 0000000..e5a3fa3 --- /dev/null +++ b/codeforces/640/d.in @@ -0,0 +1,15 @@ +7 +11 +3 1 4 1 5 9 2 6 5 3 5 +1 +1000 +3 +1 1 1 +13 +1 2 3 4 5 6 7 8 9 10 11 12 13 +2 +2 1 +6 +1 1 1 1 1 1 +7 +1 1 1 1 1 1 1 diff --git a/codeforces/640/d.out b/codeforces/640/d.out new file mode 100644 index 0000000..1a3d92b --- /dev/null +++ b/codeforces/640/d.out @@ -0,0 +1,7 @@ +6 23 21 +1 1000 0 +2 1 2 +6 45 46 +2 2 1 +3 4 2 +4 4 3 diff --git a/codeforces/640/e.cc b/codeforces/640/e.cc new file mode 100644 index 0000000..b06dcc8 --- /dev/null +++ b/codeforces/640/e.cc @@ -0,0 +1,231 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +#include +#include + +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 +struct custom_hash {}; + +template +inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) hash_combine(value, x); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +void solve() { + int n; + cin >> n; + vec a(n); + + vec freq(n + 1, 0); + for (auto &e : a) { + cin >> e; + ++freq[e]; + } + + int ans = 0; + FOR(i, 0, n) { + int total = 0; + FOR(j, i, n) { + total += a[j]; + if (i != j && total <= n) { + ans += freq[total]; + freq[total] = 0; + } + } + } + println(ans); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/e.in b/codeforces/640/e.in new file mode 100644 index 0000000..7fe04ef --- /dev/null +++ b/codeforces/640/e.in @@ -0,0 +1,11 @@ +5 +9 +3 1 4 1 5 9 2 6 5 +3 +1 1 2 +5 +1 1 1 1 1 +8 +8 7 6 5 4 3 2 1 +1 +1 diff --git a/codeforces/640/e.out b/codeforces/640/e.out new file mode 100644 index 0000000..9c0b33c --- /dev/null +++ b/codeforces/640/e.out @@ -0,0 +1,5 @@ +5 +1 +0 +4 +0 diff --git a/codeforces/640/f.cc b/codeforces/640/f.cc new file mode 100644 index 0000000..749f927 --- /dev/null +++ b/codeforces/640/f.cc @@ -0,0 +1,124 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n0, n1, n2; + cin >> n0 >> n1 >> n2; + + if (n1 == 0) { + char s = n0 ? '0' : '1'; + cout << string(max(n0, n2) + 1, s) << '\n'; + return; + } + + string ans; + FOR(i, 0, n1 + 1) + ans += i & 1 ? '0' : '1'; + ans.insert(1, string(n0, '0')); + ans = string(n2, '1') + ans; + + println(ans); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/f.in b/codeforces/640/f.in new file mode 100644 index 0000000..14c9585 --- /dev/null +++ b/codeforces/640/f.in @@ -0,0 +1,9 @@ +8 +0 3 4 +1 3 5 +1 1 1 +3 9 3 +0 1 0 +3 1 2 +0 0 3 +2 0 0 diff --git a/codeforces/640/f.out b/codeforces/640/f.out new file mode 100644 index 0000000..f48ec1b --- /dev/null +++ b/codeforces/640/f.out @@ -0,0 +1,8 @@ +11111010 +1111110010 +1100 +1111000010101010 +10 +1110000 +1111 +000 diff --git a/codeforces/640/g.cc b/codeforces/640/g.cc new file mode 100644 index 0000000..0ec3b23 --- /dev/null +++ b/codeforces/640/g.cc @@ -0,0 +1,174 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n; + cin >> n; + + /* + + 1, 4, 2, 5, 3, 6, 9, 7, 10, 8 + +1: 5, 7, 3, 6 -> pop -> 2, -4, 3 +2: 5, 7, 3, 6, 8 +3: 3, 7, 9, 6, 8 -> +4, +2, -3, +2 +4: 3, -2, 3, -2 + + 1, 4, 2, 5, 3, 7, 9, 6, 8 + + n = 4 -> 2 4 1 3 + + + +1, +3, -2, +3, -2, +3, +3, -2, +3, -2 + + */ + + if (n < 4) { + println(-1); + return; + } + + if (n == 4) { + println("2 4 1 3"); + return; + } + + vec ans{1}; + int prev = 1; + --n; + while (n >= 5) { + for (auto diff : {3, -2, 3, -2, 3}) { + prev += diff; + ans.push_back(prev); + } + n -= 5; + } + + vec diff; + switch (n) { + case 1: + ans.pop_back(); + ans.pop_back(); + diff = {2, -4, 3}; + break; + case 2: + ans.pop_back(); + ans.pop_back(); + diff = {2, -4, 3, 2}; + break; + case 3: + ans.pop_back(); + diff = {4, 2, -3, 2}; + break; + case 4: + diff = {3, -2, 3, -2}; + break; + } + for (auto d : diff) ans.push_back(ans[sz(ans) - 1] + d); + + for (auto e : ans) cout << e << ' '; + println(); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/640/g.in b/codeforces/640/g.in new file mode 100644 index 0000000..56f6744 --- /dev/null +++ b/codeforces/640/g.in @@ -0,0 +1,8 @@ +7 +10 +2 +4 +6 +7 +9 +13 diff --git a/codeforces/640/g.out b/codeforces/640/g.out new file mode 100644 index 0000000..404a102 --- /dev/null +++ b/codeforces/640/g.out @@ -0,0 +1,7 @@ +1 4 2 5 3 6 9 7 10 8 +-1 +2 4 1 3 +1 4 2 5 3 6 +1 4 2 5 7 3 6 +1 4 2 5 3 7 9 6 8 +1 4 2 5 3 6 9 7 10 12 8 11 13 diff --git a/codeforces/923/.clang-format b/codeforces/923/.clang-format new file mode 100644 index 0000000..5625628 --- /dev/null +++ b/codeforces/923/.clang-format @@ -0,0 +1,2 @@ +BasedOnStyle: Google +AllowShortFunctionsOnASingleLine: Empty diff --git a/codeforces/923/a.cc b/codeforces/923/a.cc new file mode 100644 index 0000000..14e09b1 --- /dev/null +++ b/codeforces/923/a.cc @@ -0,0 +1,120 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n; + cin >> n; + int l = -1, r = -1; + + FOR(i, 0, n) { + char c; + cin >> c; + if (l == -1 && c == 'B') l = i; + if (c == 'B') r = i; + } + + println(r - l + 1); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/923/a.in b/codeforces/923/a.in new file mode 100644 index 0000000..31d5fa9 --- /dev/null +++ b/codeforces/923/a.in @@ -0,0 +1,17 @@ +8 +6 +WBBWBW +1 +B +2 +WB +3 +BBW +4 +BWWB +6 +BWBWWB +6 +WWBBWB +9 +WBWBWWWBW diff --git a/codeforces/923/a.out b/codeforces/923/a.out new file mode 100644 index 0000000..e44b01a --- /dev/null +++ b/codeforces/923/a.out @@ -0,0 +1,24 @@ +hi + +4 +hi + +1 +hi + +1 +hi + +2 +hi + +4 +hi + +6 +hi + +4 +hi + +7 diff --git a/codeforces/923/b.cc b/codeforces/923/b.cc new file mode 100644 index 0000000..22d1fff --- /dev/null +++ b/codeforces/923/b.cc @@ -0,0 +1,231 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +#include +#include + +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 +struct custom_hash {}; + +template +inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) hash_combine(value, x); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +void solve() { + int n; + cin >> n; + + string ans; + vec> rev(n + 1); + int last_used = -1; + + FOR(i, 0, n) { + int a; + cin >> a; + if (a == 0) { + ++last_used; + cout << (char(last_used + 'a')); + rev[1].push_back(last_used); + } else { + cout << char(rev[a].front() + 'a'); + rev[a + 1].push_back(rev[a].front()); + rev[a].pop_front(); + } + } + + println(); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/923/b.in b/codeforces/923/b.in new file mode 100644 index 0000000..1c42608 --- /dev/null +++ b/codeforces/923/b.in @@ -0,0 +1,11 @@ +5 +11 +0 0 0 1 0 2 0 3 1 1 4 +10 +0 0 0 0 0 1 0 1 1 0 +1 +0 +8 +0 1 2 3 4 5 6 7 +8 +0 0 0 0 0 0 0 0 diff --git a/codeforces/923/b.out b/codeforces/923/b.out new file mode 100644 index 0000000..62e29d4 --- /dev/null +++ b/codeforces/923/b.out @@ -0,0 +1,5 @@ +abcadaeabca +abcdeafbcg +a +aaaaaaaa +abcdefgh diff --git a/codeforces/923/c.cc b/codeforces/923/c.cc new file mode 100644 index 0000000..af73b24 --- /dev/null +++ b/codeforces/923/c.cc @@ -0,0 +1,150 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +bitset<2 * 2 * 100000 + 1> a, b; + +void solve() { + int n, m, k; + cin >> n >> m >> k; + + // ensure: + // a) all found + // b) <= k / 2 elements in [1,k] from just one arry + + int x; + + while (n--) { + cin >> x; + if (x > k) continue; + a.set(x); + } + + while (m--) { + cin >> x; + if (x > k) continue; + b.set(x); + } + + bool all_found = true; + + int unique_to_a = 0, unique_to_b = 0; + for (int i = 1; i <= k; ++i) { + if (!a[i] && !b[i]) { + all_found = false; + break; + } + if (a[i] && !b[i]) ++unique_to_a; + if (!a[i] && b[i]) ++unique_to_b; + } + + if (all_found && unique_to_a <= k / 2 && unique_to_b <= k / 2) + YES(); + else + NO(); + + a.reset(); + b.reset(); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/923/c.in b/codeforces/923/c.in new file mode 100644 index 0000000..27c1ad3 --- /dev/null +++ b/codeforces/923/c.in @@ -0,0 +1,19 @@ +6 +6 5 6 +2 3 8 5 6 5 +1 3 4 10 5 +6 5 6 +2 3 4 5 6 5 +1 3 8 10 3 +3 3 4 +1 3 5 +2 4 6 +2 5 4 +1 4 +7 3 4 4 2 +1 4 2 +2 +6 4 4 2 +1 5 2 +3 +2 2 1 4 3 diff --git a/codeforces/923/c.out b/codeforces/923/c.out new file mode 100644 index 0000000..faa6105 --- /dev/null +++ b/codeforces/923/c.out @@ -0,0 +1,6 @@ +YES +NO +YES +YES +NO +NO diff --git a/codeforces/923/compile_flags.txt b/codeforces/923/compile_flags.txt new file mode 100644 index 0000000..ebd5be8 --- /dev/null +++ b/codeforces/923/compile_flags.txt @@ -0,0 +1,5 @@ +-std=c++20 +-Wall +-Wextra +-Wshadow +-DLOCAL diff --git a/codeforces/923/d.cc b/codeforces/923/d.cc new file mode 100644 index 0000000..2e06910 --- /dev/null +++ b/codeforces/923/d.cc @@ -0,0 +1,136 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n; + cin >> n; + vec a(n); + vec p(n, -1); + cin >> a[0]; + + FOR(i, 1, n) { + cin >> a[i]; + p[i] = p[i - 1]; + if (a[i] != a[i - 1]) p[i] = i - 1; + } + + int q; + cin >> q; + while (q--) { + int l, r; + cin >> l >> r; + + --l; + --r; + + int i = r; + int j = p[r]; + + if (j < l) i = -2, j = -2; + + println("{} {}", i + 1, j + 1); + } +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/923/d.in b/codeforces/923/d.in new file mode 100644 index 0000000..e0a89b3 --- /dev/null +++ b/codeforces/923/d.in @@ -0,0 +1,40 @@ +5 +5 +1 1 2 1 1 +3 +1 5 +1 2 +1 3 +6 +30 20 20 10 10 20 +5 +1 2 +2 3 +2 4 +2 6 +3 5 +4 +5 2 3 4 +4 +1 2 +1 4 +2 3 +2 4 +5 +1 4 3 2 4 +5 +1 5 +2 4 +3 4 +3 5 +4 5 +5 +2 3 1 4 2 +7 +1 2 +1 4 +1 5 +2 4 +2 5 +3 5 +4 5 diff --git a/codeforces/923/d.out b/codeforces/923/d.out new file mode 100644 index 0000000..cf249ed --- /dev/null +++ b/codeforces/923/d.out @@ -0,0 +1,24 @@ +5 3 +-1 -1 +3 2 +2 1 +-1 -1 +4 3 +6 5 +5 3 +2 1 +4 3 +3 2 +4 3 +5 4 +4 3 +4 3 +5 4 +5 4 +2 1 +4 3 +5 4 +4 3 +5 4 +5 4 +5 4 diff --git a/codeforces/923/exe b/codeforces/923/exe new file mode 100755 index 0000000000000000000000000000000000000000..756ff629b7e83128575b2ed90633529fe1353460 GIT binary patch literal 319016 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

0?ECI2FNAw!dbL3rycA}qRSkc7^;^!r&Dp3 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

1;iFq9T|q8qyoMS54@zi4YJrCw4{5( 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/$em;G;XQ&gfuQ;}H?hPMGNKJS*OS7N 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 NKvKFXng%p30|1zgyKn#i literal 0 HcmV?d00001 diff --git a/codeforces/923/j.cc b/codeforces/923/j.cc new file mode 100644 index 0000000..22f079d --- /dev/null +++ b/codeforces/923/j.cc @@ -0,0 +1,110 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + aknf; + kdsafkjadsfjadsfj +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/923/j.in b/codeforces/923/j.in new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/923/j.out b/codeforces/923/j.out new file mode 100644 index 0000000..c7aa030 --- /dev/null +++ b/codeforces/923/j.out @@ -0,0 +1,8 @@ +j.cc: In function ‘void solve()’: +j.cc:72:3: error: ‘aknf’ was not declared in this scope + 72 | aknf;kdsafkjadsfjadsfj + | ^~~~ +j.cc:72:8: error: ‘kdsafkjadsfjadsfj’ was not declared in this scope + 72 | aknf;kdsafkjadsfjadsfj + | ^~~~~~~~~~~~~~~~~ +zsh:1: permission denied: /tmp/tmp.yMxI36SPlf diff --git a/codeforces/923/k.cc b/codeforces/923/k.cc new file mode 100644 index 0000000..a1f8773 --- /dev/null +++ b/codeforces/923/k.cc @@ -0,0 +1,86 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template void print(T const &t) { std::cout << t; } + +template void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { cout << t << '\n'; } + +void println() { std::cout << '\n'; } + +template T MAX() { return std::numeric_limits::max(); } + +template T MIN() { return std::numeric_limits::min(); } + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { cout << "YES\n"; } +void NO() { cout << "NO\n"; } + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/923/k.in b/codeforces/923/k.in new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/923/k.out b/codeforces/923/k.out new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/974/.clang-format b/codeforces/974/.clang-format new file mode 100644 index 0000000..5625628 --- /dev/null +++ b/codeforces/974/.clang-format @@ -0,0 +1,2 @@ +BasedOnStyle: Google +AllowShortFunctionsOnASingleLine: Empty diff --git a/codeforces/974/a.cc b/codeforces/974/a.cc new file mode 100644 index 0000000..bb4c0b6 --- /dev/null +++ b/codeforces/974/a.cc @@ -0,0 +1,67 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n, k; + cin >> n >> k; + vec people(n); + for (auto &e : people) cin >> e; + int ans = 0, robin = 0; + for (auto amount : people) { + if (amount >= k) + robin += amount; + else if (robin > 0 && amount == 0) { + --robin; + ++ans; + } + } + cout << ans << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/974/a.debug b/codeforces/974/a.debug new file mode 100755 index 0000000000000000000000000000000000000000..3f565ded76d7e9c723f0202b7a6a5a11e4e5efb6 GIT binary patch literal 27120 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 + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat( + str, + // make_format_args binds arguments to const + str, std::make_format_args(static_cast(args)...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + int n, k; + cin >> n >> k; + + int overlaps = k - 1; + + if (n & 1) { + // need odd # odds in overlaps + int odd_count = floor(overlaps / 2); + + cout << (odd_count & 1 ? "YES" : "NO"); + } else { + int odd_count = ceil(overlaps / 2); + cout << (odd_count & 1 ? "NO" : "YES"); + } + + cout << '\n'; +} + +int main() { + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/974/b.debug b/codeforces/974/b.debug new file mode 100755 index 0000000000000000000000000000000000000000..09c0356a13144dd6362eccce344b2a3680b8f7c2 GIT binary patch literal 22960 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 literal 0 HcmV?d00001 diff --git a/codeforces/974/b.in b/codeforces/974/b.in new file mode 100644 index 0000000..8910375 --- /dev/null +++ b/codeforces/974/b.in @@ -0,0 +1,6 @@ +5 +1 1 +2 1 +2 2 +3 2 +4 4 diff --git a/codeforces/974/b.out b/codeforces/974/b.out new file mode 100644 index 0000000..0d0a576 --- /dev/null +++ b/codeforces/974/b.out @@ -0,0 +1,5 @@ +NO +YES +YES +NO +NO diff --git a/codeforces/974/c.cc b/codeforces/974/c.cc new file mode 100644 index 0000000..75799d2 --- /dev/null +++ b/codeforces/974/c.cc @@ -0,0 +1,114 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat( + str, + // make_format_args binds arguments to const + str, std::make_format_args(static_cast(args)...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + ll n; + cin >> n; + vec people(n); + ll total = 0; + for (auto &e : people) { + cin >> e; + total += e; + }; + + sort(all(people)); + + if (n >= 3) { + cout << max(static_cast(0), 1 + people[n / 2] * 2 * n - total); + } else + cout << -1; + cout << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/974/c.in b/codeforces/974/c.in new file mode 100644 index 0000000..b45c2c4 --- /dev/null +++ b/codeforces/974/c.in @@ -0,0 +1,13 @@ +6 +1 +2 +2 +2 19 +3 +1 3 20 +4 +1 2 3 4 +5 +1 2 3 4 5 +6 +1 2 1 1 1 25 diff --git a/codeforces/974/c.out b/codeforces/974/c.out new file mode 100644 index 0000000..4d752d6 --- /dev/null +++ b/codeforces/974/c.out @@ -0,0 +1,6 @@ +-1 +-1 +0 +15 +16 +0 diff --git a/codeforces/974/compile_flags.txt b/codeforces/974/compile_flags.txt new file mode 100644 index 0000000..ebd5be8 --- /dev/null +++ b/codeforces/974/compile_flags.txt @@ -0,0 +1,5 @@ +-std=c++20 +-Wall +-Wextra +-Wshadow +-DLOCAL diff --git a/codeforces/974/d.cc b/codeforces/974/d.cc new file mode 100644 index 0000000..801dd0d --- /dev/null +++ b/codeforces/974/d.cc @@ -0,0 +1,130 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat( + str, + // make_format_args binds arguments to const + str, std::make_format_args(static_cast(args)...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +void solve() { + int n, d, k; + cin >> n >> d >> k; + vec start(n + 1); + vec end(n + 1); + while (k--) { + int l, r; + cin >> l >> r; + ++start[l]; + ++end[r]; + } + + // prefix + FOR(i, 1, n + 1) { + start[i] += start[i - 1]; + end[i] += end[i - 1]; + } + + int brother = MIN(), mother = MAX(); + int brother_day = 0, mother_day = 0; + FOR(i, 0, n - d + 1) { + if (start[i + d] - end[i] > brother) { + brother = start[i + d] - end[i]; + brother_day = i; + } + if (start[i + d] - end[i] < mother) { + mother = start[i + d] - end[i]; + mother_day = i; + } + } + cout << (brother_day + 1) << ' ' << (mother_day + 1) << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/974/d.in b/codeforces/974/d.in new file mode 100644 index 0000000..f8717c0 --- /dev/null +++ b/codeforces/974/d.in @@ -0,0 +1,20 @@ +6 +2 1 1 +1 2 +4 1 2 +1 2 +2 4 +7 2 3 +1 2 +1 3 +6 7 +5 1 2 +1 2 +3 5 +9 2 1 +2 8 +9 2 4 +7 9 +4 8 +1 3 +2 3 diff --git a/codeforces/974/d.out b/codeforces/974/d.out new file mode 100644 index 0000000..4e830a2 --- /dev/null +++ b/codeforces/974/d.out @@ -0,0 +1,6 @@ +1 1 +2 1 +1 4 +1 1 +1 1 +3 4 diff --git a/codeforces/974/h.cc b/codeforces/974/h.cc new file mode 100644 index 0000000..070106a --- /dev/null +++ b/codeforces/974/h.cc @@ -0,0 +1,229 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat( + str, + // make_format_args binds arguments to const + str, std::make_format_args(static_cast(args)...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +static constexpr int MOD = 1e9 + 7; + +#include +#include + +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 +struct custom_hash {}; + +template +inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) hash_combine(value, x); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +std::random_device rd; +std::mt19937 gen(rd()); +std::uniform_int_distribution<> distrib(0, MAX()); + +void solve() { + int n, q; + cin >> n >> q; + + vector prefix_hash_xor(n); + // map index in a -> hash + hashmap hm; + + FOR(i, 0, n) { + cin >> prefix_hash_xor[i]; + prefix_hash_xor[i] ^= (i ? prefix_hash_xor[i - 1] : 0); + } + + while (q--) { + int l, r; + cin >> l >> r; + + --l; + --r; + + bool even_each = + (prefix_hash_xor[r] ^ (l ? prefix_hash_xor[l - 1] : 0)) == 0; + + cout << (even_each ? "YES" : "NO") << '\n'; + } +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/974/h.in b/codeforces/974/h.in new file mode 100644 index 0000000..5742f58 --- /dev/null +++ b/codeforces/974/h.in @@ -0,0 +1,11 @@ +2 +3 3 +1 2 2 +1 2 +1 3 +2 3 +5 3 +2 1 2 1 1 +1 2 +1 3 +4 5 diff --git a/codeforces/974/h.out b/codeforces/974/h.out new file mode 100644 index 0000000..187ad8a --- /dev/null +++ b/codeforces/974/h.out @@ -0,0 +1,6 @@ +NO +NO +YES +NO +NO +YES diff --git a/codeforces/984/a.cc b/codeforces/984/a.cc new file mode 100644 index 0000000..ccacab5 --- /dev/null +++ b/codeforces/984/a.cc @@ -0,0 +1,45 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(x) for (int i = 0; i < (x).size(); ++i) + +#ifdef LOCAL +#define dbg(x) cerr << #x << " = " << (x) << '\n' +#else +#define dbg(x) +#endif + +void solve() { + int n; + cin >> n; + vector notes(n, 0); + for (auto &x : notes) + cin >> x; + + for (int i = 1; i < notes.size(); ++i) { + auto diff = abs(notes[i] - notes[i - 1]); + + if (!(diff == 5 || diff == 7)) { + cout << "NO\n"; + return; + } + } + + cout << "YES\n"; +} + +int main() { + ios::sync_with_stdio(false); + cin.tie(nullptr); + + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/984/a.in b/codeforces/984/a.in new file mode 100644 index 0000000..b1e6ff9 --- /dev/null +++ b/codeforces/984/a.in @@ -0,0 +1,17 @@ +8 +2 +114 109 +2 +17 10 +3 +76 83 88 +8 +38 45 38 80 85 92 99 106 +5 +63 58 65 58 65 +8 +117 124 48 53 48 43 54 49 +5 +95 102 107 114 121 +10 +72 77 82 75 70 75 68 75 68 75 diff --git a/codeforces/984/b.cc b/codeforces/984/b.cc new file mode 100644 index 0000000..c6987e3 --- /dev/null +++ b/codeforces/984/b.cc @@ -0,0 +1,54 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(x) for (int i = 0; i < (x).size(); ++i) + +#ifdef LOCAL +#define dbg(x) cerr << #x << " = " << (x) << '\n' +#else +#define dbg(x) +#endif + +#define MAX_K 2 * 100000 + +// clearing/resetting vector +// clean way for x^n; exppow +// sorting in orders +// totally misread: test case time * +// how does time work???? per-test case... or + +void solve() { + int n, k; + cin >> n >> k; + + vector brand_to_cost(k + 1, 0); + + for (int i = 0; i < k; ++i) { + int b, c; + cin >> b >> c; + brand_to_cost[b] += c; + } + + sort(all(brand_to_cost), std::greater{}); + + std::cout << accumulate(brand_to_cost.begin(), + brand_to_cost.begin() + min(n, sz(brand_to_cost)), + 0LL) + << '\n'; +} + +int main() { + ios::sync_with_stdio(false); + cin.tie(nullptr); + + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/984/b.in b/codeforces/984/b.in new file mode 100644 index 0000000..f235cf6 --- /dev/null +++ b/codeforces/984/b.in @@ -0,0 +1,14 @@ +4 +3 3 +2 6 +2 7 +1 15 +1 3 +2 6 +2 7 +1 15 +6 2 +1 7 +2 5 +190000 1 +1 1000 diff --git a/codeforces/984/b.out b/codeforces/984/b.out new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/984/c.cc b/codeforces/984/c.cc new file mode 100644 index 0000000..d3343d0 --- /dev/null +++ b/codeforces/984/c.cc @@ -0,0 +1,76 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(x) for (int i = 0; i < (x).size(); ++i) + +// variable iterator macro needed +// NOTE: can prob optimize by sorting queries +// fix matchparen highlight +// NOTE: didn't realize queries are independent (bruh) + +void solve() { + string s; + cin >> s; + + auto valid = [&](int i) -> bool { + return i >= 0 && i < sz(s) - 3 && s[i] == '1' && s[i + 1] == '1' && + s[i + 2] == '0' && s[i + 3] == '0'; + }; + + int count = 0; + + for (int i = 0; i < sz(s); ++i) { + if (valid(i)) { + ++count; + } + } + + int q; + cin >> q; + + for (int _ = 0; _ < q; _++) { + int i; + char v; + cin >> i >> v; + --i; + + if (s[i] != v) { + bool left = false; + for (int j = i - 3; j <= i; ++j) { + if (valid(j)) { + left = true; + break; + } + } + + s[i] = v; + + bool right = false; + for (int j = i - 3; j <= i; ++j) { + if (valid(j)) { + right = true; + break; + } + } + + count += (right - left); + } + cout << (count > 0 ? "YES" : "NO") << '\n'; + } +} + +int main() { + ios::sync_with_stdio(false); + cin.tie(nullptr); + + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/984/c.in b/codeforces/984/c.in new file mode 100644 index 0000000..eea2dea --- /dev/null +++ b/codeforces/984/c.in @@ -0,0 +1,24 @@ +4 +100 +4 +1 1 +2 0 +2 0 +3 1 +1100000 +3 +6 1 +7 1 +4 1 +111010 +4 +1 1 +5 0 +4 1 +5 0 +0100 +4 +3 1 +1 1 +2 0 +2 1 diff --git a/codeforces/984/c.out b/codeforces/984/c.out new file mode 100644 index 0000000..202b0b7 --- /dev/null +++ b/codeforces/984/c.out @@ -0,0 +1,15 @@ +NO +NO +NO +NO +YES +YES +NO +NO +YES +YES +YES +NO +NO +NO +NO diff --git a/codeforces/984/d.cc b/codeforces/984/d.cc new file mode 100644 index 0000000..8cc00b2 --- /dev/null +++ b/codeforces/984/d.cc @@ -0,0 +1,93 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(x) for (int i = 0; i < (x).size(); ++i) + +#ifdef LOCAL +#define dbg(x) cerr << #x << " = " << (x) << '\n' +#else +#define dbg(x) +#endif + +constexpr auto _1543 = "1543"; + +int find_1543(const string &layer) { + if (sz(layer) < 4) { + return 0; + } + string extended = layer + layer.substr(0, 3); + + int count = 0; + for (int i = 0; i < sz(layer); ++i) { + bool found = true; + for (int j = 0; j < 4; j++) { + if (extended[i + j] != _1543[j]) { + found = false; + break; + } + } + + count += found; + } + return count; +} + +string layer(const vector &carpet, int n, int m, int i) { + int top = i, bot = n - 1 - i, l = i, r = m - 1 - i; + + string pattern; + for (int c = l; c <= r; c++) { + pattern.push_back(carpet[top][c]); + } + for (int row = top + 1; row < bot; row++) { + pattern.push_back(carpet[row][r]); + } + if (bot > top) { + for (int c = r; c >= l; c--) { + pattern.push_back(carpet[bot][c]); + } + } + if (l < r) { + for (int r = bot - 1; r > top; r--) { + pattern.push_back(carpet[r][l]); + } + } + + return pattern; +} + +void solve() { + int n, m; + cin >> n >> m; + + vector carpet(n); + for (auto &x : carpet) { + cin >> x; + } + + long long ans = 0; + const int LAYER_COUNT = min(n, m) / 2; + + for (int i = 0; i < LAYER_COUNT; ++i) { + string ring = layer(carpet, n, m, i); + ans += find_1543(ring); + } + + cout << ans << '\n'; +} + +int main() { + ios::sync_with_stdio(false); + cin.tie(nullptr); + + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/984/d.in b/codeforces/984/d.in new file mode 100644 index 0000000..5e89c0b --- /dev/null +++ b/codeforces/984/d.in @@ -0,0 +1,31 @@ +8 +2 4 +1543 +7777 +2 4 +7154 +8903 +2 4 +3451 +8888 +2 2 +54 +13 +2 2 +51 +43 +2 6 +432015 +512034 +4 4 +5431 +1435 +5518 +7634 +6 4 +5432 +1152 +4542 +2432 +2302 +5942 diff --git a/codeforces/984/d.out b/codeforces/984/d.out new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/984/e.cc b/codeforces/984/e.cc new file mode 100644 index 0000000..230c4f3 --- /dev/null +++ b/codeforces/984/e.cc @@ -0,0 +1,64 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(x) for (int i = 0; i < (x).size(); ++i) + +void solve() { + int n, k, q; + cin >> n >> k >> q; + + vector> b(k + 1, vector(n + 1, 0)); + + int v; + for (int i = 1; i <= n; ++i) { + for (int j = 1; j <= k; ++j) { + cin >> v; + b[j][i] = b[j][i - 1] | v; + } + } + + while (q--) { + int m; + cin >> m; + + int l = 0, r = n - 1; + + while (m--) { + int R, v; + char c; + cin >> R; + cin >> c; + cin >> v; + + if (c == '<') { + int i = distance(b[R].begin() + 1, lower_bound(all(b[R]), v)) - 1; + r = min(r, i); + } else { + int i = distance(b[R].begin() + 1, upper_bound(all(b[R]), v)); + l = max(l, i); + } + } + + if (l <= r) { + cout << l + 1 << '\n'; + } else { + cout << -1 << '\n'; + } + } +} + +int main() { + ios::sync_with_stdio(false); + cin.tie(nullptr); + + // int t; + // cin >> t; + + // while (t--) { + solve(); + // } + + return 0; +} diff --git a/codeforces/984/e.in b/codeforces/984/e.in new file mode 100644 index 0000000..a83311b --- /dev/null +++ b/codeforces/984/e.in @@ -0,0 +1,16 @@ +3 4 4 +1 3 5 9 +4 6 5 3 +2 1 2 7 +3 +1 > 4 +2 < 8 +1 < 6 +2 +1 < 8 +2 > 8 +1 +3 > 5 +2 +4 > 8 +1 < 8 diff --git a/codeforces/984/e.out b/codeforces/984/e.out new file mode 100644 index 0000000..512d5c5 --- /dev/null +++ b/codeforces/984/e.out @@ -0,0 +1,4 @@ +2 +-1 +3 +1 diff --git a/codeforces/991/.null-ls_940867_d.cc b/codeforces/991/.null-ls_940867_d.cc new file mode 100644 index 0000000..058dea0 --- /dev/null +++ b/codeforces/991/.null-ls_940867_d.cc @@ -0,0 +1,188 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +template void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + std::make_format_args(std::forward(args)...)); +} + +template void print(T const &t) { std::cout << t; } + +template void print(T const &t) { + if constexpr (std::is_same_v || + std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { cout << t << '\n'; } + +void println() { std::cout << '\n'; } + +template T MAX() { return std::numeric_limits::max(); } + +template T MIN() { return std::numeric_limits::min(); } + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +constexpr static int MOD = 1e9 + 7; + +void solve() { + string s; + cin >> s; + + for (int i = 1; i < s.size(); ++i) { + if (s[i] == '0') + continue; + + int j = i; + while (j >= 1 && s[j] - 1 > s[j - 1]) { + --s[j]; + swap(s[j], s[-1]); + --j; + } + } + + println(s); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/991/buf b/codeforces/991/buf new file mode 100644 index 0000000..4fd015e --- /dev/null +++ b/codeforces/991/buf @@ -0,0 +1,29 @@ +void solve() { + stGCD.clear(); + int n, q; cin >> n >> q; + vector a(n); + for (int &x : a) cin >> x; + + vector b; + for (int i = 1; i < n; i++) + b.push_back(abs(a[i - 1] - a[i])); + + stGCD.resize(LOGN, vector(b.size(), 1)); + for (int i = 0; i < b.size(); i++) + stGCD[0][i] = b[i]; + for (int i = 1; i < LOGN; i++) + for (int j = 0; j + (1 << (i - 1)) < b.size(); j++) + stGCD[i][j] = __gcd(stGCD[i - 1][j], stGCD[i - 1][j + (1 << (i - 1))]); + + while (q--) { + int l, r; cin >> l >> r; + if (l == r) { + cout << 0 << " "; + continue; + } + l--; r -= 2; + int gcd = get_gcd(l, r); + cout << gcd << " "; + } +} + diff --git a/codeforces/991/compile_flags.txt b/codeforces/991/compile_flags.txt new file mode 100644 index 0000000..e23b2ae --- /dev/null +++ b/codeforces/991/compile_flags.txt @@ -0,0 +1 @@ +-std=c++20 diff --git a/codeforces/991/d.cc b/codeforces/991/d.cc new file mode 100644 index 0000000..bb2a3bd --- /dev/null +++ b/codeforces/991/d.cc @@ -0,0 +1,188 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +template void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + std::make_format_args(std::forward(args)...)); +} + +template void print(T const &t) { std::cout << t; } + +template void print(T const &t) { + if constexpr (std::is_same_v || + std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { cout << t << '\n'; } + +void println() { std::cout << '\n'; } + +template T MAX() { return std::numeric_limits::max(); } + +template T MIN() { return std::numeric_limits::min(); } + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +constexpr static int MOD = 1e9 + 7; + +void solve() { + string s; + cin >> s; + + for (int i = 1; i < s.size(); ++i) { + if (s[i] == '0') + continue; + + int j = i; + while (j >= 1 && s[j] - 1 > s[j - 1]) { + --s[j]; + swap(s[j], s[j - 1]); + --j; + } + } + + println(s); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/991/d.in b/codeforces/991/d.in new file mode 100644 index 0000000..44707b6 --- /dev/null +++ b/codeforces/991/d.in @@ -0,0 +1,7 @@ +6 +19 +1709 +11555 +51476 +9876543210 +5891917899 diff --git a/codeforces/991/d.out b/codeforces/991/d.out new file mode 100644 index 0000000..6f17443 --- /dev/null +++ b/codeforces/991/d.out @@ -0,0 +1,6 @@ +81 +6710 +33311 +55431 +9876543210 +7875567711 diff --git a/codeforces/991/e.cc b/codeforces/991/e.cc new file mode 100644 index 0000000..43a44b6 --- /dev/null +++ b/codeforces/991/e.cc @@ -0,0 +1,50 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(i, x) for (int i = 0; i < (x).size(); ++i) + +#ifdef LOCAL +#define dbg(x) cerr << #x << " = " << (x) << '\n' +#else +#define dbg(x) +#endif + +void solve() { + string a, b, c; + cin >> a >> b >> c; + + if (a.size() < b.size()) { + swap(a, b); + } + + vector dp(b.size() + 1, 0); + + for (int j = 1; j <= b.size(); ++j) { + dp[j] = dp[j - 1] + (b[j - 1] != c[j - 1]); + } + + for (int i = 1; i <= a.size(); ++i) { + dp[0] += (a[i - 1] != c[i - 1]); + for (int j = 1; j <= b.size(); ++j) { + int k = i + j - 1; + dp[j] = min(dp[j] + (a[i - 1] != c[k]), dp[j - 1] + (b[j - 1] != c[k])); + } + } + + cout << dp[b.size()] << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/991/e.in b/codeforces/991/e.in new file mode 100644 index 0000000..a785c94 --- /dev/null +++ b/codeforces/991/e.in @@ -0,0 +1,22 @@ +7 +a +b +cb +ab +cd +acbd +ab +ba +aabb +xxx +yyy +xyxyxy +a +bcd +decf +codes +horse +codeforces +egg +annie +egaegaeg diff --git a/codeforces/991/e.out b/codeforces/991/e.out new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/991/f.cc b/codeforces/991/f.cc new file mode 100644 index 0000000..2040e28 --- /dev/null +++ b/codeforces/991/f.cc @@ -0,0 +1,219 @@ +#include +#include +#include + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; +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 struct custom_hash {}; + +template inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +template void print(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + std::make_format_args(std::forward(args)...)); +} + +template void print(T const &t) { std::cout << t; } + +template void print(T const &t) { + if constexpr (std::is_same_v || + std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template void println(T const &t) { print("{}\n", t); } + +template void println(T const &t) { cout << t << '\n'; } + +void println() { std::cout << '\n'; } + +template T MAX() { return std::numeric_limits::max(); } + +template T MIN() { return std::numeric_limits::min(); } + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +constexpr static int MOD = 1e9 + 7; + +template struct sparse_table { + sparse_table(std::vector const &ts, F const &f) + : f(f), st(floor(__lg(max(1, static_cast(ts.size())))) + 1, + std::vector>(ts.size())) { + for (size_t i = 0; i < ts.size(); ++i) { + st[0][i] = ts[i]; + } + + for (size_t j = 1; j < st.size(); ++j) { + for (size_t i = 0; i + (1 << (j - 1)) < ts.size(); ++i) { + st[j][i] = f(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]); + } + } + } + + [[nodiscard]] T query(int const l, int const r) const noexcept { + int k = floor(__lg(r - l + 1)); + return f(st[k][l], st[k][r - (1 << k) + 1]); + } + + F f; + std::vector>> st; +}; + +void solve() { + int n, q; + cin >> n >> q; + vector a(n); + for (auto &e : a) + cin >> e; + vector diffs(a.size() - 1, 0); + for (int i = 0; i < diffs.size(); i++) + diffs[i] = abs(a[i] - a[i + 1]); + auto gcd = [](int a, int b) { return __gcd(a, b); }; + sparse_table st(diffs, gcd); + + while (q--) { + int l, r; + cin >> l >> r; + if (l == r) { + cout << 0 << ' '; + } else { + --l; + r -= 2; + cout << st.query(l, r) << ' '; + } + } + cout << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/991/f.in b/codeforces/991/f.in new file mode 100644 index 0000000..36db677 --- /dev/null +++ b/codeforces/991/f.in @@ -0,0 +1,18 @@ +4 +1 1 +1 +1 1 +5 5 +5 14 2 6 3 +4 5 +1 4 +2 4 +3 5 +1 1 +1 1 +7 +1 1 +3 2 +1 7 8 +2 3 +1 2 diff --git a/codeforces/991/f.out b/codeforces/991/f.out new file mode 100644 index 0000000..1aa6cc5 --- /dev/null +++ b/codeforces/991/f.out @@ -0,0 +1,4 @@ +0 +3 1 4 1 0 +0 +1 6 diff --git a/codeforces/991/g.cc b/codeforces/991/g.cc new file mode 100644 index 0000000..8833614 --- /dev/null +++ b/codeforces/991/g.cc @@ -0,0 +1,82 @@ +#include +using namespace std; + +#define all(x) (x).begin(), (x).end() +#define sz(x) static_cast((x).size()) +#define FOR(i, x) for (int i = 0; i < (x).size(); ++i) + +template T max() { return numeric_limits::max(); } +template T min() { return numeric_limits::min(); } + +#ifdef LOCAL +#define dbg(x) cerr << #x << " = " << (x) << '\n' +#else +#define dbg(x) +#endif + +void solve() { + int n; + cin >> n; + + unordered_map> graph; + + while (--n) { + int u, v; + cin >> u >> v; + + graph[u].push_back(v); + graph[v].push_back(u); + } + + auto ans = min(); + + auto is_leaf = [&graph](int u) { + return (u != 1 && graph[u].size() == 1) || (u == 1) && graph[u].empty(); + }; + + auto dfs = [&](auto &dfs, int u, int parent) -> int { + if (u == parent || is_leaf(u)) { + return 0; + } + + int first = 0, second = 0; + + for (auto v : graph[u]) { + if (v == parent) + continue; + + auto through = dfs(dfs, v, u); + + if (through > first) { + second = through; + swap(first, second); + } else if (through > second) { + second = through; + } + } + + int remove_u_and_one_child = sz(graph[u]) - (u != 1) - (first != 0) + first; + int remove_through_u = + sz(graph[u]) - (u != 1) - (first != 0) - (second != 0) + first + second; + int no_remove_u = 1 + first; + + ans = max(ans, max(remove_through_u, no_remove_u)); + + return remove_u_and_one_child; + }; + + std::cout << max(ans, dfs(dfs, 1, -1)) << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/991/g.in b/codeforces/991/g.in new file mode 100644 index 0000000..c90f099 --- /dev/null +++ b/codeforces/991/g.in @@ -0,0 +1,29 @@ +6 +2 +1 2 +5 +1 2 +2 3 +3 4 +3 5 +4 +1 2 +2 3 +3 4 +5 +2 1 +3 1 +4 1 +5 4 +6 +2 1 +3 1 +4 1 +5 3 +6 3 +6 +2 1 +3 2 +4 2 +5 3 +6 4 diff --git a/codeforces/991/g.out b/codeforces/991/g.out new file mode 100644 index 0000000..0146f5f --- /dev/null +++ b/codeforces/991/g.out @@ -0,0 +1,6 @@ +1 +3 +2 +3 +4 +3 diff --git a/codeforces/991/x.out b/codeforces/991/x.out new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/993/.clang-format b/codeforces/993/.clang-format new file mode 100644 index 0000000..e7350c4 --- /dev/null +++ b/codeforces/993/.clang-format @@ -0,0 +1,9 @@ +BasedOnStyle: Google +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortCompoundRequirementOnASingleLine: false +AllowShortEnumsOnASingleLine: false +AllowShortFunctionsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLambdasOnASingleLine: false +AllowShortLoopsOnASingleLine: false diff --git a/codeforces/993/a.cc b/codeforces/993/a.cc new file mode 100644 index 0000000..146b464 --- /dev/null +++ b/codeforces/993/a.cc @@ -0,0 +1,95 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +void solve() { + int n; + cin >> n; + cout << n - 1 << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/a.in b/codeforces/993/a.in new file mode 100644 index 0000000..449693b --- /dev/null +++ b/codeforces/993/a.in @@ -0,0 +1,4 @@ +3 +2 +4 +6 diff --git a/codeforces/993/b.cc b/codeforces/993/b.cc new file mode 100644 index 0000000..26e1f02 --- /dev/null +++ b/codeforces/993/b.cc @@ -0,0 +1,104 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +void solve() { + string s; + cin >> s; + + for (int i = sz(s) - 1; i >= 0; --i) { + if (s[i] == 'w') + cout << 'w'; + else if (s[i] == 'p') + cout << 'q'; + else + cout << 'p'; + } + cout << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/b.in b/codeforces/993/b.in new file mode 100644 index 0000000..f04f0e5 --- /dev/null +++ b/codeforces/993/b.in @@ -0,0 +1,6 @@ +5 +qwq +ppppp +pppwwwqqq +wqpqwpqwwqp +pqpqpqpq diff --git a/codeforces/993/b.out b/codeforces/993/b.out new file mode 100644 index 0000000..8708425 --- /dev/null +++ b/codeforces/993/b.out @@ -0,0 +1,5 @@ +pwp +qqqqq +pppwwwqqq +qpwwpqwpqpw +pqpqpqpq diff --git a/codeforces/993/c.cc b/codeforces/993/c.cc new file mode 100644 index 0000000..0e84e5e --- /dev/null +++ b/codeforces/993/c.cc @@ -0,0 +1,98 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +void solve() { + int m, a, b, c; + cin >> m >> a >> b >> c; + int used = min(a, m) + min(b, m); + int rest = min(2 * m - used, c); + + cout << used + rest << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/c.in b/codeforces/993/c.in new file mode 100644 index 0000000..0b2b5e0 --- /dev/null +++ b/codeforces/993/c.in @@ -0,0 +1,6 @@ +5 +10 5 5 10 +3 6 1 1 +15 14 12 4 +1 1 1 1 +420 6 9 69 diff --git a/codeforces/993/c.out b/codeforces/993/c.out new file mode 100644 index 0000000..cf694eb --- /dev/null +++ b/codeforces/993/c.out @@ -0,0 +1,5 @@ +20 +5 +30 +2 +84 diff --git a/codeforces/993/compile_flags.txt b/codeforces/993/compile_flags.txt new file mode 100644 index 0000000..b5d4b68 --- /dev/null +++ b/codeforces/993/compile_flags.txt @@ -0,0 +1,5 @@ +-std=c++20 +-Wall +-Wextra +-Wpedantic +-Wshadow diff --git a/codeforces/993/d.cc b/codeforces/993/d.cc new file mode 100644 index 0000000..9651d7c --- /dev/null +++ b/codeforces/993/d.cc @@ -0,0 +1,121 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + dbg(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} +void solve() { + int n; + cin >> n; + + int maxf = 0; + + vector a(n + 1), ans(n); + FOR(i, 0, n) { + int x; + cin >> x; + if (!a[x]) { + a[x] = 1; + ans[i] = x; + } + } + + queue q; + FOR(i, 1, n + 1) + if (!a[i]) + q.push(i); + FOR(i, 0, n) { + if (!ans[i]) { + ans[i] = q.front(); + q.pop(); + } + } + + FOR(i, 0, n) + cout << ans[i] << ' '; + + cout << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/d.in b/codeforces/993/d.in new file mode 100644 index 0000000..6d3543f --- /dev/null +++ b/codeforces/993/d.in @@ -0,0 +1,9 @@ +4 +2 +1 2 +4 +1 1 1 2 +8 +4 5 5 5 1 1 2 1 +10 +1 1 2 2 1 1 3 3 1 1 diff --git a/codeforces/993/d.out b/codeforces/993/d.out new file mode 100644 index 0000000..d5111d7 --- /dev/null +++ b/codeforces/993/d.out @@ -0,0 +1,4 @@ +1 2 +1 3 4 2 +4 5 3 6 1 7 2 8 +1 4 2 5 6 7 3 8 9 10 diff --git a/codeforces/993/e.cc b/codeforces/993/e.cc new file mode 100644 index 0000000..0f928b7 --- /dev/null +++ b/codeforces/993/e.cc @@ -0,0 +1,125 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + dbg(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +void solve() { + ll k, l1, r1, l2, r2; + cin >> k >> l1 >> r1 >> l2 >> r2; + /* + y = k ^ n * x + + x in [l1, r1]; y in [l2, r2] + + y/x=k^n -> n bounded by r2/l1=k^n<-> n=log_k(r2/l1) + + knowing n, let A=k^n + y=Ax + + left bound = max{l1, ceil(l2/A)} + right bound = min{r1, floor r2/A} + + ans += right - left + */ + + ll max_n = ceill(log((ld)r2 / l1) / log(k)); + ll A = 1; + ll ans = 0; + + FOR(_, 0, max_n + 1) { + ll left = max(l1, (ll)ceill((ld)l2 / A)); + ll right = min(r1, (ll)floorl((ld)r2 / A)); + + if (left <= right) + ans += right - left + 1; + + A *= k; + } + + cout << ans << '\n'; +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/e.in b/codeforces/993/e.in new file mode 100644 index 0000000..0f3558f --- /dev/null +++ b/codeforces/993/e.in @@ -0,0 +1,6 @@ +5 +2 2 6 2 12 +2 1 1000000000 1 1000000000 +3 5 7 15 63 +1000000000 1 5 6 1000000000 +15 17 78 2596 20914861 diff --git a/codeforces/993/e.out b/codeforces/993/e.out new file mode 100644 index 0000000..a833dff --- /dev/null +++ b/codeforces/993/e.out @@ -0,0 +1,5 @@ +12 +1999999987 +6 +1 +197 diff --git a/codeforces/993/e.run b/codeforces/993/e.run new file mode 100755 index 0000000000000000000000000000000000000000..e89f32d4a383842efeb82800b9a646976c218acc GIT binary patch literal 38216 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 z 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 literal 0 HcmV?d00001 diff --git a/codeforces/993/f.cc b/codeforces/993/f.cc new file mode 100644 index 0000000..3ae6e75 --- /dev/null +++ b/codeforces/993/f.cc @@ -0,0 +1,220 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + dbg(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +#include +#include + +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 +struct custom_hash {}; + +template +inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) + hash_combine(value, x); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply( + [&value](T const &...args) { + (hash_combine(value, args), ...); + }, + a); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +void solve() { + int n, m, q; + cin >> n >> m >> q; + dbgln("{} {} {}", n, m, q); + vec a(n), b(m); + for (auto &e : a) + cin >> e; + for (auto &e : b) + cin >> e; + + ll bprod = accumulate(all(b), 1, multiplies()); + ll total = n * bprod + accumulate(all(a), 0LL); + + hashset hm; + + FOR(i, 0, n) { + FOR(j, 0, m) { + hm.insert(total - n * b[j] - m * a[i] + a[i] * b[j]); + } + } + + while (q--) { + int x; + cin >> x; + if (hm.find(x) != hm.end()) + YES(); + else + NO(); + } +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + solve(); + + return 0; +} diff --git a/codeforces/993/f.in b/codeforces/993/f.in new file mode 100644 index 0000000..7f40ee1 --- /dev/null +++ b/codeforces/993/f.in @@ -0,0 +1,9 @@ +3 3 6 +-2 3 -3 +-2 2 -1 +-1 +1 +-2 +2 +-3 +3 diff --git a/codeforces/993/g1.cc b/codeforces/993/g1.cc new file mode 100644 index 0000000..5e3c029 --- /dev/null +++ b/codeforces/993/g1.cc @@ -0,0 +1,94 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int (a) = (b); (a) < (c); ++(a)) +#define ROF(a, b, c) for (int (a) = (b); (a) > (c); --(a)) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +void solve() { + +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/g1.in b/codeforces/993/g1.in new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/993/g1.out b/codeforces/993/g1.out new file mode 100644 index 0000000..e69de29 diff --git a/codeforces/993/h.cc b/codeforces/993/h.cc new file mode 100644 index 0000000..59b83c0 --- /dev/null +++ b/codeforces/993/h.cc @@ -0,0 +1,137 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void dbg(std::string const &str, Args &&...args) { + std::cout << std::vformat(str, + // make_format_args binds arguments to const + std::make_format_args(args...)); +} + +template +void dbg(T const &t) { + std::cout << t; +} + +template +void dbgln(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void dbgln(std::string const &str, Args &&...args) { + dbg(str, std::forward(args)...); + cout << '\n'; +} + +template +void dbgln(T const &t) { + dbg("{}\n", t); +} + +void println() { + std::cout << '\n'; +} + +template +constexpr auto MIN = std::numeric_limits::min(); + +template +constexpr auto MAX = std::numeric_limits::min(); + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a)) +#define ROF(a, b, c) for (int(a) = (b); (a) > (c); --(a)) + +std::random_device rd; +std::mt19937 gen(rd()); + +void YES() { + cout << "YES\n"; +} + +void NO() { + cout << "NO\n"; +} + +void solve() { + int n, q; + cin >> n; + vec> grid(n, vec(n)); + FOR(i, 0, n) { + FOR(j, 0, n) { + cin >> grid[i][j]; + } + } + + vec> dp(n + 1, vec(n + 1, 1)); + + while (q--) { + int x1, x2, y1, y2; + cin >> x1 >> x2 >> y1 >> y2; + } + + /* + + 00 01 02 03 04 05 ... + 10 11 12 13 14 15 ... + + 1 * 00 * 2 * 01 + 3 * 02 + 4 * 01 + 5 * + + 1 * M[i][j] + 2 * M[i][j + 1] + 3 * M[i][j + 2] + + 4 * M[i + 1][j] + 5 * M[i + 1][j + 2] + + = sum r0 * n + c0 -> r1 * n + c1 + + 1 2 + 3 4 + 5 6 + + 1 2 0 0 + 1 2 + 2 2 + 1 2 + 4 4 + + 3+4^2+8^3+9^4+13^5+14^6 + + 8+9^2+13^3+14^4 - ( 8^2+9^2+13^2 ) + */ + // FIX: cout + + dbgln("hi"); +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/codeforces/993/h.in b/codeforces/993/h.in new file mode 100644 index 0000000..f4f17a1 --- /dev/null +++ b/codeforces/993/h.in @@ -0,0 +1,16 @@ +2 +4 3 +1 5 2 4 +4 9 5 3 +4 5 2 3 +1 5 5 2 +1 1 4 4 +2 2 3 3 +1 2 4 3 +3 3 +1 2 3 +4 5 6 +7 8 9 +1 1 1 3 +1 3 3 3 +2 2 2 2 diff --git a/codeforces/993/h.out b/codeforces/993/h.out new file mode 100644 index 0000000..7452ee8 --- /dev/null +++ b/codeforces/993/h.out @@ -0,0 +1,2 @@ +hi +hi diff --git a/codeforces/993/h.run b/codeforces/993/h.run new file mode 100755 index 0000000000000000000000000000000000000000..7caaba521b1486031d4aea8c2527968574a8e5da GIT binary patch literal 55320 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 C*DaU; literal 0 HcmV?d00001 diff --git a/leetcode/.clang-format b/leetcode/.clang-format new file mode 100644 index 0000000..5625628 --- /dev/null +++ b/leetcode/.clang-format @@ -0,0 +1,2 @@ +BasedOnStyle: Google +AllowShortFunctionsOnASingleLine: Empty diff --git a/leetcode/a.cc b/leetcode/a.cc new file mode 100644 index 0000000..b1ed3ac --- /dev/null +++ b/leetcode/a.cc @@ -0,0 +1,268 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat( + str, + // make_format_args binds arguments to const + std::make_format_args(static_cast(args)...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +void println(T const &t) { + print(t); + println(); +} + +template +void println(T const &t) { + print(t); + println(); +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +#include +#include + +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 +struct custom_hash {}; + +template +inline void hash_combine(u64 &seed, T const &v) { + custom_hash hasher; + seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 12) + (seed >> 4); +}; + +template +struct custom_hash::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 +struct custom_hash()))>> { + u64 operator()(T const &a) const { + u64 value = FIXED_RANDOM; + for (auto &x : a) hash_combine(value, x); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(const std::tuple &a) const { + u64 value = FIXED_RANDOM; + std::apply([&value](T const &...args) { (hash_combine(value, args), ...); }, + a); + return value; + } +}; + +template +struct custom_hash> { + u64 operator()(std::pair 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 +using hashmap = gp_hash_table< + Key, Value, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; +template +using hashset = gp_hash_table< + Key, null_type, hashing::custom_hash, std::equal_to, + direct_mask_range_hashing<>, linear_probe_fn<>, + hash_standard_resize_policy, + hash_load_check_resize_trigger<>, true>>; + +#endif +#ifdef PB_DS_TREE_POLICY_HPP +template +using multiset = tree, rb_tree_tag, + tree_order_statistics_node_update>; +template +using rbtree = tree, rb_tree_tag, + tree_order_statistics_node_update>; +#endif + +const vec> dirs = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}}; + +constexpr int RIGHT = 1, LEFT = 2, DOWN = 3, UP = 4; + +void solve() { + int m, n; + cin >> m >> n; + + vec> grid(m, vec(n, 0)); + + for (auto &row : grid) { + for (auto &cell : row) { + cin >> cell; + } + } + + deque> q{{0, 0, 0}}; + + hashset> seen; + + while (!q.empty()) { + auto [r, c, w] = q.front(); + q.pop_front(); + + println("at r={}, c={}, w={}", r, c, w); + + if (min(r, c) < 0 || r == m || c == n) continue; + + if (r == m - 1 && c == n - 1) { + println(w); + return; + } + + if (seen.find({r, c}) != seen.end()) continue; + + seen.insert({r, c}); + + switch (grid[r][c]) { + case UP: + q.emplace_front(r - 1, c, w); + break; + case LEFT: + q.emplace_front(r, c - 1, w); + break; + case DOWN: + q.emplace_front(r + 1, c, w); + break; + case RIGHT: + q.emplace_front(r, c + 1, w); + break; + } + + for (auto &[dr, dc] : dirs) { + int nr = r + dr, nc = c + dc; + + q.emplace_back(nr, nc, w + 1); + } + } +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/leetcode/a.in b/leetcode/a.in new file mode 100644 index 0000000..aca90a1 --- /dev/null +++ b/leetcode/a.in @@ -0,0 +1,7 @@ +3 +4 4 +1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2 +3 3 +1 1 3 3 2 2 1 1 4 +2 2 +1 2 4 3 diff --git a/leetcode/a.out b/leetcode/a.out new file mode 100644 index 0000000..eb297f5 --- /dev/null +++ b/leetcode/a.out @@ -0,0 +1,81 @@ +at r=0, c=0, w=0 +at r=0, c=1, w=0 +at r=0, c=2, w=0 +at r=0, c=3, w=0 +at r=0, c=4, w=0 +at r=-1, c=1, w=1 +at r=0, c=0, w=1 +at r=1, c=1, w=1 +at r=1, c=0, w=1 +at r=1, c=-1, w=1 +at r=0, c=2, w=1 +at r=-1, c=2, w=1 +at r=0, c=1, w=1 +at r=1, c=2, w=1 +at r=1, c=1, w=1 +at r=0, c=3, w=1 +at r=-1, c=3, w=1 +at r=0, c=2, w=1 +at r=1, c=3, w=1 +at r=1, c=2, w=1 +at r=0, c=4, w=1 +at r=-1, c=4, w=1 +at r=0, c=3, w=1 +at r=1, c=4, w=1 +at r=0, c=5, w=1 +at r=0, c=0, w=2 +at r=1, c=-1, w=2 +at r=2, c=0, w=2 +at r=2, c=1, w=2 +at r=2, c=2, w=2 +at r=2, c=3, w=2 +at r=2, c=4, w=2 +at r=1, c=1, w=2 +at r=0, c=-1, w=2 +at r=1, c=-2, w=2 +at r=2, c=-1, w=2 +at r=1, c=0, w=2 +at r=0, c=1, w=2 +at r=1, c=0, w=2 +at r=2, c=1, w=2 +at r=1, c=2, w=2 +at r=0, c=2, w=2 +at r=1, c=1, w=2 +at r=2, c=2, w=2 +at r=1, c=3, w=2 +at r=-1, c=5, w=2 +at r=0, c=4, w=2 +at r=1, c=5, w=2 +at r=0, c=6, w=2 +at r=1, c=1, w=3 +at r=2, c=0, w=3 +at r=3, c=1, w=3 +at r=3, c=0, w=3 +at r=3, c=-1, w=3 +at r=2, c=2, w=3 +at r=1, c=2, w=3 +at r=2, c=1, w=3 +at r=3, c=2, w=3 +at r=3, c=1, w=3 +at r=2, c=3, w=3 +at r=1, c=3, w=3 +at r=2, c=2, w=3 +at r=3, c=3, w=3 +3 +at r=0, c=0, w=0 +at r=0, c=1, w=0 +at r=0, c=2, w=0 +at r=1, c=2, w=0 +at r=1, c=1, w=0 +at r=1, c=0, w=0 +at r=2, c=0, w=0 +at r=2, c=1, w=0 +at r=2, c=2, w=0 +0 +at r=0, c=0, w=0 +at r=0, c=1, w=0 +at r=0, c=0, w=0 +at r=-1, c=1, w=1 +at r=0, c=0, w=1 +at r=1, c=1, w=1 +1 diff --git a/leetcode/b.cc b/leetcode/b.cc new file mode 100644 index 0000000..7aa6310 --- /dev/null +++ b/leetcode/b.cc @@ -0,0 +1,110 @@ +#include + +// https://codeforces.com/blog/entry/96344 + +#pragma GCC optimize("O2,unroll-loops") +#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt") + +using namespace std; + +template +void print(std::string const &str, Args &&...args) { + std::cout << std::vformat( + str, + // make_format_args binds arguments to const + str, std::make_format_args(static_cast(args)...)); +} + +template +void print(T const &t) { + std::cout << t; +} + +template +void print(T const &t) { + if constexpr (std::is_convertible_v) { + std::cout << t << '\n'; + } else { + for (auto const &e : t) { + std::cout << e << ' '; + } + std::cout << '\n'; + } +} + +template +void println(std::string const &str, Args &&...args) { + print(str, std::forward(args)...); + cout << '\n'; +} + +template +void println(T const &t) { + print("{}\n", t); +} + +template +void println(T const &t) { + cout << t << '\n'; +} + +void println() { + std::cout << '\n'; +} + +template +T MAX() { + return std::numeric_limits::max(); +} + +template +T MIN() { + return std::numeric_limits::min(); +} + +#define ff first +#define ss second +#define eb emplace_back +#define ll long long +#define ld long double +#define vec vector + +#define all(x) (x).begin(), (x).end() +#define rall(x) (r).rbegin(), (x).rend() +#define sz(x) static_cast((x).size()) +#define FOR(a, b, c) for (int a = b; a < c; ++a) + +mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); +#define randint(a, b) uniform_int_distribution(a, b)(rng) + +void YES() { + cout << "YES\n"; +} +void NO() { + cout << "NO\n"; +} + +#ifdef LOCAL +#define dbg(x) cout << __LINE__ << ": " << #x << "=<" << (x) << ">\n"; +#else +#define dbg(x) +#endif + +static constexpr int MOD = 1e9 + 7; + +void solve() { + +} + +int main() { + cin.tie(nullptr)->sync_with_stdio(false); + + int t = 1; + cin >> t; + + while (t--) { + solve(); + } + + return 0; +} diff --git a/leetcode/b.in b/leetcode/b.in new file mode 100644 index 0000000..e69de29 diff --git a/leetcode/b.out b/leetcode/b.out new file mode 100644 index 0000000..e69de29 diff --git a/leetcode/compile_flags.txt b/leetcode/compile_flags.txt new file mode 100644 index 0000000..ebd5be8 --- /dev/null +++ b/leetcode/compile_flags.txt @@ -0,0 +1,5 @@ +-std=c++20 +-Wall +-Wextra +-Wshadow +-DLOCAL