solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
std::mt19937 rnd(1337);
void ios() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
}
void solve() {
int32_t n;
std::cin >> n;
std::vector<int32_t> a(n);
std::vector<std::pair<int32_t, int32_t>> res;
for (int32_t i = 0; i < n; ++i) {
std::cin >> a[i];
}
if (a[n - 1] == 2) {
for (auto &elem : a) elem = 3 - elem;
}
std::vector<int32_t> pref(n + 1, 0);
for (int32_t i = 0; i < n; ++i) {
pref[i + 1] = pref[i] + (a[i] == 1);
}
for (int32_t t = 1; t <= n; ++t) {
int32_t l = 0;
bool can = true;
int32_t first = 0, second = 0;
bool last;
while (l < n) {
int32_t left = -1, right = n - l;
while (right - left > 1) {
int32_t mid = (left + right) / 2;
int32_t cntOne = pref[l + mid] - pref[l];
if (std::max(cntOne, mid - cntOne) >= t) {
right = mid;
} else {
left = mid;
}
}
int32_t cntOne = pref[l + right] - pref[l];
if (std::max(cntOne, right - cntOne) != t) {
can = false;
break;
} else {
l += right;
if (a[l - 1] == 1) {
++first;
last = true;
} else {
++second;
last = false;
}
}
}
if (can && first != second && (first > second == last)) {
res.emplace_back(std::max(first, second), t);
}
}
std::sort(res.begin(), res.end());
std::cout << res.size() << '\n';
for (auto &elem : res) std::cout << elem.first << ' ' << elem.second << '\n';
}
int32_t main() {
ios();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Q;
const int MAXN = 2e5 + 5;
set<int> odd[MAXN], even[MAXN];
struct node {
int l, r;
int mi, mx;
bool flag;
} tr[MAXN << 2];
void update(int id) {
if (tr[id].l == tr[id].r) {
tr[id].flag = tr[id].mi > tr[id].mx;
} else {
if (tr[id << 1].flag && tr[id << 1 | 1].flag &&
(tr[id << 1].mi > tr[id << 1 | 1].mx))
tr[id].flag = true;
else
tr[id].flag = false;
tr[id].mi = min(tr[id << 1].mi, tr[id << 1 | 1].mi);
tr[id].mx = max(tr[id << 1].mx, tr[id << 1 | 1].mx);
}
}
void update_odd(int id, int pos, int val) {
if (tr[id].l == tr[id].r) {
tr[id].mi = val;
update(id);
return;
}
int mid = (tr[id].l + tr[id].r) >> 1;
if (pos <= mid)
update_odd(id << 1, pos, val);
else
update_odd(id << 1 | 1, pos, val);
update(id);
}
void update_even(int id, int pos, int val) {
if (tr[id].l == tr[id].r) {
tr[id].mx = val;
update(id);
return;
}
int mid = (tr[id].l + tr[id].r) >> 1;
if (pos <= mid)
update_even(id << 1, pos, val);
else
update_even(id << 1 | 1, pos, val);
update(id);
}
void build(int id, int l, int r) {
tr[id].l = l;
tr[id].r = r;
tr[id].mi = M + 1;
tr[id].mx = 0;
tr[id].flag = true;
if (l == r) return;
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= N; i++) {
odd[i].insert(M + 1);
even[i].insert(0);
}
build(1, 1, N);
int x, y;
while (Q--) {
scanf("%d%d", &x, &y);
if (x & 1) {
x = (x + 1) / 2;
y = (y + 1) / 2;
if (odd[x].find(y) != odd[x].end())
odd[x].erase(y);
else
odd[x].insert(y);
update_odd(1, x, *odd[x].begin());
} else {
x /= 2;
y /= 2;
if (even[x].find(y) != even[x].end())
even[x].erase(y);
else
even[x].insert(y);
update_even(1, x, *--even[x].end());
}
if (tr[1].flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353, G = 3, INV2 = (MOD + 1) >> 1, MAXN = 500005;
long long q_pow(long long a, long long b, long long p = MOD) {
long long ret = 1;
for (; b; a = a * a % p, b >>= 1)
if (b & 1) ret = ret * a % p;
return ret;
}
long long inv(long long x, long long p = MOD) { return q_pow(x, p - 2, p); }
int rev[MAXN];
void NTT(int* A, int LIM, int op) {
for (int i = 0; i < LIM; ++i)
if (i < rev[i]) swap(A[i], A[rev[i]]);
for (int l = 2; l <= LIM; l <<= 1) {
int g = q_pow(G, (MOD - 1) / l);
if (op == -1) g = inv(g);
for (int i = 0; i < LIM; i += l) {
int w = 1;
for (int j = i; j < i + (l >> 1); ++j, w = 1ll * w * g % MOD) {
int x = A[j], y = 1ll * w * A[j + (l >> 1)] % MOD;
A[j] = (x + y) % MOD, A[j + (l >> 1)] = (x - y) % MOD;
}
}
}
}
void Multiply(int* A, int* B, int LIM, int L) {
for (int i = 0; i < LIM; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
NTT(A, LIM, 1), NTT(B, LIM, 1);
for (int i = 0; i < LIM; ++i) A[i] = 1ll * A[i] * B[i] % MOD;
NTT(A, LIM, -1);
int invLIM = inv(LIM);
for (int i = 0; i < LIM; ++i) A[i] = 1ll * A[i] * invLIM % MOD;
}
int T[MAXN];
void Inverse(const int* F, int* G, int LIM, int L) {
if (LIM == 1) {
G[0] = inv(F[0]);
return;
}
Inverse(F, G, LIM >> 1, L - 1);
for (int i = 0; i < (LIM << 1); ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << L);
for (int i = 0; i < LIM; ++i) T[i] = F[i];
for (int i = LIM; i < (LIM << 1); ++i) T[i] = 0;
NTT(T, LIM << 1, 1), NTT(G, LIM << 1, 1);
for (int i = 0; i < (LIM << 1); ++i)
G[i] = (2 * G[i] - 1ll * T[i] * G[i] % MOD * G[i]) % MOD;
NTT(G, LIM << 1, -1);
int invLIM = inv(LIM << 1);
for (int i = 0; i < LIM; ++i) G[i] = 1ll * G[i] * invLIM % MOD;
for (int i = LIM; i < (LIM << 1); ++i) G[i] = 0;
}
void Derivative(int* A, int LIM) {
for (int i = 0; i < LIM; ++i) A[i] = 1ll * A[i + 1] * (i + 1) % MOD;
}
void Inter(int* A, int LIM) {
for (int i = LIM; i >= 1; --i) A[i] = 1ll * A[i - 1] * inv(i) % MOD;
A[0] = 0;
}
int Ai[MAXN];
void Ln(int* A, int LIM, int L) {
Inverse(A, Ai, LIM, L), Derivative(A, LIM), Multiply(A, Ai, LIM << 1, L + 1),
Inter(A, LIM);
for (int i = LIM; i < (LIM << 1); ++i) A[i] = 0;
for (int i = 0; i < (LIM << 1); ++i) Ai[i] = 0;
}
int Texp[MAXN];
void Exp(const int* F, int* G, int LIM, int L) {
if (LIM == 1) {
G[0] = 1;
return;
}
Exp(F, G, LIM >> 1, L - 1);
for (int i = 0; i < LIM; ++i) Texp[i] = G[i];
Ln(G, LIM, L);
for (int i = 0; i < LIM; ++i) G[i] = (-G[i] + F[i]) % MOD;
++G[0];
Multiply(G, Texp, LIM << 1, L + 1);
for (int i = LIM; i < (LIM << 1); ++i) G[i] = 0;
}
int I[MAXN];
void Pow(int* F, int LIM, long long K) {
if (K == INV2)
F[0] = 1, F[1] = 3;
else
F[0] = 1, F[1] = -3;
I[1] = 1;
for (int i = 2; i < LIM; ++i) {
F[i] = (K * (6ll * F[i - 1] + 2 * F[i - 2]) -
(6ll * (i - 1) * F[i - 1] + (long long)(i - 2) * F[i - 2])) %
MOD;
I[i] = -1ll * (MOD / i) * I[MOD % i] % MOD, F[i] = 1ll * F[i] * I[i] % MOD;
}
}
int N, K, LIM = 1, L, A[MAXN], B[MAXN];
int main() {
scanf("%d%d", &N, &K);
int i;
while (LIM <= K) LIM <<= 1, ++L;
Pow(A, LIM, INV2);
++A[0], ++A[1];
for (i = 0; i < LIM; ++i) A[i] = 1ll * A[i] * INV2 % MOD;
Ln(A, LIM, L);
for (i = 0; i < LIM; ++i) A[i] = 1ll * A[i] * (N + 1) % MOD;
Exp(A, B, LIM, L);
Pow(A, LIM, -INV2 + MOD);
Multiply(A, B, LIM << 1, L + 1);
for (i = N + 1; i < (LIM << 1); ++i) A[i] = 0;
for (i = 1; i <= K; ++i) printf("%d ", (A[i] + MOD) % MOD);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
template <typename T>
T sqr(T a) {
return a * a;
}
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
inline int dist(const pair<int, int>& a, const pair<int, int>& b) {
return sqr(a.first - b.first) + sqr(a.second - b.second);
}
inline int smul(const pair<int, int>& a, const pair<int, int>& b) {
return a.first * b.first + a.second * b.second;
}
pair<int, int> operator-(const pair<int, int>& a, const pair<int, int>& b) {
return pair<int, int>(a.first - b.first, a.second - b.second);
}
inline bool checkRect(const vector<pair<int, int> >& a) {
for (int i = 0; i < int(int((a).size())); ++i) {
int j = i - 1;
if (j == -1) j = int((a).size()) - 1;
int k = i + 1;
if (k == int((a).size())) k = 0;
if (smul(a[j] - a[i], a[k] - a[i]) != 0) return false;
}
return true;
}
int main() {
vector<pair<int, int> > a(8);
for (int i = 0; i < int(8); ++i) {
cin >> a[i].first >> a[i].second;
}
for (int mask = 0; mask < int((1 << int((a).size()))); ++mask) {
vector<pair<int, int> > b, c;
for (int i = 0; i < int(int((a).size())); ++i)
if (mask & (1 << i))
b.push_back(a[i]);
else
c.push_back(a[i]);
if (int((b).size()) != int((c).size())) continue;
sort((b).begin(), (b).end());
sort((c).begin(), (c).end());
do {
if (!checkRect(b) || dist(b[0], b[1]) != dist(b[1], b[2]) ||
dist(b[0], b[1]) != dist(b[2], b[3]) ||
dist(b[0], b[1]) != dist(b[3], b[0]))
continue;
do {
if (!checkRect(c) || dist(c[0], c[1]) != dist(c[2], c[3]) ||
dist(c[1], c[2]) != dist(c[3], c[0]))
continue;
vector<int> a1, a2;
for (int i = 0; i < int(int((a).size())); ++i)
if (mask & (1 << i))
a1.push_back(i);
else
a2.push_back(i);
puts("YES");
for (int i = 0; i < int(int((a1).size())); ++i)
cout << a1[i] + 1 << " ";
puts("");
for (int i = 0; i < int(int((a2).size())); ++i)
cout << a2[i] + 1 << " ";
return 0;
} while (next_permutation((c).begin(), (c).end()));
} while (next_permutation((b).begin(), (b).end()));
}
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double const PI =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117;
long n;
cin >> n;
long double Px, Py;
cin >> Px >> Py;
long double closest_dist = 1000000000000000000, longest_dist = 0;
long double inputX, inputY, first_X, first_Y, lastX, lastY;
cin >> inputX >> inputY;
first_X = inputX;
first_Y = inputY;
lastX = inputX;
lastY = inputY;
long double dist =
(inputX - Px) * (inputX - Px) + (inputY - Py) * (inputY - Py);
closest_dist = min(closest_dist, dist);
longest_dist = max(longest_dist, dist);
for (long i = 0; i < n - 1; i++) {
cin >> inputX >> inputY;
dist = (inputX - Px) * (inputX - Px) + (inputY - Py) * (inputY - Py);
if (lastX != inputX and lastY != inputY) {
long double k = (lastY - inputY) / (long double)(lastX - inputX);
long double k2 = -1 / k;
long double U = (Py - (k2 * Px) - inputY + k * inputX) / (k - k2);
if ((lastX >= U and inputX <= U) or (lastX <= U and inputX >= U)) {
long double T = Py + k2 * (U - Px);
closest_dist =
min(closest_dist, ((Px - U) * (Px - U) + (Py - T) * (Py - T)));
}
} else {
if (lastX == inputX) {
if ((lastY >= Py and inputY <= Py) or (lastY <= Py and inputY >= Py)) {
closest_dist = min(closest_dist, (inputX - Px) * (inputX - Px));
}
} else {
if ((lastX >= Px and inputX <= Px) or (lastX <= Px and inputX >= Px)) {
closest_dist = min(closest_dist, (inputY - Py) * (inputY - Py));
}
}
}
lastX = inputX;
lastY = inputY;
closest_dist = min(closest_dist, dist);
longest_dist = max(longest_dist, dist);
}
inputX = first_X;
inputY = first_Y;
dist = (inputX - Px) * (inputX - Px) + (inputY - Py) * (inputY - Py);
if (lastX != inputX and lastY != inputY) {
long double k = (lastY - inputY) / (long double)(lastX - inputX);
long double k2 = -1 / k;
long double U = (Py - (k2 * Px) - inputY + k * inputX) / (k - k2);
if ((lastX >= U and inputX <= U) or (lastX <= U and inputX >= U)) {
long double T = Py + k2 * (U - Px);
closest_dist =
min(closest_dist, ((Px - U) * (Px - U) + (Py - T) * (Py - T)));
}
} else {
if (lastX == inputX) {
if ((lastY >= Py and inputY <= Py) or (lastY <= Py and inputY >= Py)) {
closest_dist = min(closest_dist, (inputX - Px) * (inputX - Px));
}
} else {
if ((lastX >= Px and inputX <= Px) or (lastX <= Px and inputX >= Px)) {
closest_dist = min(closest_dist, (inputY - Py) * (inputY - Py));
}
}
}
cout << setprecision(55) << PI * longest_dist - PI * closest_dist;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p;
int magic;
struct Boyer_Moore {
int id[8], cnt[8];
Boyer_Moore() {
for (int i = 0; i < 8; i++) id[i] = cnt[i] = 0;
}
};
void init(Boyer_Moore &a) {
for (int i = 0; i < 8; i++) a.id[i] = a.cnt[i] = 0;
}
Boyer_Moore merge(Boyer_Moore a, Boyer_Moore b) {
Boyer_Moore ret = a;
for (int i = 0; i < magic; i++) {
if (b.cnt[i] == 0) continue;
bool en = false;
for (int j = 0; j < magic; j++) {
if (ret.id[j] == b.id[i]) {
ret.cnt[j] += b.cnt[i];
en = true;
break;
}
}
if (en) continue;
bool big = true;
for (int j = 0; j < magic; j++) {
if (ret.cnt[j] < b.cnt[i]) big = false;
}
if (big) {
for (int j = 0; j < magic; j++) {
ret.cnt[j] -= b.cnt[i];
}
continue;
}
int mn = 1000000000;
for (int j = 0; j < magic; j++) {
mn = min(mn, ret.cnt[j]);
}
for (int j = 0; j < magic; j++) {
ret.cnt[j] -= mn;
}
for (int j = 0; j < magic; j++) {
if (ret.cnt[j] == 0) {
assert(b.cnt[i] - mn > 0);
ret.cnt[j] = b.cnt[i] - mn;
ret.id[j] = b.id[i];
break;
}
}
}
return ret;
}
Boyer_Moore seg[(1 << 19)], emp;
int flag[(1 << 19)];
void push(int k, int l, int r) {
flag[k * 2 + 1] = flag[k];
flag[k * 2 + 2] = flag[k];
init(seg[k * 2 + 1]);
seg[k * 2 + 1].id[0] = flag[k];
seg[k * 2 + 1].cnt[0] = (r - l + 1) / 2;
init(seg[k * 2 + 2]);
seg[k * 2 + 2].id[0] = flag[k];
seg[k * 2 + 2].cnt[0] = (r - l + 1) / 2;
flag[k] = 0;
}
Boyer_Moore update(int a, int b, int k, int l, int r, int x) {
if (r < a || b < l) return seg[k];
if (a <= l && r <= b) {
init(seg[k]);
seg[k].id[0] = x;
seg[k].cnt[0] = r - l + 1;
flag[k] = x;
return seg[k];
}
if (flag[k]) push(k, l, r);
return seg[k] = merge(update(a, b, k * 2 + 1, l, (l + r) / 2, x),
update(a, b, k * 2 + 2, (l + r) / 2 + 1, r, x));
}
Boyer_Moore query(int a, int b, int k, int l, int r) {
if (r < a || b < l) return emp;
if (a <= l && r <= b) {
return seg[k];
}
if (flag[k]) push(k, l, r);
return merge(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2 + 1, r));
}
int main() {
init(emp);
scanf("%d%d%d", &n, &m, &p);
magic = 100 / p;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
update(i, i, 0, 0, (1 << 18) - 1, a);
}
for (int i = 1; i <= m; i++) {
int a;
scanf("%d", &a);
if (a == 1) {
int l, r, id;
scanf("%d%d%d", &l, &r, &id);
update(l, r, 0, 0, (1 << 18) - 1, id);
} else {
int l, r;
scanf("%d%d", &l, &r);
Boyer_Moore ans = query(l, r, 0, 0, (1 << 18) - 1);
vector<int> vec;
for (int i = 0; i < magic; i++)
if (ans.id[i] > 0) vec.push_back(ans.id[i]);
{
printf("%d", vec.size());
for (int i = 0; i < vec.size(); i++) printf(" %d", vec[i]);
puts("");
}
}
}
}
| 12 |
#include <bits/stdc++.h>
using segment_t = std::pair<unsigned, unsigned>;
template <typename T, typename U>
std::istream& operator>>(std::istream& input, std::pair<T, U>& v) {
return input >> v.first >> v.second;
}
template <typename T>
std::istream& operator>>(std::istream& input, std::vector<T>& v) {
for (T& a : v) input >> a;
return input;
}
void answer(unsigned v) { std::cout << v << '\n'; }
void solve(std::vector<segment_t>& s) {
const size_t n = s.size();
segment_t t = {s[0].second, s[0].first};
for (size_t i = 1; i < n; ++i) {
t.first = std::min(t.first, s[i].second);
t.second = std::max(t.second, s[i].first);
}
answer(t.first < t.second ? t.second - t.first : 0);
}
void test_case() {
size_t n;
std::cin >> n;
std::vector<segment_t> s(n);
std::cin >> s;
solve(s);
}
int main() {
size_t t;
std::cin >> t;
while (t-- > 0) test_case();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
string s;
int main() {
cin >> s;
n = s.size();
for (int i = 1, l = 0; i <= n; i++) {
for (int j = 1; i - j - j >= l; j++) {
if (s[i - 1] == s[i - j - 1] && s[i - 1] == s[i - j - j - 1]) {
l = i - j - j;
}
}
ans += l;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p, n;
bool build(string& in, int i) {
bool gg = 0;
for (char v = in[i] + 1; v <= p; ++v) {
if ((i - 1 < 0 || in[i - 1] != v) && (i - 2 < 0 || in[i - 2] != v)) {
gg = true;
in[i] = v;
break;
}
}
if (gg) {
bool can = true;
for (int j = i + 1; j < n; ++j) {
can = false;
for (char v = 'a'; v <= p; ++v) {
if ((j - 1 < 0 || in[j - 1] != v) && (j - 2 < 0 || in[j - 2] != v)) {
can = true;
in[j] = v;
break;
}
}
if (!can) {
break;
}
if (j + 1 == n) {
cout << in << endl;
return 0;
}
}
if (can) {
cout << in << endl;
return 0;
}
}
return 1;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> n >> p;
p += 'a' - 1;
string in;
cin >> in;
for (int i = n; i-- > 0;) {
if (!build(in, i)) {
return 0;
}
}
cout << "NO" << endl;
}
| 4 |
// You're not going to master the rest of your life in one day.
// Just relax. Master the day.
// Then just keep doing that every day.
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
const double PI = 3.141592653589793238460;
const int mod = 1e9+7;
const int INF = (int)1e18;
void FAST(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve(){
int n;
cin >> n;
string s;
cin >> s;
set<char> st;
st.insert(s[0]);
for(int i = 1; i < n; i++){
if(s[i - 1] == s[i])
continue;
if(st.find(s[i]) != st.end()){
cout << "NO\n";
return;
}
st.insert(s[i]);
}
cout << "YES\n";
}
int32_t main(){
//Code goes past here:
FAST();
int t = 1;
cin >> t;
while(t--){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string toStr(long long a) {
ostringstream ss;
ss << a;
return ss.str();
}
bool restAre9(string& m, int i) {
while (i < int((m).size())) {
if (m[i++] != '9') {
return false;
}
}
return true;
}
int main(void) {
int i;
long long p, d, q;
string s, m, res = "";
cin >> p >> d;
q = p - d;
s = toStr(q);
m = toStr(p);
while (int((s).size()) != int((m).size())) {
s = '0' + s;
}
i = 0;
while (i < int((s).size()) && s[i] == m[i]) {
i++;
}
if (restAre9(m, i + 1)) {
cout << m << endl;
} else {
s[i] = ((char)(m[i] - 1));
i++;
while (i < int((s).size())) {
s[i++] = '9';
}
i = 0;
while (i < int((s).size()) && s[i] == '0') {
i++;
}
while (i < int((s).size())) {
res += s[i++];
}
cout << res << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, p[200009], b[200009], ans, u[200009], sum;
void dfs(int v) {
if (u[v] == 1) {
ans++;
return;
}
u[v] = 1;
dfs(p[v]);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
if (!u[p[i]]) {
dfs(p[i]);
}
}
if (ans == 1) ans = 0;
for (int i = 1; i <= n; i++) sum += b[i];
if (sum % 2 == 0) ans++;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long int INF = 9e18 + 2e17;
const int inf = 2e9;
const int N = 1e3 + 22;
const double eps = 1e-10;
const double PI = 3.14159265;
int n, a[305], m[305][305], vis[305], I = 0;
vector<int> g[305], ans[305];
char x;
void dfs(int v) {
vis[v] = 1;
ans[I].push_back(v);
for (auto u : g[v]) {
if (!vis[u]) dfs(u);
}
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cin >> x;
if (x == '1') g[i].push_back(j), g[j].push_back(i);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) I++, dfs(i);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= I; i++) {
sort(ans[i].begin(), ans[i].end());
vector<int> temp;
for (auto u : ans[i]) temp.push_back(a[u]);
sort((temp).begin(), (temp).end());
for (int j = 0; j < ans[i].size(); j++) a[ans[i][j]] = temp[j];
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> table;
vector<pair<int, int> > k;
vector<pair<int, int> > pos;
bool suit(pair<int, int> x, pair<int, int> y) {
if ((x.first - y.first + 12) % 4 == 2 && (x.second - y.second + 12) % 4 == 2)
return true;
if ((x.first - y.first + 12) % 4 == 0 && (x.second - y.second + 12) % 4 == 0)
return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
k.clear();
pos.clear();
table.clear();
for (long long i = 0; i < (8); i++) {
string x;
cin >> x;
for (long long j = 0; j < (8); j++) {
if (x[j] == 'K') {
k.push_back(make_pair(i, j));
pos.push_back(make_pair(i, j));
}
if (x[j] == '.') {
pos.push_back(make_pair(i, j));
}
}
table.push_back(x);
}
if ((k[0].first - k[1].first + 12) % 4 != 0 ||
(k[1].second - k[0].second + 12) % 4 != 0) {
cout << "NO" << endl;
continue;
}
bool flag = false;
for (long long i = 0; i < (pos.size()); i++) {
if (suit(k[0], pos[i]) && suit(k[1], pos[i])) {
flag = true;
cout << "YES" << endl;
break;
}
}
if (!flag) cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, a[5005], dp[5005][5005], last[15], last1[5005 * 20];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i <= n; i++) {
memset(last, 0, sizeof(last));
memset(last1, 0, sizeof(last1));
for (int j = 0; j < i; j++) {
last[a[j] % 7] = max(last[a[j] % 7], dp[i][j]);
last1[a[j]] = max(last1[a[j]], dp[i][j]);
}
for (int j = i + 1; j <= n; j++) {
dp[i][j] = max(dp[i][j], last[a[j] % 7] + 1);
dp[i][j] = max(dp[i][j], last1[a[j] + 1] + 1);
dp[i][j] = max(dp[i][j], last1[a[j] - 1] + 1);
dp[i][j] = max(dp[i][j], dp[i][0] + 1);
dp[j][i] = dp[i][j];
ans = max(ans, dp[i][j]);
last[a[j] % 7] = max(last[a[j] % 7], dp[i][j]);
last1[a[j]] = max(last1[a[j]], dp[i][j]);
}
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const bool testcases = false;
int64_t seed;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int64_t rnd(int64_t l = 0, int64_t r = INT_MAX) {
return uniform_int_distribution<int64_t>(l, r)(rng);
}
inline bool in_range(int64_t a, int64_t l, int64_t r) {
return (a >= l && a <= r);
}
template <typename H, typename... T>
void inp(H &head) {
cin >> head;
}
template <typename H, typename... T>
void inp(H &head, T &...tail) {
cin >> head;
inp(tail...);
}
template <typename T>
bool isPrime(T n) {
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return n >= 2;
}
template <typename T>
inline istream &operator>>(istream &in, vector<T> &a) {
for (T &x : a) in >> x;
return in;
}
template <typename T, typename U>
inline istream &operator>>(istream &in, pair<T, U> &a) {
in >> a.first >> a.second;
return in;
}
void solve();
void fast_io();
int32_t main(int32_t argc, char **argv) {
fast_io();
int64_t TC = 1;
if (testcases) cin >> TC;
for (int64_t tc = 1; tc <= TC; tc++) solve(), 108;
return 0;
}
set<int64_t> hc, vc;
multiset<int64_t> hl, vl;
void solve() {
char cut;
int64_t w, h, n, l, r, x, mxw, mxh;
cin >> w >> h >> n;
hc.insert({0, h});
vc.insert({0, w});
hl.insert(h);
vl.insert(w);
for (int64_t i = 0; i < n; i++) {
cin >> cut >> x;
if (cut == 'H') {
auto it = hc.lower_bound(x);
r = *it;
it--;
l = *it;
hc.insert(x);
hl.erase(hl.find(r - l));
hl.insert({r - x, x - l});
} else {
auto it = vc.lower_bound(x);
r = *it;
it--;
l = *it;
vc.insert(x);
vl.erase(vl.find(r - l));
vl.insert({r - x, x - l});
}
mxw = *vl.rbegin();
mxh = *hl.rbegin();
cout << mxw * mxh << '\n';
}
}
void fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 2e6 + 5;
const int maxn = 2e6 + 100;
const int SIGMA_SIZE = 26;
const int MAXNODE = 1000005;
const int MAXS = 1e6 + 10;
struct ACautomata {
int ch[MAXNODE][SIGMA_SIZE];
int f[MAXNODE];
int deep[MAXNODE];
int sz;
void init() {
sz = 1;
memset(ch[0], 0, sizeof(ch[0]));
}
inline int idx(char c) { return c - 'a'; }
void insert(char *s) {
int u = 0, n = strlen(s), dlen = 0;
for (int i = 0; i < n; i++) {
int c = idx(s[i]);
dlen++;
if (!ch[u][c]) {
memset(ch[sz], 0, sizeof(ch[sz]));
deep[sz] = dlen;
f[sz] = 0;
ch[u][c] = sz++;
}
u = ch[u][c];
}
}
void getFail() {
queue<int> q;
f[0] = 0;
for (int c = 0; c < SIGMA_SIZE; c++) {
int u = ch[0][c];
if (u) {
f[u] = 0;
q.push(u);
}
}
while (!q.empty()) {
int r = q.front();
q.pop();
for (int c = 0; c < SIGMA_SIZE; c++) {
int u = ch[r][c];
if (!u) {
ch[r][c] = ch[f[r]][c];
continue;
}
q.push(u);
f[u] = ch[f[r]][c];
}
}
}
long long dp[2][MAXS];
bool vis[MAXS];
class Edge {
public:
int v, nxt;
};
Edge edge[MAXS << 2];
int tot;
int head[MAXS];
void add(int u, int v) {
edge[tot].nxt = head[u];
edge[tot].v = v;
head[u] = tot;
tot++;
}
void build_tree() {
for (int i = 0; i <= sz; i++) {
vis[i] = 0;
head[i] = -1;
}
tot = 0;
for (int i = 1; i < sz; i++) {
int fa = f[i];
if ((deep[fa] == deep[i] - 1) && deep[fa] != 0) {
add(fa, i);
add(i, fa);
}
}
}
void dfs(int u, int pre) {
if (vis[u]) return;
vis[u] = 1;
dp[1][u] = 1;
dp[0][u] = 0;
long long sum = 0;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
if (v == pre) continue;
dfs(v, u);
dp[1][u] += dp[0][v];
dp[0][u] += max(dp[0][v], dp[1][v]);
}
}
void solve() {
long long ans = 0;
for (int i = 1; i < sz; i++) {
if (!vis[i]) {
dfs(i, -1);
ans += max(dp[0][i], dp[1][i]);
}
}
printf("%lld\n", ans);
}
} ac;
char s[MAXN];
int main() {
int n;
int T;
cin >> T;
while (T--) {
scanf("%d", &n);
ac.init();
for (int i = 1; i <= n; i++) {
scanf("%s", s);
ac.insert(s);
}
ac.getFail();
ac.build_tree();
ac.solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = (1 << 16) + 5;
int n, m, two[N], cnt[M], x, y, a[N], b[N], p[N];
long long f[M][N], k;
void dp(int x) {
for (int i = 0; i <= two[n] - 1; i++)
for (int j = 0; j <= n; j++) f[i][j] = 0;
f[0][0] = 1;
for (int i = 0; i <= two[n] - 1; i++) {
for (int j = 0; j <= n; j++) {
int y = cnt[i] + 1;
if (b[y]) {
if ((a[b[y]] & i) != a[b[y]]) continue;
if ((two[b[y] - 1] & i) == two[b[y] - 1]) continue;
f[i | two[b[y] - 1]][j | ((b[y] == x) * y)] += f[i][j];
continue;
} else {
for (int k = 1; k <= n; k++)
if (!(two[k - 1] & i)) {
if ((a[k] & i) != a[k]) continue;
f[i | two[k - 1]][j | ((k == x) * y)] += f[i][j];
}
}
}
}
}
int main() {
scanf("%d%lld%d", &n, &k, &m);
k -= 2000;
two[0] = 1;
for (int i = 1; i <= n; i++) two[i] = two[i - 1] << 1;
for (int i = 0; i <= two[n] - 1; i++)
for (int j = 1; j <= n; j++)
if (i & two[j - 1]) cnt[i]++;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
a[y] |= two[x - 1];
}
for (int i = 1; i <= n; i++) {
dp(i);
long long sum = 0;
for (int j = 1; j <= n; j++) {
if (!b[j] && sum + f[two[n] - 1][j] >= k) {
b[j] = i;
p[i] = j;
k -= sum;
break;
}
sum += f[two[n] - 1][j];
}
if (!p[i]) {
printf("The times have changed\n");
return 0;
}
}
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, u, sol, d;
int f[1000010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
if (x == 1)
++u;
else
++d;
}
f[0] = 1;
f[1] = 1;
for (int i = 2; i <= u; ++i)
f[i] = (1LL * (i - 1) * f[i - 2] + f[i - 1]) % 1000000007;
sol = f[u];
for (int i = n; i > n - d; --i) sol = (1LL * sol * i) % 1000000007;
printf("%d\n", sol);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ar[300005], tr[700005], mn[300005], mx[300005], ps[300005];
long long val(long long a) {
long long ret = 0;
while (a) {
ret += tr[a];
a -= a & -a;
}
return ret;
}
void upd(long long a, long long x) {
while (a <= n + m) {
tr[a] += x;
a += a & -a;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) mn[i] = mx[i] = i, upd(m + i, 1), ps[i] = m + i;
for (int i = 1; i <= m; i++) {
long long a;
cin >> a;
mx[a] = max(mx[a], val(ps[a])), mn[a] = 1;
upd(ps[a], -1), ps[a] = m + 1 - i, upd(ps[a], 1);
}
for (int i = 1; i <= n; i++) mx[i] = max(mx[i], val(ps[i]));
for (int i = 1; i <= n; i++) cout << mn[i] << " " << mx[i] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
int a[200005] = {0}, b[200005] = {0};
int main() {
long long sum = 0;
int n, k, j;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
for (int i = 2; i <= n; i++) {
sum += abs(b[i] - b[i - 1]);
}
printf("%lld\n", sum);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
struct Edge {
int to, next;
} edge[N * 2];
int head[N], tot;
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v) {
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
int vis[N];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
init();
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
memset(vis, 0, sizeof(vis));
queue<int> q;
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = head[i]; j != -1; j = edge[j].next) {
int v = edge[j].to;
if (vis[v] == vis[i]) cnt++;
}
if (cnt > 1) q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
int cnt = 0;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (vis[u] == vis[v]) cnt++;
}
if (cnt > 1) {
vis[u] ^= 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int x = edge[i].to, cnt = 0;
for (int j = head[x]; j != -1; j = edge[j].next) {
int v = edge[j].to;
if (vis[x] == vis[v]) cnt++;
}
if (cnt > 1) q.push(x);
}
}
}
for (int i = 1; i <= n; i++) printf("%d", vis[i]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n;
char s[N], t[N];
int a[N];
int main() {
scanf("%d%s", &n, t + 1);
for (int i = 1; i <= n; ++i) {
if (t[i] == '(')
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1] - 1;
}
if (a[n] == 2) {
for (int i = 1; i <= n; ++i) {
s[i] = t[i];
}
}
if (a[n] == -2) {
for (int i = 1; i <= n; ++i) {
if (t[n - i + 1] == '(')
s[i] = ')';
else
s[i] = '(';
if (s[i] == '(')
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1] - 1;
}
}
int res = 0;
if (a[n] == 2) {
int w = 0;
bool ok = true;
for (int i = n; i >= 1; --i) {
if (a[i] < 0) {
ok = false;
break;
}
if (a[i] == 1 && w == 0) w = i;
}
if (ok) {
for (int i = w + 1; i <= n; ++i) {
if (s[i] == '(') res++;
}
}
}
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int mins = 0;
while (a > 0 && b > 0) {
if (a < b) {
a += 1;
if (b < 2) break;
b -= 2;
} else {
if (a < 2) break;
a -= 2;
b += 1;
}
mins += 1;
}
cout << mins << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans[10005];
bool f(int x) {
int flag = 0;
while (x) {
flag += x % 10;
x /= 10;
}
return flag == 10;
}
void init() {
int cnt = 1;
int pos = 19;
while (1) {
if (f(pos)) ans[cnt++] = pos;
pos++;
if (cnt > 10000) break;
}
}
int main() {
ios::sync_with_stdio(false);
init();
int k;
cin >> k;
cout << ans[k] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int primes[] = {2, 3, 5, 7, 11};
int n;
vector<int> ans = {1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0;; ++i) {
for (int j = 0; j < ans.size(); ++j) {
if (ans[j] * primes[i] <= 2 * n * n) {
ans.push_back(ans[j] * primes[i]);
}
}
if (ans.size() >= n) break;
}
for (int i = 0; i < n; ++i) cout << ans[ans.size() - i - 1] << " ";
puts("");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y;
int n;
double a, b, c, mi = 10000000, num;
cin >> x >> y;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
num = sqrt(pow(x - a, 2) + pow(y - b, 2)) / c;
if (num < mi) mi = num;
}
printf("%.20lf", mi);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int a[maxn];
long long dp[maxn][20], ans;
char c[maxn];
int Laxt[maxn];
int id(char s) {
if (s == 'h') return 0;
if (s == 'a') return 1;
if (s == 'r') return 2;
if (s == 'd') return 3;
return -1;
}
void ADD(long long &x, long long y) {
if (y == -1) return;
if (x == -1)
x = y;
else
x = min(x, y);
}
int main() {
int N;
scanf("%d%s", &N, c + 1);
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= N; i++) scanf("%d", &a[i]);
dp[0][0] = 0;
for (int i = 1; i <= N; i++) {
int p = id(c[i]), pre = 0, now;
if (p == -1) {
for (int j = 0; j <= (1 << 4) - 1; j++) {
if (dp[i - 1][j] != -1) ADD(dp[i][j], dp[i - 1][j]);
}
continue;
}
for (int j = 0; j <= p - 1; j++) pre += (1 << j);
now = pre + (1 << p);
ADD(dp[i][pre], dp[i - 1][pre] + a[i]);
ADD(dp[i][now], dp[i - 1][pre]);
for (int j = 0; j <= (1 << 4) - 1; j++) {
if (j == pre) continue;
ADD(dp[i][j], dp[i - 1][j]);
}
}
ans = 1LL << 60;
for (int i = 0; i <= (1 << 4) - 2; i++)
if (dp[N][i] != -1) ans = min(ans, dp[N][i]);
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans;
char s[100];
set<char> X;
int n;
inline void work(char a1, char a0) {
X.clear();
int now = n - 1;
char nowc = a0;
if (s[now] >= '0' && s[now] <= '9') {
if (s[now] != nowc) return;
}
if (s[now] == 'X') X.insert(nowc);
--now;
nowc = a1;
if (s[now] >= '0' && s[now] <= '9') {
if (s[now] != nowc) return;
}
if (s[now] == 'X') X.insert(nowc);
if (s[0] == '0') return;
if (X.size() > 1) return;
if (s[0] == 'X') {
if (!X.empty() && *X.begin() == '0') return;
}
int sum = 1, cz = 0;
for (int i = 0; i < now; ++i) {
if (s[i] == '_') sum *= (i == 0 ? 9 : 10);
if (s[i] == 'X') cz = 1;
}
if (cz && X.empty()) {
if (s[0] == 'X')
sum *= 9;
else
sum *= 10;
}
ans += sum;
}
int main() {
scanf("%s", s);
n = strlen(s);
if (n == 1) {
if (s[0] == '_' || s[0] == '0' || s[0] == 'X')
puts("1");
else
puts("0");
return 0;
}
ans = 0;
if (s[0] == '_') {
for (int i = 1; i <= 9; ++i) {
s[0] = i + '0';
work('0', '0');
work('2', '5');
work('5', '0');
work('7', '5');
}
} else {
work('0', '0');
work('2', '5');
work('5', '0');
work('7', '5');
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class X>
bool mini(X& a, const X& b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class X>
bool maxi(X& a, const X& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
typedef const int& ci;
long long k;
void enter() {}
long long mul(int l, int r) {
long long res = 1;
while (l <= r) res *= l++;
return res;
}
long long calc(vector<int> a) {
long long res = 1;
for (int i = 0, n = a.size(); i < n;) {
int j = i;
while (j < n && a[i] == a[j]) ++j;
res *= mul(n - j + 1 - max(a[i] - 1, 0), n - i - max(a[i] - 1, 0));
res /= mul(1, j - i);
i = j;
}
return --res;
}
void solve() {
int test;
for (cin >> test; test--;) {
cin >> k;
vector<int> a;
for (int i = 2; k; ++i) {
a.emplace_back(k % i);
k /= i;
}
sort(a.rbegin(), a.rend());
if (a.back()) {
cout << calc(a) << '\n';
continue;
}
cout << calc(a) - calc(vector<int>(a.begin(), a.end() - 1)) - 1 << '\n';
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
enter();
solve();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long int k;
cin >> k;
long long int n = s.size();
string ans(n, '1');
for (long long int i = 0; i < n; i++) {
if (s[i] == '0') {
if (i - k >= 0) ans[i - k] = '0';
if (i + k < n) ans[i + k] = '0';
}
}
long long int flag = 0;
for (long long int i = 0; i < n; i++) {
bool a = false;
if (s[i] == '1') {
if (i - k >= 0 and ans[i - k] == '1') a = true;
if (i + k < n and ans[i + k] == '1') a = true;
if (!a) {
flag = 1;
break;
}
}
}
if (flag == 1)
cout << -1 << endl;
else
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
const int maxn = 100005;
int n, m, a[maxn], deg[maxn << 2];
long long Pow[20], dis[maxn << 2], tag1[maxn << 2], tag2[maxn << 2];
int Log(long long x) { return lower_bound(Pow, Pow + 11, x) - Pow; }
void build(int s, int l, int r) {
if (l == r) return deg[s] = Log(a[l]), dis[s] = Pow[deg[s]] - a[l], void();
build((s << 1), l, ((l + r) >> 1));
build((s << 1 | 1), ((l + r) >> 1) + 1, r);
dis[s] = min(dis[(s << 1)], dis[(s << 1 | 1)]);
}
inline void cov(int s, long long v) {
tag2[s] = 0;
tag1[s] = v;
deg[s] = Log(v);
dis[s] = Pow[deg[s]] - v;
}
inline void add(int s, long long v) {
if (tag1[s])
tag1[s] += v;
else
tag2[s] += v;
dis[s] -= v;
}
void pushdown(int s) {
if (!tag1[s] && !tag2[s]) return;
if (tag1[s]) cov((s << 1), tag1[s]), cov((s << 1 | 1), tag1[s]), tag1[s] = 0;
if (tag2[s]) add((s << 1), tag2[s]), add((s << 1 | 1), tag2[s]), tag2[s] = 0;
}
void cover(int s, int l, int r, int ql, int qr, int w) {
if (ql <= l && r <= qr) return cov(s, w);
pushdown(s);
if (ql <= ((l + r) >> 1)) cover((s << 1), l, ((l + r) >> 1), ql, qr, w);
if (qr >= ((l + r) >> 1) + 1)
cover((s << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, w);
dis[s] = min(dis[(s << 1)], dis[(s << 1 | 1)]);
}
void insert(int s, int l, int r, int ql, int qr, int w) {
if (ql <= l && r <= qr) return add(s, w);
pushdown(s);
if (ql <= ((l + r) >> 1)) insert((s << 1), l, ((l + r) >> 1), ql, qr, w);
if (qr >= ((l + r) >> 1) + 1)
insert((s << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, w);
dis[s] = min(dis[(s << 1)], dis[(s << 1 | 1)]);
}
long long query(int s, int l, int r, int p) {
if (l == r) return Pow[deg[s]] - dis[s];
pushdown(s);
if (p <= ((l + r) >> 1))
return query((s << 1), l, ((l + r) >> 1), p);
else
return query((s << 1 | 1), ((l + r) >> 1) + 1, r, p);
}
int query(int s, int l, int r) {
if (dis[s] >= 0) return dis[s];
if (l == r) {
long long x = Pow[deg[s]] - dis[s];
deg[s] = Log(x);
dis[s] = Pow[deg[s]] - x;
return dis[s];
}
pushdown(s);
query((s << 1), l, ((l + r) >> 1));
query((s << 1 | 1), ((l + r) >> 1) + 1, r);
return dis[s] = min(dis[(s << 1)], dis[(s << 1 | 1)]);
}
int main() {
double p = 1;
for (int i = 0; p * 42 <= 1e18; p *= 42, ++i) Pow[i] = p;
n = gi();
m = gi();
for (int i = 1; i <= n; ++i) a[i] = gi();
build(1, 1, n);
for (int op, x, y, a, i = 1; i <= m; ++i) {
op = gi();
if (op == 1)
printf("%lld\n", query(1, 1, n, gi()));
else if (op == 2)
x = gi(), y = gi(), cover(1, 1, n, x, y, gi());
else {
x = gi();
y = gi();
a = gi();
do insert(1, 1, n, x, y, a);
while (!query(1, 1, n));
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int N, M;
int dist[3010][3010];
vector<int> adj[3010];
vector<pair<int, int>> to[3010];
vector<pair<int, int>> from[3010];
int vis[3010];
void bfs(int u) {
for (int(i) = 0; (i) < (N); (i)++) vis[i] = 0;
for (int(i) = 0; (i) < (N); (i)++) dist[u][i] = INF;
dist[u][u] = 0;
deque<int> q;
q.push_back(u);
while (int((q).size()) > 0) {
int v = q.front();
q.pop_front();
if (vis[v]) continue;
vis[v] = 1;
for (int(i) = 0; (i) < (int((adj[v]).size())); (i)++) {
int t = adj[v][i];
if (dist[u][t] > dist[u][v] + 1) {
dist[u][t] = dist[u][v] + 1;
q.push_back(t);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> N >> M;
for (int(i) = 0; (i) < (M); (i)++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
}
for (int(i) = 0; (i) < (N); (i)++) {
sort(adj[i].begin(), adj[i].end());
adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());
}
for (int(i) = 0; (i) < (N); (i)++) {
bfs(i);
}
for (int(i) = 0; (i) < (N); (i)++) {
for (int(j) = 0; (j) < (N); (j)++) {
if (dist[j][i] < INF) {
to[i].push_back(make_pair(dist[j][i], j));
}
if (dist[i][j] < INF) {
from[i].push_back(make_pair(dist[i][j], j));
}
}
sort(to[i].begin(), to[i].end());
sort(from[i].begin(), from[i].end());
}
vector<int> ans;
int max = 0;
for (int(i) = 0; (i) < (N); (i)++) {
for (int(j) = 0; (j) < (N); (j)++) {
if (i == j) continue;
if (dist[i][j] >= INF) continue;
int s1 = int((to[i]).size());
int s2 = int((from[j]).size());
vector<int> vertices;
for (int k1 = s1 - 3; k1 < s1; k1++) {
if (k1 < 0) continue;
for (int k2 = s2 - 3; k2 < s2; k2++) {
if (k2 < 0) continue;
int a = to[i][k1].second;
int b = from[j][k2].second;
int m = dist[a][i] + dist[i][j] + dist[j][b];
if (m <= max) continue;
vertices.clear();
vertices.push_back(i);
vertices.push_back(j);
vertices.push_back(a);
vertices.push_back(b);
sort(vertices.begin(), vertices.end());
int good = 1;
for (int(index) = 0; (index) < (int((vertices).size())); (index)++)
if (index + 1 < int((vertices).size()))
good &= vertices[index] != vertices[index + 1];
if (good) {
ans.clear();
ans.push_back(a);
ans.push_back(i);
ans.push_back(j);
ans.push_back(b);
max = m;
}
}
}
}
}
for (int(i) = 0; (i) < (int((ans).size())); (i)++) {
cout << ans[i] + 1 << " ";
}
cout << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t;
char x[100];
int num;
int a[100], b[100];
int d[100];
void work() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(d, 0, sizeof(d));
int i, j;
num = 0;
for (i = 1; i <= 12; i++)
if (x[i] == 'X') {
num += 1;
a[num] = 1;
b[num] = 12;
break;
}
for (i = 1; i <= 6; i++)
if (x[i] == 'X' && x[i + 6] == 'X') {
num += 1;
a[num] = 2;
b[num] = 6;
break;
}
for (i = 1; i <= 4; i++)
if (x[i] == 'X' && x[i + 4] == 'X' && x[i + 8] == 'X') {
num += 1;
a[num] = 3;
b[num] = 4;
break;
}
for (i = 1; i <= 3; i++)
if (x[i] == 'X' && x[i + 3] == 'X' && x[i + 6] == 'X' && x[i + 9] == 'X') {
num += 1;
a[num] = 4;
b[num] = 3;
break;
}
for (i = 1; i <= 2; i++)
if (x[i] == 'X' && x[i + 2] == 'X' && x[i + 4] == 'X' && x[i + 6] == 'X' &&
x[i + 8] == 'X' && x[i + 10] == 'X') {
num += 1;
a[num] = 6;
b[num] = 2;
break;
}
int dp = 1;
for (i = 1; i <= 12; i++) {
if (x[i] != 'X') {
dp = 0;
break;
}
}
if (dp) {
num += 1;
a[num] = 12;
b[num] = 1;
}
cout << num << " ";
if (num > 0) {
for (i = 1; i <= num; i++) {
cout << a[i] << "x" << b[i] << " ";
}
}
cout << endl;
return;
}
int main() {
cin >> t;
for (int j = 1; j <= t; j++) {
for (int i = 1; i <= 12; i++) {
cin >> x[i];
}
work();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int l, n, p, t;
int L[N], R[N];
int f[N], g[N];
int head = 0;
int main() {
scanf("%d%d%d%d", &l, &n, &p, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &L[i], &R[i]);
g[0] = -t;
int x, y, z;
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1], g[i] = g[i - 1];
while (head < i && g[head] + t <= R[i]) {
x = max(g[head] + t, L[i]);
y = f[head] + (R[i] - x) / p;
z = R[i] - (R[i] - x) % p;
if (y > f[i] || (y == f[i] && z < g[i])) f[i] = y, g[i] = z;
head++;
}
head--;
}
printf("%d\n", f[n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 1e5, _ = 26;
typedef int fuko[yuzu | 10];
char s[yuzu | 10];
int n = read(), q = read();
struct segtree {
struct node {
int d[_], cnt;
bool sort, inc;
void insert(int k) {
memset(d, 0, sizeof d);
cnt = d[k] = 1, sort = 0;
}
void bring(bool from, int sum) {
cnt = sum;
int i;
if (from) {
for (i = 0; i < _; ++i) {
sum >= d[i] ? sum -= d[i] : (d[i] = sum, sum = 0);
}
} else {
for (i = _ - 1; ~i; --i) {
sum >= d[i] ? sum -= d[i] : (d[i] = sum, sum = 0);
}
}
}
void reng(bool from, int sum) {
cnt -= sum;
int i;
if (from) {
for (i = 0; i < _; ++i) {
sum >= d[i] ? (sum -= d[i], d[i] = 0) : (d[i] -= sum, sum = 0);
}
} else {
for (i = _ - 1; ~i; --i) {
sum >= d[i] ? (sum -= d[i], d[i] = 0) : (d[i] -= sum, sum = 0);
}
}
}
node operator+(const node &b) const {
node ans;
ans.sort = 0;
for (int i = 0; i < _; ++i) ans.d[i] = d[i] + b.d[i];
ans.cnt = cnt + b.cnt;
return ans;
}
void yuri() {
printf("cnt=%d\n", cnt);
for (int i = 0; i < _; ++i) {
if (d[i]) printf("d[%d]=%d\n", i, d[i]);
}
}
} tr[yuzu << 2 | 13];
void push_down(int rt) {
node &l = tr[rt << 1], &r = tr[rt << 1 | 1];
if (tr[rt].sort) {
int now = l.cnt;
l = tr[rt], l.bring(tr[rt].inc, now);
now = r.cnt;
r = tr[rt], r.bring(!tr[rt].inc, now);
tr[rt].sort = 0;
}
}
void build(int rt = 1, int l = 1, int r = n) {
if (l == r) return tr[rt].insert(s[l] - 'a');
int mid = l + r >> 1;
build(rt << 1, l, mid), build(rt << 1 | 1, mid + 1, r);
tr[rt] = tr[rt << 1] + tr[rt << 1 | 1];
}
node query(int ql, int qr, int rt = 1, int l = 1, int r = n) {
if (ql > r || qr < l) return node{{0}, 0, 0, 0};
if (ql <= l && qr >= r) return tr[rt];
push_down(rt);
int mid = l + r >> 1;
return query(ql, qr, rt << 1, l, mid) +
query(ql, qr, rt << 1 | 1, mid + 1, r);
}
node sum;
void update(int ql, int qr, int rt = 1, int l = 1, int r = n) {
if (ql > r || qr < l) return;
if (ql <= l && qr >= r) {
int now = tr[rt].cnt;
tr[rt] = sum;
tr[rt].bring(sum.inc, now);
sum.reng(sum.inc, now);
} else {
int mid = l + r >> 1;
update(ql, qr, rt << 1, l, mid), update(ql, qr, rt << 1 | 1, mid + 1, r);
tr[rt] = tr[rt << 1] + tr[rt << 1 | 1];
}
}
void sortit(int l, int r, int inc) {
sum = query(l, r), sum.sort = 1, sum.inc = inc;
update(l, r);
}
void boom(int rt = 1, int l = 1, int r = n) {
if (l == r) {
for (int i = 0; i < _; ++i) {
if (tr[rt].d[i]) {
s[l] = i + 'a';
break;
}
}
} else {
int mid = l + r >> 1;
push_down(rt);
boom(rt << 1, l, mid), boom(rt << 1 | 1, mid + 1, r);
}
}
void dfs(int rt = 1, int l = 1, int r = n) {
printf("#%d %d %d ", rt, l, r);
tr[rt].yuri();
int mid = l + r >> 1;
if (l ^ r) dfs(rt << 1, l, mid), dfs(rt << 1 | 1, mid + 1, r);
}
} my_;
int main() {
scanf("%s", s + 1);
my_.build();
for (; q--;) {
int l = read(), r = read();
my_.sortit(l, r, read());
}
my_.boom();
puts(s + 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int A[N][N], B[N][N];
int lx[N], ly[N], p[N], slack[N], linky[N];
bool visy[N];
int n;
int G[N][N];
int ans;
void bfs(int u) {
int x, v = 0, vl = 0, mmin;
for (int i = 1; i <= n; i++) {
p[i] = 0;
slack[i] = 0x7f7f7f7f;
}
linky[v] = u;
do {
x = linky[v], mmin = 0x7f7f7f7f, visy[v] = 1;
for (int y = 1; y <= n; y++) {
if (!visy[y]) {
if (slack[y] > lx[x] + ly[y] - G[x][y]) {
slack[y] = lx[x] + ly[y] - G[x][y];
p[y] = v;
}
if (slack[y] < mmin) {
mmin = slack[y];
vl = y;
}
}
}
for (int y = 0; y <= n; y++) {
if (visy[y]) {
lx[linky[y]] -= mmin;
ly[y] += mmin;
} else {
slack[y] -= mmin;
}
}
v = vl;
} while (linky[v]);
while (v) {
linky[v] = linky[p[v]];
v = p[v];
}
}
int KM(int s) {
for (int i = 1; i <= n; i++) {
memset(visy, 0, sizeof(visy));
for (int j = 1; j <= n; j++) {
G[i][j] = ((1 << i - 1) & s) ? A[i][j] : B[i][j];
}
bfs(i);
}
int res = 0;
for (int y = 1; y <= n; y++) {
res += G[linky[y]][y];
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> A[i][j];
A[i][0] = max(A[i][0], A[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> B[i][j];
B[i][0] = max(B[i][0], B[i][j]);
}
}
int S = (1 << n) - 1;
for (int s = 0; s <= S; s++) {
if (__builtin_popcount(s) != n / 2) {
continue;
}
for (int i = 1; i <= n; i++) {
lx[i] = ((1 << (i - 1)) & s) ? A[i][0] : B[i][0];
ly[i] = visy[i] = linky[i] = 0;
}
ans = max(ans, KM(s));
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &F) {
F = 0;
int R = 1;
char CH = getchar();
for (; !isdigit(CH); CH = getchar())
if (CH == '-') R = -1;
for (; isdigit(CH); CH = getchar()) F = F * 10 + CH - 48;
F *= R;
}
const int N = 1000005;
int n, a[N], pre[N][2];
int main() {
int n;
string st;
cin >> n >> st;
for (int i = 0; i < st.size(); i++) {
pre[i + 1][0] = pre[i][0], pre[i + 1][1] = pre[i][1];
if (st[i] == '?') continue;
pre[i + 1][st[i] & 1 ^ 1] = i + 1;
}
for (int len = 1; len <= n; len++) {
int pos = 0, ans = 0;
while (pos + len <= n) {
if (pre[pos + len][0] == pre[pos][0] || pre[pos + len][1] == pre[pos][1])
pos += len, ans++;
else
pos = pre[pos + len][pre[pos + len][1] < pre[pos + len][0]];
}
printf("%d ", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int k;
int n;
vector<int> v;
int read() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
v.push_back(t);
}
sort(v.begin(), v.end());
printf("%d", v[n - k]);
return 0;
}
int process() { return 0; }
int main() {
read();
process();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10, mod = 998244353;
using ordered_set = struct BIT {
int n;
vector<int> bit;
BIT(int n) : n(n), bit(n + 1, 0) {}
int read(int idx) {
idx--;
int res = 0;
while (idx > 0) {
res += bit[idx];
idx -= idx & -idx;
}
return res;
}
void update(int idx, int val) {
while (idx <= n) {
bit[idx] += val;
idx += idx & -idx;
}
}
void insert(int p) {
if (read(p) == read(p + 1)) {
update(p, 1);
}
}
void erase(int p) {
if (read(p) < read(p + 1)) {
update(p, -1);
}
}
int order_of_key(int v) { return read(v); }
int find(int v) { return read(v + 1) - read(v); }
int size() { return read(n + 1); }
};
long long perm_rank(int *p, int n);
long long der_rank(int *p, int *q, int n);
long long pwr(long long x, long long e);
int p[N][N];
long long fact[N], f[N][N], d[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> p[i][j];
}
}
fact[0] = 1;
for (int i = 1; i <= n; ++i) {
fact[i] = (i * fact[i - 1]) % mod;
}
for (int i = 0; i <= n; ++i) {
f[i][0] = fact[i];
for (int j = 1; j <= i; ++j) {
f[i][j] = (j - 1) * f[i - 1][j - 2] + (i - j) * f[i - 1][j - 1];
f[i][j] %= mod;
}
d[i] = f[i][i];
}
long long ans = perm_rank(p[1], n) * pwr(d[n], n - 1);
ans %= mod;
for (int i = 1; i < n; ++i) {
ans += der_rank(p[i], p[i + 1], n) * pwr(d[n], n - i - 1);
ans %= mod;
}
cout << ans << endl;
}
long long perm_rank(int *p, int n) {
ordered_set s(n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
s.insert(p[i]);
long long temp = (p[i] - 1) - s.order_of_key(p[i]);
ans += temp * fact[n - i];
ans %= mod;
}
return ans;
}
long long der_rank(int *p, int *q, int n) {
ordered_set s(n), t(n);
for (int i = 1; i <= n; ++i) {
t.insert(i);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
s.insert(q[i]);
long long tot = (q[i] - 1) - s.order_of_key(q[i]);
if (p[i] < q[i] and !s.find(p[i])) {
--tot;
}
t.erase(p[i]);
long long c1 = t.order_of_key(q[i]);
ans += c1 * f[n - i][t.size() - 1];
ans += (tot - c1) * f[n - i][t.size()];
ans %= mod;
t.erase(q[i]);
}
return ans;
}
long long pwr(long long x, long long e) {
long long res = 1;
while (e) {
if (e & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
e /= 2;
}
return res;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
set<int> remaining;
set<pair<int, int>> edges;
int size = 0;
void dfs(int k) {
size++;
vector<int> temp;
for (auto it : remaining) {
if (it > k && edges.find(make_pair(k, it)) == edges.end()) {
temp.push_back(it);
} else if (it < k && edges.find(make_pair(it, k)) == edges.end()) {
temp.push_back(it);
}
}
for (auto it : temp) remaining.erase(it);
for (auto it : temp) dfs(it);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> sizes;
for (int i = 1; i <= n; i++) remaining.insert(i);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
edges.insert(make_pair(x, y));
}
for (int i = 1; i <= n; i++) {
if (remaining.find(i) != remaining.end()) {
remaining.erase(i);
size = 0;
dfs(i);
sizes.push_back(size);
}
}
sort(sizes.begin(), sizes.end());
cout << sizes.size() << "\n";
for (auto it : sizes) cout << it << " ";
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long a[n], count[101] = {0};
for (long long i = 1; i <= n; i++) {
cin >> a[i];
count[a[i]]++;
}
long long ans = 0;
for (long long i = 1; i <= 100; i++) {
ans += (count[i] / 2);
}
cout << ans / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100009;
int vis[N], n, m, flag, s;
vector<pair<int, int> > E[N];
void dfs(int x, int k) {
vis[x] = k;
--s;
for (auto &i : E[x]) {
if (!~vis[i.first]) {
dfs(i.first, k ^ i.second);
} else {
if ((vis[x] ^ vis[i.first]) != i.second) {
flag = 1;
return;
}
}
if (flag) return;
}
}
int main() {
memset(vis, -1, sizeof vis);
ios::sync_with_stdio(0);
cin >> n >> m;
s = n;
for (int i = 1, u, v, c; i <= m; ++i) {
cin >> u >> v >> c;
E[u].push_back(make_pair(v, c ^ 1));
E[v].push_back(make_pair(u, c ^ 1));
}
for (int i = 1; i <= n; ++i) {
if (!~vis[i] && !E[i].empty()) {
++s;
dfs(i, 1);
}
if (flag) {
cout << 0 << endl;
return 0;
}
}
long long ans = 1, p = 2;
--s;
while (s > 0) {
if (s & 1) ans = ans * p % 1000000007;
p = (p * p) % 1000000007;
s >>= 1;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a;
cin >> n;
if (n < 10)
a = 1 * (n + 1) - 1;
else if (n < 100)
a = a = 2 * (n + 1) - 11;
else if (n < 1000)
a = 3 * (n + 1) - 111;
else if (n < 10000)
a = 4 * (n + 1) - 1111;
else if (n < 100000)
a = 5 * (n + 1) - 11111;
else if (n < 1000000)
a = 6 * (n + 1) - 111111;
else if (n < 10000000)
a = 7 * (n + 1) - 1111111;
else if (n < 100000000)
a = 8 * (n + 1) - 11111111;
else if (n < 1000000000)
a = 9 * (n + 1) - 111111111;
else if (n < 1000000000)
a = 10 * (n + 1) - 1111111111;
else if (n == 1000000000)
a = 8888888899;
cout << a << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int logN = 17;
const int inf = 1e9;
const int N = 1e6 + 5;
int l[N], n, m, mod, dp[5005][5005], P[N], C[N];
vector<int> all[N];
int f(int l, int k) {
if (!l) return k == 0;
if (!k) return 0;
int &r = dp[l][k];
if (r != -1) return r;
return r = (f(l - 1, k - 1) + f(l - 1, k) * (long long)(k - 1) % mod) % mod;
}
int main() {
scanf("%d %d %d", &n, &m, &mod);
all[0].resize(1, 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &l[i]);
all[i].resize(max(l[i], l[i - 1]) + 1, 0);
}
memset(dp, -1, sizeof dp);
P[0] = 1;
for (int i = 1; i <= m; i++) P[i] = P[i - 1] * (long long)i % mod;
C[0] = 1;
for (int i = 1; i <= m; i++) C[i] = C[i - 1] * (long long)(m - i + 1) % mod;
for (int i = 1; i <= n; i++) {
long long sum = 0;
for (int j = 0; j <= l[i - 1]; j++) sum = (sum + all[i - 1][j]) % mod;
for (int j = 1; j <= l[i]; j++) {
all[i][j] = sum * (long long)C[j] % mod * f(l[i], j) % mod;
if (l[i - 1] >= j) {
all[i][j] -= all[i - 1][j] * (long long)P[j] % mod * f(l[i], j) % mod;
all[i][j] = (all[i][j] + mod) % mod;
}
}
}
long long sum = 0;
for (int j = 0; j <= l[n]; j++) sum = (sum + all[n][j]) % mod;
printf("%lld\n", sum);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char ans[400][300];
int c;
char v[110];
int p;
void draw(int h);
int depthmax();
int main() {
int n;
cin >> n >> v;
int h(depthmax());
while (v[p] != 0) h = max(h, depthmax());
p = 0;
while (v[p] != 0) draw(h);
for (int i(200 - h - 1); i <= 200 + h + 1; i++)
for (int j(0); j < c; j++)
cout << (ans[i][j] ? ans[i][j] : ' ') << (j + 1 == c ? "\n" : "");
return 0;
}
void draw(int h) {
for (int i(0); i <= h; i++) ans[200 - i][c] = ans[200 + i][c] = '|';
ans[200 - h - 1][c] = ans[200 + h + 1][c] = '+';
ans[200 - h - 1][c + 1] = ans[200 + h + 1][c + 1] = '-';
p++;
c++;
if (v[p] == ']')
c += 3;
else
while (v[p] != ']') draw(h - 1);
for (int i(0); i <= h; i++) ans[200 - i][c] = ans[200 + i][c] = '|';
ans[200 - h - 1][c] = ans[200 + h + 1][c] = '+';
ans[200 - h - 1][c - 1] = ans[200 + h + 1][c - 1] = '-';
c++;
p++;
}
int depthmax() {
p++;
int ans(0);
while (v[p] != ']') ans = max(ans, depthmax() + 1);
p++;
return ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, fr[22];
int pre[1 << 22];
int choice[1 << 22];
vector<int> res;
void Solve() {
int st = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (i != j && !(fr[i] & (1 << j))) st |= (1 << i) | (1 << j);
if (st == 0) return;
queue<int> q;
q.push(st);
pre[st] = -1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 22; ++i) {
int v = (1 << i) | (u ^ (u & fr[i]));
if (!pre[v]) {
pre[v] = u, choice[v] = i, q.push(v);
if (__builtin_popcount(v) == 1) {
while (v != st) {
res.push_back(choice[v] + 1);
v = pre[v];
}
reverse(res.begin(), res.end());
return;
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v), --u, --v;
fr[u] |= 1 << v;
fr[v] |= 1 << u;
}
Solve();
printf("%u\n", res.size());
for (int x : res) printf("%d ", x);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e2 + 10;
int a[MX], b[MX];
int main() {
int n;
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
b[x]++;
}
int ans = 0;
for (int i = 0; i < MX; i++) {
if (a[i] > 0) {
int p1 = 0, p2 = 0, p3 = 0;
while (a[i] > 0) {
if (b[i - 1] > 0) {
a[i]--;
b[i - 1]--;
ans++;
continue;
} else {
p1 = 1;
}
if (b[i] > 0) {
a[i]--;
b[i]--;
ans++;
continue;
} else {
p2 = 1;
}
if (b[i + 1] > 0) {
a[i]--;
b[i + 1]--;
ans++;
continue;
} else {
p3 = 1;
}
if (p1 && p2 && p3) {
break;
}
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, heighti;
cin >> n >> h;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> heighti;
if (heighti > h)
sum += 2;
else
sum++;
}
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string var[5555];
vector<string> v[5555];
int map2[5555][5];
map<string, int> Map;
int c[5555];
int solve(int idx, int num) {
fill(c, c + 5555, 0);
int cnt = 0;
int t1, t2;
for (int i = 1; i <= n; i++) {
if (v[i].size() == 1)
c[i] = v[i][0][idx] - '0';
else {
if (v[i][0] == "?")
t1 = num;
else
t1 = c[map2[i][0]];
if (v[i][2] == "?")
t2 = num;
else
t2 = c[map2[i][2]];
if (v[i][1] == "XOR")
c[i] = t1 ^ t2;
else if (v[i][1] == "AND")
c[i] = t1 & t2;
else
c[i] = t1 | t2;
cnt += c[i];
}
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
string waste;
string line;
string inp;
memset(map2, -1, sizeof map2);
for (int i = 1; i <= n; i++) {
cin >> var[i] >> waste;
Map[var[i]] = i;
getline(cin, line);
stringstream ss(line);
while (ss >> inp) v[i].push_back(inp);
for (int j = 0; j < v[i].size(); j++)
if (Map[v[i][j]]) map2[i][j] = Map[v[i][j]];
}
int n1, n2;
string ans;
ans.resize(m);
string ans2;
ans2.resize(m);
for (int i = 0; i < m; i++) {
n1 = solve(i, 0);
n2 = solve(i, 1);
if (n1 <= n2)
ans[i] = '0';
else
ans[i] = '1';
if (n1 >= n2)
ans2[i] = '0';
else
ans2[i] = '1';
}
cout << ans << "\n" << ans2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long black = 0;
long long all = 0;
for (int i = 0; i < n; i++) {
long long now = a[i];
all += now;
if (i % 2 == 0) {
black += (now - 1) / 2 + 1;
} else {
black += now / 2;
}
}
long long white = all - black;
cout << min(white, black) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int n, ans;
string s, ss;
int f[11][4][10][100005];
int N = 100005;
int type(char ch) {
if (ch == 'A') return 0;
if (ch == 'T') return 1;
if (ch == 'G') return 2;
return 3;
}
void upd(int j, int typ, int id, int pos, int val) {
for (; pos < N; pos |= pos + 1) f[j][typ][id][pos] += val;
}
int sum(int j, int typ, int id, int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) res += f[j][typ][id][x];
return res;
}
int get(int j, int typ, int id, int l, int r) {
return sum(j, typ, id, r) - sum(j, typ, id, l - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
s = "#" + s;
for (int i = 1; i < s.size(); i++) {
for (int j = 1; j <= 10; j++) {
upd(j, type(s[i]), i % j, i, 1);
}
}
cin >> n;
for (int i = 1; i <= n; i++) {
int ty;
cin >> ty;
if (ty == 1) {
int x;
char c;
cin >> x >> c;
if (s[x] != c) {
for (int j = 1; j <= 10; j++) {
upd(j, type(s[x]), x % j, x, -1);
upd(j, type(c), x % j, x, 1);
}
s[x] = c;
}
} else {
int l, r;
cin >> l >> r >> ss;
ans = 0;
for (int j = 0; j < ss.size(); j++, l++) {
ans += get(ss.size(), type(ss[j]), l % ss.size(), l, r);
}
cout << ans << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const long long inf = 1e9 + 7;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
int n, m, a[1005], b[1005], s;
bool c[1005][1005];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++) b[i] = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= a[i]; j++) c[i][j] = true;
for (int j = 1; j <= m; j++)
for (int i = 1; i <= b[j]; i++) c[i][j] = true;
for (int i = 1; i <= n; i++)
if (c[i][a[i] + 1]) return 0 * printf("0\n");
for (int j = 1; j <= m; j++)
if (c[b[j] + 1][j]) return 0 * printf("0\n");
for (int i = 1; i <= n; i++) c[i][a[i] + 1]++;
for (int j = 1; j <= m; j++) c[b[j] + 1][j]++;
s = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!c[i][j]) s = s * 2 % inf, c[i][j]++;
printf("%d\n", s);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int u = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
u = (u << 1) + (u << 3) + ch - 48;
ch = getchar();
}
return u * f;
}
int main() {
int x = read(), y = read(), z = read(), t1 = read(), t2 = read(), t3 = read();
if ((abs(z - x) + abs(y - x)) * t2 + 3 * t3 <= abs(x - y) * t1)
puts("YES");
else
puts("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> p[100001];
int n, length, leng, cnt1, cnt2, P[100001];
queue<int> A;
queue<int> B;
string s;
vector<int> LL;
vector<int> RR;
vector<int> LR;
vector<int> RL;
int main() {
cin >> s, n = s.length();
for (int i = 0; i < n; ++i) {
if (s[i] == 'L') {
cnt1++;
if (A.empty())
p[++length].push_back(i), B.push(length);
else
p[A.front()].push_back(i), B.push(A.front()), A.pop();
} else {
cnt2++;
if (B.empty())
p[++length].push_back(i), A.push(length);
else
p[B.front()].push_back(i), A.push(B.front()), B.pop();
}
}
for (int i = 1; i <= length; ++i) {
if (s[p[i][0]] == 'L' && s[p[i].back()] == 'L') LL.push_back(i);
if (s[p[i][0]] == 'L' && s[p[i].back()] == 'R') LR.push_back(i);
if (s[p[i][0]] == 'R' && s[p[i].back()] == 'L') RL.push_back(i);
if (s[p[i][0]] == 'R' && s[p[i].back()] == 'R') RR.push_back(i);
}
if (LL.empty() && RR.empty() && LR.size() && RL.size()) {
if (s[s.length() - 1] == 'L') {
p[LR.back()].push_back(n - 1), p[RL.back()].pop_back();
LL.push_back(LR.back()), RR.push_back(RL.back()), LR.pop_back(),
RL.pop_back();
} else {
p[RL.back()].push_back(n - 1), p[LR.back()].pop_back();
RR.push_back(RL.back()), RR.push_back(LR.back()), RL.pop_back(),
LR.pop_back();
}
}
if (cnt1 < cnt2) swap(LL, RR), swap(LR, RL);
for (int i = 0; i < LR.size(); ++i) P[++leng] = LR[i];
if (LL.size()) P[++leng] = LL[0];
for (int i = 0; i < RL.size(); ++i) P[++leng] = RL[i];
for (int i = 0; i < RR.size(); ++i) {
P[++leng] = RR[i];
if (i + 1 < LL.size()) P[++leng] = LL[i + 1];
}
printf("%d\n", length - 1);
for (int i = 1; i <= leng; ++i)
for (int j = 0; j < p[P[i]].size(); ++j) printf("%d ", p[P[i]][j] + 1);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
inline bool Min(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool Max(T &a, T b) {
return a < b ? (a = b, true) : false;
}
inline int ni() {
int a;
scanf("%d", &a);
return a;
}
inline ll nl() {
ll a;
scanf("%lld", &a);
return a;
}
inline double nd() {
double a;
scanf("%lf", &a);
return a;
}
inline void pi(int a) { printf("%d ", a); }
inline void pl(ll a) { printf("%lld ", a); }
inline void pd(double a) { printf("%.12lf ", a); }
const int N = 1e6 + 100;
int parent[N];
int rang[N];
int a[N];
int res[N];
int income[N];
vector<int> gp[N];
bool was[N];
vector<int> topo;
void make_set(int v) {
parent[v] = v;
rang[v] = 1;
}
int find(int v) {
if (parent[v] == v) return v;
return parent[v] = ::find(parent[v]);
}
void union_set(int a, int b) {
if ((a = find(a)) != (b = find(b))) {
if (rang[a] < rang[b]) swap(a, b);
if (rang[a] == rang[b]) rang[a]++;
parent[b] = a;
}
}
void dfs(int v) {
res[v] = 1;
was[v] = true;
for (int next : gp[v])
if (!was[next]) dfs(next);
for (int next : gp[v]) Max(res[v], res[next] + 1);
}
void solve() {
int n = ni();
int m = ni();
for (int i = 0; i < (int)(n * m); ++i) a[i] = ni();
for (int i = 0; i < (int)(n * m); ++i) make_set(i);
for (int i = 0; i < (int)(n); ++i) {
vector<pii> v;
for (int j = 0; j < (int)(m); ++j)
v.push_back(make_pair(a[i * m + j], i * m + j));
sort((v).rbegin(), (v).rend());
for (int j = 0; j < (int)(m - 1); ++j)
if (v[j].first == v[j + 1].first) union_set(v[j].second, v[j + 1].second);
}
for (int j = 0; j < (int)(m); ++j) {
vector<pii> v;
for (int i = 0; i < (int)(n); ++i)
v.push_back(make_pair(a[i * m + j], i * m + j));
sort((v).rbegin(), (v).rend());
for (int i = 0; i < (int)(n - 1); ++i)
if (v[i].first == v[i + 1].first) union_set(v[i].second, v[i + 1].second);
}
for (int i = 0; i < (int)(n); ++i) {
vector<pii> v;
for (int j = 0; j < (int)(m); ++j)
v.push_back(make_pair(a[i * m + j], find(i * m + j)));
sort((v).rbegin(), (v).rend());
for (int j = 0; j < (int)(m - 1); ++j)
if (v[j].first != v[j + 1].first)
gp[v[j].second].push_back(v[j + 1].second), income[v[j + 1].second]++;
}
for (int j = 0; j < (int)(m); ++j) {
vector<pii> v;
for (int i = 0; i < (int)(n); ++i)
v.push_back(make_pair(a[i * m + j], find(i * m + j)));
sort((v).rbegin(), (v).rend());
for (int i = 0; i < (int)(n - 1); ++i)
if (v[i].first != v[i + 1].first)
gp[v[i].second].push_back(v[i + 1].second), income[v[i + 1].second]++;
}
for (int i = 0; i < (int)(n * m); ++i)
if (find(i) == i and income[i] == 0) dfs(i);
for (int i = 0; i < (int)(n * m); ++i) {
printf("%d ", res[find(i)]);
if ((i + 1) % m == 0) puts("");
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand((int)clock());
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const int N = 200005;
const long long mod = 998244353;
long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long b[N];
int main() {
int n = read(), m = read();
long long A = read();
for (int i = 1; i <= m; ++i) b[i] = read();
long long ans = 1, inv2 = ksm(2, mod - 2);
for (int i = 1; i <= m; ++i) {
long long L = b[i] - b[i - 1];
long long tmp = ksm(A, L);
ans = ans * tmp % mod * (tmp + 1) % mod;
ans = ans * inv2 % mod;
}
ans = ans * ksm(A, n - b[m] - b[m]) % mod;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, a, x, i, f;
a = 0;
cin >> n;
while (n--) {
i = 3;
f = 0;
while (i--) {
cin >> x;
if (x == 1) f++;
}
if (f >= 2) a++;
}
cout << a << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool detect_cycle(vector<vector<int>> &arr, int n, stack<int> &st, int i,
vector<int> &vis) {
vis[i] = 1;
int par = -1;
if (st.size()) par = st.top();
st.push(i);
for (int j = 0; j < arr[i].size(); j++) {
if (arr[i][j] == par || arr[i][j] == i)
continue;
else {
if (vis[arr[i][j]]) {
st.push(arr[i][j]);
return 1;
} else {
int y = detect_cycle(arr, n, st, arr[i][j], vis);
if (y) return 1;
}
}
}
st.pop();
return 0;
}
void dfs(vector<vector<int>> &arr, vector<int> &ans, int curr, int temp,
int par) {
for (int j = 0; j < arr[temp].size(); j++) {
if (ans[arr[temp][j]] != 0 & arr[temp][j] != par) {
ans[arr[temp][j]] = curr;
dfs(arr, ans, curr + 1, arr[temp][j], temp);
}
}
}
int main() {
int n;
cin >> n;
vector<vector<int>> arr(n + 1);
for (long long i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
arr[x].push_back(y);
arr[y].push_back(x);
}
stack<int> st;
vector<int> vis(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (detect_cycle(arr, n, st, i, vis)) {
break;
}
}
while (st.size()) st.pop();
}
vector<int> ans(n + 1, -1);
int top = st.top();
st.pop();
stack<int> st2;
ans[top] = 0;
st2.push(top);
while (st.size() && st.top() != top) {
int temp = st.top();
st.pop();
ans[temp] = 0;
st2.push(temp);
}
st = st2;
while (st2.size()) st2.pop();
while (st.size()) {
int temp = st.top();
st.pop();
dfs(arr, ans, 1, temp, -1);
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << "\n";
}
| 4 |
/*
KAMUI!
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓██████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓███▓▓▓▓▓▓▓▓▓▓█████▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓███▓▒▒░▒▒▒▒▒░░░▒▒▒▓▓███▓▓▓▓▓▓▓
▓▓▓▓▓▓█▓▒▒▒▓▓████████▓▒▒░▒▒▒▓██▓▓▓▓▓▓
▓▓▓▓██▒▓████████████████▓░▒▒▒▒▓██▓▓▓▓
▓▓▓██▓███████▓▒░░░░░░░▒███▒░░▒▒▒██▓▓▓
▓▓█████████▓░░░░░░░░░░░░░██▓▓██████▓▓
▓▓█▒▓███████████▓▓▒▒▒▓▓██████████▓█▓▓
▓██▒▒▒███████████████████████████▓▓█▓
▓█▓▒▒░░████████▒░░░░▓███████████▓░▒█▓
▓█▒▒▒░██░▒████░░░░░░█████░░████▓░░▒█▓
▓█▒▒▒▒██░░░██▓░░░░░░░███▒░░████▒▒▒▒█▓
▓█▓▒▒▒██▒░░░▓█▓░░░░░▓█▓░░░▓███▓▒▒░▓█▓
▓█▓▒▒▒███░░░░████████▓░░░░░████▒▒▒▓█▓
▓▓█▒▒░▓███░░░▒███████▒░░░▒███▓▒▒▒▒█▓▓
▓▓██▒▒░████▒░░███████░░░▓███▓░▒▒▒██▓▓
▓▓▓██▒▒▒█████▓░░██████▒▓███▓▒░▒▒██▓▓▓
▓▓▓▓██▓▒░▓██████████████▓▒░▒▒▒▓██▓▓▓▓
▓▓▓▓▓▓██▓░▒▓█████████▒░░▒▒▒▒▓██▓▓▓▓▓▓
▓▓▓▓▓▓▓███▓▒▒▓██████▓░▒▒▒▓▓███▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓███▓▓▓▓███▓▓▓████▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓███████████▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
*/
#include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
using namespace std;
template<typename T1, typename T2> inline void chkmin(T1 &a, T2 b) {if (a > b) a = b;}
template<typename T1, typename T2> inline void chkmax(T1 &a, T2 b) {if (a < b) a = b;}
#define files(FILENAME) read(FILENAME); write(FILENAME)
#define read(FILENAME) freopen((FILENAME + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((FILENAME + ".out").c_str(), "w", stdout)
#define all(c) (c).begin(), (c).end()
#define sz(c) (int)(c).size()
#define left left228
#define right right228
#define y1 y1228
#define mp make_pair
#define pb push_back
#define y2 y2228
#define rank rank228
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int Mod = 998244353;
int sum(int a, int b) {
return (a + b >= Mod ? a + b - Mod: a + b);
}
int mul(int a, int b) {
return ((ll)a * b) % Mod;
}
int powm(int a, int b) {
int res = 1;
while (b) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
int inv(int a) {
return powm(a, Mod - 2);
}
const int MAXN = 2000228;
int n;
int dp[MAXN];
int cnt[MAXN];
void solve() {
cin >> n;
dp[0] = 1;
dp[1] = 1;
for (int j = 2; j <= 2 * n; j += 2) {
for (int k = j + j; k <= 2 * n; k+= j) {
cnt[k]++;
}
}
int cur = 2;
for (int i = 2; i <= n; i++) {
dp[i] = sum(cnt[i * 2], cur);
cur = sum(cur, dp[i]);
}
cout << dp[n] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// read(FILENAME);
int t;
// cin >> t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int dp[100][2];
int arr[100];
int cdp(int x, int y) {
if (x < 0) return y == 0;
if (dp[x][y] >= 0) return dp[x][y];
int r = arr[x] + y;
long long ans = 0;
if (r != 2) ans += cdp(x - 1, 0);
if (r && x >= 2 && arr[x - 1] == 0) ans += cdp(x - 2, 1);
return dp[x][y] = ans;
}
int main() {
long long a = 1;
long long b = 2;
v.push_back(1);
v.push_back(2);
long long lim = 1;
for (int i = 0; i < 18; ++i) lim *= 10;
while (a + b <= lim) {
long long t = a + b;
v.push_back(t);
a = b;
b = t;
}
int t;
cin >> t;
long long n;
while (t--) {
cin >> n;
memset(arr, 0, sizeof arr);
for (int j = v.size() - 1; j >= 0; --j) {
if (v[j] <= n) {
arr[j] = 1;
n -= v[j];
--j;
}
}
memset(dp, -1, sizeof dp);
cout << cdp(v.size() - 1, 0) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void modify_triple(vector<vector<int> > &arr, vector<vector<int> > &ans, int x,
int y) {
vector<int> temp;
if (!arr[x][y]) {
arr[x][y + 1] = 0;
arr[x + 1][y] = 0;
arr[x + 1][y + 1] = 0;
temp.push_back(x);
temp.push_back(y + 1);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y + 1);
} else if (!arr[x][y + 1]) {
arr[x][y] = 0;
arr[x + 1][y] = 0;
arr[x + 1][y + 1] = 0;
temp.push_back(x);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y + 1);
} else if (!arr[x + 1][y]) {
arr[x][y + 1] = 0;
arr[x][y] = 0;
arr[x + 1][y + 1] = 0;
temp.push_back(x);
temp.push_back(y + 1);
temp.push_back(x);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y + 1);
} else {
arr[x][y + 1] = 0;
arr[x + 1][y] = 0;
arr[x][y] = 0;
temp.push_back(x);
temp.push_back(y + 1);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x);
temp.push_back(y);
}
ans.push_back(temp);
return;
}
void modify_double(vector<vector<int> > &arr, vector<vector<int> > &ans, int x,
int y) {
vector<int> temp;
if ((arr[x][y + 1] && arr[x + 1][y + 1]) ||
(arr[x + 1][y] && arr[x + 1][y + 1]) ||
(arr[x][y] && arr[x + 1][y + 1])) {
temp.push_back(x);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x);
temp.push_back(y + 1);
if (arr[x][y + 1] && arr[x + 1][y + 1]) {
arr[x][y + 1] = 0;
arr[x][y] = 1;
arr[x + 1][y] = 1;
} else if (arr[x + 1][y] && arr[x + 1][y + 1]) {
arr[x + 1][y] = 0;
arr[x][y] = 1;
arr[x][y + 1] = 1;
} else {
arr[x][y + 1] = 1;
arr[x][y] = 0;
arr[x + 1][y] = 1;
}
} else if ((arr[x][y] && arr[x + 1][y]) || (arr[x][y] && arr[x][y + 1])) {
temp.push_back(x + 1);
temp.push_back(y + 1);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x);
temp.push_back(y + 1);
if (arr[x][y] && arr[x + 1][y]) {
arr[x + 1][y] = 0;
arr[x][y + 1] = 1;
arr[x + 1][y + 1] = 1;
} else {
arr[x + 1][y] = 1;
arr[x][y + 1] = 0;
arr[x + 1][y + 1] = 1;
}
} else {
temp.push_back(x);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y + 1);
temp.push_back(x);
temp.push_back(y + 1);
arr[x][y] = 1;
arr[x][y + 1] = 0;
arr[x + 1][y + 1] = 1;
}
ans.push_back(temp);
modify_triple(arr, ans, x, y);
return;
}
void modify_single(vector<vector<int> > &arr, vector<vector<int> > &ans, int x,
int y) {
vector<int> temp;
if (arr[x][y] || arr[x][y + 1] || arr[x + 1][y]) {
if (arr[x][y]) {
arr[x][y] = 0;
arr[x][y + 1] = 1;
arr[x + 1][y] = 1;
} else if (arr[x][y + 1]) {
arr[x][y] = 1;
arr[x][y + 1] = 0;
arr[x + 1][y] = 1;
} else {
arr[x][y] = 1;
arr[x][y + 1] = 1;
arr[x + 1][y] = 0;
}
temp.push_back(x);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x);
temp.push_back(y + 1);
} else {
arr[x][y + 1] = 1;
arr[x + 1][y + 1] = 0;
arr[x + 1][y] = 1;
temp.push_back(x);
temp.push_back(y + 1);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y + 1);
}
ans.push_back(temp);
modify_double(arr, ans, x, y);
return;
}
void modify_quad(vector<vector<int> > &arr, vector<vector<int> > &ans, int x,
int y) {
arr[x][y] = 0;
arr[x][y + 1] = 0;
arr[x + 1][y] = 0;
vector<int> temp;
temp.push_back(x);
temp.push_back(y);
temp.push_back(x + 1);
temp.push_back(y);
temp.push_back(x);
temp.push_back(y + 1);
ans.push_back(temp);
modify_single(arr, ans, x, y);
return;
}
void modify(vector<vector<int> > &arr, vector<vector<int> > &ans, int x,
int y) {
int count = 0;
if (arr[x][y]) count++;
if (arr[x + 1][y]) count++;
if (arr[x][y + 1]) count++;
if (arr[x + 1][y + 1]) count++;
if (count == 0)
return;
else if (count == 1)
modify_single(arr, ans, x, y);
else if (count == 2)
modify_double(arr, ans, x, y);
else if (count == 3)
modify_triple(arr, ans, x, y);
else
modify_quad(arr, ans, x, y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<vector<int> > arr(n, vector<int>(m, 0));
vector<vector<int> > ans;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < m; j++) {
if (str[j] == '0')
arr[i][j] = 0;
else
arr[i][j] = 1;
}
}
for (int i = 0; i < n; i += 2) {
if (i == n - 1) i--;
for (int j = 0; j < m; j += 2) {
if (j == m - 1) j--;
modify(arr, ans, i, j);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i][0] + 1 << " " << ans[i][1] + 1 << " " << ans[i][2] + 1
<< " " << ans[i][3] + 1 << " " << ans[i][4] + 1 << " "
<< ans[i][5] + 1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
int dfn1[N], dfn2[N], tot1, tot2;
int par[N], siz[N], key[N];
int g[N][26];
void dfs(int u) {
dfn1[tot1++] = u;
if (key[u])
dfn2[u] = ++tot2;
else
dfn2[u] = tot2;
siz[u] = 1;
for (int i = 0; i < 26; i++)
if (g[u][i]) {
int v = g[u][i];
par[v] = u;
dfs(v);
siz[u] += siz[v];
}
}
int a[N], f[N];
vector<int> d[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int p;
char c[2];
scanf("%d%s", &p, c);
g[p][c[0] - 'a'] = i;
}
int k;
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
key[a[i]] = 1;
}
dfs(0);
multiset<int> s;
for (int i = 0; i <= n; i++) {
int u = dfn1[i];
if (i) f[u] = f[par[u]] + 1;
for (int j : d[i]) s.erase(s.find(j));
if (key[u]) f[u] = min(f[u], *s.begin() + dfn2[u]);
int x = dfn2[u];
if (key[u]) x--;
s.insert(f[u] - x);
d[i + siz[u]].push_back(f[u] - x);
}
for (int i = 1; i <= k; i++) printf("%d%c", f[a[i]], " \n"[i == k]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int MaxN = 100005;
int g[MaxN][3];
int cnt[MaxN];
bool vis[50];
int n, m;
int tot;
bool add(int a, int b) {
bool flag = true;
int id1 = -1, id2 = -1;
for (int i = 0; i < tot; i++) {
for (int j = 0; j < cnt[i]; j++) {
if (g[i][j] == a) id1 = i;
if (g[i][j] == b) id2 = i;
}
}
if (id1 != -1 && id2 != -1)
return id1 == id2;
else if (id1 != -1) {
if (cnt[id1] < 3)
g[id1][cnt[id1]++] = b;
else
return false;
} else if (id2 != -1) {
if (cnt[id2] < 3)
g[id2][cnt[id2]++] = a;
else
return false;
} else {
g[tot][0] = a;
g[tot][1] = b;
cnt[tot++] = 2;
}
return true;
}
int main() {
while (2 == scanf("%d%d", &n, &m)) {
bool f;
memset(vis, false, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
tot = 0;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
vis[a] = vis[b] = true;
f = add(a, b);
if (!f) break;
}
if (m > 0)
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
}
if (f) {
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) cnt1++;
for (int i = 0; i < tot; i++) {
if (cnt[i] == 2) cnt2++;
}
if ((cnt1 == cnt2) || ((cnt1 > cnt2) && ((cnt1 - cnt2) % 3 == 0))) {
for (int i = 0; i < tot; i++) {
if (cnt[i] == 3) {
printf("%d %d %d\n", g[i][0], g[i][1], g[i][2]);
} else if (cnt[i] == 2) {
printf("%d %d ", g[i][0], g[i][1]);
for (int j = 1; j <= n; j++) {
if (!vis[j]) {
printf("%d\n", j);
vis[j] = true;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
int t = 0;
if (!vis[i]) {
t = 1;
printf("%d ", i);
vis[i] = true;
for (int j = i + 1; j <= n; j++) {
if (!vis[j]) {
t++;
printf("%d%c\n", j, (t == 3 ? '\n' : ' '));
vis[j] = true;
}
if (t == 3) break;
}
}
}
} else
puts("-1");
} else
puts("-1");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename C, typename T = decay<decltype(*begin(declval<C>()))>,
typename enable_if<!is_same<C, string>::value>::type * = nullptr>
ostream &operator<<(ostream &os, const C &c) {
bool f = true;
os << "[";
for (const auto &x : c) {
if (!f) os << ", ";
f = false;
os << x;
}
return os << "]";
}
template <typename T>
void debug(string s, T x) {
cerr << s << " = " << x << "\n";
}
template <typename T, typename... Args>
void debug(string s, T x, Args... args) {
cerr << s.substr(0, s.find(',')) << " = " << x << " | ";
debug(s.substr(s.find(',') + 2), args...);
}
const long long INF = 2e18;
int c[1000005];
long long dp[1000005][3];
unordered_set<int> st;
void factor(int x) {
for (int i = 2; 1LL * i * i <= x; i++)
if (x % i == 0) {
st.insert(i);
while (x % i == 0) x /= i;
}
if (x > 1) st.insert(x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> c[i];
factor(c[0] - 1);
factor(c[0]);
factor(c[0] + 1);
factor(c[n - 1] - 1);
factor(c[n - 1]);
factor(c[n - 1] + 1);
long long ret = LLONG_MAX;
for (int p : st) {
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1][1] = min(dp[i][0], dp[i][1]) + a;
if (c[i] % p == 0) {
dp[i + 1][0] = dp[i][0];
dp[i + 1][2] = min(dp[i][1], dp[i][2]);
} else if ((c[i] - 1) % p == 0 || (c[i] + 1) % p == 0) {
dp[i + 1][0] = dp[i][0] + b;
dp[i + 1][2] = min(dp[i][1], dp[i][2]) + b;
} else {
dp[i + 1][0] = dp[i + 1][2] = INF;
}
}
ret = min({ret, dp[n][0], dp[n][1], dp[n][2]});
}
cout << ret << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[300009];
long long int ans = 0;
void merge(int l, int h, int mid) {
for (int i = l; i <= h; ++i) ans += arr[i];
}
void part(int l, int h) {
int mid = (l + h) / 2;
if (l < h) {
part(l, mid);
part(mid + 1, h);
merge(l, h, mid);
}
}
int main() {
int i, j, n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < n - 1; ++i) {
ans += (i + 2) * 1LL * arr[i];
}
ans += (n)*1LL * arr[n - 1];
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int a[35];
void find(long long int x) {
int v = 1;
while (x != 1) {
if (x % 2 == 1) v++;
x /= 2;
}
a[v]++;
}
long long int ncr(long long int x) { return x * (x - 1) / 2; }
int main() {
int n;
long long int ans = 0, x;
cin >> n;
for (int i = 0; i < 35; i++) a[i] = 0;
for (int i = 0; i < n; i++) {
cin >> x;
find(x);
}
for (int i = 0; i < 35; i++) ans += ncr(a[i]);
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, k, cnt;
vector<long long> v;
queue<long long> q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
v.push_back(b);
while (b > a) {
if (b % 2 == 0) {
b /= 2;
v.push_back(b);
++cnt;
} else if ((b - 1) % 10 == 0) {
b -= 1;
b /= 10;
v.push_back(b);
++cnt;
} else if (b == a)
break;
else {
cout << "NO";
return 0;
}
}
if (b != a) {
cout << "NO";
return 0;
}
cout << "YES" << endl << cnt + 1 << endl;
for (int i = v.size() - 1; i >= 0; --i) cout << v[i] << ' ';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18 + 7;
const int maxn = 1e6 + 5;
const long long mod = 100000007;
const double eps = 1e-6;
inline long long read() {
bool f = 0;
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
int n, m;
int vis[maxn];
vector<int> ans;
int main() {
int T = read();
while (T--) {
ans.clear();
n = read(), m = read();
for (int i = 1; i <= 3 * n; ++i) vis[i] = 0;
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
if (!vis[u] && !vis[v]) {
vis[u] = 1, vis[v] = 1;
ans.push_back(i);
}
}
if (ans.size() >= n) {
printf("Matching\n");
for (int i = 0; i < n; ++i) {
if (i) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
} else {
int tot = 0;
printf("IndSet\n");
for (int i = 1; i <= n * 3; ++i) {
if (!vis[i] && ++tot <= n) {
if (tot != 1) printf(" ");
printf("%d", i);
}
}
printf("\n");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<int> graph[], bool visited[], int k, int color[],
set<int> &st) {
if (visited[k]) {
return;
}
visited[k] = true;
st.insert(color[k]);
for (auto i : graph[k]) {
dfs(graph, visited, i, color, st);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> graph[n + 1];
int a = -1, b = -1;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
int color[n + 1];
for (int i = 0; i < n; i++) {
int c;
cin >> c;
color[i + 1] = c;
}
for (int i = 1; i <= n; i++) {
bool condi = true;
for (auto x : graph[i]) {
if (color[x] != color[i]) {
condi = false;
a = x;
b = i;
break;
}
}
if (condi == false) {
break;
}
}
if (a == -1) {
cout << "YES" << endl;
cout << 1 << endl;
return 0;
}
bool cond1 = true;
bool visited[n + 1];
memset(visited, false, sizeof(visited));
visited[a] = true;
for (auto x : graph[a]) {
set<int> st;
dfs(graph, visited, x, color, st);
if (st.size() > 1) {
cond1 = false;
break;
}
}
bool cond2 = true;
if (cond1 == false) {
memset(visited, false, sizeof(visited));
visited[b] = true;
for (auto x : graph[b]) {
set<int> st;
dfs(graph, visited, x, color, st);
if (st.size() > 1) {
cond2 = false;
break;
}
}
}
if (cond1 == true || cond2 == true) {
cout << "YES" << endl;
if (cond1 == true) {
cout << a << endl;
} else {
cout << b << endl;
}
} else {
cout << "NO" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
set<string> st;
int rots[2][6] = {{3, 2, 0, 1, 4, 5}, {0, 1, 5, 4, 2, 3}};
bool dfs(string& s, set<string>& tmp) {
if (st.count(s)) return true;
if (tmp.count(s)) return false;
tmp.insert(s);
string t;
for (int i = 0; i < (int)(2); i++) {
t = "";
for (int k = 0; k < (int)(6); k++) t += s[rots[i][k]];
if (dfs(t, tmp)) return true;
}
return false;
}
bool check_exists(string s) {
set<string> tmp;
if (dfs(s, tmp)) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
sort(s.begin(), s.end());
do {
if (!check_exists(s)) st.insert(s);
} while (next_permutation(s.begin(), s.end()));
cout << ((int)st.size()) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const int MAXN = 110;
double in[MAXN];
int main() {
int n;
while (cin >> n) {
for (int(i) = (0); (i) < (n); ++(i)) cin >> in[i];
sort(in, in + n, greater<double>());
double resp = in[0];
cerr << "resp"
<< " = " << resp << endl;
;
for (int(i) = (1); (i) < (n); ++(i)) {
double nresp = 0;
for (int(j) = (0); (j) < (i + 1); ++(j)) {
double aux = in[j];
for (int(k) = (0); (k) < (i + 1); ++(k)) {
if (k != j) aux *= (1 - in[k]);
}
nresp += aux;
}
if (nresp > resp)
resp = nresp;
else
break;
}
printf("%.10lf\n", resp);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10, inf = 1e9, V = 1e6;
long long n, a[N], k;
long long check(long long d) {
long long cost = 0, st = 0;
for (int i = 1; i <= n; i++) {
long long t = (a[i] - 1) / d + 1;
cost += t * d - a[i];
st += t;
}
if (cost > k) return -1;
return d + (k - cost) / st;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
long long res = 1;
for (int i = 1; i <= V; i++) res = max(res, check(i));
for (int i = 1; i <= n; i++)
for (int t = 1; t <= inf / V; t++)
res = max(res, check((a[i] - 1) / t + 1));
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int count(int S) {
int ret = 0;
while (S) {
ret += S & 1;
S >>= 1;
}
return ret;
}
int n, m, d, cnt[30], a[100010], mark[1 << 21];
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 0; i < m; i++) {
int k;
scanf("%d", &k);
while (k--) {
int t;
scanf("%d", &t);
a[t] = i;
}
}
for (int i = 1; i <= n; i++) {
cnt[a[i]]++;
if (i < d) continue;
if (i > d) cnt[a[i - d]]--;
int S = 0;
for (int j = 0; j < m; j++)
if (!cnt[j]) S += 1 << j;
mark[S] = 1;
}
int ans = 1 << 30;
for (int S = (1 << m) - 1; S; S--) {
if (!mark[S]) {
ans = min(ans, count(S));
continue;
}
for (int i = 0; i < m; i++)
if ((S >> i) & 1) mark[S ^ (1 << i)] = 1;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int N = 25, MAXN = N * 50001;
int n, m, k, u, v, x, y, t, a, b, ans;
int A[2 * N];
int B[2][MAXN];
long long dp[N][MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < 2 * n; i++) cin >> A[i];
sort(A, A + 2 * n);
reverse(A, A + 2 * n);
n--;
B[0][n] = A[2 * n];
B[1][n] = A[2 * n + 1];
long long sum = 0;
for (int i = 0; i < 2 * n; i++) {
sum += A[i];
for (int j = n; j; j--)
for (int x = A[i]; x < MAXN; x++)
if (dp[j - 1][x - A[i]]) dp[j][x] = dp[j - 1][x - A[i]] | (1ll << i);
dp[1][A[i]] = (1ll << i);
}
long long mask;
for (int i = sum; i >= sum - i; i--)
if (dp[n][i]) mask = dp[n][i];
int x = 0, y = 0;
for (int i = 0; i < 2 * n; i++) {
if (mask & (1ll << i))
B[0][x++] = A[i];
else
B[1][y++] = A[i];
}
n++;
sort(B[0], B[0] + n);
sort(B[1], B[1] + n);
reverse(B[1], B[1] + n);
for (int i : {0, 1}) {
for (int j = 0; j < n; j++) cout << B[i][j] << ' ';
cout << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int N = 1 << 31;
int d[][3] = {{1, 1, 1}, {1, 0, 1}, {1, -1, 1}, {0, 1, 0}};
int s[8][2], n, X[2], x[2], A;
int main() {
scanf("%d%d%d", &n, &X[0], &X[1]);
for (int i = 0; i < 8; i++) s[i][0] = i < 4 ? N - 1 : N;
for (; n > 0; n--) {
char c;
scanf(" %c%d%d", &c, &x[0], &x[1]);
x[0] -= X[0], x[1] -= X[1];
for (int i = 0; i < 4; i++)
if (!((long long)d[i][0] * x[0] + d[i][1] * x[1])) {
int j = i + (x[d[i][2]] > 0 ? 0 : 4), t = x[d[i][2]];
if (t < s[j][0] != t < 0) s[j][0] = t, s[j][1] = c;
}
}
for (int i = 0; i < 4; i++) {
int a = s[i][1], b = s[i + 4][1], c = i & 1 ? 'R' : 'B';
if (a == 'Q' || b == 'Q' || a == c || b == c) A = 1;
}
printf("%s\n", A ? "YES" : "NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void print(long long int a[], long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
long long int power(long long int x) {
long long int u = 0;
while (x % 2 == 0) {
u++;
x = x / 2;
}
return u;
}
long long int powM(long long int x, long long int y, long long int m) {
if (m == 1) {
return 0;
}
long long int ans = 1, r = 1;
x %= m;
while (r > 0 && r <= y) {
if (r & y) {
ans *= x;
ans %= m;
}
r <<= 1;
x *= x;
x %= m;
}
return ans;
}
int powm(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
int t1 = 1;
long long int M = 1e9 + 7;
while (t1--) {
long long int n, b;
cin >> n >> b;
long long int u1 = -1;
for (long long int i = 2; i * i <= b; i++) {
long long int p = b;
long long int o = 0;
while (b % i == 0) {
o++;
b /= i;
}
if (p % i == 0) {
long long int r = 0;
long long int y = i;
while (1) {
if (n / y == 0) {
break;
}
r += n / y;
if (y > n / i) {
break;
}
y *= i;
}
if (u1 == -1) {
u1 = r / o;
} else {
u1 = min(u1, r / o);
}
}
}
if (b != 1) {
long long int o = n;
long long int r = 0;
long long int y = b;
while (y <= n) {
if (o / y == 0) {
break;
}
r += o / y;
if (y > n / b) {
break;
}
y *= b;
}
if (u1 == -1) {
u1 = r;
} else {
u1 = min(u1, r);
}
}
cout << u1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, q;
int a[maxn];
int x[maxn];
char s[maxn];
int ans[maxn];
vector<pair<int, int> > arr;
signed main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
arr.push_back(pair<int, int>(abs(a[i]), i));
}
sort(arr.begin(), arr.end());
for (int i = 0; i < q; i++) {
cin >> s[i] >> x[i];
}
int tmp = 0;
while (q--) {
int l = abs(x[q]);
if (s[q] == '>' && x[q] > 0) {
l++;
}
if (s[q] == '<' && x[q] < 0) {
l++;
}
while (arr.size()) {
if (arr.back().first >= l) {
if (s[q] == '>') {
ans[arr.back().second] = -arr.back().first;
} else {
ans[arr.back().second] = arr.back().first;
}
if (tmp % 2 == 1) {
ans[arr.back().second] = -ans[arr.back().second];
}
arr.pop_back();
} else {
break;
}
}
if (s[q] == '>' && x[q] < 0) {
tmp++;
}
if (s[q] == '<' && x[q] > 0) {
tmp++;
}
}
while (arr.size()) {
if (tmp % 2 == 1) {
ans[arr.back().second] = -a[arr.back().second];
} else {
ans[arr.back().second] = a[arr.back().second];
}
arr.pop_back();
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 8 |
#include <bits/stdc++.h>
int sm(int a, int b) {
if (a % b == 0)
return b;
else
return a % b;
}
int main() {
int n, m, s;
scanf("%d%d%d", &n, &m, &s);
printf("%I64d", (long long)sm(n, s) * sm(m, s) * ((n - 1) / s + 1) *
((m - 1) / s + 1));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1.5e7 + 10, N = 3e5 + 10;
inline int Read(int &r) {
int b = 1, c = getchar();
r = 0;
while (c < '0' || '9' < c) b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9')
r = (r << 1) + (r << 3) + (c ^ '0'), c = getchar();
return r *= b;
}
int prm[M], mnprm[M], nprm, n, m;
int exi[N * 10], mne[N * 10][2];
void Init() {
for (int i = 2; i < M; i++) {
if (!mnprm[i]) mnprm[i] = i, prm[++nprm] = i;
for (int j = 1; j <= nprm && prm[j] * i < M; j++) {
mnprm[i * prm[j]] = prm[j];
if (i % prm[j] == 0) break;
}
}
}
int main() {
Init();
memset(prm, 0, sizeof prm);
memset(mne, 0x3f, sizeof mne);
Read(n);
for (int i = 1, num; i <= n; i++) {
Read(num);
int las = -1, lcnt = 0;
while (num > 1) {
if (las == mnprm[num])
lcnt++;
else {
if (~las) {
if (!prm[las]) prm[las] = ++m;
exi[prm[las]]++;
if (mne[prm[las]][0] > lcnt)
mne[prm[las]][0] = lcnt, mne[prm[las]][1] = 1;
else if (mne[prm[las]][0] == lcnt)
mne[prm[las]][1]++;
}
las = mnprm[num], lcnt = 1;
}
num /= mnprm[num];
}
if (~las) {
if (!prm[las]) prm[las] = ++m;
exi[prm[las]]++;
if (mne[prm[las]][0] > lcnt)
mne[prm[las]][0] = lcnt, mne[prm[las]][1] = 1;
else if (mne[prm[las]][0] == lcnt)
mne[prm[las]][1]++;
}
}
int ans = n;
for (int i = 1; i <= m; i++) {
if (exi[i] < n) mne[i][0] = 0, mne[i][1] = n - exi[i];
ans = min(ans, mne[i][1]);
}
printf("%d\n", ans == n ? -1 : ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
long long a[N], r[N], l[N];
long long s1[N], s2[N], k;
double ans[N];
int n, m;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
a[0] = a[n + 1] = -((long long)1 << 62);
for (int i = n; i >= 1; i--) {
if (a[i + 1] <= a[i])
r[i] = i + 1;
else
for (int j = r[i + 1]; j <= n + 1; j = r[j])
if (a[j] <= a[i]) {
r[i] = j;
break;
}
}
for (int i = 1; i <= n; i++) {
if (a[i - 1] < a[i])
l[i] = i - 1;
else
for (int j = l[i - 1]; j >= 0; j = l[j])
if (a[j] < a[i]) {
l[i] = j;
break;
}
}
for (int i = 1; i <= n; i++) {
long long x = i - l[i], y = r[i] - i;
if (x > y) swap(x, y);
s1[1] += a[i];
s1[x + 1] -= a[i];
s2[x + 1] += x * a[i];
s2[y + 1] -= x * a[i];
s2[y + 1] += (x + y) * a[i];
s2[x + y] -= (x + y) * a[i];
s1[y + 1] -= a[i];
s1[x + y] += a[i];
}
long long S1 = 0, S2 = 0;
for (int i = 1; i <= n; i++) {
S1 += s1[i];
S2 += s2[i];
ans[i] = (S1 * i + S2) * 1.0 / ((n - i + 1) * 1.0);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%lld", &k);
printf("%.9lf\n", ans[k]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x[1005], y[1005], cnt = 0, t, l, r, a[1005];
bool num[1005];
int main() {
cin >> n >> m;
while (m--) {
cin >> t >> l >> r;
if (t)
for (int i = l; i < r; i++) num[i] = 1;
else {
cnt++;
x[cnt] = l;
y[cnt] = r;
}
}
a[1] = n;
for (int i = 2; i <= n; i++) {
if (num[i - 1])
a[i] = a[i - 1];
else
a[i] = a[i - 1] - 1;
}
for (int i = 1; i <= cnt; i++)
if (a[x[i]] == a[y[i]]) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using bulbs = bitset<1000>;
bulbs sw[30];
int lefter, righter;
int n, s, d;
unordered_map<bulbs, int> leftHalves;
void generate_large(int idx, bulbs &curr, int flips = 0) {
if (idx == lefter) {
if (leftHalves.find(curr) == leftHalves.end())
leftHalves[curr] = flips;
else
leftHalves[curr] = min(leftHalves[curr], flips);
return;
}
generate_large(idx + 1, curr, flips);
auto x = curr ^ sw[idx];
generate_large(idx + 1, x, flips + 1);
}
int ans = INT_MAX;
void generater(int idx, bulbs &curr, int flips = 0) {
if (idx == righter) {
if (leftHalves.find(curr) != leftHalves.end())
ans = min(ans, leftHalves[curr] + flips);
return;
}
generater(idx + 1, curr, flips);
auto x = curr ^ sw[idx + lefter];
generater(idx + 1, x, flips + 1);
}
void solve() {
cin >> n >> s >> d;
for (int i = 0; i < s; i++) {
int c;
cin >> c;
for (int _ = 0; _ < c; _++) {
int x;
cin >> x;
sw[i][x - 1] = 1;
}
}
lefter = max(1, 2 * s / 3);
righter = s - lefter;
bulbs init;
generate_large(0, init);
for (int i = 0; i < d; i++) {
bulbs day;
int c;
cin >> c;
for (int _ = 0; _ < c; _++) {
int x;
cin >> x;
day[x - 1] = 1;
}
ans = INT_MAX;
generater(0, day);
if (ans == INT_MAX)
cout << -1 << "\n";
else
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
long long d, n, m;
pair<long long, long long> p[MAXN];
long long nxt[MAXN];
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
signed main() {
memset(nxt, -1, sizeof nxt);
cin >> d >> n >> m;
p[0] = {0, 0};
p[m + 1] = {d, 0};
for (long long i = 1; i <= m; i++) cin >> p[i].first >> p[i].second;
sort(p, p + m + 1, comp);
deque<long long> fila;
fila.push_back(m + 1);
for (long long i = m; i >= 0; i--) {
while (!fila.empty()) {
long long at = fila.back();
if (p[at].first - p[i].first > n) {
fila.pop_back();
continue;
} else
break;
}
while (!fila.empty()) {
long long at = fila.front();
if (p[at].second > p[i].second) {
if (fila.size() == 1) nxt[i] = fila.front();
fila.pop_front();
} else
break;
}
if (!fila.empty()) nxt[i] = fila.front();
fila.push_front(i);
}
long long resp = 0;
long long at = 0;
long long tank = n;
while (true) {
if (at == m + 1) break;
if (nxt[at] == -1) {
cout << -1 << endl;
return 0;
}
if (at == 0) {
at = nxt[0];
tank -= p[nxt[0]].first;
continue;
}
long long b = nxt[at];
if (p[b].second > p[at].second)
resp += (n - tank) * p[at].second, tank = n - (p[b].first - p[at].first);
else {
long long h = p[b].first - p[at].first;
if (tank < h)
resp += (h - tank) * p[at].second, tank = 0;
else
tank -= h;
}
at = b;
}
cout << resp << endl;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int row, col, i, j, check = 0, cnt = 0;
int index[100][100];
char color;
scanf("%i %i %c", &row, &col, &color);
char office[row][col];
for (i = 0; i < row; i++) scanf("%s", &office[i]);
for (i = 0; i < row; i++)
for (j = 0; j < col; j++)
if (office[i][j] == color) cnt++;
char neighbors[cnt * 4];
cnt = 0;
for (i = 0; i < row; i++)
for (j = 0; j < col; j++)
if (office[i][j] == color) {
if (i - 1 >= 0) {
neighbors[cnt] = office[i - 1][j];
cnt++;
}
if (i + 1 < row) {
neighbors[cnt] = office[i + 1][j];
cnt++;
}
if (j - 1 >= 0) {
neighbors[cnt] = office[i][j - 1];
cnt++;
}
if (j + 1 < col) {
neighbors[cnt] = office[i][j + 1];
cnt++;
}
}
for (i = 0; i < cnt; i++) {
if (neighbors[i] == color) neighbors[i] = '.';
if (neighbors[i] != color && neighbors[i] != '.')
for (j = 1 + i; j < cnt; j++) {
if (neighbors[i] == neighbors[j]) neighbors[i] = '.';
}
}
for (i = 0; i < cnt; i++)
if (neighbors[i] != '.') check++;
printf("%i", check);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100005];
int main() {
int n, two = 0;
long long sum = 0, ap;
bool win = true, pos = false;
scanf("%d", &n);
for (int i = 0; i < n; ++i) cin >> arr[i], sum += arr[i];
sort(arr, arr + n);
if (n >= 2 && arr[0] == 0 && arr[1] == 0) {
printf("cslnb\n");
return 0;
}
for (int i = 1; i < n; ++i)
if (arr[i] == arr[i - 1]) {
two++;
if (i >= 2 && abs(arr[i - 2] - arr[i]) >= 2)
pos = true;
else if (i < 2)
pos = true;
}
if (two >= 2) {
printf("cslnb\n");
return 0;
}
if (two == 1 && pos == false) {
printf("cslnb\n");
return 0;
}
ap = n * (n - 1) / 2;
if ((sum - ap) % 2) {
printf("sjfnb\n");
return 0;
} else {
printf("cslnb\n");
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int maxn = 1010;
int px[maxn], py[maxn];
int cr[maxn], cx[maxn], cy[maxn];
int ind[maxn];
int par[maxn];
long long dist(int x1, int y1, int x2, int y2) {
return ((long long)x1 - x2) * ((long long)x1 - x2) +
((long long)y1 - y2) * ((long long)y1 - y2);
}
vector<int> a[maxn];
int di[maxn];
int d[maxn][maxn];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) scanf("%d%d", &px[i], &py[i]);
for (int i = 0; i < m; ++i) scanf("%d%d%d", &cr[i], &cx[i], &cy[i]);
cr[m] = 2000000010;
cx[m] = 0;
cy[m++] = 0;
for (int i = 0; i < n; ++i) {
ind[i] = -1;
for (int j = 0; j < m; ++j) {
if (dist(px[i], py[i], cx[j], cy[j]) <=
((long long)cr[j]) * ((long long)cr[j])) {
if (ind[i] == -1 || cr[j] < cr[ind[i]]) ind[i] = j;
}
}
}
for (int i = 0; i < m; ++i) {
par[i] = -1;
for (int j = 0; j < m; ++j) {
if (cr[i] < cr[j] && dist(cx[i], cy[i], cx[j], cy[j]) <=
((long long)cr[j]) * ((long long)cr[j])) {
if (par[i] == -1 || cr[j] < cr[par[i]]) par[i] = j;
}
}
if (par[i] != -1) a[i].push_back(par[i]), a[par[i]].push_back(i);
}
for (int i = 0; i < m; ++i) {
memset(di, -1, sizeof(di));
di[i] = 0;
queue<int> q;
q.push(i);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int j = 0; j < int((a[cur]).size()); ++j) {
int to = a[cur][j];
if (di[to] == -1) {
di[to] = di[cur] + 1;
q.push(to);
}
}
}
for (int j = 0; j < m; ++j) d[i][j] = di[j];
}
for (int i = 0; i < k; ++i) {
int fr, to;
scanf("%d%d", &fr, &to);
fr--;
to--;
printf("%d\n", d[ind[fr]][ind[to]]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x, primes[350588], p = 0;
vector<vector<int> > pfs(194598);
bool isprime[5032107 + 1];
unordered_map<int, int> rankd;
int dp[8][5032107], ans[15][194598], a[194598];
void getprimes() {
for (int i = 2; i <= 5032107; i++) isprime[i] = true;
for (int i = 2; i * i <= 5032107; i++) {
if (isprime[i])
for (int j = i + i; j <= 5032107; j += i) isprime[j] = false;
}
for (int i = 2; i <= 5032107; i++)
if (isprime[i]) primes[p++] = i;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
getprimes();
int n, x, i, j, cnt = 0, q;
scanf("%d %d", &n, &q);
for (i = 0; i < 8; i++)
for (j = 0; j < 5032107; j++) dp[i][j] = -1;
for (i = 0; i < 15; i++)
for (j = 0; j < n; j++) ans[i][j] = -1;
for (i = 0; i < n; i++) {
scanf("%d", &x);
for (j = 0; primes[j] * primes[j] <= x; j++) {
if (x % primes[j] != 0) continue;
while (x % (primes[j] * primes[j]) == 0) x /= (primes[j] * primes[j]);
if (x % primes[j] == 0) {
pfs[i].push_back(primes[j]);
x /= primes[j];
}
}
if (x > 1) pfs[i].push_back(x);
a[i] = 1;
for (auto it : pfs[i]) a[i] *= it;
int jp = pfs[i].size();
for (j = 0; j < (1 << jp); j++) {
int curr = 1;
for (int m = 0; m < jp; m++)
if ((1 << m) & j) {
curr *= pfs[i][m];
}
if (rankd.find(curr) != rankd.end()) {
int sol = jp - __builtin_popcount(j), jj;
for (jj = 0; jj < 8; jj++) {
if (jj + sol > 14) break;
ans[jj + sol][i] = max(ans[jj + sol][i], dp[jj][rankd[curr]]);
}
}
}
for (j = 0; j < (1 << jp); j++) {
int curr = 1;
for (int m = 0; m < jp; m++)
if ((1 << m) & j) {
curr *= pfs[i][m];
}
if (rankd.find(curr) == rankd.end()) {
rankd.insert(make_pair(curr, cnt++));
}
int req = jp - __builtin_popcount(j);
dp[req][rankd[curr]] = i;
}
}
for (i = 1; i < n; i++) {
for (j = 0; j < 15; j++) ans[j][i] = max(ans[j][i], ans[j][i - 1]);
}
while (q--) {
int l, r, sol;
scanf("%d %d", &l, &r);
for (sol = 0; sol < 15; sol++)
if (ans[sol][r - 1] >= l - 1) break;
printf("%d\n", sol);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
const int MAXN = 2e5 + 5;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
ll pw(ll a, ll n) {
ll ret = 1;
while (n > 0) {
if (n & 1 == 1) {
ret = (ret * a) % MOD;
}
a = (a * a) % MOD;
n = n >> 1;
}
return ret;
}
ll inv(ll a) { return pw(a, MOD - 2); }
void solve() {
ll D;
cin >> D;
vl primes;
for (ll i = 2; i * i <= D; i++) {
if (D % i == 0) {
primes.push_back(i);
while (D % i == 0) {
D /= i;
}
}
}
if (D > 1) {
primes.push_back(D);
}
vl fat(101);
fat[0] = 1;
fat[1] = 1;
vl invfat(101);
invfat[0] = 1;
invfat[1] = 1;
for (int i = 2; i <= 100; i++) {
fat[i] = (fat[i - 1] * i) % MOD;
invfat[i] = (invfat[i - 1] * inv(i)) % MOD;
}
int sz = primes.size();
int n;
cin >> n;
for (int i = 0; i < n; i++) {
ll u, v;
cin >> u >> v;
vl difs_u;
vl difs_d;
ll sum1 = 0;
ll sum2 = 0;
ll ans = 1;
for (int i = 0; i < sz; i++) {
ll x1 = 0;
ll x2 = 0;
while (u % primes[i] == 0) {
x1++;
u /= primes[i];
}
while (v % primes[i] == 0) {
x2++;
v /= primes[i];
}
ll dif = x1 - x2;
if (dif == 0) continue;
if (dif < 0) {
dif = -dif;
sum2 += dif;
} else {
sum1 += dif;
}
ans = (ans * invfat[dif]) % MOD;
}
ans = (ans * fat[sum1]) % MOD;
ans = (ans * fat[sum2]) % MOD;
cout << ans << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e6 + 11;
const double eps = 0.00000001;
string s, r;
int n, pos[205], cnt[205];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
s = " " + s;
r = s;
for (int i = 1; i <= s.length(); ++i) {
if (!pos[s[i]]) pos[s[i]] = i;
++cnt[s[i]];
}
long long ans = 0;
for (int i = n; i > 0; --i) {
int x = r[i];
ans += pos[x] - 1;
--cnt[x];
s.erase(pos[x], 1);
for (int k = 'a'; k <= 'z'; ++k) {
if (pos[k] > pos[x]) --pos[k];
}
if (cnt[x] == 0)
pos[x] = 0;
else {
while (s[pos[x]] != x) {
++pos[x];
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n;
int d[N];
int child[N];
vector<int> g[N];
void pre_dfs(int v, int p) {
child[v] = 1;
for (int s : g[v]) {
if (s == p) continue;
pre_dfs(s, v);
child[v] += child[s];
}
}
int find_centroid(int v, int p) {
for (int s : g[v])
if (s != p) {
if (child[s] * 2 >= n) return find_centroid(s, v);
}
return v;
}
void go(int v, int p, int &cur, int delta) {
cur += delta;
d[v] = cur;
cout << v << " " << p << " " << d[v] - d[p] << endl;
for (int s : g[v])
if (s != p) {
go(s, v, cur, delta);
}
}
bitset<1010> dp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
srand(time(NULL));
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
pre_dfs(1, 0);
int root = find_centroid(1, 0);
pre_dfs(root, 0);
int sum_a = 0, sum_b = 0;
vector<int> a, b;
dp[0][0] = 1;
for (int i = 0; i < g[root].size(); ++i) {
dp[i + 1] = (dp[i] | (dp[i] << child[g[root][i]]));
}
int best = n / 2;
while (!dp[g[root].size()][best]) --best;
for (int i = g[root].size() - 1; i >= 0; --i) {
int x = g[root][i];
if (dp[i][best]) {
a.push_back(x);
sum_a += child[x];
} else {
b.push_back(x);
sum_b += child[x];
best -= child[x];
}
}
int cur_a = 0, cur_b = 0;
for (int node : a) {
go(node, root, cur_a, 1);
}
for (int node : b) {
go(node, root, cur_b, sum_a + 1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct edge {
int to, next, v;
} e[N * 2];
int head[N], n, tot;
int sz[N], mxv, rt;
int co[N], sz1[N], sz2[N], mat[N];
set<int> S[N];
set<pair<int, int> > SS, SSS;
long long ans;
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
}
void dfs(int x, int fa) {
sz[x] = 1;
int mx = 0;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
dfs(e[i].to, x);
sz[x] += sz[e[i].to];
mx = max(mx, sz[e[i].to]);
ans += 2ll * min(sz[e[i].to], n - sz[e[i].to]) * e[i].v;
}
mx = max(mx, n - sz[x]);
if (mx < mxv) mxv = mx, rt = x;
}
void color(int x, int fa, int c) {
co[x] = c;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) color(e[i].to, x, c);
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n - 1); i++) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
add(x, y, v);
add(y, x, v);
}
mxv = 1 << 30;
dfs(1, 0);
printf("%lld\n", ans);
co[rt] = rt;
for (int i = head[rt]; i; i = e[i].next) color(e[i].to, rt, e[i].to);
for (int i = (int)(1); i <= (int)(n); i++) S[co[i]].insert(i);
for (int i = (int)(1); i <= (int)(n); i++) S[i].insert(1 << 30);
for (int i = (int)(1); i <= (int)(n); i++) ++sz1[co[i]], ++sz2[co[i]];
--sz2[rt];
for (int i = (int)(1); i <= (int)(n); i++)
if (co[i] == i) SS.insert(pair<int, int>(*S[i].begin(), i));
for (int i = (int)(1); i <= (int)(n); i++)
if (co[i] == i) SSS.insert(pair<int, int>(sz1[i] + sz2[i], i));
for (int i = (int)(1); i <= (int)(n); i++) {
int be = co[i];
SSS.erase(pair<int, int>(sz1[be] + sz2[be], be));
--sz1[be];
SSS.insert(pair<int, int>(sz1[be] + sz2[be], be));
int id;
if (SSS.rbegin()->first == n - i + 1)
id = SSS.rbegin()->second;
else {
set<pair<int, int> >::iterator it = SS.begin();
if (it->second == be && i != rt) ++it;
id = it->second;
}
mat[i] = *S[id].begin();
SS.erase(pair<int, int>(*S[id].begin(), id));
S[id].erase(S[id].begin());
SS.insert(pair<int, int>(*S[id].begin(), id));
SSS.erase(pair<int, int>(sz1[id] + sz2[id], id));
--sz2[id];
SSS.insert(pair<int, int>(sz1[id] + sz2[id], id));
}
for (int i = (int)(1); i <= (int)(n); i++) printf("%d ", mat[i]);
puts("");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch;
int x = 0, f = 1;
while (ch = getchar(), ch < '!')
;
if (ch == '-') f = -1, ch = getchar();
while (x = x * 10 + ch - '0', ch = getchar(), isdigit(ch))
;
return f * x;
}
const int N = 100005;
vector<int> G[N], con[N], fu[N], sum[N];
map<pair<int, int>, double> mem;
long long f[N], size[N], fur[N], dis[N], d[N];
int n, m, q;
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
double query(int u, int v) {
if (u > v) swap(u, v);
pair<int, int> pa = make_pair(u, v);
if (mem.count(pa)) return mem[pa];
long long maxd = max(d[u], d[v]);
if (size[u] > size[v]) swap(u, v);
double ans = 0;
for (int i = 0; i < size[u]; i++) {
int j = upper_bound(fu[v].begin(), fu[v].end(), maxd - fu[u][i] - 1) -
fu[v].begin() - 1;
ans += maxd * (j + 1);
ans += sum[v][j + 1] + (fu[u][i] + 1) * (size[v] - j - 1);
}
ans = ans / size[u] / size[v];
return mem[pa] = ans;
}
void dfs(int u, int fa, int x = 0) {
dis[u] = dis[fa] + 1;
if (x) fur[u] = max(fur[u], dis[u]);
for (int i = 0; i < (int)(G[u]).size(); i++)
if (G[u][i] != fa) dfs(G[u][i], u, x);
}
void get_fur(int p) {
dis[0] = -1;
dfs(p, 0);
int u = 0, v = 0;
for (int i = 0; i < (int)(con[p]).size(); i++)
if (dis[con[p][i]] > dis[u]) u = con[p][i];
dfs(u, 0);
for (int i = 0; i < (int)(con[p]).size(); i++)
if (dis[con[p][i]] > dis[v]) v = con[p][i];
d[p] = dis[v];
dfs(u, 0, 1);
dfs(v, 0, 1);
for (int i = 0; i < (int)(con[p]).size(); i++)
fu[p].push_back(fur[con[p][i]]);
sort(fu[p].begin(), fu[p].end());
static long long s[N];
s[size[p]] = 0;
for (int i = size[p] - 1; i >= 0; i--) s[i] = s[i + 1] + fu[p][i];
for (int i = 0; i < size[p]; i++) sum[p].push_back(s[i]);
sum[p].push_back(0);
}
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= n; i++) f[i] = i, size[i] = 1;
for (int i = 1, u, v; i <= m; i++) {
u = read(), v = read();
int k1 = find(u), k2 = find(v);
if (size[k1] > size[k2]) swap(k1, k2);
f[k1] = k2, size[k2] += size[k1];
G[u].push_back(v), G[v].push_back(u);
}
for (int i = 1; i <= n; i++) con[find(i)].push_back(i);
for (int i = 1; i <= n; i++)
if (i == find(i)) get_fur(i);
for (int i = 1, u, v; i <= q; i++) {
u = read(), v = read();
int k1 = find(u), k2 = find(v);
if (k1 == k2)
puts("-1");
else
printf("%.8lf\n", query(k1, k2));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1) * 4;
const int MAXN = 1e5 + 20;
int main() {
int n, m, l, r, minq = 1 << 30;
cin >> n >> m;
for (int i = 0; i < (int)m; ++i) {
cin >> l >> r;
minq = min(minq, r - l + 1);
}
cout << minq << '\n';
for (int i = 0; i < (int)n; ++i) {
cout << i % (minq) << " ";
}
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100 + 7][100 + 7], dp[100 + 7][100 + 7];
int main() {
vector<pair<long long, long long> > v;
long long N, i, j, n, m, k, L, R, notr = 0, s, p;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> k;
for (j = 1; j <= k; j++) {
cin >> L >> R;
v.push_back({L, R});
for (p = L; p <= R; p++) a[i][p] = notr;
notr++;
}
}
for (j = 1; j <= m; j++) {
for (i = 1; i <= m; i++) {
if (i + j - 1 > m) break;
for (k = i; k <= i + j - 1; k++) {
s = 0;
for (p = 1; p <= n; p++) {
notr = a[p][k];
if (v[notr].first >= i && v[notr].second <= i + j - 1) s++;
}
if (s * s + dp[i][k - 1] + dp[k + 1][i + j - 1] > dp[i][i + j - 1])
dp[i][i + j - 1] = s * s + dp[i][k - 1] + dp[k + 1][i + j - 1];
}
}
}
cout << dp[1][m];
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k, fri = 0;
cin >> n >> m >> k;
vector<int> v;
for (int i = 0; i < m + 1; i++) {
int t;
cin >> t;
v.push_back(t);
}
int la = v[m];
vector<int> labit;
for (int i = 0; i < 32; i++) {
if ((1 << i) & la)
labit.push_back(1);
else
labit.push_back(0);
}
for (int i = 0; i < m; i++) {
int cnt = 0;
for (int j = 0; j < 32; j++) {
int tembit;
if ((1 << j) & v[i])
tembit = 1;
else
tembit = 0;
if (tembit != labit[j]) cnt++;
}
if (cnt <= k) fri++;
}
cout << fri;
}
int main() {
int t = 1;
for (int i = 0; i < t; i++) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int w, h, k;
int count = 0;
scanf("%d %d %d", &w, &h, &k);
for (int i = 0; i < k; i++) {
count = count + ((w - 2) * 2 + (h - 2) * 2 + 4);
w -= 4;
h -= 4;
}
printf("%d", count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
long long n, m, w, a[N], b[N], d[N], ans, l = 0, r;
bool judge(long long x) {
for (long long i = 1; i <= n; i++) {
d[i] = a[i] - a[i - 1];
b[i] = a[i];
}
long long tot = 0;
for (long long i = 1; i <= n; i++) {
b[i] = d[i] + b[i - 1];
if (b[i] < x) {
d[i] += x - b[i];
tot += x - b[i];
if (tot > m) return 0;
d[min(n + 1, i + w)] -= x - b[i];
}
b[i] = d[i] + b[i - 1];
}
if (tot <= m)
return 1;
else
return 0;
}
signed main() {
scanf("%I64d%I64d%I64d", &n, &w, &m);
for (long long i = 1; i <= n; i++) {
long long dis;
scanf("%I64d", &dis);
d[max(1ll, i - w)] += dis;
d[min(n + 1, i + w + 1)] -= dis;
}
for (long long i = 1; i <= n; i++) a[i] = a[i - 1] + d[i], r = max(r, a[i]);
w = w * 2 + 1;
r += m;
while (l <= r) {
long long mid = (l + r) >> 1;
if (judge(mid)) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
printf("%I64d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int l, r, a;
int main() {
cin >> l >> r >> a;
if (l < r) {
if (a + l <= r)
l += a, a = 0;
else
a -= r - l, l = r;
} else if (r < l) {
if (a + r <= l)
r += a, a = 0;
else
a -= l - r, r = l;
}
int ans = min(r, l) * 2;
if (a >= 2) {
if (a & 1) a--;
ans += a;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s, t, aes;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
cin >> s, aes = s, sort(aes.begin(), aes.end());
if (k > n) {
t = s;
for (int i = 0; i <= k - n - 1; i += 1) t.push_back(aes[0]);
} else {
t = s.substr(0, k);
for (int i = (int)t.size() - 1; i >= 0; i -= 1) {
auto j = upper_bound(aes.begin(), aes.end(), t[i]);
if (j != aes.end()) {
t[i] = *j;
break;
}
t[i] = aes[0];
}
}
cout << t << '\n';
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.