subcrip
/
CompetitiveProgramming
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

backup

This commit is contained in:
arielherself 2024-01-18 12:40:12 +08:00
parent 653d1c1d30
commit 97477a73db
66 changed files with 3236 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
src/bin/at-abc335a.cc Normal file
View File

2
src/bin/at-abs335a.py Normal file
View File

@ -0,0 +1,2 @@
s = input()
print(s[:-1] + '4')

5
src/bin/at-abs335b.py Normal file
View File

@ -0,0 +1,5 @@
n = int(input())
for i in range(n + 1):
for j in range(n - i + 1):
for k in range(n - i - j + 1):
print(i, j, k)

160
src/bin/cf-1873g.cc Normal file
View File

@ -0,0 +1,160 @@
/////////////////////////////////////////////////////////
/**
* Useful Macros
* by subcrip
* (requires C++17)
*/
#include<bits/stdc++.h>
#include <queue>
using namespace std;
/* macro helpers */
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __DECOMPOSE_S(a, x) auto x = a;
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
constexpr void __() {}
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
#define __as_typeof(container) decltype(container)::value_type
/* type aliases */
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
/* constants */
constexpr int INF = 0x3f3f3f3f;
constexpr ull MDL = 1e9 + 7;
constexpr ull PRIME = 998'244'353;
constexpr ull MDL1 = 825;
constexpr ull MDL2 = 87825;
/* bit-wise operations */
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
/* arithmetic operations */
#define mod(x, y) (((x) + (y)) % (y))
/* fast pairs */
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
/* conditions */
#define loop while (1)
#define if_or(var, val) if (!(var == val)) var = val; else
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
/* build data structures */
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];)
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
/* io */
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << x << endl;)
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
/* pops */
#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
/* algorithms */
vector<int> kmp(string s, string t) { // find all t in s
int n = s.length(), m = t.length();
vector<int> next; next.push_back(-1);
int j = -1, i = 0;
while (i < m)
if (j == -1 || t[i] == t[j]) {
++i, ++j;
if (i != m && t[i] == t[j]) next.push_back(next[j]);
else next.push_back(j);
} else j = next[j];
vector<int> res;
i = 0, j = 0;
while (i < n && j < m)
if (j == -1 || s[i] == t[j]) {
++i, ++j;
if (j == m) res.push_back(i - j), j = next[j];
} else j = next[j];
return res;
}
/////////////////////////////////////////////////////////
void solve() {
read(string, s);
s.push_back('B');
int n = s.length();
int curr = 0;
int sum = 0;
int mn = INT_MAX;
int no_b = 1;
int res = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'A') {
++curr;
} else {
if (s[i - 1] == 'B') {
res += sum;
sum = 0;
mn = INT_MAX;
no_b = 0;
} else {
sum += curr;
mn = min(mn, curr);
}
curr = 0;
}
}
if (sum) {
if (no_b) {
res += sum - mn;
} else {
res += sum;
}
}
cout << res << endl;
}
int main() {
read(int, t);
while (t--) solve();
}

173
src/bin/cf-1873h.cc Normal file
View File

@ -0,0 +1,173 @@
/////////////////////////////////////////////////////////
/**
* Useful Macros
* by subcrip
* (requires C++17)
*/
#include<bits/stdc++.h>
using namespace std;
/* macro helpers */
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __DECOMPOSE_S(a, x) auto x = a;
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
constexpr void __() {}
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
#define __as_typeof(container) decltype(container)::value_type
/* type aliases */
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
/* constants */
constexpr int INF = 0x3f3f3f3f;
constexpr ull MDL = 1e9 + 7;
constexpr ull PRIME = 998'244'353;
constexpr ull MDL1 = 825;
constexpr ull MDL2 = 87825;
/* bit-wise operations */
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
/* fast pairs */
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
/* conditions */
#define loop while (1)
#define if_or(var, val) if (!(var == val)) var = val; else
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
/* build data structures */
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];)
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
/* io */
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << x << endl;)
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
/* pops */
#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
/* algorithms */
vector<int> kmp(string s, string t) { // find all t in s
int n = s.length(), m = t.length();
vector<int> next; next.push_back(-1);
int j = -1, i = 0;
while (i < m)
if (j == -1 || t[i] == t[j]) {
++i, ++j;
if (i != m && t[i] == t[j]) next.push_back(next[j]);
else next.push_back(j);
} else j = next[j];
vector<int> res;
i = 0, j = 0;
while (i < n && j < m)
if (j == -1 || s[i] == t[j]) {
++i, ++j;
if (j == m) res.push_back(i - j), j = next[j];
} else j = next[j];
return res;
}
/////////////////////////////////////////////////////////
void solve() {
read(int, n, a, b);
adj(ch, n);
for (int i = 0; i < n; ++i) {
read(int, u, v);
edge(ch, u, v);
}
vector<int> vis(n + 1);
// bfs => distance from M to each vertex
deque<pair<int, int>> dq;
vector<int> dis_m(n + 1, INF);
dq.emplace_back(a, 0);
while (dq.size()) {
popfront(dq, v, d);
continue_or(vis[v], 1);
dis_m[v] = d;
for (auto&& u : ch[v]) {
dq.emplace_back(u, d + 1);
}
}
fill(vis.begin(), vis.end(), 0);
// bfs => distance from V to each vertex
vector<int> dis_v(n + 1, INF);
dq.emplace_back(b, 0);
while (dq.size()) {
popfront(dq, v, d);
continue_or(vis[v], 1);
dis_v[v] = d;
for (auto&& u : ch[v]) {
dq.emplace_back(u, d + 1);
}
}
// dfs => find qualified cycle
fill(vis.begin(), vis.end(), 0);
function<bool(int, int)> dfs = [&] (int v, int pa) -> bool {
if_or(vis[v], 1) {
if (dis_m[v] > dis_v[v]) {
}
return dis_m[v] > dis_v[v];
}
for (auto&& u : ch[v]) {
if (u != pa && dfs(u, v)) return 1;
}
return 0;
};
if (dfs(b, 0)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
int main() {
read(int, t);
while(t--) solve();
}

123
src/bin/cf-1875d.cc Normal file
View File

@ -0,0 +1,123 @@
#include<bits/stdc++.h>
using namespace std;
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __DECOMPOSE_S(a, x) auto x = a;
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
constexpr void __() {}
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
#define __as_typeof(container) decltype(container)::value_type
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
constexpr ull MDL = 1e9 + 7;
constexpr ull PRIME = 998244353;
constexpr ull MDL1 = 825;
constexpr ull MDL2 = 87825;
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];)
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << x << endl;)
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
vector<int> kmp(string s, string t) { // find all t in s
int n = s.length(), m = t.length();
vector<int> next; next.push_back(-1);
int j = -1, i = 0;
while (i < m)
if (j == -1 || t[i] == t[j]) {
++i, ++j;
if (i != m && t[i] == t[j]) next.push_back(next[j]);
else next.push_back(j);
} else j = next[j];
vector<int> res;
i = 0, j = 0;
while (i < n && j < m)
if (j == -1 || s[i] == t[j]) {
++i, ++j;
if (j == m) res.push_back(i - j), j = next[j];
} else j = next[j];
return res;
}
void solve() {
read(int, n);
readvec(int, a, n);
counter(a, ct, greater<>);
unordered_map<int, int> res;
int init = ct.begin()->first + 1;
int prev = init;
for (auto&& [i, _] : ct) {
if (i < prev - 1) {
init = i + 1;
}
prev = i;
}
for (auto&& [i, t] : ct) {
if (i > init) continue;
int mn = init * int(t - 1) + i;
for (auto&& [j, prev] : res) {
mn = min(mn, prev + j * int(t - 1) + i);
}
res[i] = mn;
// debug(i), debug(res[i]);
}
cout << res[0] << endl;
}
int main() {
read(int, t);
while (t--) solve();
}

143
src/bin/cf-1878d.cc Normal file
View File

@ -0,0 +1,143 @@
#include<bits/stdc++.h>
using namespace std;
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __DECOMPOSE_S(a, x) auto x = a;
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
constexpr void __() {}
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
constexpr ull MDL = 1e9 + 7;
constexpr ull PRIME = 998244353;
constexpr ull MDL1 = 825;
constexpr ull MDL2 = 87825;
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << x << endl;)
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
vector<int> kmp(string s, string t) { // find all t in s
int n = s.length(), m = t.length();
vector<int> next; next.push_back(-1);
int j = -1, i = 0;
while (i < m)
if (j == -1 || t[i] == t[j]) {
++i, ++j;
if (i != m && t[i] == t[j]) next.push_back(next[j]);
else next.push_back(j);
} else j = next[j];
vector<int> res;
i = 0, j = 0;
while (i < n && j < m)
if (j == -1 || s[i] == t[j]) {
++i, ++j;
if (j == m) res.push_back(i - j), j = next[j];
} else j = next[j];
return res;
}
void solve() {
read(int, n, k);
read(string, s);
readvec(int, l, k);
readvec(int, r, k);
read(int, q);
readvec(int, x, q);
for (int i = 0; i < k; ++i) {
--l[i], --r[i];
}
for (int i = 0; i < q; ++i) {
--x[i];
}
vector<int> pos(n);
{
int curr = 0;
for (int i = 0; i < n; ++i) {
if (i > r[curr]) ++curr;
pos[i] = curr;
}
}
vector<vector<int>> mark(k, vector<int>(n));
for (auto&& i : x) {
int ipos = pos[i];
int offset = min(i, l[ipos] + r[ipos] - i) - l[ipos];
mark[ipos][offset] ^= 1;
}
for (int i = 0; i < k; ++i) {
int left = l[i], right = r[i];
vector<char> c(right - left + 1);
int mid = right - left + 2 >> 1;
int rev = 0;
for (int j = 0; j < mid; ++j) {
rev ^= mark[i][j];
if (rev) {
debug(j), debug(right - j), debug(c.size());
c[j] = s[right - j];
c[right - left - j] = s[left + j];
} else {
c[j] = s[left + j];
c[right - left - j] = s[right - j];
}
}
for (auto&& x : c) cout << x;
}
cout << endl;
}
int main() {
read(int, t);
while (t--) solve();
}

110
src/bin/cf-1879d.cc Normal file
View File

@ -0,0 +1,110 @@
#include<bits/stdc++.h>
#include <initializer_list>
using namespace std;
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __decompose_s(a, x) auto x = a;
#define __decompose_n(a, ...) auto [__VA_ARGS__] = a;
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
constexpr ull MDL = 1e9 + 7;
constexpr ull PRIME = 998244353;
constexpr ull MDL1 = 825;
constexpr ull MDL2 = 87825;
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
#define untie ios_base::sync_with_stdio(0), cin.tie(NULL)
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) type __VA_ARGS__; __read(__VA_ARGS__);
#define readvec(type, a, n) vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];
#define putvec(a) for (auto&& x : a) cout << x << ' '; cout << endl;
#define debug(x) cerr << #x" = " << x << endl;
#define debugvec(a) cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;
#define pa(a) __typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);
#define sa(a) __typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};
#define poptop(q, ...) auto [__VA_ARGS__] = q.top(); q.pop();
#define popback(q, ...) auto [__VA_ARGS__] = q.back(); q.pop_back();
#define popfront(q, ...) auto [__VA_ARGS__] = q.front();q.pop_front();
#define adj(ch, n) vector<vector<int>> ch((n) + 1);
#define edge(ch, u, v) ch[u].push_back(v), ch[v].push_back(u);
#define Edge(ch, u, v) ch[u].push_back(v);
vector<int> kmp(string s, string t) { // find all t in s
int n = s.length(), m = t.length();
vector<int> next; next.push_back(-1);
int j = -1, i = 0;
while (i < m)
if (j == -1 || t[i] == t[j]) {
++i, ++j;
if (i != m && t[i] == t[j]) next.push_back(next[j]);
else next.push_back(j);
} else j = next[j];
vector<int> res;
i = 0, j = 0;
while (i < n && j < m)
if (j == -1 || s[i] == t[j]) {
++i, ++j;
if (j == m) res.push_back(i - j), j = next[j];
} else j = next[j];
return res;
}
int main() {
read(int, n);
readvec(ull, a, n);
ull s1, s2, s3, s4, pa;
s1 = s2 = 0, pa = 0;
for (int i = 0; i < n; ++i) {
pa ^= a[i];
s1 = (s1 + (i + 1) * pa) % PRIME;
s2 = (s2 + pa) % PRIME;
}
s3 = s4 = 0, pa = 0;
for (int i = 0; i < n; ++i) {
s3 = (s3 + i * pa) % PRIME;
s4 = (s4 + pa) % PRIME;
pa ^= a[i];
}
ull res = n * s1 - n * (n - 1) / 2 * s2 + n * s3 - n * (n + 1) / 2 * s4;
cout << (res % PRIME);
}

99
src/bin/cf-1881f.cc Normal file
View File

@ -0,0 +1,99 @@
#include<bits/stdc++.h>
using namespace std;
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __decompose_s(a, x) auto x = a;
#define __decompose_n(a, ...) auto [__VA_ARGS__] = a;
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
#define untie ios_base::sync_with_stdio(0), cin.tie(NULL)
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) type __VA_ARGS__; __read(__VA_ARGS__);
#define readvec(type, a, n) vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];
#define putvec(a) for (auto&& x : a) cout << x << ' '; cout << endl;
#define debug(x) cerr << #x" = " << x << endl;
#define debugvec(a) cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;
#define pa(a) __typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);
#define sa(a) __typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};
#define poptop(q, ...) auto [__VA_ARGS__] = q.top(); q.pop();
#define popback(q, ...) auto [__VA_ARGS__] = q.back(); q.pop_back();
#define popfront(q, ...) auto [__VA_ARGS__] = q.front();q.pop_front();
#define adj(ch, n) vector<vector<int>> ch((n) + 1);
#define edge(ch, u, v) ch[u].push_back(v), ch[v].push_back(u);
#define Edge(ch, u, v) ch[u].push_back(v);
void solve() {
read(int, n, k);
vector<int> marks(n + 1);
for (int i = 0; i < k; ++i) {
read(int, v);
marks[v] = 1;
}
adj(ch, n);
for (int i = 0; i < n - 1; ++i) {
read(int, u, v);
edge(ch, u, v);
}
function<tuple<int, int, int>(int, int)> dfs = [&] (int v, int pa) {
int res = 0;
int max_w = marks[v] == 0 ? 0 : -1;
int max_r = marks[v] == 1 ? 0 : -1;
for (auto&& u : ch[v]) {
if (u == pa) continue;
auto [sub_ans, w, r] = dfs(u, v);
if (w != -1 && max_r != -1) res = min(res, w + 1 + max_r);
if (r != -1 && max_w != -1) res = min(res, r + 1 + max_w);
if (w != -1) max_w = max(max_w, w + 1);
if (r != -1) max_r = max(max_r, r + 1);
res = min(res, sub_ans);
}
return make_tuple(res, max_w, max_r);
};
cout << get<0>(dfs(1, 0)) << endl;
}
int main() {
read(int, t);
while (t--) solve();
}

40
src/bin/cf-1883e.cc Normal file
View File

@ -0,0 +1,40 @@
#include<bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define msd_power(x) (63LL - __builtin_clz(x))
void solve() {
int n; cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
ll res = 0;
ll last_power = 0;
for (int i = 1; i < n; ++i) {
if (msd_power(a[i]) >= msd_power(a[i-1]) + last_power) {
ll prev = a[i-1] << last_power;
if (prev > a[i]) {
last_power = 1;
} else {
last_power = 0;
}
} else {
ll diff = 0;
if (msd_power(a[i]) <= msd_power(a[i-1])) {
ll curr = a[i] << (msd_power(a[i-1]) - msd_power(a[i]));
if (curr < a[i-1]) diff = 1;
} else {
ll prev = a[i-1] << (msd_power(a[i]) - msd_power(a[i-1]));
if (prev > a[i]) diff = 1;
}
last_power = msd_power(a[i-1]) + last_power - msd_power(a[i]) + diff;
}
// cerr << last_power << ' ';
res += last_power;
}
// cerr << endl;
cout << res << endl;
}
int main() {
int t; cin >> t;
while (t--) solve();
}

43
src/bin/cf-1884c.cc Normal file
View File

@ -0,0 +1,43 @@
#include<bits/stdc++.h>
using namespace std;
void solve() {
int n, m; cin >> n >> m;
vector<pair<int, int>> seg(n);
for (int i = 0; i < n; ++i) {
int l, r; cin >> l >> r;
seg[i] = {l, r};
}
sort(seg.begin(), seg.end(), [](const pair<int, int>& x, const pair<int, int>& y) {
if (x.first == y.first) {
return x.second > y.second;
}
return x.first < y.first;
});
int res = 0;
set<pair<int, int>> lefts;
set<pair<int, int>> rights;
int prev = 0;
for (int i = 0; i < n; ++i) {
auto&& [l, r] = seg[i];
if (l == 1 || l == prev) continue;
prev = l;
auto rp = rights.begin();
while (rights.size() && rp->first < l) {
lefts.erase({seg[rp->second].first, rp->second});
rp = rights.erase(rp);
}
lefts.insert({l, i});
rights.insert({r, i});
res = max(res, int(lefts.size()));
cerr << lefts.size() << ' ' << res << endl;
}
lefts.clear(), rights.clear(), prev = 0;
cout << res << endl;
}
int main() {
int t; cin >> t;
while (t--) solve();
}

29
src/bin/cf-1889b.cc Normal file
View File

@ -0,0 +1,29 @@
#include<bits/stdc++.h>
using namespace std;
using ll = int64_t;
void solve() {
int n, c; cin >> n >> c;
vector<ll> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> idx(n - 1);
iota(idx.begin(), idx.end(), 1);
sort(idx.begin(), idx.end(), [&](int i, int j) {
if (a[i] == a[j]) return i < j;
return a[i] > a[j];
});
ll sum = a[0];
for (auto&& i : idx) {
sum += a[i];
if (sum < (i + 1) * c) {
cout << "No\n";
return;
}
}
cout << "Yes\n";
}
int main() {
int t; cin >> t;
while (t--) solve();
}

22
src/bin/cf-1901d.rs Normal file
View File

@ -0,0 +1,22 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let n: usize = buf.trim().parse::<usize>().unwrap();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let mut pa = vec![0;n+1];
let mut sa = vec![0;n+1];
pa[0] = 0 - n as i64 - 1;
for i in 1..=n {
pa[i] = pa[i-1].max(a[i-1] - i as i64 - 1);
}
for i in (0..n).rev() {
sa[i] = sa[i+1].max(a[i] + i as i64);
}
let mut res = i64::MAX;
for i in 0..n {
res = res.min(a[i].max((pa[i] + n as i64 + 1).max(sa[i+1])));
}
println!("{res}");
}

26
src/bin/cf-1903c.rs Normal file
View File

@ -0,0 +1,26 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let mut s: i64 = a.iter().sum();
let mut curr_seg = 0;
let mut curr_sum = 0;
let mut res = 0;
for x in a {
curr_sum += x;
s -= x;
if s >= 0 {
curr_seg += 1;
res += curr_seg * curr_sum;
curr_sum = 0;
}
}
println!("{res}");
}
}

45
src/bin/cf-1903d1.rs Normal file
View File

@ -0,0 +1,45 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let nq: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (n, q) = (nq[0], nq[1]);
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
for _ in 0..q {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let mut k: i64 = buf.trim().parse::<i64>().unwrap();
let mut a = a.to_owned();
let mut pow = 59;
let mut res = 0;
while pow >= 0 {
let target = 1 << pow;
let mut need = 0;
let mut f = true;
for i in 0..n {
let curr = 0.max(target - a[i]);
if curr > k - need {
f = false;
break;
}
need += 0.max(target - a[i]);
}
if f {
for i in 0..n {
a[i] = a[i].max(target) - target;
}
k -= need;
res += target;
} else {
for i in 0..n {
if a[i] >= target {
a[i] -= target;
}
}
}
pow -= 1;
}
println!("{res}");
}
}

12
src/bin/cf-1905a.cc Normal file
View File

@ -0,0 +1,12 @@
#include<bits/stdc++.h>
using namespace std;
void solve() {
int n, m; cin >> n >> m;
cout << max(n, m) << endl;
}
int main() {
int t; cin >> t;
while(t--) solve();
}

43
src/bin/cf-1905b.cc Normal file
View File

@ -0,0 +1,43 @@
#include<bits/stdc++.h>
using namespace std;
constexpr int MAXN = 1e5 + 10;
vector<int> ch[MAXN];
void solve() {
int n; cin >> n;
fill(ch, ch + n + 1, vector<int>());
for (int i = 0; i < n - 1; ++i) {
int u, v; cin >> u >> v;
ch[u].push_back(v);
ch[v].push_back(u);
}
int cnt = 0;
function<void(int, int)> dfs = [&](int v, int pa) {
int f = 1;
for (auto&&u : ch[v]) {
if (u != pa) {
f = 0;
dfs(u, v);
}
}
if (f) ++cnt;
};
if (n == 2) {
cout << 1 << endl;
} else {
for (int i = 1; i <= n; ++i) {
if (ch[i].size() > 1) {
dfs(i, 0);
break;
}
}
cout << (cnt + 1 >> 1) << endl;
}
}
int main() {
int t; cin >> t;
while(t--) solve();
}

43
src/bin/cf-1905c.cc Normal file
View File

@ -0,0 +1,43 @@
#include<bits/stdc++.h>
using namespace std;
using ull = uint64_t;
constexpr int MAXN = 1e5 + 10;
constexpr ull mdl = 1e9 + 7;
ull table[MAXN + 1];
void prep() {
ull l1 = 1, l2 = 0;
for (int i = 0; i < MAXN + 1; ++i) {
table[i] = (l1 + l2) % mdl;
l1 = l2;
l2 = table[i];
}
}
int main() {
prep();
string s; cin >> s;
s.push_back(0);
ull res = 1;
int acc = 0;
char prev = 0;
for (auto&& c : s) {
if (c == 'w' || c == 'm') {
goto zero;
}
if (c != prev) {
if (prev == 'u' || prev == 'n') {
res = (res * (table[acc] % mdl)) % mdl;
}
acc = 1;
prev = c;
} else {
++acc;
}
}
cout << res;
return 0;
zero: cout << '0';
}

13
src/bin/cf-1905c.gen.cc Normal file
View File

@ -0,0 +1,13 @@
#include<bits/stdc++.h>
using namespace std;
using ull = uint64_t;
int main() {
ull l1 = 1, l2 = 1;
cout << "1, 1";
for (int i = 2; i <= 1e5 + 1; ++i) {
ull t = l1 + l2;
cout << ", " << t;
l1 = l2;
l2 = t;
}
}

17
src/bin/cf-1907e.rs Normal file
View File

@ -0,0 +1,17 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let mut n: i64 = buf.trim().parse::<i64>().unwrap();
let mut res = 1;
while n != 0 {
let digit = n % 10;
n /= 10;
res *= (digit + 2) * (digit + 1) >> 1;
}
println!("{res}");
}
}

38
src/bin/cf-1909a.rs Normal file
View File

@ -0,0 +1,38 @@
fn judge(x: Vec<Vec<i32>>) -> bool {
let a = x.iter().fold(true, |b, p|{
b && p[0] <= 0
});
let b = x.iter().fold(true, |b, p|{
b && p[1] <= 0
});
let c = x.iter().fold(true, |b, p|{
b && p[0] >= 0
});
let d = x.iter().fold(true, |b, p|{
b && p[1] >= 0
});
a || b || c || d
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let n: usize = buf.trim().parse::<usize>().unwrap();
let mut co = Vec::with_capacity(n);
for _ in 0..n {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let tmp: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
co.push(tmp);
}
if judge(co) {
println!("YES");
} else {
println!("NO");
}
}
}

30
src/bin/cf-1909b.rs Normal file
View File

@ -0,0 +1,30 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let mut a: Vec<u64> = buf.trim().split(' ').map(|x|x.parse::<u64>().unwrap()).collect::<Vec<u64>>();
let mut mdl = 2u64;
loop {
let mut one = false;
let mut zero = false;
for x in &mut a {
if *x & 1 == 0 {
zero = true;
} else {
one = true;
}
*x >>= 1;
}
if zero && one {
println!("{mdl}");
break;
}
mdl <<= 1;
}
}
}

33
src/bin/cf-1909c.rs Normal file
View File

@ -0,0 +1,33 @@
use std::collections::BTreeSet;
use std::ops::Bound::*;
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let mut l: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let r: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let mut rst = BTreeSet::new();
r.into_iter().for_each(|x|{ rst.insert(x); });
let mut c: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
l.sort_unstable();
let mut ranges = vec![];
for &x in l.iter().rev() {
let cr = *rst.range((Excluded(x), Unbounded)).next().unwrap();
rst.remove(&cr);
ranges.push(cr - x);
}
ranges.sort_unstable_by_key(|x|-x);
c.sort_unstable();
let res = ranges.into_iter().zip(c.into_iter()).fold(0i64, |s, p|s + p.0 * p.1);
println!("{res}");
}
}

37
src/bin/cf-1913c.rs Normal file
View File

@ -0,0 +1,37 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let m: usize = buf.trim().parse::<usize>().unwrap();
let mut cnt = vec![0;30];
for _ in 0..m {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let query: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
let (t, mut v) = (query[0], query[1]);
if t == 1 {
cnt[query[1] as usize] += 1;
} else {
let mut f = true;
let mut ccnt = 0;
let mut i = 0;
while v != 0 {
ccnt = (ccnt >> 1) + cnt[i];
let curr_bit = v & 1;
v >>= 1;
if curr_bit == 1 {
if ccnt == 0 {
f = false;
break;
}
ccnt -= 1;
}
i += 1;
}
if f {
println!("YES");
} else {
println!("NO");
}
}
}
}

24
src/bin/cf-1914a.rs Normal file
View File

@ -0,0 +1,24 @@
use std::collections::HashMap;
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let t: String = buf.trim().parse::<String>().unwrap();
let a = t.into_bytes();
let mut mp = HashMap::<u8, usize>::new();
let mut cnt = 0;
for x in a {
*mp.entry(x).or_default() += 1;
if matches!(mp.get(&x), Some(&t) if t + 64 == x as usize) {
cnt += 1;
}
}
println!("{cnt}");
}
}

18
src/bin/cf-1914b.rs Normal file
View File

@ -0,0 +1,18 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let t: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (n, k) = (t[0], t[1]);
for i in 1..=k {
print!("{i} ");
}
for i in (k+1..=n).rev() {
print!("{i} ");
}
println!();
}
}

26
src/bin/cf-1914c.rs Normal file
View File

@ -0,0 +1,26 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let nk: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (n, k) = (nk[0], nk[1]);
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let b: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let mut res = 0;
let mut a_sum = 0;
let mut b_max = 0;
for i in 0..n.min(k) {
a_sum += a[i];
b_max = b_max.max(b[i]);
res = res.max(a_sum + b_max * (k - i - 1) as i64);
}
println!("{res}");
}
}

30
src/bin/cf-1914d.rs Normal file
View File

@ -0,0 +1,30 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let n: usize = buf.trim().parse::<usize>().unwrap();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let b: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let c: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let mut dp = vec![vec![i64::MIN;8];n+1];
for i in 1..=n {
dp[i][0b001] = dp[i-1][0b001].max(c[i-1]);
dp[i][0b010] = dp[i-1][0b010].max(b[i-1]);
dp[i][0b100] = dp[i-1][0b100].max(a[i-1]);
dp[i][0b011] = dp[i-1][0b011].max(dp[i-1][0b001] + b[i-1]).max(dp[i-1][0b010] + c[i-1]);
dp[i][0b101] = dp[i-1][0b101].max(dp[i-1][0b001] + a[i-1]).max(dp[i-1][0b100] + c[i-1]);
dp[i][0b110] = dp[i-1][0b110].max(dp[i-1][0b010] + a[i-1]).max(dp[i-1][0b100] + b[i-1]);
dp[i][0b111] = dp[i-1][0b111].max(dp[i-1][0b110] + c[i-1]).max(dp[i-1][0b101] + b[i-1]).max(dp[i-1][0b011] + a[i-1]);
}
println!("{}", dp[n][0b111]);
}
}

40
src/bin/cf-1915e.rs Normal file
View File

@ -0,0 +1,40 @@
use std::collections::HashSet;
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let n: usize = buf.trim().parse::<usize>().unwrap();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let mut x = vec![0;n+1];
let mut y = vec![0;n+1];
for i in 1..=n {
x[i] = x[i-1];
y[i] = y[i-1];
if i & 1 == 0 {
x[i] += a[i-1];
} else {
y[i] += a[i-1];
}
}
let mut oc = HashSet::new();
let mut f = true;
for i in 0..=n {
if oc.contains(&(x[i] - y[i])) {
println!("YES");
f = false;
break;
} else {
oc.insert(x[i] - y[i]);
}
}
if f {
println!("NO");
}
}
}

62
src/bin/cf-1915f.rs Normal file
View File

@ -0,0 +1,62 @@
use std::collections::{BTreeSet, HashMap};
struct BIT(usize, Vec<i64>);
impl BIT {
fn new(n: usize) -> Self {
Self(n, vec![0;n+1])
}
fn query(&self, mut i: usize) -> i64 {
let lowbit = |x: i64|x&-x;
let mut res = 0;
while i > 0 {
res += self.1[i];
i -= lowbit(i as i64) as usize;
}
res
}
fn insert(&mut self, mut i: usize) {
let lowbit = |x: i64| x & -x;
while i <= self.0 {
self.1[i] += 1;
i += lowbit(i as i64) as usize;
}
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let n : usize = buf.trim().parse::<usize>().unwrap();
let mut a = vec![];
let mut numbers = BTreeSet::new();
for _ in 0..n {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let tmp: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
a.push((tmp[0], tmp[1]));
numbers.insert(tmp[0]);
numbers.insert(tmp[1]);
}
let mut mp = HashMap::new();
let mut tot = 0;
for p in numbers {
tot += 1;
mp.insert(p, tot);
}
a.sort_unstable();
let mut st = BIT::new(tot);
let mut res = 0;
for x in a.iter().rev() {
let td = *mp.get(&x.1).unwrap();
let cnt = st.query(td);
res += cnt;
st.insert(td);
}
println!("{res}");
}
}

41
src/bin/cf-1916c.rs Normal file
View File

@ -0,0 +1,41 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect();
let mut odd = 0;
let mut even = 0;
let mut sum = 0;
for x in a {
sum += x;
if x & 1 == 1 {
odd += 1;
} else {
even += 1;
}
if odd + even == 1 {
print!("{x} ");
} else if odd + even == 2 {
if odd == 1 && even == 1 {
print!("{} ", sum - 1);
} else {
print!("{} ", sum);
}
} else {
let mut res = sum;
res -= odd / 3;
if odd % 3 == 1 {
print!("{} ", res - 1);
} else {
print!("{} ", res);
}
}
}
println!();
}
}

35
src/bin/cf-1917a.rs Normal file
View File

@ -0,0 +1,35 @@
/**
* 如果有负数，那么就不需要变，因为现在已经是最小的了
* 如果没负数，至多需要把随便一个数变成0即可。
*/
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
let mut f = true;
let mut sgn = 1;
for x in a {
sgn *= x.signum();
if x == 0 {
println!("0");
f = false;
break;
}
}
if f {
if sgn == 1 {
println!("1\n1 0");
} else {
println!("0");
}
}
}
}

28
src/bin/cf-1917b.rs Normal file
View File

@ -0,0 +1,28 @@
use std::collections::HashMap;
/**
* dp[i] 表示进行i次删除首字母操作后得到的结果
*/
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let n: usize = buf.trim().parse::<usize>().unwrap();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a = buf.trim().parse::<String>().unwrap().into_bytes();
let mut res = 0;
let mut mp = HashMap::new();
let mut dp = vec![0;n+1];
for i in (0..n).rev() {
dp[i] = mp.get(&a[i]).unwrap_or(&n) - i;
res += dp[i];
mp.insert(a[i], i);
}
println!("{}", res);
}
}

85
src/bin/cf-1917c.rs Normal file
View File

@ -0,0 +1,85 @@
fn solve(a: Vec<i64>, v: Vec<usize>, start_date: usize, limit: i64) -> (usize, i64) {
let n = a.len();
let k = v.len();
let mut delta_delta = vec![0i64;n+1];
for i in 0..k {
delta_delta[0] += 1;
delta_delta[v[i]] -= 1;
}
let mut delta = vec![0;n];
let mut t = 0;
for i in 0..n {
t += delta_delta[i];
delta[i] = t;
}
let mut idx = n + 1;
let mut raw = 0;
for i in 0..n {
if a[i] <= i as i64 + 1 && idx == n + 1 {
idx = i;
}
if a[i] == i as i64 + 1 {
raw += 1;
}
}
if idx == n + 1 || delta[idx] == 0 {
return (1, raw);
}
let full = (idx as i64 + 1 - a[idx]) / delta[idx];
let mut res = full * k as i64;
let mut rs = idx as i64 + 1 - (a[idx] + full * delta[idx]);
eprintln!("idx={idx}, full={full}, res={res}, rs={rs}");
let mut cf = vec![0;n+1];
for t in 0..k {
if rs == 0 {
if res + 1 > limit {
return if raw != 0 {
(1, raw)
} else {
(usize::MAX, 0)
};
}
let mut cnt = 0;
let mut acc = 0;
for i in 0..n {
acc += cf[i];
if a[i] + delta[i] * full + acc == i as i64 + 1 {
cnt += 1;
}
}
return (res as usize + 1, cnt);
}
res += 1;
cf[0] += 1;
cf[v[(start_date+t)%k]] -= 1;
if v[(start_date+t)%k] > idx {
rs -= 1;
}
}
panic!()
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let tmp: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let d = tmp[2];
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let v: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (next_date, init_score) = solve(a, v, 0, d as i64);
eprintln!("{next_date} {init_score}");
if init_score == 0 || next_date > d {
println!("{}", (d - 1) / 2);
} else {
println!("{}", init_score + (d - next_date) as i64 / 2);
}
}
}

12
src/bin/cf-1917d.py Normal file
View File

@ -0,0 +1,12 @@
from sortedcontainers import SortedList
def solve():
n, k = [int(x) for x in input().strip().split(' ')]
p = [int(x) for x in input().strip().split(' ')]
q = [int(x) for x in input().strip().split(' ')]
assert n == len(p) and k == len(q)
st = SortedList()
res = 0
for i in range(n - 1, -1, -1):
res += st.bisect_left(p[i])
res +=

0
src/bin/cf-1917d.rs Normal file
View File

33
src/bin/cf-1919c.rs Normal file
View File

@ -0,0 +1,33 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
let f = t == 10000;
for k in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
let mut others = vec![];
let mut last = i32::MAX;
for &x in &a {
if x > last {
others.push(x);
} else {
last = x;
}
}
let mut res = 0;
if !others.is_empty() {
for i in 0..others.len()-1 {
res += if others[i] < others[i+1] {1} else {0};
}
}
if !f {
println!("{res}");
} else if k == 470 {
println!("{:?}", &a);
}
}
}

120
src/bin/dancing-links.rs Normal file
View File

@ -0,0 +1,120 @@
struct DancingLinks<T: Copy + Eq> {
cnt: usize,
left: Vec<usize>,
right: Vec<usize>,
up: Vec<usize>,
down: Vec<usize>,
row_head: Vec<usize>,
col_head: Vec<usize>,
val: Vec<T>,
row_info: Vec<usize>,
col_info: Vec<usize>,
}
impl<T: Copy + Eq> DancingLinks<T> {
fn new(max_n: usize) -> Self {
let mut ins = Self {
cnt: 0,
left: vec![],
right: vec![],
up: vec![],
down: vec![],
row_head: vec![0;max_n],
col_head: vec![0;max_n],
val: vec![],
row_info: vec![],
col_info: vec![],
};
ins.left.push(0);
ins.right.push(0);
ins.up.push(0);
ins.down.push(0);
ins.row_info.push(0);
ins.col_info.push(0);
ins
}
fn get_item(&self, idx: usize) -> T {
self.val[idx-1]
}
fn get(&self, i: usize, j: usize) -> Option<T> {
let mut curr = self.row_head[i];
while curr != 0 {
if self.col_info[curr] == j {
return Some(self.get_item(curr));
}
curr = self.right[curr];
}
curr = self.row_head[i];
while curr != 0 {
if self.col_info[curr] == j {
return Some(self.get_item(curr));
}
curr = self.left[curr];
}
None
}
fn insert(&mut self, i: usize, j: usize, val: T) {
self.cnt += 1;
self.val.push(val);
self.left.push(0);
self.right.push(self.row_head[i]);
self.left[self.row_head[i]] = self.cnt;
self.row_head[i] = self.cnt;
self.up.push(0);
self.down.push(self.col_head[j]);
self.up[self.col_head[j]] = self.cnt;
self.col_head[j] = self.cnt;
self.row_info.push(i);
self.col_info.push(j);
}
fn remove_row(&mut self, i: usize) {
let mut curr = self.row_head[i];
while curr != 0 {
self.down[self.up[curr]] = self.down[curr];
self.up[self.down[curr]] = self.up[curr];
curr = self.right[curr];
}
self.row_head[i] = 0;
}
fn remove_col(&mut self, j: usize) {
let mut curr = self.col_head[j];
while curr != 0 {
self.right[self.left[curr]] = self.right[curr];
self.left[self.right[curr]] = self.left[curr];
curr = self.right[curr];
}
self.col_head[j] = 0;
}
fn dance_remove(&mut self, i: usize, plain: T) {
let mut curr = self.row_head[i];
while curr != 0 {
if self.val[curr] != plain {
let mut curr = self.col_head[self.col_info[curr]];
while curr != 0 {
if self.row_info[curr] != i && self.val[curr] != plain {
self.remove_row(self.row_info[curr]);
}
curr = self.down[curr];
}
}
self.remove_col(self.col_info[curr]);
curr = self.right[curr];
}
self.remove_row(i);
}
}
fn main() {
let mut mat = DancingLinks::new(100);
mat.insert(0,0,10086);
mat.insert(0,1,234);
mat.insert(1,1,10010);
mat.insert(12,25,12345);
assert_eq!(mat.get(0,0), Some(10086));
assert_eq!(mat.get(1,0), None);
assert_eq!(mat.get(12, 25), Some(12345));
mat.dance_remove(0,0);
assert_eq!(mat.get(0,0), None);
assert_eq!(mat.get(1,0), None);
assert_eq!(mat.get(1,1), None);
}

63
src/bin/lc-100163.rs Normal file
View File

@ -0,0 +1,63 @@
struct Solution;
struct Sol;
impl Sol {
fn solve(mut x: i64, limit: i64, mut s: i64) -> i64 {
let mut pow = vec![1i64;17];
for i in 1..17 {
pow[i] = pow[i-1] * 10;
}
let mut cnt = vec![0;17];
let m = s;
let mut s_len = 0;
while s != 0 {
s_len += 1;
s /= 10;
}
let pass = m <= x % pow[s_len];
let mut x_len = 0;
let mut x_digit = vec![];
x_digit.push(0);
while x != 0 {
x_len += 1;
x_digit.push(x % 10);
x /= 10;
}
if s_len > x_len {
return 0;
}
for i in 1..=x_len {
if i <= s_len {
cnt[i] = 1;
} else {
cnt[i] = cnt[i-1] * (limit + 1);
}
}
let mut res = 0;
let mut f = true;
for i in (s_len+1..=x_len).rev() {
res += cnt[i-1] * (limit.min(x_digit[i] - 1) + 1);
if limit < x_digit[i] {
f = false;
break;
}
}
if f && pass {
res += 1;
}
res
}
}
impl Solution {
pub fn number_of_powerful_int(start: i64, finish: i64, limit: i32, s: String) -> i64 {
let upper = Sol::solve(finish , limit as i64, s.parse().unwrap());
let lower = Sol::solve(start - 1, limit as i64, s.parse().unwrap());
upper - lower
}
}
fn main() {
println!("{}", Solution::number_of_powerful_int(1, 1000000000000000, 4, "1".to_string()));
}

38
src/bin/lc-1691.rs Normal file
View File

@ -0,0 +1,38 @@
struct Solution;
impl Solution {
pub fn max_height(mut cuboids: Vec<Vec<i32>>) -> i32 {
for x in cuboids.iter_mut() {
x.sort_unstable_by_key(|x|-x);
}
cuboids.sort_unstable_by(|x, y| {
if x[0] == y[0] {
if x[1] == y[1] {
return y[2].cmp(&x[2]);
}
return y[1].cmp(&x[1]);
}
return y[0].cmp(&x[0]);
});
let n = cuboids.len();
let if_fit = |x: &Vec<i32>, y: &Vec<i32>| {
x[1] <= y[1] && x[2] <= y[2]
};
let mut dp = vec![0;n];
let mut res = 0;
for i in 0..n {
for j in 0..i {
if if_fit(&cuboids[i], &cuboids[j]) {
dp[i] = dp[i].max(dp[j]);
}
}
dp[i] += cuboids[i][0];
res = res.max(dp[i]);
}
res
}
}
fn main() {
}

59
src/bin/lc-1703.rs Normal file
View File

@ -0,0 +1,59 @@
// 中位数贪心，枚举结果中的中间那个1的位置。
// 预处理一下前缀和和后缀和，这样在枚举的过程中就可以用二分查找，实现O(n\log n)复杂度。
// nums = [1 0 0 1 0 1]
// pa = [1 1 1 2 2 3]
// pasum= [0 0 0 3 3 8]
struct Solution;
#[inline]
fn sum(start: i32, length: i32) -> i64 {
(2 * start as i64 + length as i64 - 1) * length as i64 >> 1
}
impl Solution {
pub fn min_moves(nums: Vec<i32>, k: i32) -> i32 {
if k == 1 {
return 0;
}
let n = nums.len();
let mut pa = vec![0;n+1];
let mut pa_sum = vec![0;n+1];
for i in 1..=n {
pa[i] = pa[i-1] + nums[i-1];
if nums[i-1] == 1 {
pa_sum[i] = pa_sum[i-1] + i as i64 - 1;
} else {
pa_sum[i] = pa_sum[i-1];
}
}
let part = k >> 1;
let mut res = i64::MAX;
for (i,&x) in nums.iter().enumerate() {
let i = i as i32;
if x == 0 { continue; }
let lsr = if k & 1 == 0 {i} else {i-1};
let rsl = i + 1;
if lsr < 0 || rsl >= n as i32 {continue;}
if let Ok(li) = pa[0..=lsr as usize+1].binary_search_by_key(&-part, |t|t-pa[lsr as usize+1]) {
if let Ok(ri) = pa[rsl as usize+1..=n].binary_search_by_key(&part, |t|t-pa[rsl as usize]) {
let right_sum = pa_sum[ri+rsl as usize + 1] - pa_sum[rsl as usize] - sum(rsl, part);
let left_sum = sum(lsr - part + 1, part) - pa_sum[lsr as usize + 1] + pa_sum[li];
res = res.min(left_sum + right_sum);
}
}
}
res as i32
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let nums: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let k: i32 = buf.trim().parse::<i32>().unwrap();
println!("{}", Solution::min_moves(nums, k));
}

64
src/bin/lc-1723.rs Normal file
View File

@ -0,0 +1,64 @@
struct Solution;
struct Sol {
jobs: Vec<i32>,
k: i32,
n: usize,
tm: Vec<i32>,
}
impl Sol {
fn init(&mut self, i: usize, curr_st: usize, curr_tm: i32) {
if i == self.n {
self.tm[curr_st] = curr_tm;
return;
}
self.init(i + 1, curr_st, curr_tm);
self.init(i + 1, curr_st | 1 << i, curr_tm + self.jobs[i]);
}
fn dfs(&mut self, i: usize, cnt: i32, curr_st: usize, curr_tm: i32, tm_res: i32) -> bool {
// eprintln!("{} {} {:#b} {}", i, cnt, curr_st, curr_tm);
if cnt == self.k {
return curr_st + 1 == 1 << self.n;
}
if i == self.tm.len() {
return false;
}
self.dfs(i + 1, cnt, curr_st, curr_tm, tm_res) ||
if curr_st & i == 0 && self.tm[i] <= tm_res {
self.dfs(i + 1, cnt + 1, curr_st | i, curr_tm.max(self.tm[i]), tm_res)
} else {false}
}
fn solve(&mut self) -> i32 {
self.init(0, 0, 0);
let mut l = *self.jobs.iter().min().unwrap();;
let mut r = self.jobs.iter().sum::<i32>();
while l < r {
let mid = l + r >> 1;
if self.dfs(0, 0, 0, 0, mid) {
r = mid;
} else {
l = mid + 1;
}
}
l
}
}
impl Solution {
pub fn minimum_time_required(jobs: Vec<i32>, k: i32) -> i32 {
let n = jobs.len();
let mut sol = Sol {jobs, k, n, tm: vec![0;1<<n]};
sol.solve()
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let jobs: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let k: i32 = buf.trim().parse::<i32>().unwrap();
println!("{}", Solution::minimum_time_required(jobs, k));
}

20
src/bin/lc-20.rs Normal file
View File

@ -0,0 +1,20 @@
struct Solution;
impl Solution {
pub fn is_valid(s: String) -> bool {
let s = s.into_bytes();
let mut st = vec![];
for x in s {
if matches!(st.last(), Some(y) if x - y == 2 || x - y == 1) {
st.pop();
} else {
st.push(x);
}
}
st.is_empty()
}
}
fn main() {
}

47
src/bin/lc-2305.rs Normal file
View File

@ -0,0 +1,47 @@
/// 状压dp
/// 状态c表示c的每一位1对应的饼干包都已经被分发
/// dp[i][j] 表示分给前 i 个人，状态为 j 时每个人获得的最大饼干数量。
/// 新的状态中，考虑是否有新的人出现。如果有新的人出现，那么枚举他分到了哪些饼干
/// dp[i][j] = min(max(dp[i-1][j^t],cookies_sum[t]))，其中t|j==j
struct Solution;
impl Solution {
pub fn distribute_cookies(cookies: Vec<i32>, k: i32) -> i32 {
let k = k as usize;
let n = cookies.len();
let mut cookies_sum = vec![0;1<<n];
let mut dp = vec![vec![i32::MAX;1<<n];k+1];
for j in 1..1<<n {
for i in 0..n {
if (j >> i) & 1 == 1 {
cookies_sum[j] += cookies[i];
}
}
}
dp[0][0] = 0;
for i in 1..=k {
dp[i][0] = 0;
for j in 1..1<<n {
let mut t = j;
loop {
dp[i][j] = dp[i][j].min(dp[i-1][j^t].max(cookies_sum[t]));
if t == 0 {
break;
}
t = (t - 1) & j;
}
}
}
dp[k][(1<<n)-1]
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let cookies: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let k: i32 = buf.trim().parse::<i32>().unwrap();
println!("{}", Solution::distribute_cookies(cookies, k));
}

27
src/bin/lc-238.rs Normal file
View File

@ -0,0 +1,27 @@
struct Solution;
impl Solution {
pub fn product_except_self(a: Vec<i32>) -> Vec<i32> {
let n = a.len();
let mut pa = vec![1;n+1];
for i in 1..=n {
pa[i] = pa[i-1] * a[i-1];
}
let mut sa = vec![1;n+1];
for i in (0..n).rev() {
sa[i] = sa[i+1] * a[i];
}
let mut res = vec![];
for i in 0..n {
res.push(sa[i+1]*pa[i]);
}
res
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
println!("{:?}", Solution::product_except_self(a));
}

27
src/bin/lc-2680.rs Normal file
View File

@ -0,0 +1,27 @@
struct Solution;
impl Solution {
pub fn maximum_or(nums: Vec<i32>, k: i32) -> i64 {
let n = nums.len();
let k = k as i64;
let mut pa = vec![0;n+1];
for i in 1..=n {
pa[i] = pa[i-1] | nums[i-1] as i64;
}
let mut sa = vec![0;n+1];
for i in (0..n).rev() {
sa[i] = sa[i+1] | nums[i] as i64;
}
(0..n).fold(0, |res, i|res.max((nums[i] as i64) <<k | pa[i] | sa[i+1]))
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let nums: Vec<i32> = buf.trim().split(' ').map(|x|x.parse::<i32>().unwrap()).collect::<Vec<i32>>();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let k: i32 = buf.trim().parse::<i32>().unwrap();
println!("{}", Solution::maximum_or(nums, k));
}

29
src/bin/lc-2696.rs Normal file
View File

@ -0,0 +1,29 @@
struct Solution;
impl Solution {
pub fn min_length(s: String) -> i32 {
let mut s = s.into_bytes();
let mut n = s.len();
let mut f = true;
while f && n != 0 {
f = false;
for i in 0..n-1 {
if s[i] == 65 && s[i+1] == 66 || s[i] == 67 && s[i+1] == 68 {
s.remove(i);
s.remove(i);
n -= 2;
f = true;
break;
}
}
}
n as i32
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let s: String = buf.trim().parse::<String>().unwrap();
println!("{}", Solution::min_length(s));
}

71
src/bin/lc-2707.rs Normal file
View File

@ -0,0 +1,71 @@
struct Solution;
use std::collections::HashMap;
struct Trie {
mark: bool,
nxt: HashMap<u8, Box<Trie>>,
}
impl Trie {
fn new() -> Self {
Self {mark: false, nxt: HashMap::new()}
}
fn insert(&mut self, s: Vec<u8>) {
let mut ptr = self;
for x in s.into_iter().rev() {
ptr = ptr.nxt.entry(x).or_insert(Box::new(Trie{mark: false, nxt: HashMap::new()}));
}
ptr.mark = true;
}
fn query(&self, s: &Vec<u8>) -> Vec<usize> {
let mut ptr = self;
let mut res = vec![];
for (i, &x) in s.iter().rev().enumerate() {
if ptr.mark {
res.push(i);
}
if let Some(p) = ptr.nxt.get(&x) {
ptr = p.as_ref();
} else {
return res;
}
}
if ptr.mark {
res.push(s.len());
}
res
}
}
impl Solution {
pub fn min_extra_char(s: String, dictionary: Vec<String>) -> i32 {
let s = s.into_bytes();
let n = s.len();
let mut trie = Trie::new();
for word in dictionary {
trie.insert(word.into_bytes());
}
// eprintln!("{:?}", trie.query(&("leetcode".to_string().into_bytes())));
// eprintln!("{:?}", trie.query(&("code".to_string().into_bytes())));
let mut dp = vec![0;n+1];
let mut query_string = vec![];
for i in 1..=n {
query_string.push(s[i-1]);
let matchings = trie.query(&query_string);
dp[i] = (0..i).fold(usize::MAX, |c, j|c.min(i - j + dp[j]));
dp[i] = dp[i].min(matchings.into_iter().fold(usize::MAX, |c,j|c.min(dp[i-j])));
}
dp[n] as i32
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let s: String = buf.trim().parse::<String>().unwrap();
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let dictionary: Vec<String> = buf.trim().split(' ').map(|x|x.parse::<String>().unwrap()).collect::<Vec<String>>();
println!("{}", Solution::min_extra_char(s, dictionary));
}

42
src/bin/lc-2807.rs Normal file
View File

@ -0,0 +1,42 @@
// Definition for singly-linked list.
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct ListNode {
pub val: i32,
pub next: Option<Box<ListNode>>
}
impl ListNode {
#[inline]
fn new(val: i32) -> Self {
ListNode {
next: None,
val
}
}
}
struct Solution;
impl Solution {
pub fn insert_greatest_common_divisors(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
let gcd = |mut x: i32, mut y: i32| {
while y != 0 {
(x, y) = (y, x % y);
}
x
};
let mut t = head.as_mut().unwrap();
while t.next != None {
let next = t.next.take().unwrap();
let mut mid = Box::new(ListNode::new(gcd(t.val, next.val)));
mid.next = Some(next);
t.next = Some(mid);
t = t.next.as_mut().unwrap().next.as_mut().unwrap();
}
head
}
}
fn main() {
}

20
src/bin/lc-32.rs Normal file
View File

@ -0,0 +1,20 @@
struct Solution;
impl Solution {
pub fn longest_valid_parentheses(s: String) -> i32 {
let mut st = vec![];
let s = s.into_bytes();
let mut res = 0;
for (i, &x) in s.iter().enumerate() {
if x == 41 && matches!(st.last(), Some(j) if s[j - 1] == 40) {
st.pop();
res = res.max(i + 1 - st.last().unwrap_or(&0));
} else {
st.push(i + 1);
}
}
res as i32
}
}
fn main() {}

55
src/bin/lc-5.cc Normal file
View File

@ -0,0 +1,55 @@
#include<bits/stdc++.h>
using namespace std;
#define mod(x, y) (((x) % (y) + (y)) % (y))
using ll = int64_t;
constexpr ll prime = 1e9 + 7;
constexpr ll b1 = 825;
constexpr ll b2 = 87825;
class Solution {
public:
string longestPalindrome(string s) {
int n = s.length();
vector<ll> pa1(n + 1), pa2(n + 1);
ll hash1 = 0, hash2 = 0;
for (int i = 1; i <= n; ++i) {
hash1 = (hash1 * b1 + s[i - 1]) % prime;
hash2 = (hash2 * b2 + s[i - 1]) % prime;
pa1[i] = hash1;
pa2[i] = hash2;
}
vector<ll> sa1(n + 1), sa2(n + 1);
hash1 = 0, hash2 = 0;
for (int i = n - 1; i >= 0; --i) {
hash1 = (hash1 * b1 + s[i]) % prime;
hash2 = (hash2 * b2 + s[i]) % prime;
sa1[i] = hash1;
sa2[i] = hash2;
}
vector<ll> p1(n + 1), p2(n + 1);
p1[0] = 1, p2[0] = 1;
for (int i = 1; i < n; ++i) {
p1[i] = (p1[i - 1] * b1) % prime;
p2[i] = (p2[i - 1] * b2) % prime;
}
function<bool(int, int)> check_palindrome = [&] (int l, int r) {
int p = l + r >> 1, q = l + r + 1 >> 1;
return mod((pa1[p + 1] - pa1[l] * p1[p + 1 - l]), prime) == mod((sa1[q] - sa1[r + 1] * p1[r + 1 - q]), prime) &&
mod((pa2[p + 1] - pa2[l] * p2[p + 1 - l]), prime) == mod((sa2[q] - sa2[r + 1] * p2[r + 1 - q]), prime);
};
int l = 0;
pair<int, int> res;
for (int i = 0; i < n; ++i) {
l = max(0, l - 1);
while (!check_palindrome(l, i)) ++l;
res = max(res, {i - l + 1, l});
}
return s.substr(res.second, res.first);
}
};
int main() {
string s; cin >> s;
cout << Solution().longestPalindrome(s);
}

35
src/bin/lc-83.rs Normal file
View File

@ -0,0 +1,35 @@
// Definition for singly-linked list.
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct ListNode {
pub val: i32,
pub next: Option<Box<ListNode>>
}
impl ListNode {
#[inline]
fn new(val: i32) -> Self {
ListNode {
next: None,
val
}
}
}
struct Solution;
impl Solution {
pub fn delete_duplicates(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
let mut c = head.as_mut();
while let Some(curr) = c {
while let Some(next) = curr.next.as_mut() {
if next.val == curr.val {
curr.next = next.next.take();
} else {
break;
}
}
c = curr.next.as_mut();
}
head
}
}

65
src/bin/lg-1048.rs Normal file
View File

@ -0,0 +1,65 @@
struct Item {
time: i64,
value: i64,
cost: f64
}
impl Item {
fn new(time: i64, value: i64) -> Self {
Item { time, value, cost : value as f64 / time as f64 }
}
}
struct Sol {
a: Vec<Item>,
tt: i64,
m: usize,
res: i64
}
impl Sol {
fn estimate(&self, mut curr_t: i64, next_idx: usize) -> f64 {
let mut res = 0.;
for i in next_idx..self.m {
if self.a[i].time + curr_t > self.tt {
return res + (self.tt - curr_t) as f64 * self.a[i].cost;
}
curr_t += self.a[i].time;
res += self.a[i].value as f64;
}
res
}
fn dfs(&mut self, curr_t: i64, idx: usize, curr_v: i64) {
self.res = self.res.max(curr_v);
if idx == self.m {
return;
}
if curr_t + self.a[idx].time <= self.tt {
self.dfs(curr_t + self.a[idx].time, idx + 1, curr_v + self.a[idx].value);
}
if curr_v + self.estimate(curr_t, idx + 1).ceil() as i64 > self.res {
self.dfs(curr_t, idx + 1, curr_v);
}
}
fn solve(&mut self) -> i64 {
self.dfs(0, 0, 0);
self.res
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let tm: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let (tt, m) = (tm[0], tm[1]);
let mut a = Vec::<Item>::with_capacity(m as usize);
for _ in 0..m {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let mut iter = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap());
a.push(Item::new(iter.next().unwrap(), iter.next().unwrap()));
}
a.sort_unstable_by(|x,y|y.cost.total_cmp(&x.cost));
let mut sol = Sol { a, tt, m: m as usize, res: 0 };
println!("{}", sol.solve());
}

60
src/bin/lg-uva437.cc Normal file
View File

@ -0,0 +1,60 @@
#include<bits/stdc++.h>
using namespace std;
using ll = int64_t;
ll solve(vector<vector<ll>> boxes) {
int m = boxes.size();
int n = m * 3;
for (int i = 0; i < m; ++i) {
boxes.push_back({boxes[i][0], boxes[i][2], boxes[i][1]});
boxes.push_back({boxes[i][1], boxes[i][2], boxes[i][0]});
}
vector<vector<int>> ch(n);
vector<int> ind(n, 0);
function<bool(const vector<ll>&, const vector<ll>&)> is_fit = [](const vector<ll>& x, const vector<ll>& y) {
return x[0] < y[0] && x[1] < y[1] || x[0] < y[1] && x[1] < y[0];
};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n ;++j) {
if (is_fit(boxes[j], boxes[i])) {
ch[i].push_back(j);
++ind[j];
}
}
}
ll res = 0;
deque<int> dq;
vector<ll> dp(n, 0);
for (int i = 0; i < n; ++i) {
if (!ind[i]) dq.push_back(i);
}
while (!dq.empty()) {
int i = dq.front();
dq.pop_front();
dp[i] += boxes[i][2];
res = max(res, dp[i]);
for (auto&& j : ch[i]) {
dp[j] = max(dp[j], dp[i]);
--ind[j];
if (!ind[j]) dq.push_back(j);
}
}
return res;
}
int main() {
int i = 0;
while (1) {
++i;
int n;
cin >> n;
if (!n) break;
vector<vector<ll>> boxes(n);
for (int i = 0;i < n; ++i) {
for (int j = 0; j < 3; ++j) {
int t; cin >> t; boxes[i].push_back(t);
}
}
cout << "Case " << i << ": maximum height = " << solve(move(boxes)) << endl;
}
}

65
src/bin/lg-uva437.rs Normal file
View File

@ -0,0 +1,65 @@
use std::collections::VecDeque;
fn solve(mut boxes: Vec<Vec<i64>>) -> i64 {
let m = boxes.len();
let n = m * 3;
for i in 0..m {
let curr = boxes[i].to_owned();
boxes.push(vec![curr[0], curr[2], curr[1]]);
boxes.push(vec![curr[1], curr[2], curr[0]]);
}
let mut ch = vec![vec![];n];
let mut ind = vec![0;n];
let is_fit = |x: &Vec<i64>, y: &Vec<i64>| {
x[0] < y[0] && x[1] < y[1] || x[0] < y[1] && x[1] < y[0]
};
for i in 0..n {
for j in 0..n {
if is_fit(&boxes[j], &boxes[i]) {
ch[i].push(j);
ind[j] += 1;
}
}
}
let mut res = 0;
let mut dq = VecDeque::new();
let mut dp = vec![0;n];
for i in 0..n {
if ind[i] == 0 {
dq.push_back(i);
}
}
while let Some(i) = dq.pop_front() {
dp[i] += boxes[i][2];
res = res.max(dp[i]);
for &j in &ch[i] {
dp[j] = dp[j].max(dp[i]);
ind[j] -= 1;
if ind[j] == 0 {
dq.push_back(j);
}
}
}
res
}
fn main() {
let mut i = 0;
loop {
i += 1;
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let n: usize = buf.trim().parse::<usize>().unwrap();
if n == 0 {
break;
}
let mut boxes = Vec::with_capacity(n);
for _ in 0..n {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let v: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
boxes.push(v);
}
println!("Case {i}: maximum height = {}", solve(boxes));
}
}

80
src/bin/loj-101-1.rs Normal file
View File

@ -0,0 +1,80 @@
use std::collections::VecDeque;
#[derive(Clone, Copy, Debug)]
struct Edge {
to: usize,
flow: i64,
cap: i64,
rev: usize,
}
struct Net(Vec<Vec<Edge>>, Vec<usize>, Vec<bool>);
impl Net {
fn new(n: usize) -> Self {
Self(vec![vec![]; n+1], vec![0; n+1], vec![false; n+1])
}
fn add_edge(&mut self, from: usize, to: usize, cap: i64) {
let to_edge = Edge {to, cap, flow: 0, rev: self.0[to].len()};
self.0[from].push(to_edge);
let from_edge = Edge {to: from, flow: 0, cap: 0, rev: self.0[from].len() - 1};
self.0[to].push(from_edge);
}
fn bfs(&mut self, s: usize, t: usize) -> bool {
self.1.fill(0);
let mut dq = VecDeque::new();
self.1[s] = 1;
dq.push_back((s, 1));
while let Some((v, l)) = dq.pop_front() {
for e in &self.0[v] {
if self.1[e.to] == 0 && e.cap > e.flow {
self.1[e.to] = l + 1;
dq.push_back((e.to, l + 1));
}
}
}
self.1[t] != 0
}
fn dfs(&mut self, s: usize, t: usize, cap: i64) -> i64 {
if self.2[s] { return 0; }
self.2[s] = true;
if s == t { return cap; }
let mut res = 0;
let n = self.0[s].len();
for i in 0..n {
let e = self.0[s][i];
if e.cap > e.flow && self.1[e.to] == self.1[s] + 1 {
let new = self.dfs(e.to, t, (cap - res).min(e.cap - e.flow));
self.0[s][i].flow += new;
self.0[e.to][e.rev].flow -= new;
res += new;
if res == cap { return res; }
}
}
res
}
fn max_flow(&mut self, s: usize, t: usize) -> i64 {
let mut res = 0;
while self.bfs(s, t) {
self.2.fill(false);
res += self.dfs(s, t, i64::MAX);
}
res
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let nmst: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (n, m, s, t) = (nmst[0], nmst[1], nmst[2], nmst[3]);
let mut net = Net::new(n);
for _ in 0..m {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let uvc: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
let (u, v, c) = (uvc[0] as usize, uvc[1] as usize, uvc[2]);
net.add_edge(u, v, c);
}
println!("{}", net.max_flow(s, t));
}

74
src/bin/loj-101.rs Normal file
View File

@ -0,0 +1,74 @@
use std::collections::VecDeque;
#[derive(Clone, Debug)]
struct Edge {
to: usize,
cap: i64,
flow: i64,
rev: (usize, usize)
}
struct Net(Vec<Vec<Edge>>);
impl Net {
fn new(n: usize) -> Self {
Self(vec![vec![];n+1])
}
fn add_edge(&mut self, from: usize, to: usize, cap: i64) {
let to_edge = Edge {to, cap, flow: 0, rev: (to, self.0[to].len())};
self.0[from].push(to_edge);
let from_edge = Edge {to: from, cap: 0, flow: 0, rev: (from, self.0[from].len() - 1)};
self.0[to].push(from_edge);
}
fn max_flow(&mut self, s: usize, t: usize) -> i64 {
let n = self.0.len();
let mut pa = vec![(0, 0);n+1];
let mut res = 0;
loop {
let mut pf = vec![0;n+1];
let mut dq = VecDeque::new();
dq.push_back(s);
pf[s] = i64::MAX;
while let Some(v) = dq.pop_front() {
for (i, ne) in self.0[v].iter().enumerate() {
if pf[ne.to] == 0 && ne.cap > ne.flow {
pf[ne.to] = pf[v].min(ne.cap - ne.flow);
pa[ne.to] = (v, i);
dq.push_back(ne.to);
}
}
if pf[t] != 0 {
break;
}
}
if pf[t] == 0 {
break;
}
let mut p = t;
while pa[p].0 != 0 {
let (x, y) = pa[p];
self.0[x][y].flow += pf[t];
let (z, w) = self.0[x][y].rev;
self.0[z][w].flow -= pf[t];
p = x;
}
res += pf[t];
}
res
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let tmp: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (n, m, s, t) = (tmp[0], tmp[1], tmp[2], tmp[3]);
let mut net = Net::new(n);
for _ in 0..m {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let tmp: Vec<i64> = buf.trim().split(' ').map(|x|x.parse::<i64>().unwrap()).collect::<Vec<i64>>();
net.add_edge(tmp[0] as usize, tmp[1] as usize, tmp[2]);
}
println!("{}", net.max_flow(s, t));
}

0
src/bin/lzf-t2.rs Normal file
View File

86
src/bin/lzf-t3-tianping.cc Normal file
View File

@ -0,0 +1,86 @@
#include<bits/stdc++.h>
using namespace std;
using ll = int64_t;
constexpr int MAXN = 42;
int n, m;
ll a[MAXN][MAXN];
ll x[MAXN][MAXN];
int main() {
cin >> n >> m;
ll cnt1 = 0, sum1 = 0, cnt2 = 0, sum2 = 0;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
cin >> a[i][j];
if ((i + j) & 1) {
++cnt1;
sum1 += a[i][j];
} else {
++cnt2;
sum2 += a[i][j];
}
}
}
ll l = 0, r = LLONG_MAX / (MAXN * MAXN);
if ((n * m) & 1) {
l = (sum1 - sum2) / (cnt1 - cnt2);
r = l + 1;
}
ll res = LLONG_MAX;
int o = 0;
while(l < r) {
memset(x, 0, sizeof(x));
ll mid = l + r >> 1;
cerr << mid << endl;
int f = 1;
ll cnt = 0;
for(int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
ll available = mid - a[i][j] - x[i][j];
if (available < 0) {
f = 0;
goto finish;
}
if (i + 1 == n) {
if (j + 1 == m) {
continue;
}
ll lo = min(available, mid - a[i][j+1] - x[i][j+1]);
x[i][j+1] += lo;
if (available != lo) {
f = 0;
goto finish;
}
} else {
if (j + 1 == m) {
ll lo = min(available, mid - a[i+1][j] - x[i+1][j]);
x[i+1][j] += lo;
if (available != lo) {
f = 0;
goto finish;
}
} else {
ll lo = min(available, mid - a[i][j+1] - x[i][j+1]);
x[i][j+1] += lo;
x[i+1][j] += available - lo;
}
}
cnt += 2 * available;
}
}
finish:
if(f) {
r = mid;
o = 1;
res = min(res, cnt);
} else {
l = mid + 1;
}
}
if (o) {
cout << res;
} else {
cout << -1;
}
}

0
src/bin/lzf-t3-tianping.rs Normal file
View File

52
src/bin/number-dp.rs Normal file
View File

@ -0,0 +1,52 @@
struct Sol {
dp: Vec<usize>,
pow: Vec<usize>,
}
impl Sol {
fn solve(&self, mut x: usize) -> Vec<usize> {
let mut cnt = x;
let mut digit = vec![];
let mut res = vec![0;10];
let mut len = 0;
digit.push(0);
while x != 0 {
len += 1;
digit.push(x as usize % 10);
x /= 10;
}
for i in (1..=len).rev() {
cnt -= digit[i] * self.pow[i-1];
res[digit[i]] += cnt + 1;
for b in 0..10 {
res[b] += self.dp[i-1] * digit[i];
}
for j in 0..digit[i] {
res[j] += self.pow[i-1];
}
res[0] -= self.pow[i-1];
}
res
}
}
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let ab: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let a = ab[0];
let b = ab[1];
let mut dp = vec![0;13];
let mut pow = vec![1;13];
for i in 1..13 {
pow[i] = pow[i-1] * 10;
dp[i] = dp[i-1] * 10 + pow[i-1];
}
let sol = Sol { dp, pow };
let res_a_1 = sol.solve(a - 1);
let res_b = sol.solve(b);
for i in 0..10 {
print!("{} ", res_b[i] - res_a_1[i]);
}
}

160
src/bin/test.cc Normal file
View File

@ -0,0 +1,160 @@
/////////////////////////////////////////////////////////
/**
* Useful Macros
* by subcrip
* (requires C++17)
*/
#include<bits/stdc++.h>
using namespace std;
/* macro helpers */
#define __NARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define __DECOMPOSE_S(a, x) auto x = a;
#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a;
constexpr void __() {}
#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __()
#define __as_typeof(container) decltype(container)::value_type
/* type aliases */
using ll = int64_t;
using ull = uint64_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
/* constants */
constexpr int INF = 0x3f3f3f3f;
constexpr ull MDL = 1e9 + 7;
constexpr ull PRIME = 998'244'353;
constexpr ull MDL1 = 825;
constexpr ull MDL2 = 87825;
/* bit-wise operations */
#define lowbit(x) ((x) & -(x))
#define popcount(x) (__builtin_popcountll(ll(x)))
#define parity(x) (__builtin_parityll(ll(x)))
#define msp(x) (63LL - __builtin_clzll(ll(x)))
#define lsp(x) (__builtin_ctzll(ll(x)))
/* arithmetic operations */
#define mod(x, y) (((x) + (y)) % (y))
/* fast pairs */
#define upair ull
#define umake(x, y) (ull(x) << 32 | ull(y))
#define u1(p) ((p) >> 32)
#define u2(p) ((p) & ((1ULL << 32) - 1))
#define ult std::less<upair>
#define ugt std::greater<upair>
#define ipair ull
#define imake(x, y) (umake(x, y))
#define i1(p) (int(u1(p)))
#define i2(p) (int(u2(p)))
struct ilt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) < i2(b);
else return i1(a) < i1(b);
}
};
struct igt {
bool operator()(const ipair& a, const ipair& b) const {
if (i1(a) == i1(b)) return i2(a) > i2(b);
else return i1(a) > i1(b);
}
};
/* conditions */
#define loop while (1)
#define if_or(var, val) if (!(var == val)) var = val; else
#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;)
#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;)
/* build data structures */
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];)
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};)
#define adj(ch, n) __AS_PROCEDURE(vector<vector<int>> ch((n) + 1);)
#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);)
#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);)
/* io */
#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL))
template<typename T> void __read(T& x) { cin >> x; }
template<typename T, typename... U> void __read(T& x, U&... args) { cin >> x; __read(args...); }
#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);)
#define readvec(type, a, n) __AS_PROCEDURE(vector<type> a(n); for (int i = 0; i < (n); ++i) cin >> a[i];)
#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;)
#define debug(x) __AS_PROCEDURE(cerr << #x" = " << x << endl;)
#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;)
/* pops */
#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)
#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();)
#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();)
/* algorithms */
vector<int> calc_next(string t) { // pi function of t
int n = (int)t.length();
vector<int> pi(n);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && t[i] != t[j]) j = pi[j - 1];
if (t[i] == t[j]) j++;
pi[i] = j;
}
return pi;
}
vector<int> calc_z(string t) { // z function of t
int m = t.length();
vector<int> z;
z.push_back(m);
pair<int, int> prev = {1, -1};
for (int i = 1; i < m; ++i) {
if (z[i - prev.first] + i <= prev.second) {
z.push_back(z[i - prev.first]);
} else {
int j = max(i, prev.second + 1);
while (j < m && t[j] == t[j - i]) ++j;
z.push_back(j - i);
prev = {i, j - 1};
}
}
return z;
}
vector<int> kmp(string s, string t) { // find all t in s
string cur = t + '#' + s;
int sz1 = s.size(), sz2 = t.size();
vector<int> v;
vector<int> lps = calc_next(cur);
for (int i = sz2 + 1; i <= sz1 + sz2; i++) {
if (lps[i] == sz2) v.push_back(i - 2 * sz2);
}
return v;
}
/////////////////////////////////////////////////////////
int main() {
read(string, s);
int n = s.length();
string rev(s.rbegin(), s.rend());
auto translate = [&] (int i) {return n - i - 1;};
auto z = calc_z(s);
auto pi = calc_next(rev);
int res = 0;
for (int i = 1; i < n - 1; ++i) {
int suf = pi[translate(i)];
if (suf > 0 && suf <= z[i]) {
res = max(res, suf);
}
}
if (res) {
cout << s.substr(0, res);
} else {
cout << "Just a legend";
}
}

29
src/bin/test.py Normal file
View File

@ -0,0 +1,29 @@
def kmp(s, t): # find all occurrences of t in s
n = len(s)
m = len(t)
next = [-1]
j = -1
i = 0
while i < m:
if j == -1 or t[i] == t[j]:
i += 1
j += 1
if i != m and t[j] == t[i]:
next.append(next[j])
else:
next.append(j)
else:
j = next[j]
res = []
i = 0
j = 0
while i < n and j < m:
if j == -1 or s[i] == t[j]:
i += 1
j += 1
if j == m:
res.append(i - j)
j = next[j]
else:
j = next[j]
return res

37
src/bin/test.rs Normal file
View File

@ -0,0 +1,37 @@
fn main() {
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).ok();
let t: usize = buf.trim().parse::<usize>().unwrap();
let mut curr = vec![0;1000];
let mut tmp = vec![0;1000];
for _ in 0..t {
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let nxz: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
let (n, x, z) = (nxz[0], nxz[1], nxz[2]);
buf.clear();
std::io::stdin().read_line(&mut buf).ok();
let a: Vec<usize> = buf.trim().split(' ').map(|x|x.parse::<usize>().unwrap()).collect::<Vec<usize>>();
curr.fill(usize::MAX);
curr[z%x] = z;
let mut res = usize::MAX;
for &i in &a {
for j in 0..x {
tmp[j] = curr[j];
}
for j in 0..x {
if tmp[j] != usize::MAX {
curr[(j + i) % x] = curr[(j + i) % x].min(tmp[j] + i);
if (tmp[j] + i) % x == 0 {
res = res.min(curr[0] / x);
}
}
}
}
if res != usize::MAX {
println!("{res}");
} else {
println!("-1");
}
}
}

35
src/bin/test_b.cc Normal file
View File

@ -0,0 +1,35 @@
#include<bits/stdc++.h>
using namespace std;
void solve() {
int n, k, x; cin >> n >> k >> x;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end(), greater<>());
vector<int> pa(n + 1);
int sum = 0;
for (int i = 1; i <= n; ++i) {
pa[i] = pa[i - 1] + a[i - 1];
sum += a[i - 1];
}
function<int(int)> get = [&](int idx) {
if (idx + x > n) {
return pa[n] - pa[idx];
} else {
return pa[idx + x] - pa[idx];
}
};
int res = sum - 2 * get(0);
// cerr << "*" << sum << "*" << get(0) << "*" << res << endl;
for (int i = 1; i <= k; ++i) {
sum -= a[i-1];
res = max(res, sum - 2 * get(i));
// cerr << "*" << sum << "*" << get(i) << "*" << res << endl;
}
cout << res << endl;
}
int main() {
int t; cin >> t;
while(t--) solve();
}

56
src/bin/uoj-78.cc Normal file
View File

@ -0,0 +1,56 @@
#include<bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL);
int nl, nr, m;
cin >> nl >> nr >> m;
vector<vector<int>> left(nl+1);
vector<vector<int>> right(nr+1);
vector<int> choice_left(nl+1);
vector<int> choice_right(nr+1);
vector<int> vis(nl+1);
while(m--) {
int v, u;
cin >> v >> u;
left[v].push_back(u);
right[u].push_back(v);
}
function<bool(int)> dfs = [&](int v) -> bool {
if (vis[v]) return false;
vis[v] = true;
for (auto&& u : left[v]) {
if (choice_right[u]) {
int t = choice_right[u];
if (dfs(t)) {
choice_left[v] = u;
choice_right[u] = v;
vis[v] = false;
return true;
}
} else {
choice_left[v] = u;
choice_right[u] = v;
vis[v] = false;
return true;
}
}
return false;
};
for (int i = 1; i <= nl; ++i) {
if (!choice_left[i]) {
dfs(i);
}
}
vector<int> res;
int cnt = 0;
for (int i = 1; i <= nl; ++i) {
if (choice_left[i]) {
++cnt;
}
res.push_back(choice_left[i]);
}
cout << cnt << endl;
for (auto&& j : res)
cout << j << ' ';
}