solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool vis[200000005];
int n;
int x[2005];
int y[2005];
int ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
vis[x[i]] = 1;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &y[i]);
vis[y[i]] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (vis[x[i] ^ y[j]] == 1) ans++;
if (ans % 2 == 1) printf("Koyomi");
if (ans % 2 == 0) printf("Karen");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void onlinejuge() {}
int isVowel(char c) {
return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
}
bool ranklist(pair<int, int> &p1, pair<int, int> &p2) {
if (p1.first > p2.first)
return 1;
else if (p1.first == p2.first)
return (p1.second < p2.second);
else
return 0;
}
int main() {
onlinejuge();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
map<int, int> map;
int t, max = 0;
cin >> t;
while (t--) {
int a;
cin >> a;
map[a]++;
if (max < map[a]) max = map[a];
}
cout << max << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long comb(long long a, long long b) {
long long res = 1LL;
if (b > a) return 0LL;
int k = min(b, a - b);
for (long long i = a; i > max(a - b, b); i--) {
res *= i;
if (res % k == 0 && k >= 1) {
res /= 1LL * k;
k--;
}
}
for (long long i = k; i >= 1; i--) {
res /= i;
}
return res;
}
int main() {
long long m, n, t;
cin >> n >> m >> t;
long long tot = 0LL;
for (long long i = 4LL; i < t; i++) {
tot += comb(n, i) * comb(m, t - i);
}
cout << tot << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
bitset<12000000> isp;
int sieve(int A, int B) {
if (A > B) return 0;
isp.set();
for (__typeof((primes).begin()) ip = (primes).begin(); ip != (primes).end();
++ip) {
int p = *ip;
if (p * p > B) break;
for (int i = max(p, (A + p - 1) / p) * p; i <= B; i += p)
isp[i - A] = false;
}
int res = 0;
if (A <= 2 && 2 <= B) res++;
for (int i = (A); i <= (int)(B); ++i)
if (isp[i - A] && i >= 5 && i % 4 == 1) res++;
return res;
}
int main() {
for (int i = (3); i <= (int)(20000); ++i) {
bool f = true;
for (int j = 2; j * j <= i; j++)
if (i % j == 0) f = false;
if (f) primes.push_back(i);
}
int A, B;
while (scanf("%d%d", &A, &B) != EOF) {
int cut[31];
for (int i = 0; i < (int)(31); ++i)
cut[i] = ((long long)B * i + (long long)A * (30 - i)) / 30LL;
int res = 0;
for (int i = 0; i < (int)(30); ++i) {
int C = cut[i], D = cut[i + 1];
if (i) C++;
res += sieve(C, D);
}
printf("%d\n", res);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int tmp[105];
int dp[105][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> tmp[i];
dp[i][0] = dp[i][1] = dp[i][2] = 100000008;
}
if (tmp[0] & 1) dp[0][0] = 0;
if (tmp[0] & 2) dp[0][1] = 0;
dp[0][2] = 1;
for (int i = 1; i < n; ++i) {
if (tmp[i] & 1) {
dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]);
}
if (tmp[i] & 2) {
dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]);
}
dp[i][2] = min(min(dp[i - 1][1], dp[i - 1][0]), dp[i - 1][2]) + 1;
}
int ans = min(min(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long double PI = acos(-1);
const long double eps = 0.0000000001;
const long long INF = 0x3fffffffffffffff;
long long n, v[1005], lim;
bool did[1005][1005];
long long dfn[1005][1005];
void work(long long a, long long b) {
did[a][b] = did[b][a] = true;
dfn[a][b] = dfn[b][a] = -1;
std::cout << a << ' ' << b << std::endl;
}
void work4(long long a, long long b, long long c, long long d) {
work(a, b);
work(a, c);
work(b, d);
work(a, d);
work(b, c);
work(c, d);
}
void work5(long long a, long long b, long long c, long long d, long long e) {
work(a, b);
work(a, c);
work(a, d);
work(b, c);
work(b, e);
work(c, e);
work(a, e);
work(c, d);
work(b, d);
work(d, e);
}
void work2_4(long long a, long long b, long long c, long long d, long long e,
long long f, long long g, long long h) {
work(a, e);
work(a, f);
work(a, g);
work(b, e);
work(b, h);
work(a, h);
work(b, g);
work(c, e);
work(d, f);
work(c, f);
work(b, f);
work(c, g);
work(d, e);
work(d, h);
work(c, h);
work(d, g);
}
void dfs(long long tim, long long good) {
for (long long i = 1; i <= n; ++i) {
if (v[i] != i) {
bool can = false;
for (long long j = 1; j < i; ++j) can |= !dfn[j][i];
for (long long j = i + 1; j <= n; ++j) can |= !dfn[i][j];
if (!can) return;
}
}
if (tim == lim && good == n) {
for (long long t = 1; t <= tim; ++t)
for (long long i = 1; i <= n; ++i)
for (long long j = i + 1; j <= n; ++j)
if (dfn[i][j] == t) std::cout << i << ' ' << j << std::endl;
exit(0);
}
for (long long i = 1; i <= n; ++i)
for (long long j = i + 1; j <= n; ++j)
if (!dfn[i][j]) {
dfn[i][j] = tim + 1;
good -= (i == v[i]);
good -= (j == v[j]);
std::swap(v[i], v[j]);
good += (i == v[i]);
good += (j == v[j]);
dfs(tim + 1, good);
good -= (i == v[i]);
good -= (j == v[j]);
std::swap(v[i], v[j]);
good += (i == v[i]);
good += (j == v[j]);
dfn[i][j] = 0;
}
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin >> n;
for (long long i = 1; i <= n; ++i) v[i] = i;
switch (n % 4) {
case 0:
std::cout << "YES" << std::endl;
for (long long i = 4; i <= n; i += 4) work4(i - 3, i - 2, i - 1, i);
for (long long i = 4; i <= n; i += 4)
for (long long j = i + 4; j <= n; j += 4)
work2_4(i - 3, i - 2, i - 1, i, j - 3, j - 2, j - 1, j);
break;
case 1:
std::cout << "YES" << std::endl;
for (long long i = 4; i <= n; i += 4) work5(i - 3, i - 2, i - 1, i, n);
for (long long i = 4; i <= n; i += 4)
for (long long j = i + 4; j <= n; j += 4)
work2_4(i - 3, i - 2, i - 1, i, j - 3, j - 2, j - 1, j);
break;
case 2:
case 3:
std::cout << "NO" << std::endl;
break;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int spf[N];
int status[N] = {0};
void makeprime() {
for (int i = 2; i <= N / i; i++) {
if (spf[i] == 1) {
for (int j = i * i; j < N; j += i) {
if (spf[j] == 1) {
spf[j] = i;
}
}
}
}
}
int checkstatus(int x) {
int t = x, y = t;
while (t > 1 && spf[t] >= 1) {
if (status[y] > 0) {
if (status[y] != x) {
return status[y];
}
}
y = spf[t];
if (y == 1) {
if (status[t] != 0 && status[t] != x) return status[t];
break;
} else {
t = t / y;
}
}
return -1;
}
void makestatus(int x) {
int t = x;
int y = t;
while (t > 1 && spf[t] >= 1) {
status[y] = x;
y = spf[t];
if (y == 1) {
status[t] = x;
break;
} else {
t = t / y;
}
}
return;
}
void removestatus(int x) {
int t = x, y = t;
while (t > 1 && spf[t] >= 1) {
status[y] = 0;
y = spf[t];
if (y == 1) {
status[t] = 0;
break;
} else {
t = t / y;
}
}
return;
}
int main() {
int n, m;
cin >> n >> m;
unordered_set<int> s;
fill(spf, spf + N, 1);
makeprime();
while (m--) {
char sign;
int q;
cin >> sign >> q;
if (sign == '+') {
if (s.find(q) != s.end()) {
cout << "Already on" << endl;
} else {
int conflict = checkstatus(q);
if (conflict == -1) {
makestatus(q);
s.insert(q);
cout << "Success" << endl;
} else {
cout << "Conflict with " << conflict << endl;
}
}
} else {
if (s.find(q) == s.end()) {
cout << "Already off" << endl;
} else {
s.erase(q);
removestatus(q);
cout << "Success" << endl;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 15], *fs, *ft;
inline char getc() {
return (fs == ft &&
(ft = (fs = buf) + fread(buf, 1, 1 << 15, stdin), fs == ft))
? 0
: *fs++;
}
inline int read() {
register int x = 0, f = 1;
register char ch = getc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getc();
}
return x * f;
}
const int MAXN = 110;
int T, ans, cnt;
int n, m;
string a[MAXN], b;
map<string, int> H;
int vis[MAXN];
int q[MAXN], mark[MAXN];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
b = "";
int flag = 0;
for (int j = m - 1; j >= 0; --j) b += a[i][j];
for (int j = 0; j < m; ++j)
if (b[j] != a[i][j]) flag = 1;
if (!flag) mark[i] = 1, ++cnt;
if (H.find(b) != H.end()) {
++ans;
vis[H[b]] = i;
vis[i] = H[b];
}
H[a[i]] = i;
}
if (!ans) {
if (!cnt) {
cout << 0 << endl;
return 0;
} else {
cout << m << endl;
for (int i = 1; i <= n; ++i)
if (mark[i]) {
cout << a[i];
break;
}
}
} else {
cout << ans * 2 * m + (cnt ? m : 0) << endl;
for (int i = 1; i <= n; ++i) {
if (vis[i]) {
q[++T] = vis[i];
vis[vis[i]] = 0;
cout << a[i];
}
}
for (int i = 1; i <= n; ++i)
if (mark[i]) {
cout << a[i];
break;
}
for (int i = T; i >= 1; --i) cout << a[q[i]];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int sz[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
map<string, int> mp;
int id = 0;
int ans = 0;
vector<int> v;
for (int i = 1; i < n + 1; i++) {
string s;
cin >> s;
ans += s.size();
if (mp.find(s) == mp.end()) {
mp[s] = ++id;
sz[id] = s.size();
}
v.push_back(mp[s]);
}
ans += n - 1;
int fans = ans;
for (int i = 0; i < v.size(); i++) {
int tot = 0;
for (int j = i; j < v.size(); j++) {
tot += sz[v[j]] - 1;
int idx = j + 1, cnt = 1;
while (idx + j - i < v.size()) {
bool flag = true;
for (int k = idx; k < idx + j - i + 1; k++) {
if (v[k] != v[k - idx + i]) {
flag = false;
break;
}
}
if (!flag) {
idx++;
} else {
idx += j - i + 1;
cnt++;
}
}
if (cnt > 1) {
ans = min(ans, fans - cnt * (j - i + tot));
}
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r, L = 0, R = 0;
cin >> n;
vector<vector<int> > lr;
vector<int> xd;
for (int i = 0; i < n; i++) {
cin >> l >> r;
xd.push_back(l);
xd.push_back(r);
lr.push_back(xd);
xd.clear();
L = L + l;
R = R + r;
}
int max = abs(L - R);
int index = -1;
for (int i = 0; i < lr.size(); i++) {
L += lr[i][1] - lr[i][0];
R += lr[i][0] - lr[i][1];
if (abs(L - R) > max) {
max = abs(L - R);
index = i;
}
L += lr[i][0] - lr[i][1];
R += lr[i][1] - lr[i][0];
}
cout << index + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
int n, m, k, q, tot, fir[M], las[M], reg[M], in[M], out[M], siz[M], dfs_clock;
bool vis[M];
struct edge {
int v, nex;
} e[M << 1];
void add(int u, int v) {
e[++tot] = (edge){v, fir[u]};
fir[u] = tot;
}
void dfs(int u) {
siz[u] = vis[u] = 1;
in[u] = ++dfs_clock;
for (int i = fir[u]; i; i = e[i].nex) {
int v = e[i].v;
dfs(v);
siz[u] += siz[v];
}
out[u] = dfs_clock;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k >> q;
for (int i = 1; i <= k; i++) {
int x, y;
cin >> x >> y;
if (las[y]) {
out[x]++;
add(las[y], x);
}
las[y] = x;
}
for (int i = 1; i <= n; i++)
if (!vis[i] && !out[i]) dfs(i);
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
y = las[y];
if (in[y] >= in[x] && in[y] <= out[x])
cout << siz[x] << endl;
else
cout << 0 << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int kol[100500];
void cnt(vector<pair<int, int>> v) {
sort(v.begin(), v.end());
int l = v.size();
if (l < 2) return;
kol[v[0].second]++;
kol[v[l - 1].second]++;
for (int i = 1; i < l - 1; i++) kol[v[i].second] += 2;
}
int main() {
int n, m, r, c, i;
int t[10];
cin >> n >> m;
vector<vector<pair<int, int>>> hor(n);
vector<vector<pair<int, int>>> ver(n);
vector<vector<pair<int, int>>> d1(2 * n - 1);
vector<vector<pair<int, int>>> d2(2 * n - 1);
for (i = 0; i < m; i++) {
scanf("%d%d", &r, &c);
r--;
c--;
hor[r].push_back(make_pair(c, i));
ver[c].push_back(make_pair(r, i));
d1[c - r + n - 1].push_back(make_pair(c, i));
d2[c + r].push_back(make_pair(c, i));
}
memset(kol, 0, sizeof(kol));
for (i = 0; i < n; i++) {
cnt(hor[i]);
cnt(ver[i]);
}
for (i = 0; i < 2 * n - 1; i++) {
cnt(d1[i]);
cnt(d2[i]);
}
memset(t, 0, sizeof(t));
for (i = 0; i < m; i++) t[kol[i]]++;
for (i = 0; i < 9; i++) cout << t[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
long long res, a[9];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
a[i % 9]++;
res -= n / i;
}
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
res += a[i] * a[j] * a[i * j % 9];
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[105];
int brr[105];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
}
sort(arr, arr + n, greater<int>());
sort(arr + 1, arr + n - 1);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, root, ans, a, b;
scanf("%d", &n);
root = sqrt(n);
a = n / root;
ans = a * root;
while (ans != n) {
root = root - 1;
a = n / root;
ans = a * root;
}
printf("%d %d\n", root, a);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long NMAX = 111111;
long long p25[NMAX + 1], p26[NMAX + 1];
long long p25inv[NMAX + 1], p26inv[NMAX + 1];
long long pinv[NMAX + 1];
long long fp(long long x, long long y) {
if (y == 0) return 1;
if (y % 2) return x * fp(x, y - 1) % MOD;
long long h = fp(x, y / 2);
return h * h % MOD;
}
long long minv(long long t) { return fp(t, MOD - 2); }
vector<long long> gen(long long s) {
vector<long long> ret(NMAX + 1);
ret[s] = p25[s] * p26inv[s] % MOD;
for (long long i = s; i < NMAX; i++) {
ret[i + 1] = ret[i];
ret[i + 1] *= i * pinv[i + 1 - s] % MOD;
ret[i + 1] %= MOD;
ret[i + 1] *= 25 * p26inv[1] % MOD;
ret[i + 1] %= MOD;
}
for (long long i = s; i <= NMAX; i++) {
ret[i] = (ret[i] + ret[i - 1]) % MOD;
}
for (long long i = s; i <= NMAX; i++)
ret[i] = ret[i] * (p26[i] * p25inv[s] % MOD) % MOD;
return ret;
}
unordered_map<int, vector<pair<int, int> > > quries;
long long ans[NMAX];
int main() {
p25[0] = p26[0] = p25inv[0] = p26inv[0] = 1;
for (int i = 0; i < NMAX; i++) {
p25[i + 1] = p25[i] * 25 % MOD;
p26[i + 1] = p26[i] * 26 % MOD;
}
long long tmp = minv(25);
for (int i = 1; i < NMAX; i++) p25inv[i] = p25inv[i - 1] * tmp % MOD;
tmp = minv(26);
for (int i = 1; i < NMAX; i++) p26inv[i] = p26inv[i - 1] * tmp % MOD;
pinv[1] = 1;
for (long long i = 2; i < NMAX; i++)
pinv[i] = MOD - (MOD / i) * pinv[MOD % i] % MOD;
cin.sync_with_stdio(0), cout.sync_with_stdio(0);
int m;
string str;
cin >> m >> str;
int n, s;
s = str.size();
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
cin >> str;
s = str.size();
} else {
cin >> n;
quries[s].push_back(pair<int, int>(n, i));
}
}
for (int i = 0; i < m; i++) ans[i] = -1;
for (auto& kv : quries) {
s = kv.first;
auto v = gen(s);
for (auto p : kv.second) {
ans[p.second] = v[p.first];
}
}
for (int i = 0; i < m; i++)
if (ans[i] >= 0) cout << ans[i] << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long Power(long long BaSe, long long PoWeR, long long MoD) {
BaSe %= MoD;
long long ret = 1;
while (PoWeR > 0) {
if (PoWeR & 1) ret = (ret * BaSe) % MoD;
PoWeR >>= 1;
BaSe = (BaSe * BaSe) % MoD;
}
return ret;
}
long long a[100010], p[1010], t, mx = 0;
void find_d(long long x) {
t = 0;
long long cur = 1;
while (cur * cur <= x) {
if (x % cur == 0) {
p[t++] = cur;
if (cur * cur < x) p[t++] = x / cur;
}
cur++;
}
sort(p, p + t), p[t] = mx + 1;
}
int main() {
long long n, x, ans = 0, q, cur;
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
scanf("%lld", &x);
a[x]++;
mx = mx > x ? mx : x;
}
for (long long i = 1; i <= mx; i++) a[i] += a[i - 1];
for (long long i = 1; i <= mx; i++) {
find_d(i);
x = 1;
for (long long j = 0; j < t; j++) {
q = a[p[j + 1] - 1] - a[p[j] - 1];
cur = Power(j + 1, q, 1000000007);
if (j == t - 1)
cur = (cur - Power(j, q, 1000000007) + 1000000007) % 1000000007;
x *= cur;
x %= 1000000007;
}
ans = (ans + x) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int d = 31;
int basis[d];
int sz;
void insertVector(int mask) {
for (int i = 0; i < d; i++) {
if ((mask & 1 << i) == 0) continue;
if (!basis[i]) {
basis[i] = mask;
++sz;
return;
}
mask ^= basis[i];
}
}
int main() {
srand(chrono::steady_clock::now().time_since_epoch().count());
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int a;
long long int x = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
cin >> a;
x ^= a;
insertVector(a);
}
if (x)
cout << sz;
else
cout << -1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long p[17] = {19634730635520000, 67665248476907597, 877779077635511999,
15031861979012587, 239868713978954299, 8100049778130103,
32826117705688133, 96265407405451883, 260006624961107813,
707992818804600227, 3676594834162829, 6402204344683229,
9797084445859807, 15916020492768661, 27616086651273059,
41286304414422503, 229580147};
long long t;
cin >> t;
while (t--) {
long long X = 1, Y;
for (auto i : p) {
cout << "? " << i << endl;
cin >> Y;
X *= Y;
}
long long ans = 1;
for (long long i = 2; i <= 800; i++) {
long long c = 0;
while (X % i == 0) {
X /= i;
c++;
}
ans *= c + 1;
}
cout << "! " << max(8LL, ans * 2) << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<int> v;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.')
v.push_back(0);
else if (s[i] == '-' && s[i + 1] == '.' && i + 1 < s.size()) {
v.push_back(1);
i++;
} else if (s[i] == '-' && s[i + 1] == '-' && i + 1 < s.size()) {
v.push_back(2);
i++;
}
}
for (int i = 0; i < v.size(); i++) cout << v[i];
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, k, flag = 0, x, i, j;
string st;
cin >> n >> k >> st;
for (i = 0; i < n; i++) {
if (st[i] == 'G') {
break;
}
}
for (j = i + k; j < n; j = j + k) {
if (st[j] == '#') {
break;
}
if (st[j] == 'T') {
cout << "YES";
return 0;
}
}
for (j = i - k; j >= 0; j = j - k) {
if (st[j] == '#') {
cout << "NO";
return 0;
}
if (st[j] == 'T') {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str[10];
int r[500], l[500];
int main() {
str[1] = "qwertyuiop";
str[2] = "asdfghjkl;";
str[3] = "zxcvbnm,./";
for (int i = 1; i <= 3; i++) {
for (int j = 0; j < str[i].length(); j++) {
if (j >= 1) l[(int)str[i][j]] = (int)str[i][j - 1];
if (j < str[i].length() - 1) r[(int)str[i][j]] = (int)str[i][j + 1];
}
}
char ch;
string str;
cin >> ch >> str;
for (int t = 0; t < str.length(); t++) {
str[t] = (ch == 'R') ? (char)l[(int)str[t]] : (char)r[(int)str[t]];
}
cout << str;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
vector<int> adj[100009][2];
vector<int> ans[3];
vector<int> node[3];
int n, m, vis[100009], group[100009];
void _add(int color, int x) {
for (typeof((ans[x]).begin()) it = (ans[x]).begin(); it != (ans[x]).end();
it++)
node[color].push_back(*it);
}
int dfs(int nd, int x, int y) {
vis[nd] = 1;
ans[y].push_back(nd);
int ret = 1;
group[nd] = y;
for (typeof((adj[nd][x]).begin()) it = (adj[nd][x]).begin();
it != (adj[nd][x]).end(); it++) {
if (!vis[*it])
ret &= dfs(*it, x, y ^ 1);
else if (group[nd] == group[*it])
return 0;
}
for (typeof((adj[nd][x ^ 1]).begin()) it = (adj[nd][x ^ 1]).begin();
it != (adj[nd][x ^ 1]).end(); it++) {
if (!vis[*it])
ret &= dfs(*it, x, y);
else if (group[nd] != group[*it])
return 0;
}
return ret;
}
int calc(int x) {
memset(vis, 0, sizeof(vis));
memset(group, -1, sizeof(group));
for (int i = 1; i <= n; i++)
if (!vis[i]) {
ans[0].resize(0);
ans[1].resize(0);
if (dfs(i, x, 0))
_add(x, (ans[0].size() > ans[1].size()));
else
return 1000000007;
}
return int(node[x].size());
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
char col;
scanf("%d%d %c", &u, &v, &col);
adj[u][col == 'R'].push_back(v);
adj[v][col == 'R'].push_back(u);
}
int kind = -1, mn = 1000000007;
if (umin(mn, calc(0))) kind = 0;
if (umin(mn, calc(1))) kind = 1;
if (kind == -1) return printf("-1\n"), 0;
printf("%d\n", int(node[kind].size()));
for (typeof((node[kind]).begin()) it = (node[kind]).begin();
it != (node[kind]).end(); it++)
printf("%d ", *it);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> right1;
vector<int> rang, col, dsu;
vector<pair<int, int> > vec;
int n, m, q;
pair<int, int> pred(int a) {
if (a == dsu[a]) {
return {dsu[a], 0};
}
pair<int, int> t = pred(dsu[a]);
return {t.first, col[a] ^ t.second};
}
bool flag1 = true;
void unite(int a, int b) {
pair<int, int> t1 = pred(a);
pair<int, int> t2 = pred(b);
if (t1.first == t2.first && t1.second == t2.second) {
flag1 = false;
}
if (t1.first == t2.first) {
return;
}
if (rang[t1.first] < rang[t2.first]) {
swap(t1, t2);
}
if (t1.second == t2.second ^ col[t2.first]) {
col[t2.first] ^= 1;
}
dsu[t2.first] = t1.first;
rang[t1.first] += rang[t2.first];
}
vector<vector<pair<int, int> > > mass1, mass2, mass3;
vector<pair<int, int> > mass4, mass5, mass6;
void build(int w, int l, int r, int l1, int r1) {
mass1[w].resize(r - l + 1);
mass2[w].resize(r - l + 1);
mass3[w].resize(r - l + 1);
if (l == r) {
int r2 = r1;
bool flag = flag1;
while (r1 > max(l1, l) && flag1) {
r1--;
mass4[r1].first = pred(vec[r1].first).first;
mass5[r1].first = rang[pred(vec[r1].first).first];
mass6[r1].first = col[pred(vec[r1].first).first];
mass4[r1].second = pred(vec[r1].second).first;
mass5[r1].second = rang[pred(vec[r1].second).first];
mass6[r1].second = col[pred(vec[r1].second).first];
unite(vec[r1].first, vec[r1].second);
}
right1[l] = r1;
flag1 = flag;
while (r1 < r2) {
int v = mass4[r1].first;
dsu[v] = v;
rang[v] = mass5[r1].first;
col[v] = mass6[r1].first;
v = mass4[r1].second;
dsu[v] = v;
rang[v] = mass5[r1].second;
col[v] = mass6[r1].second;
r1++;
}
} else {
bool flag = flag1;
int midd = (r + l) / 2;
for (int i = l; i <= midd; i++) {
mass1[w][i - l].first = pred(vec[i].first).first;
mass2[w][i - l].first = rang[pred(vec[i].first).first];
mass3[w][i - l].first = col[pred(vec[i].first).first];
mass1[w][i - l].second = pred(vec[i].second).first;
mass2[w][i - l].second = rang[pred(vec[i].second).first];
mass3[w][i - l].second = col[pred(vec[i].second).first];
}
for (int i = l; i < midd; i++) {
unite(vec[i].first, vec[i].second);
}
int r2 = r1;
while (r1 > max(l1, midd) && flag1) {
r1--;
mass4[r1].first = pred(vec[r1].first).first;
mass5[r1].first = rang[pred(vec[r1].first).first];
mass6[r1].first = col[pred(vec[r1].first).first];
mass4[r1].second = pred(vec[r1].second).first;
mass5[r1].second = rang[pred(vec[r1].second).first];
mass6[r1].second = col[pred(vec[r1].second).first];
unite(vec[r1].first, vec[r1].second);
}
for (int i = r1; i < r2; i++) {
int v = mass4[i].first;
dsu[v] = v;
rang[v] = mass5[i].first;
col[v] = mass6[i].first;
v = mass4[i].second;
dsu[v] = v;
rang[v] = mass5[i].second;
col[v] = mass6[i].second;
}
for (int i = midd - 1; i >= l; i--) {
int v = mass1[w][i - l].first;
rang[v] = mass2[w][i - l].first;
col[v] = mass3[w][i - l].first;
dsu[v] = v;
v = mass1[w][i - l].second;
dsu[v] = v;
rang[v] = mass2[w][i - l].second;
col[v] = mass3[w][i - l].second;
}
flag1 = flag;
for (int i = r2 - 1; i >= r1; i--) {
mass4[i].first = pred(vec[i].first).first;
mass5[i].first = rang[pred(vec[i].first).first];
mass6[i].first = col[pred(vec[i].first).first];
mass4[i].second = pred(vec[i].second).first;
mass5[i].second = rang[pred(vec[i].second).first];
mass6[i].second = col[pred(vec[i].second).first];
unite(vec[i].first, vec[i].second);
}
build(w * 2, l, midd, l1, r1);
for (int i = r1; i < r2; i++) {
int v = mass4[i].first;
rang[v] = mass5[i].first;
col[v] = mass6[i].first;
dsu[v] = v;
v = mass4[i].second;
rang[v] = mass5[i].second;
col[v] = mass6[i].second;
dsu[v] = v;
}
flag1 = flag;
for (int j = l; j <= midd; j++) {
unite(vec[j].first, vec[j].second);
}
build(w * 2 + 1, midd + 1, r, r1, r2);
for (int i = l; i <= midd; i++) {
int v = mass1[w][i - l].first;
rang[v] = mass2[w][i - l].first;
col[v] = mass3[w][i - l].first;
dsu[v] = v;
v = mass1[w][i - l].second;
rang[v] = mass2[w][i - l].second;
col[v] = mass3[w][i - l].second;
dsu[v] = v;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> q;
right1.resize(m);
vec.resize(m);
mass1.resize(4 * m);
mass2.resize(4 * m);
mass3.resize(4 * m);
rang.resize(n);
dsu.resize(n);
mass4.resize(m);
mass5.resize(m);
mass6.resize(m);
col.resize(n);
for (int i = 0; i < n; i++) {
dsu[i] = i;
rang[i] = 1;
col[i] = 0;
}
for (int i = 0; i < m; i++) {
cin >> vec[i].first >> vec[i].second;
vec[i].first--;
vec[i].second--;
}
build(1, 0, m - 1, 0, m);
while (q--) {
int l, r;
cin >> l >> r;
l--;
if (right1[l] < r) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, c;
cin >> n >> b >> c;
int tab[n];
int suma = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
tab[i] = x;
}
for (int i = 0; i < ((n - (n % 2)) / 2); i++) {
if (tab[i] == 2 && tab[n - i - 1] == 2) {
if (b < c)
suma += 2 * b;
else
suma += 2 * c;
} else if (tab[i] == 1 && tab[n - i - 1] == 2)
suma += c;
else if (tab[i] == 2 && tab[n - i - 1] == 1)
suma += c;
else if (tab[i] == 0 && tab[n - i - 1] == 2)
suma += b;
else if (tab[i] == 2 && tab[n - i - 1] == 0)
suma += b;
else if (tab[i] != tab[n - i - 1]) {
cout << "-1";
return 0;
}
}
if (n % 2 == 1) {
if (tab[((n - 1) / 2)] == 2) {
if (b < c)
suma += b;
else
suma += c;
}
}
cout << suma;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 2010;
int N, M, L;
char A[NMax][NMax];
set<pair<pair<int, int>, pair<int, int> > > S;
int check(int first, int second) {
if (first < 0 || second < 0 || first >= N || second >= M) return 0;
if (A[first][second] == '.') return 1;
return 0;
}
void run(int i, int j) {
if (!check(i, j)) return;
if (check(i - 1, j) && !check(i + 1, j) && !check(i, j - 1) &&
!check(i, j + 1))
S.insert(make_pair(make_pair(i, j), make_pair(i - 1, j)));
else if (check(i + 1, j) && !check(i - 1, j) && !check(i, j - 1) &&
!check(i, j + 1))
S.insert(make_pair(make_pair(i, j), make_pair(i + 1, j)));
else if (check(i, j - 1) && !check(i - 1, j) && !check(i + 1, j) &&
!check(i, j + 1))
S.insert(make_pair(make_pair(i, j), make_pair(i, j - 1)));
else if (check(i, j + 1) && !check(i - 1, j) && !check(i + 1, j) &&
!check(i, j - 1))
S.insert(make_pair(make_pair(i, j), make_pair(i, j + 1)));
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", A[i]);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) run(i, j);
while (!S.empty()) {
pair<pair<int, int>, pair<int, int> > tmp = *(S.begin());
S.erase(tmp);
if (!check(tmp.first.first, tmp.first.second) ||
!check(tmp.second.first, tmp.second.second))
continue;
if (tmp.first.first == tmp.second.first) {
if (tmp.first.second > tmp.second.second) swap(tmp.first, tmp.second);
A[tmp.first.first][tmp.first.second] = '<';
A[tmp.second.first][tmp.second.second] = '>';
} else {
if (tmp.first.first > tmp.second.first) swap(tmp.first, tmp.second);
A[tmp.first.first][tmp.first.second] = '^';
A[tmp.second.first][tmp.second.second] = 'v';
}
run(tmp.first.first - 1, tmp.first.second);
run(tmp.first.first + 1, tmp.first.second);
run(tmp.first.first, tmp.first.second - 1);
run(tmp.first.first, tmp.first.second + 1);
run(tmp.second.first - 1, tmp.second.second);
run(tmp.second.first + 1, tmp.second.second);
run(tmp.second.first, tmp.second.second - 1);
run(tmp.second.first, tmp.second.second + 1);
}
int flag = 1;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (A[i][j] == '.') {
flag = 0;
break;
}
if (!flag) {
puts("Not unique");
getchar();
getchar();
return 0;
}
for (int i = 0; i < N; i++) printf("%s\n", A[i]);
getchar();
getchar();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> answer(n + 3, 0);
vector<int> par(n + 3);
vector<int> max1(n + 3, 0);
vector<int> max2(n + 3, 0);
int res = 1;
for (int i = 2; i <= n + 1; ++i) {
cin >> par[i];
int curr = i;
while (curr != 1) {
int val = max(max1[curr], 1 + max2[curr]);
if (answer[curr] >= val) break;
answer[curr] = val;
if (max1[par[curr]] < val) {
max2[par[curr]] = max1[par[curr]];
max1[par[curr]] = val;
} else if (max2[par[curr]] < val) {
max2[par[curr]] = val;
}
curr = par[curr];
}
cout << max(max1[1], max2[1]) << ' ';
}
cout << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int mpow(int base, int exp);
void sieve();
vector<int> getFactors(long long x);
template <typename F, typename S>
ostream &operator<<(ostream &out, const pair<F, S> &p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) out << ", ";
out << *it;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, const set<T> &v) {
out << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) out << ", ";
out << *it;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, const unordered_set<T> &v) {
out << "[";
typename unordered_set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) out << ", ";
out << *it;
}
return out << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &out, const map<F, S> &v) {
out << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) out << ", ";
out << it->first << ":" << it->second;
}
return out << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &out, const unordered_map<F, S> &v) {
out << "[";
typename unordered_map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) out << ", ";
out << it->first << ":" << it->second;
}
return out << "]";
}
long long randGen(long long lower, long long upper) {
return (rand() % (upper - lower + 1)) + lower;
}
long long dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int MAX = 1e6 + 5;
bool prime[MAX];
int spf[MAX];
void test_case() {
int n, x;
cin >> n >> x;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end(), greater<int>());
for (int i = 0; i < n; i++) {
if ((a[i] + b[i]) > x) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t-- > 0) {
test_case();
}
return 0;
}
int mpow(int base, int exp) {
base %= MOD;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % MOD;
base = ((long long)base * base) % MOD;
exp >>= 1;
}
return result;
}
void sieve() {
fill(prime, prime + MAX, true);
for (int i = 1; i < MAX; i++) spf[i] = i;
prime[0] = prime[1] = false;
for (int i = 2; i * i < MAX; i++) {
if (prime[i]) {
for (int j = i * i; j < MAX; j += i) {
if (prime[j]) spf[j] = i;
prime[j] = false;
}
}
}
}
vector<int> getFactors(long long int x) {
vector<int> ret;
while (x != 1) {
ret.push_back(spf[x]);
x = x / spf[x];
}
return ret;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
const int N = 1e5 + 100;
const int M = 1e9 + 7;
struct op {
int x, y;
op() : x(0), y(0) {}
inline op(int _x, int _y) : x(_x), y(_y) {}
};
inline op operator+(const op &a, const op &b) {
return op((a.x + b.x) % M, (a.y + b.y) % M);
}
inline op operator*(const op &a, const int &b) {
return op((1ll * a.x * b) % M, (1ll * a.y * b) % M);
}
char s[N];
int n;
string req[N];
op r[10];
op apply(const op &a, const op &b) {
return op((1ll * a.x * b.x) % M, (1ll * b.x * a.y + b.y) % M);
}
int main() {
assert(scanf("%s%d", s, &n) == 2);
for (int i = 0; i < n; i++) {
static char buf[N];
assert(scanf("%s", buf) == 1);
req[i] = string(buf);
}
for (int i = 0; i < 10; i++) r[i] = op(10, i);
for (int i = n - 1; i >= 0; i--) {
int index1 = find((req[i]).begin(), (req[i]).end(), '-') - req[i].begin();
int start = index1 + 2, digit = req[i][0] - '0';
op res(1, 0);
for (int j = start; j < ((int)(req[i]).size()); j++)
res = apply(res, r[req[i][j] - '0']);
r[digit] = res;
}
int res = 0;
for (int i = 0; s[i]; i++) {
res = (1ll * res * r[s[i] - '0'].x + r[s[i] - '0'].y) % M;
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, n, m, x, y, i = 1, j, a[100010], b[100010];
string st, stt;
cin >> n;
x = 0;
for (i = 1; i < n; i++) {
x += i;
x = x % n;
cout << x + 1 << ' ';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
int ctz(unsigned x) { return __builtin_ctz(x); }
int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
int clz(unsigned x) { return __builtin_clz(x); }
int clzll(unsigned long long x) { return __builtin_clzll(x); }
int popcnt(unsigned x) { return __builtin_popcount(x); }
int popcntll(unsigned long long x) { return __builtin_popcountll(x); }
int bsr(unsigned x) { return 31 ^ clz(x); }
int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int deg[100016];
pair<int, int> e[100016];
int main() {
canhazfast();
int n, s, k = 0;
double ans;
cin >> n >> s;
for (int i = 1; i < n; ++i) {
cin >> e[i].first >> e[i].second;
++deg[e[i].first];
++deg[e[i].second];
}
if (n == 2) return cout << s, 0;
for (int i = 1; i < n; ++i) {
int x = min(deg[e[i].first], deg[e[i].second]);
if (x == 1) ++k;
}
ans = 2.0 * s / k;
cout << setprecision(7) << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int a[N], b[N], n, m, x, y, z, temp;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) b[i] = i + 1;
for (int k = 0; k < m; k++) {
cin >> x >> y >> z;
for (int i = x; i < z; i = temp) {
temp = b[i];
if (!a[i]) a[i] = z;
b[i] = z;
}
for (int i = z + 1; i <= y; i = temp) {
temp = b[i];
if (!a[i]) a[i] = z;
b[i] = b[y];
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 998244353;
long long inv2 = (p + 1) / 2;
const long long maxn = 5e5 + 5;
vector<long long> a[maxn];
bool used[maxn];
long long dp[maxn][2];
long long po(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
if (b % 2 == 0) {
long long u = po(a, b / 2);
return (u * u) % p;
} else {
long long u = po(a, b - 1);
return (a * u) % p;
}
}
void dfs(long long x) {
used[x] = true;
long long r = 1;
long long sz = 0;
for (auto v : a[x]) {
if (!used[v]) {
dfs(v);
dp[x][0] += dp[v][1];
dp[x][0] %= p;
++sz;
r *= (1 + dp[v][1] - dp[v][0]);
r %= p;
}
}
r *= po(inv2, sz);
r %= p;
dp[x][1] = dp[x][0] + (1 - r);
dp[x][1] %= p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < (n - 1); ++i) {
long long x, y;
cin >> x >> y;
x--;
y--;
a[x].push_back(y);
a[y].push_back(x);
}
dfs(0);
cout << ((dp[0][1] * po(2, n)) % p + p) % p;
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
char ary1[102], ary2[102];
scanf("%s%s", ary1, ary2);
if (strcmp(ary1, ary2) == 0) {
printf("%s\n", ary1);
} else {
printf("1\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int N;
int V1, Q;
int op[200000];
int qa[200000];
int qb[200000];
int parent[200001];
vector<int> adj[200001];
int deg[200001];
int in[200001];
int out[200001];
int now;
int powmod(int a, int b) {
int ret = 1;
for (; b > 0; b /= 2) {
if (b & 1) ret = 1LL * ret * a % MOD;
a = 1LL * a * a % MOD;
}
return ret;
}
int inv(int x) { return powmod(x, MOD - 2); }
struct node {
int A, B, lazy;
} seg[1 << 19];
void apply(int idx, int val) {
seg[idx].A = 1LL * seg[idx].A * val % MOD;
seg[idx].B = 1LL * seg[idx].B * val % MOD;
seg[idx].lazy = 1LL * seg[idx].lazy * val % MOD;
}
void down(int idx) {
if (seg[idx].lazy != 1) {
apply(idx * 2, seg[idx].lazy);
apply(idx * 2 + 1, seg[idx].lazy);
seg[idx].lazy = 1;
}
}
node combine(node a, node b) {
node c;
c.A = (a.A + b.A) % MOD;
c.B = (a.B + b.B) % MOD;
c.lazy = 1;
return c;
}
void updateLabel(int idx, int begin, int end, int x, int v) {
if (x < begin || end < x) return;
if (begin == end)
seg[idx].A = 1LL * v * seg[idx].B % MOD;
else {
down(idx);
int mid = (begin + end) / 2;
updateLabel(idx * 2, begin, mid, x, v);
updateLabel(idx * 2 + 1, mid + 1, end, x, v);
seg[idx] = combine(seg[idx * 2], seg[idx * 2 + 1]);
}
}
void update(int idx, int begin, int end, int l, int r, int v) {
if (r < begin || end < l) return;
if (l <= begin && end <= r)
apply(idx, v);
else {
down(idx);
int mid = (begin + end) / 2;
update(idx * 2, begin, mid, l, r, v);
update(idx * 2 + 1, mid + 1, end, l, r, v);
seg[idx] = combine(seg[idx * 2], seg[idx * 2 + 1]);
}
}
node query(int idx, int begin, int end, int l, int r) {
if (r < begin || end < l) return (node){0, 0, 1};
if (l <= begin && end <= r) return seg[idx];
down(idx);
int mid = (begin + end) / 2;
return combine(query(idx * 2, begin, mid, l, r),
query(idx * 2 + 1, mid + 1, end, l, r));
}
void build(int idx, int begin, int end) {
if (begin == end) {
if (begin == 1)
seg[idx] = (node){V1, 1, 1};
else
seg[idx] = (node){0, 1, 1};
} else {
int mid = (begin + end) / 2;
build(idx * 2, begin, mid);
build(idx * 2 + 1, mid + 1, end);
seg[idx] = combine(seg[idx * 2], seg[idx * 2 + 1]);
}
}
void dfs(int u) {
in[u] = ++now;
for (auto& v : adj[u]) dfs(v);
out[u] = now;
}
int main() {
scanf("%d%d", &V1, &Q);
N = 1;
for (int i = 0; i < Q; i++) {
scanf("%d", op + i);
if (op[i] == 1) {
scanf("%d%d", qa + i, qb + i);
N++;
adj[qa[i]].push_back(N);
parent[N] = qa[i];
qa[i] = N;
} else
scanf("%d", qa + i);
}
dfs(1);
build(1, 1, N);
for (int i = 1; i <= N; i++) deg[i] = 1;
for (int i = 0; i < Q; i++) {
if (op[i] == 1) {
int u = qa[i];
int x = qb[i];
int p = parent[u];
updateLabel(1, 1, N, in[u], x);
deg[p]++;
update(1, 1, N, in[p], out[p], 1LL * deg[p] * inv(deg[p] - 1) % MOD);
} else {
int u = qa[i];
int p = parent[u];
int bval = 1;
if (u != 1) bval = query(1, 1, N, in[p], in[p]).B;
int ans = inv(bval);
ans = 1LL * ans * query(1, 1, N, in[u], out[u]).A % MOD;
printf("%d\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a[4][100];
fill(a[0], a[0] + 100, 0);
fill(a[1], a[1] + 100, INT_MAX);
fill(a[2], a[2] + 100, 0);
fill(a[3], a[3] + 100, INT_MAX);
cin >> n;
for (int i = 0; i < 3; i++)
for (int j = (i == 2 ? 0 : 1); j < 2 * (i == 2 ? n : (n - 1)); j += 2)
cin >> a[(i == 0 ? 0 : i == 1 ? 2 : i == 2 ? 1 : 3)][j];
for (int i = 0; i < 2 * n - 1; i++) {
int sum = 0;
for (int j = 0; j <= i; j++) {
sum += a[0][j];
}
sum += a[1][i];
for (int j = i; j < 2 * n - 1; j++) {
sum += a[2][j];
}
a[3][i] = (sum < 0 ? INT_MAX : sum);
}
sort(a[3], a[3] + 2 * n);
cout << a[3][0] + a[3][1];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long a, b;
int id;
pt(long long a = 0, long long b = 0, int id = 0) : a(a), b(b), id(id) {}
bool operator<(const pt x) const {
return (x.a - a) > 3ll * (x.b + b + 1) * (x.b - b);
}
};
priority_queue<pt> pq;
int n;
long long k, a[100005], b[100005];
bool check(double x) {
double ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= x) {
ans += min(sqrt((a[i] - x) / 3.0), (double)a[i]);
if (ans > k) return 0;
}
}
return ans <= k;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
long long l = -3e18, r = 1e9, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
for (int i = 1; i <= n; i++)
if (a[i] >= r)
b[i] = max(
min(max((long long)floor(sqrt((a[i] - r) / 3.0) - 1e-9), 0ll), a[i]) -
2,
0ll);
else
b[i] = 0;
for (int i = 1; i <= n; i++) {
k -= b[i];
if (b[i] < a[i]) pq.push(pt(a[i], b[i], i));
}
while (k--) {
pt u = pq.top();
pq.pop();
b[u.id]++;
if (u.b + 1 < u.a) pq.push(pt(u.a, u.b + 1, u.id));
}
for (int i = 1; i <= n; i++) printf("%lld ", b[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int N = 2e5 + 10;
int k;
long long sum[N], dp[N], z[N], rsum[N], ind;
long long solve(int *a, int n) {
for (int i = 0; i <= k; i++) dp[i] = 0;
if (a[0] == -1) {
sum[0] = 1;
ind = n + 1;
z[0] = -1;
rsum[0] = 0;
} else {
dp[a[0]] = 1;
ind = a[0];
sum[0] = 0;
z[0] = -1;
rsum[0] = 1;
}
for (int i = 1; i < n; i++) {
if (a[i] == -1) {
sum[i] =
((((k - 1) * sum[i - 1] - z[i - 1] * rsum[i - 1]) % MOD) + MOD) % MOD;
z[i] = -z[i - 1];
rsum[i] = rsum[i - 1];
} else {
long long tmp =
(((k * sum[i - 1] - z[i - 1] * rsum[i - 1]) % MOD) + MOD) % MOD;
tmp -= (sum[i - 1] - z[i - 1] * dp[a[i]]) % MOD;
tmp = ((tmp % MOD) + MOD) % MOD;
sum[i] = 0;
dp[ind] = 0;
dp[a[i]] = tmp;
ind = a[i];
z[i] = -1;
rsum[i] = tmp;
}
}
return (((k * sum[n - 1] - z[n - 1] * rsum[n - 1]) % MOD) + MOD) % MOD;
}
int n;
int a[N], b[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
cin >> a[i / 2];
else
cin >> b[i / 2];
}
long long a1 = solve(a, (n / 2) + (n % 2)), a2 = solve(b, n / 2);
cout << (a1 * a2) % MOD << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int h1, h2;
cin >> h1 >> h2;
int a, b;
cin >> a >> b;
int ans = 0;
if (b >= a) {
h1 = h1 + 8 * a;
if (h1 >= h2) {
cout << 0 << endl;
return 0;
}
if (h1 < h2) {
cout << -1 << endl;
return 0;
}
} else {
h1 = h1 + 8 * a;
if (h1 >= h2) {
cout << 0 << endl;
return 0;
}
h1 = h1 - 12 * b;
while (h1 < h2) {
ans++;
h1 += 12 * a;
if (h1 >= h2) {
cout << ans << endl;
return 0;
}
h1 -= 12 * b;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1;
int T, n, m, o;
char v[2000100];
int main() {
scanf("%d %d", &n, &m);
cin >> v;
int ct = 0;
if (n > 1) {
if (v[0] != '1') {
ct = 1;
}
if (m == 0) {
printf("%c", v[0]);
} else {
printf("%c", '1');
}
o = 0;
for (int i = 1; i < n; i++) {
if (ct >= m) {
break;
}
o = i;
if (v[i] != '0') {
ct++;
}
printf("%c", '0');
}
for (int i = o + 1; i < n; i++) {
printf("%c", v[i]);
}
} else {
if (m == 0) {
printf("%c", v[0]);
} else {
printf("%c", '0');
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
for (long long int x = 0; x < t; x++) {
long long int n;
cin >> n;
long long int ans = 0;
long long int prevMaxSize = n;
vector<vector<long long int> > prevArr(1);
for (long long int i = 1; i < n + 1; i++) {
prevArr[0].push_back(i);
}
while (prevMaxSize > 1) {
vector<vector<long long int> > split;
long long int size = 0;
for (auto arr : prevArr) {
long long int mid = ((int)(arr).size()) / 2;
vector<long long int> x(arr.begin(), arr.begin() + mid);
vector<long long int> y(arr.begin() + mid, arr.end());
split.push_back(x);
split.push_back(y);
size = max((long long int)((int)(x).size()),
max((long long int)((int)(y).size()), size));
}
vector<long long int> q1;
vector<long long int> q2;
for (long long int i = 0; i < ((int)(split).size()); i++) {
for (auto item : split[i]) {
if (i % 2 == 0) {
q1.push_back(item);
} else {
q2.push_back(item);
}
}
}
cout << ((int)(q1).size()) << " " << ((int)(q2).size()) << " ";
for (auto item : q1) {
cout << item << " ";
}
for (auto item : q2) {
cout << item << " ";
}
cout << endl;
long long int x;
cin >> x;
ans = max(x, ans);
prevMaxSize = size;
prevArr = split;
}
cout << "-1 " << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k1, k2;
long long a[123456], b[123456];
priority_queue<int> q;
int main() {
cin >> n >> k1 >> k2;
long long total = k1 + k2;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
q.push(abs(a[i] - b[i]));
}
bool zero = false;
while (total) {
long long x = q.top();
q.pop();
if (x == 0) {
q.push(1);
} else {
x--;
q.push(x);
}
total--;
}
long long mn = 0;
while (!q.empty()) {
int tmp = q.top();
q.pop();
mn += (long long)tmp * (long long)tmp;
}
cout << mn << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / (gcd(a, b));
}
long long int prime(long long int n) {
long long int i;
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return 0;
}
}
if (n <= 1) return 0;
return 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int sum = 0;
for (long long int i = 0; i < n; i++) sum += a[i];
if (!prime(sum)) {
cout << n << "\n";
for (long long int i = 0; i < n; i++) cout << i + 1 << " ";
cout << "\n";
} else {
long long int f;
for (long long int i = 0; i < n; i++) {
if (!prime((sum - a[i]))) {
f = i + 1;
break;
}
}
cout << n - 1 << "\n";
for (long long int i = 0; i < n; i++) {
if (i != f - 1) cout << i + 1 << " ";
}
cout << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double PI = acos(-1.);
const double eps = 1e-9;
char s[1000005];
char t[1000005];
int fs[11];
int ft[11];
int fx[11];
char y[1000005];
int main() {
int i, j, k, _T;
while (~scanf("%s%s", s, t)) {
if (strcmp(s, "01") == 0 || strcmp(s, "10") == 0) {
printf("0\n");
continue;
}
memset(fs, 0, sizeof fs);
memset(ft, 0, sizeof ft);
for (i = 0; s[i]; i++) fs[s[i] - '0']++;
for (i = 0; t[i]; i++) ft[t[i] - '0']++;
int ls = strlen(s);
int lt = strlen(t);
for (int len = lt; len <= ls; len++) {
char x[15];
memset(fx, 0, sizeof fx);
memset(x, 0, sizeof x);
sprintf(x, "%d", len);
int lx = strlen(x);
for (i = 0; x[i]; i++) fx[x[i] - '0']++;
int fail = 0;
for (i = 0; i <= 9; i++)
if (fs[i] < ft[i] + fx[i]) {
fail = 1;
}
if (fail || ls - lx != len) continue;
int flag = 0;
for (i = 1; i <= 9; i++) flag |= fs[i] > fx[i] + ft[i];
if (t[0] == '0' && !flag) continue;
if (!flag) {
printf("%s", t);
for (i = 0; i <= 9; i++)
for (j = 0; j < fs[i] - fx[i] - ft[i]; j++) putchar('0' + i);
putchar('\n');
break;
}
int id = 0, fi = -1;
for (i = 1; i <= 9; i++)
if (fs[i] > fx[i] + ft[i]) {
fi = i;
break;
}
fs[fi]--;
y[id++] = '0' + fi;
for (i = 0; i <= 9; i++) {
if (t[0] == '0' + i) {
int big = 0;
for (j = 1; j < lt; j++) {
if (t[j] != t[0]) {
if (t[j] > t[0]) big = 1;
break;
}
}
if (!big) {
for (j = 0; j < lt; j++) y[id++] = t[j];
}
for (j = 0; j < fs[i] - fx[i] - ft[i]; j++) y[id++] = '0' + i;
if (big) {
for (j = 0; j < lt; j++) y[id++] = t[j];
}
} else
for (j = 0; j < fs[i] - fx[i] - ft[i]; j++) y[id++] = '0' + i;
}
int ly = id;
fs[fi]++;
id = lt;
for (i = 0; i <= 9; i++)
for (j = 0; j < fs[i] - fx[i] - ft[i]; j++) t[id++] = '0' + i;
int uset = 0;
for (i = 0; i < ly; i++) {
if (y[i] != t[i]) {
if (y[i] > t[i]) uset = 1;
break;
}
}
if (uset && t[0] != '0') {
for (i = 0; i < ly; i++) putchar(t[i]);
putchar('\n');
} else {
for (i = 0; i < ly; i++) putchar(y[i]);
putchar('\n');
}
break;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace wode {
template <typename T>
inline void read(T &x) {
static char ch;
bool f = 1;
for (x = 0, ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = 0;
for (; isdigit(ch); x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar())
;
x = f ? x : -x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void print(T x, char ap) {
print(x);
if (ap) putchar(ap);
}
template <typename T>
inline T max(const T &x, const T &y) {
return x < y ? y : x;
}
template <typename T>
inline T min(const T &x, const T &y) {
return x < y ? x : y;
}
template <typename T>
inline void chkmax(T &x, const T &y) {
x = x < y ? y : x;
}
template <typename T>
inline void chkmin(T &x, const T &y) {
x = x < y ? x : y;
}
} // namespace wode
using wode::chkmax;
using wode::chkmin;
using wode::print;
using wode::read;
bool tong[26];
int t, n, len, a[501];
char s[501];
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> (s + 1), n = strlen(s + 1), a[len = 1] = 1,
memset(tong, false, sizeof(tong));
for (register int i = 2; i <= n; ++i)
if (s[i] == s[i - 1])
++a[len];
else
s[++len] = s[i], a[len] = 1;
for (register int i = 1; i <= len; ++i)
if (a[i] & 1) tong[s[i] - 'a'] = true;
for (register int i = 0; i < 26; ++i)
if (tong[i]) putchar(i + 'a');
puts("");
}
cout << flush;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int kNMax = 100010;
int cnt1, cnt2, cnt3, cnt4;
int arr3[kNMax], arr4[kNMax];
int c[kNMax], f[kNMax], l[kNMax];
int n, d, S;
bool cmpF(int i, int j) { return f[i] < f[j]; }
pair<int, int> work(int S, int lim) {
pair<int, int> ret = make_pair(0, 0);
for (int i = 0; ret.first < lim && i < cnt3; i++) {
if (S < f[arr3[i]]) break;
S -= f[arr3[i]];
ret.second += f[arr3[i]];
ret.first++;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &d, &S);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &c[i], &f[i], &l[i]);
if (c[i] == 0 && l[i] < d) cnt1++;
if (c[i] > 0 && l[i] < d) cnt2++;
if (c[i] == 0 && l[i] >= d) arr3[cnt3++] = i;
if (c[i] > 0 && l[i] >= d) arr4[cnt4++] = i;
}
sort(arr3, arr3 + cnt3, cmpF);
sort(arr4, arr4 + cnt4, cmpF);
pair<int, int> tmpp = work(S, cnt3);
if (!(cnt4 == 0 || f[arr4[0]] > S)) {
int best = arr4[0];
S -= f[best];
long long sumC = 0;
int goodCnt = 0;
for (int i = 0; i < n; i++)
if (c[i] > 0) {
goodCnt++;
sumC += c[i];
}
if (cnt4 - 1 <= cnt1) {
for (int i = 1; i < cnt4; i++) arr3[cnt3++] = arr4[i];
cnt1 -= cnt4 - 1;
} else {
for (int i = 1; i <= cnt1; i++) arr3[cnt3++] = arr4[i];
sort(arr3, arr3 + cnt3, cmpF);
for (int i = cnt1 + 1, j = cnt3 - 1; j >= 0 && i < cnt4; i++, j--) {
f[arr3[j]] = min(f[arr3[j]], f[arr4[i]]);
}
sort(arr3, arr3 + cnt3, cmpF);
cnt1 = 0;
}
int more = (int)min((long long)cnt1 + cnt3, sumC - goodCnt + 1);
pair<int, int> tmp;
if (more <= cnt1)
tmp = work(S, cnt3);
else
tmp = work(S, cnt3 - (more - cnt1));
tmp.first += more + goodCnt;
tmp.second += f[best];
if (tmp.first > tmpp.first ||
(tmp.first == tmpp.first && tmp.second < tmpp.second))
tmpp = tmp;
}
printf("%d %d\n", tmpp.first, tmpp.second);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double logten(double x) {
const double eps = 1e-9;
if (fabs(x - 1.0) < eps) return 0.0;
if (fabs(x - 10.0) < eps) return 1.0;
bool small = 0;
if (x < 1.0) {
small = 1;
x = 1.0 / x;
}
double ans = 1.0;
for (int i = 0;; i++) {
if (x < 10) break;
x = x / 10.0;
ans = ans + 1.0;
}
const double ln10 = 2.30258509299;
double wow = 10.0 - x;
wow = wow / 10;
double taylor = 0.0;
for (double i = 1.0; i < 1000.9; i = i + 1.0) {
taylor = taylor + wow / i;
wow = wow / 10;
wow = wow * (10 - x);
}
taylor = taylor / ln10;
if (small) return taylor - ans;
return ans - taylor;
}
double logall(double a, double b) {
const double eps = 1e-9;
if (fabs(b - 1.0) < eps) return 0.0;
if (fabs(a - b) < eps) return 1.0;
return logten(b) / logten(a);
}
int main() {
bool tr = 0;
string s;
int n, bef, aft;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> bef >> aft;
if ((bef > 2399) && (aft > bef)) tr = 1;
}
if (tr)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
long long x[100000 + 5], y[100000 + 5];
struct P {
long long x, y;
};
P operator-(const P &a, const P &b) { return P{a.x - b.x, a.y - b.y}; }
long long cross(const P &a, const P &b) { return a.x * b.y - a.y * b.x; }
struct monoqueue {
pair<P, int> a[100000 + 5];
int head, rear;
void init() {
head = 0;
rear = -1;
}
monoqueue() { init(); }
void push(P x, int id) {
while (head < rear &&
cross(x - a[rear].first, a[rear].first - a[rear - 1].first) <= 0)
rear--;
a[++rear] = {x, id};
}
void pop() {
while (head < rear && a[head].first.x == a[head + 1].first.x) head++;
}
int size() { return rear - head + 1; }
} q;
P p[100000 + 5];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[i] = P{x, y - 1ll * x * x};
}
sort(p + 1, p + n + 1, [](const P &a, const P &b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
});
for (int i = 1; i <= n; i++) q.push(p[i], i);
q.pop();
printf("%d\n", q.size() - 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e9;
int main() {
long long n, k;
cin >> n >> k;
long long a[n], b[n], d[n];
vector<pair<long long, long long> > c(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> b[i];
c[i].first = b[i] / a[i];
c[i].second = i;
d[i] = b[i] % a[i];
}
sort(c.begin(), c.end());
while (k > 0) {
int x = a[c[0].second] - d[c[0].second];
if (x <= k) {
d[c[0].second] = 0;
k -= x;
c[0].first++;
} else
k = 0;
sort(c.begin(), c.end());
}
cout << c[0].first;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
long long k;
struct S {
long long mn;
long long mx;
};
S operator+(S a, S b) { return {min(a.mn, b.mn), max(a.mx, b.mx)}; }
struct T {
S a[10];
long long cnt;
};
T operator+(T first, T second) {
first.cnt += second.cnt;
for (long long i = 0; i < k; i++) {
first.a[i] = first.a[i] + second.a[i];
}
return first;
}
bool win(T first, T second) {
for (long long i = 0; i < k; i++) {
if (first.a[i].mx > second.a[i].mn) {
return 1;
}
}
return 0;
}
bool lose(T first, T second) {
for (long long i = 0; i < k; i++) {
if (first.a[i].mn < second.a[i].mx) {
return 1;
}
}
return 0;
}
T get(vector<long long> v) {
assert((long long)v.size() == k);
T ret;
for (long long i = 0; i < k; i++) {
ret.a[i] = {v[i], v[i]};
}
ret.cnt = 1;
return ret;
}
bool operator<(T first, T second) { return first.a[0].mx < second.a[0].mx; }
const long long N = (long long)5e4 + 7;
long long n;
set<T> s;
void baga(vector<long long> v) {
T now = get(v);
s.insert(now);
while (1) {
auto it = s.find(now), nxt = it;
nxt++;
if (nxt != s.end()) {
if (lose(*nxt, *it)) {
now = *it + *nxt;
s.erase(it);
s.erase(nxt);
s.insert(now);
continue;
}
}
auto ant = it;
if (it != s.begin()) {
ant--;
if (win(*ant, *it)) {
now = *it + *ant;
s.erase(it);
s.erase(ant);
s.insert(now);
continue;
}
}
break;
}
}
signed realMain() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
vector<long long> v(k);
for (auto &x : v) {
cin >> x;
}
baga(v);
assert(!s.empty());
auto it = s.end();
it--;
cout << it->cnt << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<vector<int> >;
using VS = vector<string>;
using SS = stringstream;
using PII = pair<int, int>;
using VPII = vector<pair<int, int> >;
template <typename T = int>
using VT = vector<T>;
template <typename T = int>
using VVT = vector<vector<T> >;
template <typename T = int>
using LIM = numeric_limits<T>;
template <typename T>
inline istream &operator>>(istream &s, vector<T> &v) {
for (T &t : v) {
s >> t;
}
return s;
}
template <typename T>
inline ostream &operator<<(ostream &s, const vector<T> &v) {
for (int i = 0; i < int(v.size()); ++i) {
s << (" " + !i) << v[i];
}
return s;
}
template <typename T>
inline T fromString(const string &s) {
T res;
istringstream iss(s);
iss >> res;
return res;
}
template <typename T>
inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
}
template <typename T>
inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
VVI G;
VI stsizes;
int sizes(const int u) {
stsizes[u] = 1;
for (auto &&v : G[u]) {
stsizes[u] += sizes(v);
}
return stsizes[u];
}
VT<double> res;
void dfs(const int u, const double T = 0.) {
res[u] = T + 1;
double t = T + 1;
for (auto &&v : G[u]) {
t += stsizes[v] / 2.;
}
for (auto &&v : G[u]) {
dfs(v, t - stsizes[v] / 2.);
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(12) << fixed;
int N;
scanf("%d", &N);
G.resize(N);
for (int i = (int)(0); i < (int)(N - 1); ++i) {
int p;
scanf("%d", &p);
G[p - 1].push_back(i + 1);
}
stsizes.resize(N);
res.resize(N);
sizes(0);
dfs(0);
for (int i = (int)(0); i < (int)(N); ++i) {
printf("%.12f%c", res[i], i + 1 == N ? '\n' : ' ');
}
fflush(stdout);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return 0;
}
template <typename T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return 0;
}
void solve() {
ll N;
cin >> N;
cout << (N - 1) / 2 + 1 << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
for (int i = (int)0; i < (int)T; ++i) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int a[1005];
long long dp[2005][3005][2];
int k;
long long dfs(int pos, int pre, int sta, bool limit) {
if (pos < 0) return sta;
if (!limit && dp[pos][pre][sta] != -1) return dp[pos][pre][sta];
int up = limit ? a[pos] : 9;
long long tmp = 0;
for (int i = 0; i <= up; i++) {
if (i == 4 || i == 7)
tmp = (tmp + dfs(pos - 1, pos, sta || (pre != -1 && abs(pre - pos) <= k),
limit && i == up)) %
MOD;
else
tmp = (tmp + dfs(pos - 1, pre, sta, limit && i == up)) % MOD;
}
if (!limit) dp[pos][pre][sta] = tmp;
return tmp;
}
long long DP(char *s) {
int l = strlen(s);
for (int i = 0; i <= l - 1; i++) a[l - i - 1] = s[i] - '0';
return dfs(l - 1, -1, 0, true);
}
char le[3005], ri[3005];
void solve() {
memset(dp, -1, sizeof(dp));
int t;
scanf("%d%d", &t, &k);
while (t--) {
scanf("%s%s", le, ri);
int p = 0;
int l = strlen(le);
int q = -1;
for (int i = 0; i <= l - 1; i++) {
if (le[i] == '4' || le[i] == '7') {
if (q == -1 || abs(i - q) > k)
q = i;
else {
p = 1;
break;
}
}
}
printf("%lld\n", ((DP(ri) - DP(le) + p) % MOD + MOD) % MOD);
}
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int n, t;
scanf("%d%d", &(n), &(t));
if (n == 1 && t == 10)
puts("-1");
else {
if (t != 10) {
printf("%d", t);
for (int i = 0; i < n - 1; i++) printf("0");
} else {
printf("%d", t);
for (int i = 0; i < n - 2; i++) printf("0");
}
}
}
| 1 |
#include <bits/stdc++.h>
template <typename T>
T min(const T &a, const T &b) {
return ((a > b) ? b : a);
}
const int MAX_N = 10;
char plate[MAX_N][MAX_N][MAX_N + 1];
bool visited[MAX_N][MAX_N][MAX_N + 1];
int componentSize;
int k, n, m;
const int offset[6][3] = {0, 0, -1, 0, 1, 0, 1, 0, 0,
0, -1, 0, -1, 0, 0, 0, 0, 1};
void dfs(const int x, const int y, const int z) {
if (0 <= min(x, min(y, z)) && x < n && y < m && z < k) {
if (plate[z][x][y] == '#' || visited[z][x][y]) return;
visited[z][x][y] = true;
++componentSize;
for (int i = 0; i < 6; ++i) {
dfs(x + offset[i][0], y + offset[i][1], z + offset[i][2]);
}
}
}
int main() {
scanf("%d %d %d", &k, &n, &m);
for (int i = 0; i < k; ++i) {
for (int j1 = 0; j1 < n; ++j1)
for (int j2 = 0; j2 < m; ++j2) scanf("%1s", &plate[i][j1][j2]);
}
int x, y;
scanf("%d %d", &x, &y);
componentSize = 0;
dfs(--x, --y, 0);
printf("%d\n", componentSize);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, k, q, a[228228], b[228228], x, y, d, h;
long long Abs(long long x) { return x > 0 ? x : -x; }
int main() {
cin >> n >> x;
for (i = 0; i <= n; i++) {
scanf("%I64d", &a[i]);
b[i] = a[i];
}
for (i = 0; i < n; i++) {
if (b[i] % 2 != 0) break;
b[i + 1] += b[i] / 2;
}
k = i;
long long val = 0;
for (i = n; i >= k; i--) {
val = val * 2 + b[i];
if (Abs(val) > 2 * x) {
cout << 0 << endl;
return 0;
}
}
while (Abs(val) <= 2 * x && k > 0) {
k--;
val *= 2;
}
long long ans = 0;
for (i = k; i <= n; i++) {
if (i == n && a[i] - val == 0) break;
if (Abs(a[i] - val) <= x) {
ans++;
}
if (val % 2 != 0) break;
val /= 2;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, x;
cin >> t >> x;
map<long long int, long long int> m;
long long int cur = 0;
long long int maxSoFar = 0;
map<long long int, set<long long int>> second;
for (long long int i = 0; i < t; i++) {
long long int n;
cin >> n;
m[n]++;
second[n % x].insert(n);
while (1) {
bool flag = false;
long long int get = cur % x;
for (auto v : second[get]) {
m[v]--;
second[get].erase(v);
cur++;
flag = true;
break;
}
if (!flag) {
break;
}
}
cout << cur << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e18;
const int mod = 1;
template <typename T = int>
T gi() {
T x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
template <typename T>
bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
};
template <typename T>
bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
};
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
void inc(int &a, int b) { a = (a + b >= mod ? a + b - mod : a + b); }
void dec(int &a, int b) { a = (a - b < 0 ? a - b + mod : a - b); }
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + "," + to_string(p.second) + ")";
}
template <typename T>
string to_string(T v) {
int fst = 1;
string ret = "{";
for (auto x : v) {
if (!fst) ret += ",";
fst = 0, ret += to_string(x);
}
ret += "}";
return ret;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << " " << to_string(H);
dbg_out(T...);
}
template <typename T>
int qpow(int a, T b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod, b >>= 1;
}
return ret;
}
char gc() {
char ch = getchar();
while (!isupper(ch)) ch = getchar();
return ch;
}
const int N = 1e5 + 10;
int n, c, d, t[N];
char p[N];
long long ans = 0, sum = 0;
int main() {
n = gi(), c = gi(), d = gi();
for (int i = 1; i <= n; i++) t[i] = gi(), p[i] = gc();
t[n + 1] = gi();
ans = 1ll * n * d;
int lst = 0;
for (int i = n; i; i--) {
if (p[i] == p[i + 1])
sum += min(d, c * (lst - t[i + 1]));
else
lst = t[i + 1];
chkmin(ans, (t[n + 1] - t[i]) * c + sum + 1ll * (i - 1) * d);
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int f[maxn];
int a;
inline int getValue(int &left, int &right) {
return right - left + min(right - a, a - left);
}
int main() {
int n;
cin >> n >> a;
for (int i = 0; i < n; ++i) {
cin >> f[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
sort(f, f + n);
int mixs = f[0], maxs = f[n - 1];
if (a >= maxs) {
cout << a - f[1] << endl;
} else if (a <= mixs) {
cout << f[n - 2] - a << endl;
} else if (n == 2) {
cout << min(abs(f[0] - a), f[1] - a);
} else {
if (f[0] == f[1] && f[n - 2] == f[n - 1]) {
cout << getValue(f[0], f[n - 1]);
} else if (f[0] == f[1]) {
cout << getValue(f[0], f[n - 2]);
} else if (f[n - 2] == f[n - 1]) {
cout << getValue(f[1], f[n - 1]);
} else if (a >= f[n - 2]) {
cout << min(getValue(f[1], f[n - 1]), a - f[0]);
} else if (a <= f[1]) {
cout << min(getValue(f[0], f[n - 2]), f[n - 1] - a);
} else {
cout << min(getValue(f[0], f[n - 2]), getValue(f[1], f[n - 1]));
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[200100];
int perm[200100];
bool isIn(string a, string b) {
int start = 0;
for (int i = 0; i < b.size(); i++) {
if (b[i] == a[start]) {
start++;
}
}
if (start == a.size()) {
return true;
}
return false;
}
int main() {
string t, p;
cin >> t >> p;
for (int i = 0; i < t.size(); i++) {
scanf("%d", &perm[i]);
}
int l = 0;
int r = t.size() - 1;
int answer = -1;
while (l <= r) {
int mid = (l + r) / 2;
string tmp_string = t;
for (int i = 0; i <= mid; i++) {
tmp_string[perm[i] - 1] = '0';
}
if (isIn(p, tmp_string)) {
answer = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << answer + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int g[70][70];
double dp[70][10], win[70][10];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++)
for (int j = 0; j < (1 << n); j++) scanf("%d", &g[i][j]);
for (int i = 0; i < (1 << n); i++) win[i][0] = 1;
for (int r = 1; r <= n; r++) {
for (int i = 0; i < (1 << n); i++) {
int x = 1 << (r - 1), t = i / x, L, R;
if (t & 1)
L = x * (t - 1), R = x * (t)-1;
else
L = x * (t + 1), R = x * (t + 2) - 1;
for (int j = L; j <= R; j++) {
win[i][r] += win[i][r - 1] * g[i][j] / 100.0 * win[j][r - 1];
}
for (int j = L; j <= R; j++) {
dp[i][r] = max(dp[i][r], win[i][r] * (x) + dp[j][r - 1] + dp[i][r - 1]);
}
}
}
double ans = 0;
for (int i = 0; i < (1 << n); i++) {
ans = max(ans, dp[i][n]);
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse2")
void opting() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
}
long long inp() {
long long x;
cin >> x;
return x;
}
const int maxn = 1e5 + 69, delta = 1e9 + 7;
int main() {
opting();
int t = inp();
while (t--) {
int n, k;
cin >> n >> k;
char r[k];
memset(r, '?', sizeof r);
string s;
cin >> s;
bool pos = true;
for (int i = 0; i < n; i++)
if (s[i] == '?')
continue;
else if (s[i] != r[i % k] and r[i % k] != '?')
pos = false;
else
r[i % k] = s[i];
int O, Z;
O = Z = 0;
for (int i = 0; i < k; i++)
if (r[i] == '1')
O++;
else if (r[i] == '0')
Z++;
if (!pos or O > k / 2 or Z > k / 2)
cout << "NO";
else
cout << "YES";
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using std::abs;
using std::array;
using std::cerr;
using std::cin;
using std::cout;
using std::generate;
using std::get;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::pair;
using std::reverse;
using std::set;
using std::sort;
using std::string;
using std::tuple;
using std::unique;
using std::vector;
template <typename T>
T input() {
T res;
cin >> res;
{};
return res;
}
template <typename IT>
void input_seq(IT b, IT e) {
std::generate(b, e,
input<typename std::remove_reference<decltype(*b)>::type>);
}
template <typename T>
struct vec {
T x;
T y;
};
template <typename T>
vec<T> operator+(vec<T> a, vec<T> b) {
return vec<T>{a.x + b.x, a.y + b.y};
}
template <typename T>
vec<T> operator-(vec<T> a, vec<T> b) {
return vec<T>{a.x - b.x, a.y - b.y};
}
template <typename U, typename T>
vec<U> cast(vec<T> v) {
return vec<U>{(U)v.x, (U)v.y};
}
int64_t cross64(vec<int> a, vec<int> b) {
return a.x * int64_t(b.y) - b.x * int64_t(a.y);
}
int64_t dot64(vec<int> a, vec<int> b) {
return a.x * int64_t(b.x) + a.y * int64_t(b.y);
}
int64_t dist2(vec<int> a) { return a.x * int64_t(a.x) + a.y * int64_t(a.y); }
template <typename T>
vec<T> rot90(vec<T> a) {
return vec<T>{-a.y, a.x};
}
vector<vec<int>> minkowsky_sum(vector<vec<int>> a, vector<vec<int>> b) {
auto kek = [&](vector<vec<int>>& v) {
auto it = std::min_element(v.begin(), v.end(), [](vec<int> u, vec<int> w) {
return make_pair(u.x, u.y) < make_pair(w.x, w.y);
});
std::rotate(v.begin(), it, v.end());
};
kek(a);
kek(b);
int n = int((a).size());
int m = int((b).size());
a.push_back(a[0]);
a.push_back(a[1]);
b.push_back(b[0]);
b.push_back(b[1]);
vector<vec<int>> res;
int p = 0, q = 0;
while (p < n or q < m) {
res.push_back(a[p] + b[q]);
if (cross64(a[p + 1] - a[p], b[q + 1] - b[q]) > 0)
++p;
else if (cross64(a[p + 1] - a[p], b[q + 1] - b[q]) < 0)
++q;
else
++p, ++q;
}
return res;
}
bool inside(const vector<vec<int>>& poly, vec<int> pt) {
for (int i = 0; i != int((poly).size()); ++i) {
int j = (i + 1) % int((poly).size());
if (cross64(poly[i] - pt, poly[j] - pt) == 0 and
dot64(poly[i] - pt, poly[j] - pt) <= 0)
return true;
}
double ang = 0;
for (int i = 0; i != int((poly).size()); ++i) {
int j = (i + 1) % int((poly).size());
ang += atan2(cross64(poly[i] - pt, poly[j] - pt),
dot64(poly[i] - pt, poly[j] - pt));
}
return abs(ang - 2.0 * acos(-1)) < 1e-3;
}
bool ok(const vector<vec<int>>& poly, vec<int> pt, int rad) {
for (auto elem : poly)
if (dist2(pt - elem) < rad * int64_t(rad)) return false;
if (inside(poly, pt)) return false;
for (int i = 0; i != int((poly).size()); ++i) {
auto p = poly[i];
auto q = poly[(i + 1) % int((poly).size())];
if (dot64(q - p, pt - p) <= 0) continue;
if (dot64(p - q, pt - q) <= 0) continue;
auto norm = rot90(q - p);
int64_t c = norm.x * p.x + norm.y * p.y;
int64_t dst = abs(norm.x * pt.x + norm.y * pt.y - c);
if (dst * dst < rad * rad * dist2(norm)) return false;
}
return true;
}
struct edge_t {
int to;
int flow;
int cap;
int next;
};
int push(vector<int>& head, vector<edge_t>& edges, vector<char>& used, int v,
int T, int mx) {
if (v == T) return mx;
used[v] = 1;
for (int e = head[v]; e != -1; e = edges[e].next)
if (edges[e].flow < edges[e].cap and not used[edges[e].to]) {
int val = push(head, edges, used, edges[e].to, T,
min(mx, edges[e].cap - edges[e].flow));
if (val > 0) {
edges[e].flow += val;
edges[e ^ 1].flow -= val;
return val;
}
}
return 0;
}
int main() {
std::iostream::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int min_x = std::numeric_limits<int>::max(),
max_x = std::numeric_limits<int>::min();
int n = input<int>();
int w = input<int>();
vector<vec<int>> poly(n);
for (int i = 0; i != n; ++i) {
cin >> poly[i].x >> poly[i].y;
min_x = min(min_x, poly[i].x);
max_x = max(max_x, poly[i].x);
}
for (int i = 0; i != n; ++i) poly[i].x -= min_x;
max_x -= min_x;
int m = input<int>();
vector<pair<vec<int>, int>> jelly(m);
for (auto& elem : jelly) cin >> elem.first.x >> elem.first.y >> elem.second;
vector<vec<int>> antipoly(n);
for (int i = 0; i != n; ++i) antipoly[i] = {-poly[i].x, -poly[i].y};
auto poly_minus_poly = minkowsky_sum(poly, antipoly);
int S = 2 * m;
int T = 2 * m + 1;
vector<int> head(2 * m + 2, -1);
vector<edge_t> edges;
auto add_edge = [&](int v, int u, int cap, int rcap) {
edges.push_back(edge_t{u, 0, cap, head[v]});
head[v] = int((edges).size()) - 1;
edges.push_back(edge_t{v, 0, rcap, head[u]});
head[u] = int((edges).size()) - 1;
};
const int inf = 1e3;
for (int i = 0; i < m; ++i) add_edge(2 * i + 1, 2 * i, 1, 0);
for (int i = 0; i < m; ++i)
for (int j = i + 1; j < m; ++j) {
if (not ok(poly_minus_poly, jelly[i].first - jelly[j].first,
jelly[i].second + jelly[j].second)) {
add_edge(2 * i, 2 * j + 1, inf, 0);
add_edge(2 * j, 2 * i + 1, inf, 0);
}
}
for (int i = 0; i != m; ++i) {
int L = jelly[i].first.x - jelly[i].second - max_x;
int R = jelly[i].first.x + jelly[i].second;
if (L < 0) {
add_edge(S, 2 * i + 1, inf, 0);
}
if (R > w - max_x) {
add_edge(2 * i, T, inf, 0);
}
}
int flow = 0;
while (true) {
vector<char> used(2 * m + 2, false);
int tmp;
if ((tmp = push(head, edges, used, S, T,
std::numeric_limits<int>::max())) != 0)
flow += tmp;
else
break;
}
cout << flow << "\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n;
int mas[n];
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> a;
mas[i] = a;
if (a == 0) flag = 1;
}
if (flag) {
cout << 0;
return 0;
}
int k = -1;
for (int i = 0; i < n; i++) {
if (i >= n - 1 - i) {
if (k == -1) {
k = mas[i] / i;
}
if (mas[i] / i < k) k = mas[i] / i;
if (mas[0] / i < k) k = mas[0] / i;
}
if (i <= n - 1 - i) {
if (k == -1) {
k = mas[i] / (n - 1 - i);
}
if (mas[i] / (n - 1 - i) < k) k = mas[i] / (n - 1 - i);
if (mas[n - 1] / (n - 1 - i) < k) k = mas[n - 1] / (n - 1 - i);
}
}
cout << k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1 << 22;
const int MOD = 1000000007;
const int64_t mod2 = 1000000007 * 1LL * 1000000007;
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int64_t strtoll(string second) {
stringstream str(second);
int64_t number = 0;
str >> number;
return number;
}
class Test {
public:
int a;
Test() {
a = 10;
std::cout << "Constructor is executed\n";
}
~Test() { std::cout << "Destructor is executed\n"; }
};
class Base {
public:
virtual void show() { cout << "In Base \n"; }
};
class Derived : public Base {
public:
void show() { cout << "In Derived \n"; }
};
unsigned int onesComplement(unsigned int n) {
int number_of_bits = floor(log2(n)) + 1;
return ((1 << number_of_bits) - 1) ^ n;
}
bool vov(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return true;
return false;
}
int solve(int a[26], int i) {
int ct = 0, one = 0;
for (int i = 0; i < 26; i++) {
if (a[i] == 4) {
return 0;
} else if (a[i] == 3) {
return 1;
} else if (a[i] == 2) {
ct++;
} else if (a[i] == 1)
one++;
}
if (ct == 2) return 0;
if (one == 4) return 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
for (int tt = 1; tt <= t; tt++) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
a = " " + a;
b = " " + b;
int ans = 0;
for (int i = 1; i <= n / 2; i++) {
int c[26] = {0};
c[a[i] - 'a']++;
c[b[i] - 'a']++;
c[a[n - i + 1] - 'a']++;
c[b[n - i + 1] - 'a']++;
bool done = false;
int ct = 0, one = 0;
for (int j = 0; j < 26; j++) {
if (c[j] == 4) {
done = true;
break;
} else if (c[j] == 3) {
ans += 1;
done = true;
break;
} else if (c[j] == 2) {
ct++;
} else if (c[j] == 1)
one++;
}
if (!done) {
if (one == 4)
ans += 2;
else if (ct == 1) {
ans += 1 + (a[i] == a[n - i + 1]);
}
}
}
if (n & 1) {
ans += (a[n / 2 + 1] != b[n / 2 + 1]) ? 1 : 0;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " , ";
__f(comma + 1, args...);
}
inline long long int gcd(long long int a, long long int b) {
a = abs(a), b = abs(b);
while (b) a = a % b, swap(a, b);
return a;
}
inline long long int power(long long int a, long long int p) {
long long int res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x), p >>= 1;
}
return res;
}
inline long long int mul_mod(long long int a, long long int p,
long long int m) {
long long int res = 0, x = a % m;
while (p) {
if (p & 1) res = (res + x) % m;
x = (x << 1) % m, p >>= 1;
}
return res;
}
inline long long int big_mod(long long int a, long long int p,
long long int m) {
long long int res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m, p >>= 1;
}
return res;
}
long long int ext_gcd(long long int A, long long int B, long long int* X,
long long int* Y) {
long long int x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1, y2 = 0;
x1 = 0, y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1, r = r2 % r1;
x = x2 - (q * x1), y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long int mod_inv(long long int a, long long int m) {
long long int x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
const int INF = 1e9 + 9;
int ara[55];
map<long long int, bool> sum_visit;
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &ara[i]);
}
for (int cnt = 1; cnt <= n; cnt++) {
for (int t = 0; t < 1000; t++) {
vector<int> soldiers;
bool visit[55];
memset(visit, false, sizeof(visit));
int sum = 0;
for (int trial = 0; trial < 1000 && soldiers.size() < cnt; trial++) {
int idx = ((((rand() << 15) ^ rand()) % ((n - 1) - (0) + 1)) + (0));
if (!visit[idx]) {
sum += ara[idx];
soldiers.push_back(ara[idx]);
visit[idx] = true;
}
}
if (!sum_visit[sum] && soldiers.size() == cnt) {
sum_visit[sum] = true;
printf("%d", cnt);
for (int i = 0; i < cnt; i++) {
printf(" %d", soldiers[i]);
}
printf("\n");
k--;
}
if (!k) {
return 0;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int inf = 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
int t;
int n, a, b, da, db;
vector<int> g[N];
int h[N];
void dfs(int v, int p) {
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
h[to] = h[v] + 1;
dfs(to, v);
}
}
void clean() {
for (int i = 1; i <= n; i++) {
g[i].clear();
}
}
int main() {
cin >> t;
while (t--) {
scanf("%d", &n);
scanf("%d%d%d%d", &a, &b, &da, &db);
for (int i = 1; i < n; i++) {
int v1, v2;
scanf("%d%d", &v1, &v2);
g[v1].push_back(v2);
g[v2].push_back(v1);
}
h[a] = 0;
dfs(a, -1);
if (h[b] <= da) {
printf("Alice\n");
clean();
continue;
}
int s, mx = 0;
for (int i = 1; i <= n; i++) {
if (h[i] > mx) {
mx = h[i];
s = i;
}
}
h[s] = 0;
dfs(s, -1);
mx = 0;
for (int i = 1; i <= n; i++) {
if (h[i] > mx) {
mx = h[i];
}
}
da = min(da, mx);
db = min(db, mx);
if (da * 2 < db) {
printf("Bob\n");
clean();
continue;
}
printf("Alice\n");
clean();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
bool prime[10000001];
long long P = 1000000007 - 2;
long long factorial[10000001] = {0};
long long powerFunction(long long a, long long n) {
long long r;
if (n == 0)
return 1;
else if (n == 1)
return a;
else
r = powerFunction(a, n / 2);
if (n % 2 == 0)
return ((r) % 1000000007) * ((r) % 1000000007) % 1000000007;
else
return ((r) % 1000000007) * ((r) % 1000000007) * ((a) % 1000000007) %
1000000007;
}
long long modInverseFunctionFunction(long long no) {
long long inverse = 1;
while (P > 0) {
if (P & 1) {
inverse = (inverse % 1000000007 * no % 1000000007) % 1000000007;
}
no = (no % 1000000007 * no % 1000000007) % 1000000007;
P = P / 2;
}
P = 1000000007 - 2;
return inverse % 1000000007;
}
void sieveFunction(long long maxLimit) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long i = 2; maxLimit >= i; i++) {
if (prime[i]) {
for (long long j = 2 * i; maxLimit > j; j += i) prime[j] = false;
}
}
}
void factorialFunction(long long maxLimit) {
factorial[0] = 1;
for (long long i = 1; i <= maxLimit; i++)
factorial[i] = (factorial[i - 1] * i) % 1000000007;
return;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, t;
cin >> n >> t;
long long arr[n];
long long mx = INT_MIN;
long long idx = -1;
deque<long long> q;
for (long long i = 0; n > i; i++) {
cin >> arr[i];
q.push_back(arr[i]);
if (arr[i] >= mx) {
mx = arr[i];
idx = i;
}
}
vector<long long> v;
vector<pair<long long, long long>> vp;
long long count = 0;
while (count != idx) {
long long top = q.front();
q.pop_front();
long long newTop = q.front();
vp.push_back({top, newTop});
if (newTop > top) {
q.push_back(top);
} else {
q.pop_front();
q.push_back(newTop);
q.push_front(top);
}
count++;
}
q.pop_front();
while (q.size()) {
long long p = q.front();
q.pop_front();
v.push_back(p);
}
while (t--) {
long long m;
cin >> m;
if (m <= idx) {
cout << vp[m - 1].first << ' ' << vp[m - 1].second << "\n";
} else {
m -= idx;
m--;
m = (m + 2 * (n - 1)) % (n - 1);
cout << mx << ' ' << v[m] << "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using ii = pair<int, int>;
using lu = unsigned long long;
using l = long long;
using vs = vector<string>;
using vii = vector<ii>;
using vl = vector<l>;
using vvl = vector<vl>;
using vvvl = vector<vvl>;
using vlu = vector<lu>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using vd = vector<double>;
using vvd = vector<vd>;
using mll = unordered_map<l, l>;
using sl = unordered_set<l>;
const l INF = numeric_limits<l>::max();
const double EPS = 1e-10;
const double PI = 3.14159265358979323846;
const l e0 = 1, e3 = 1000, e5 = 100000, e6 = 10 * e5, e7 = 10 * e6,
e8 = 10 * e7, e9 = 10 * e8, l0 = 0, l1 = 1, l2 = 2;
const char lf = '\n';
void solve(istream &in, ostream &out);
void solve_brute(istream &, ostream &);
bool interactive_judge(istream &, istream &, ostream &);
bool generate_random(l, ostream &);
bool solution_checker(istream &, istream &, istream &, ostream &);
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve(cin, cout);
}
const l MOD = e9 + 7;
struct BIT {
vl tree;
l max_p;
BIT(size_t n) {
max_p = n;
tree.resize(n + 1);
};
l get(l p) {
l sum = 0;
while (p) {
sum += tree[p];
p -= (p & -p);
}
return sum;
}
l get(l from, l to) { return get(to) - get(from - 1); }
void add(l p, l value) {
while (p <= max_p) {
tree[p] += value;
p += (p & -p);
}
}
l find(l sum) {
l mask = max_p;
while (true) {
l lower = (mask & -mask);
if (lower == mask) break;
mask -= lower;
}
l p = 0;
l top = -1;
while (mask != 0) {
l m = p + mask;
if (m <= max_p) {
if (sum == tree[m]) top = m;
if (sum > tree[m]) {
p = m;
sum -= tree[m];
}
}
mask >>= 1;
}
if (sum != 0) return top;
return p;
}
};
void solve(istream &in, ostream &out) {
l n;
in >> n;
vl v(n);
for (l i = l(0); i < l(n); i++) in >> v[i];
vll s(n);
for (l i = l(0); i < l(n); i++) s[i] = {-v[i], i};
sort(begin(s), end(s));
(s);
l m;
in >> m;
vector<tuple<l, l, l>> q(m);
for (l i = l(0); i < l(m); i++) {
l a, b;
in >> a >> b;
q[i] = {a, b, i};
}
sort(begin(q), end(q));
l kk = 0;
BIT bit(n);
vl z(m);
for (auto j : q) {
l k = get<0>(j);
while (kk < k) {
bit.add(s[kk].second + 1, 1);
kk++;
}
l p = get<1>(j);
l i = bit.find(p);
(k);
z[get<2>(j)] = v[i - 1];
}
for (l i = l(0); i < l(m); i++) out << z[i] << lf;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x, y, ans[1000006];
bool findxy(int n, int a, int b) {
x = 0, y = n / b;
while (y >= 0) {
if (x * a + y * b == n) return true;
x++;
y = (n - x * a) / b;
}
return false;
}
int main() {
int n, a, b;
cin >> n >> a >> b;
if (!findxy(n, a, b)) {
puts("-1");
return 0;
}
int at = 1;
while (x--) {
int t = a - 1;
while (t--) {
ans[at] = at + 1;
at++;
}
ans[at] = at - (a - 1);
at++;
}
while (y--) {
int t = b - 1;
while (t--) {
ans[at] = at + 1;
at++;
}
ans[at] = at - (b - 1);
at++;
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct node {
long long mmax;
long long mmin;
long long v;
} tree[maxn << 3];
long long cover[maxn << 3];
void PushUp(long long rt) {
tree[rt].mmax = max(tree[rt << 1].mmax, tree[rt << 1 | 1].mmax);
tree[rt].mmin = min(tree[rt << 1].mmin, tree[rt << 1 | 1].mmin);
tree[rt].v = tree[rt << 1].v + tree[rt << 1 | 1].v;
}
void build(long long rt, long long l, long long r) {
cover[rt] = -1;
if (l == r) {
scanf("%lld", &tree[rt].v);
tree[rt].mmax = tree[rt].mmin = tree[rt].v;
return;
}
long long mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
PushUp(rt);
}
void PushDown(long long rt, long long l, long long r) {
if (cover[rt] != -1) {
tree[rt].v = (r - l + 1) * cover[rt];
tree[rt << 1].mmax = tree[rt << 1].mmin = tree[rt << 1 | 1].mmax =
tree[rt << 1 | 1].mmin = cover[rt];
int rc = (r - l + 1) >> 1;
int lc = (r - l + 1) - rc;
tree[rt << 1].v = lc * cover[rt];
tree[rt << 1 | 1].v = rc * cover[rt];
cover[rt << 1] = cover[rt << 1 | 1] = cover[rt];
cover[rt] = -1;
}
}
void update(long long rt, long long l, long long r, long long L, long long R,
long long v) {
if (L > R) return;
if (L <= l && R >= r) {
if (tree[rt].mmax <= v) {
cover[rt] = v;
tree[rt].mmax = tree[rt].mmin = v;
tree[rt].v = (r - l + 1) * v;
return;
}
if (tree[rt].mmin >= v) {
return;
}
}
PushDown(rt, l, r);
long long mid = (l + r) >> 1;
if (L <= mid) update(rt << 1, l, mid, L, R, v);
if (R > mid) update(rt << 1 | 1, mid + 1, r, L, R, v);
PushUp(rt);
}
long long ans = 0;
long long query(long long rt, long long l, long long r, long long L,
long long now) {
if (now <= 0) return 0;
if (l >= L) {
if (tree[rt].mmin > now)
return 0;
else if (cover[rt] != -1) {
long long res = min(now / cover[rt], r - l + 1);
ans += res;
res = res * cover[rt];
return res;
} else if (tree[rt].v <= now) {
ans += r - l + 1;
return tree[rt].v;
}
}
if (l == r) return 0;
PushDown(rt, l, r);
long long mid = (l + r) >> 1;
long long sub = 0;
if (L <= mid) sub += query(rt << 1, l, mid, L, now);
sub += query(rt << 1 | 1, mid + 1, r, L, now - sub);
PushUp(rt);
return sub;
}
int main() {
long long n, q;
cin >> n >> q;
build(1, 1, n);
while (q--) {
long long op, x, y;
cin >> op >> x >> y;
if (op == 1) {
update(1, 1, n, 1, x, y);
} else {
ans = 0;
long long sub = query(1, 1, n, x, y);
cout << ans << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
struct Edge {
int v, next;
};
int head[100100];
int pre[100100];
int dep[100100];
int wt[100100];
bool vis[100100];
bool gt[100100];
Edge eg[100100];
int ans[100100];
int tp, n, m, cnt;
void Add(int u, int v) {
eg[tp].v = v;
eg[tp].next = head[u];
head[u] = tp++;
}
bool dfs(int u, int depth, int mn) {
int v;
for (int i = head[u]; i != -1; i = eg[i].next) {
v = eg[i].v;
dep[v] = depth + 1;
if (dep[wt[v]] < dep[mn]) return false;
if (!dfs(v, depth + 1, gt[v] ? v : mn)) return false;
if (gt[v]) ans[cnt++] = v;
}
return true;
}
int main() {
int u, v;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
memset(pre, -1, sizeof(pre));
tp = 0;
while (m--) {
scanf("%d%d", &u, &v);
Add(u, v);
pre[v] = u;
}
memset(gt, 0, sizeof(gt));
for (int i = 1; i <= n; ++i) {
scanf("%d", &wt[i]);
gt[wt[i]] = 1;
}
memset(vis, 0, sizeof(vis));
cnt = 0;
for (int i = 1; i <= n; ++i) {
if (pre[i] == -1) {
Add(0, i);
pre[i] = 0;
}
}
dep[0] = 0;
if (!dfs(0, 0, 0))
puts("-1");
else {
printf("%d\n", cnt);
for (int i = 0; i < cnt; ++i) printf("%d\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct bian {
int next, point;
} b[210000];
int p[110000], len, pd[210000], n, m, pre[210000], in[210000], flag;
queue<int> Q;
void ade(int k1, int k2) {
b[++len] = (bian){p[k1], k2};
p[k1] = len;
}
void add(int k1, int k2) {
ade(k1, k2);
ade(k2, k1);
}
void dfs(int k) {
in[k] = 1;
pd[k] = 1;
for (int i = p[k]; i; i = b[i].next) {
int j = b[i].point;
if (pd[j] == 0)
dfs(j);
else if (in[j])
flag = 1;
}
in[k] = 0;
}
vector<int> way;
void printpath(int K) {
for (int i = K; i; i = pre[i]) way.push_back(i / 2);
for (int i = 0; i < way.size(); i++) printf("%d ", way[way.size() - i - 1]);
cout << endl;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int k1;
scanf("%d", &k1);
for (; k1; k1--) {
int k2;
scanf("%d", &k2);
ade(i, k2);
}
}
int s;
scanf("%d", &s);
Q.push(s * 2);
pd[s * 2] = 1;
while (!Q.empty()) {
int k = Q.front();
Q.pop();
int k1 = k / 2, sign = k & 1;
for (int i = p[k1]; i; i = b[i].next) {
int j = b[i].point;
int k2 = j * 2 + (sign ^ 1);
if (pd[k2] == 0) {
pd[k2] = 1;
Q.push(k2);
pre[k2] = k;
}
}
}
for (int i = 1; i <= n; i++)
if (p[i] == 0 && pd[i * 2 + 1]) {
printf("Win\n");
printpath(i * 2 + 1);
return 0;
}
memset(pd, 0x00, sizeof pd);
dfs(s);
if (flag)
printf("Draw\n");
else
printf("Lose\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int T, n, m, a;
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> a, cout << a + (a % 2 != (i + j) % 2) << " \n"[j == m];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int a, b, p;
cin >> a >> b >> p;
string s;
cin >> s;
char prev = 'k';
long long int ans = 1;
long long int n = s.length();
for (int i = n - 2; i >= 0; i--) {
if (s[i] != prev) {
if (s[i] == 'A') {
p -= a;
} else {
p -= b;
}
prev = s[i];
if (p < 0) {
ans = i + 2;
break;
}
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
struct space {
int a, b;
space(int x = 1, int y = 0) {
a = x, b = y;
assert(a >= 1);
assert(b <= N);
}
space(const space& other) {
a = other.a;
b = other.b;
}
int len() const {
int res = b - a + 1;
assert(res >= 0);
return res;
}
int spot() const {
if (a == 1) return 1;
if (b == N) return N;
return (a + b) / 2;
}
int dist() const {
if (a > b) return -1;
int s = spot();
if (s == 1) return (b + 1) - 1;
if (s == N) return N - (a - 1);
int d1 = s - (a - 1);
int d2 = (b + 1) - s;
return min(d1, d2);
}
bool operator<(const space& other) const {
if (dist() > other.dist()) return true;
if (other.dist() > dist()) return false;
if (a < other.a) return true;
if (other.a < a) return false;
assert((*this) == other);
return false;
}
space operator+(space& other) const {
space res;
res.a = min(a, other.a);
res.b = max(b, other.b);
return res;
}
bool operator==(const space& other) const {
return (a == other.a) && (b == other.b);
}
};
set<space> S;
int pos[1000010];
int leftival[200010];
int rightival[200010];
int insert(int id) {
assert(S.size() > 0);
space x = (*S.begin());
S.erase(S.begin());
int a = x.a, b = x.b;
int p = x.spot();
S.insert(space(a, p - 1));
S.insert(space(p + 1, b));
pos[id] = p;
leftival[p] = a;
rightival[p] = b;
rightival[a - 1] = p - 1;
leftival[b + 1] = p + 1;
return p;
}
void print() {
for (set<space>::iterator it = S.begin(); it != S.end(); it++) {
cout << (*it).a << " " << (*it).b << endl;
}
cout << endl;
}
void remove(int id) {
assert(S.size() >= 2);
int p = pos[id];
pos[id] = 0;
space lspace(leftival[p], p - 1);
space rspace(p + 1, rightival[p]);
assert(S.find(lspace) != S.end());
assert(S.find(rspace) != S.end());
S.erase(S.find(lspace));
S.erase(S.find(rspace));
leftival[p] = 0;
rightival[p] = 0;
space final = lspace + rspace;
S.insert(lspace + rspace);
int a = final.a;
int b = final.b;
rightival[a - 1] = b;
leftival[b + 1] = a;
}
int main() {
cin >> N >> M;
S.insert(space(1, N));
for (int x = 0; x < (M); x++) {
int t, id;
cin >> t >> id;
if (t == 1) {
int spot = insert(id);
printf("%d\n", spot);
} else {
assert(t == 2);
remove(id);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int now[5 * 100010], after[5 * 100010], mx[5 * 100010];
int lft[5 * 100010], rgt[5 * 100010], vi[5 * 100010], timer = 0, comp = 0;
long long Add[5 * 100010];
vector<int> g[5 * 100010];
stack<int> stk;
inline void dfs(int c, int p) {
vi[c] = 1;
now[c] = after[c] = ++timer;
stk.push(c);
for (auto x : g[c]) {
if (x != p) {
if (!vi[x]) {
dfs(x, c);
now[c] = min(now[c], now[x]);
} else
now[c] = min(now[c], now[x]);
}
}
if (now[c] == after[c]) {
comp++;
lft[comp] = rgt[comp] = c;
while (1) {
int node = stk.top();
stk.pop();
lft[comp] = min(lft[comp], node);
rgt[comp] = max(rgt[comp], node);
if (node == c) break;
}
}
}
int main() {
int n, m;
scanf("%d", &n);
;
scanf("%d", &m);
;
memset(vi, 0, sizeof(vi));
;
for (int x = 1; x <= m; x++) {
int u, v;
scanf("%d", &u);
;
scanf("%d", &v);
;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
for (int x = 1; x <= n; x++)
if (!vi[x]) dfs(x, 0);
for (int x = 1; x <= n; x++) mx[x] = n;
for (int x = 1; x <= comp; x++)
if (lft[x] != rgt[x]) mx[lft[x]] = rgt[x] - 1;
for (int x = n - 1; x >= 1; x--) mx[x] = min(mx[x + 1], mx[x]);
for (int x = 1; x <= n; x++) Add[x] = Add[x - 1] + mx[x] - x + 1;
int q;
scanf("%d", &q);
;
while (q--) {
int from, to;
scanf("%d", &from);
;
scanf("%d", &to);
;
int l = from, r = to, chk = -1;
while (l <= r) {
int m = l + r >> 1;
if (mx[m] > to)
r = m - 1;
else
chk = max(chk, m), l = m + 1;
}
long long res;
if (chk == -1)
res = 1LL * (to - from + 1LL) * (to - from + 2LL) / 2LL;
else
res = Add[chk] - Add[from - 1] + 1LL * (to - chk) * (to - chk + 1LL) / 2;
printf("%lld\n", res);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, x, cnt;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (x == 0)
ans += cnt;
else
cnt++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n;
int x1, y1, x2, y2;
while (~scanf("%d", &n)) {
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
sum += (x2 - x1 + 1) * (y2 - y1 + 1);
}
printf("%d\n", sum);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[500004];
int n, i, j, nr, nr1, ap[500004];
char s[500004];
int main() {
scanf("%d\n", &n);
for (i = 1; i <= n; i++) {
gets(s);
ap[i] = strlen(s);
for (j = 0; j <= (ap[i] - 1); j++) v[i].push_back(s[j] - '#');
}
for (i = (n - 1); i >= 1; i--) {
nr = ap[i];
nr1 = ap[i + 1];
j = 0;
while (j <= (nr - 1) && j <= (nr1 - 1)) {
if (v[i][j] > v[i + 1][j])
break;
else if (v[i][j] < v[i + 1][j]) {
j = nr;
break;
}
j++;
}
ap[i] = j;
}
for (i = 1; i <= n; i++) {
for (j = 0; j <= (ap[i] - 1); j++) printf("%c", char(v[i][j] + '#'));
printf("\n");
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define FASTIO ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
#define vt vector
#define sz(x) int(x.size())
#define N 2e5+7
int main()
{
FASTIO;
ll t;
cin>>t;
while(t--)
{
ll s,sum=0;
cin>>s;
ll x=sqrt(s);
if(x*x==s) cout<<x<<"\n";
else cout<<x+1<<"\n";
}
}
| 0 |
// Problem: C. Sum of Cubes
// Contest: Codeforces - Codeforces Round #702 (Div. 3)
// URL: https://codeforces.com/contest/1490/problem/C
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define ff first
#define VI vector <int>
#define VVI vector <VI>
#define ss second
#define pii pair<int, int>
#define ppi pair<pii, int>
#define mii map<int, int>
#define mci map<char, int>
#define mis map<int, set<int>>
#define setbits(n) __builtin_popcount(n)
#define fill(a,b) memset(a, b, sizeof(a))
#define all(v) (v).begin(), (v).end()
#define yes cout<<"Yes"<<endl
#define no cout<<"No"<<endl
#define endl "\n"
#define show2(a, b) cout<<a<<' '<<b<<endl;
#define show3(a, b, c) cout<<a<<' '<<b<<' '<<c<<endl;
#define show(arr) for (auto i:arr) cout<<i<<' ';
const long long N=1e5+5;
const long long mod=1000000007; //998244353
set<int> s;
void pre(){
for (int i=1; i<=10000; i++) s.insert(i*i*i);
}
void cases(){
int x;
cin>>x;
for (auto i:s){
int num=i;
if (num>x) break;
if (s.find(x-num)!=s.end()){
yes;
return;
}
}
no;
}
int32_t main(){
std::ios::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
int t;
t=1;
cin>>t;
pre();
while (t--){
cases();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(const vector<T> &a) {
for (T x : a) cout << x << " ";
cout << '\n';
}
const long long sze = 3e5 + 50, oo = 1e18 + 500, mod = 1e9 + 7;
const long double eps = 1e-9, PI = 2 * acos(0.0);
const long long N = 1e6 + 10;
vector<long long> vertices[sze];
vector<long long> visit(sze, 0);
vector<char> used(sze, false);
vector<long long> arr(sze, 0);
long long n, m, k;
long long cnt = 0;
signed main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n;
vector<long long> a(n);
long long mx = -oo;
long long ind = -1;
for (long long i = 0; i < n; i++) {
cin >> m;
if (m >= 0) {
m = -m - 1;
}
if (-m != 1) {
if (-m > mx) {
mx = -m;
ind = i;
}
}
a[i] = m;
}
if (ind == -1) ind = 0;
if (n & 1) {
a[ind] = -a[ind] - 1;
}
show(a);
return 0;
}
| 3 |
#include <bits/stdc++.h>
class LazyPropSegtree {
struct Lazy {
int add;
Lazy(int add = 0) : add(add) {}
void apply(const Lazy& lazy) { add += lazy.add; }
};
struct Data {
int val;
Data(int val = std::numeric_limits<int>::min()) : val(val) {}
void apply(const Lazy& lazy) { val += lazy.add; }
};
Data combine(Data a, Data b) { return Data(std::max(a.val, b.val)); }
struct Node {
Lazy lazy;
Data data;
};
std::vector<Node> st;
int N;
void push(int w, int L, int R) {
if (R - L > 1) {
st[w * 2 + 1].lazy.apply(st[w].lazy);
st[w * 2 + 2].lazy.apply(st[w].lazy);
}
st[w].data.apply(st[w].lazy);
st[w].lazy = Lazy();
}
void pull(int w, int L, int R) {
st[w].data = combine(st[w * 2 + 1].data, st[w * 2 + 2].data);
}
void build(int w, int L, int R) {
if (R - L == 1) {
st[w].data = Data(0);
} else {
int M = (L + R) / 2;
build(w * 2 + 1, L, M);
build(w * 2 + 2, M, R);
pull(w, L, R);
}
}
void update_add(int w, int L, int R, int a, int b, int v) {
push(w, L, R);
if (a >= R || b <= L) return;
if (a <= L && b >= R) {
st[w].lazy = Lazy{v};
push(w, L, R);
} else {
int M = (L + R) / 2;
update_add(w * 2 + 1, L, M, a, b, v);
update_add(w * 2 + 2, M, R, a, b, v);
pull(w, L, R);
}
}
Data query_max(int w, int L, int R, int a, int b) {
push(w, L, R);
if (a >= R || b <= L) return Data();
if (a <= L && b >= R) {
return st[w].data;
} else {
int M = (L + R) / 2;
return combine(query_max(w * 2 + 1, L, M, a, b),
query_max(w * 2 + 2, M, R, a, b));
}
}
public:
LazyPropSegtree(int N) : st(N * 4), N(N) { build(0, 0, N); }
void update_add(int a, int b, int v) { update_add(0, 0, N, a, b, v); }
Data query_max(int a, int b) { return query_max(0, 0, N, a, b); }
};
int ls[200005];
int rs[200005];
int ts[200005];
std::vector<int> bucket[2][400005];
int main() {
int N;
scanf("%d", &N);
std::map<int, int> cps;
for (int i = 0; i < N; i++) {
scanf("%d %d %d", &ls[i], &rs[i], &ts[i]);
cps[ls[i]], cps[rs[i]];
}
int last = 0;
for (auto& it : cps) {
it.second = ++last;
}
for (int i = 0; i < N; i++) {
bucket[ts[i] - 1][cps[rs[i]]].push_back(cps[ls[i]]);
}
LazyPropSegtree dp[2] = {LazyPropSegtree(last + 1),
LazyPropSegtree(last + 1)};
for (int i = 1; i <= last; i++) {
for (int t = 0; t < 2; t++) {
for (int l : bucket[t][i]) {
dp[t].update_add(0, l, 1);
}
dp[t ^ 1].update_add(i, i + 1, dp[t].query_max(0, i).val);
}
}
printf("%d\n", std::max(dp[0].query_max(0, last + 1).val,
dp[1].query_max(0, last + 1).val));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b = 1;
int main() {
cin >> t;
while (t--) {
b = 1;
cin >> a;
for (int i = 0; i <= 25; i++) {
if (a >= b) {
b *= 2;
} else {
if (a != b - 1) {
cout << b - 1 << endl;
} else {
int j;
for (j = 2; j * j <= a; j++) {
if (a % j == 0) break;
}
if (j * j > a)
puts("1");
else
cout << a / j << endl;
}
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 1000006;
long long int prime[MAX];
vector<long long int> v;
void Sieve() {
long long int i, j;
prime[0] = prime[1] = 1;
v.push_back(2);
for (i = 4; i < MAX; i += 2) prime[i] = 1;
for (i = 3; i * i <= MAX; i += 2) {
if (prime[i] == 0) {
for (j = i * i; j <= MAX; j += 2 * i) prime[j] = 1;
}
}
for (i = 3; i <= MAX; i += 2)
if (prime[i] == 0) v.push_back(i);
}
long long int arr[MAX];
int main() {
Sieve();
long long int n;
scanf("%lld", &(n));
long long int i, j;
for (i = 2; i <= n; i += 2) arr[i] = 1;
for (i = 1; i < v.size(); i++) {
arr[v[i]] = i + 1;
for (j = v[i] * v[i]; j <= n; j += (2 * v[i])) arr[j] = i + 1;
}
for (i = 2; i <= n; i++) printf("%lld ", arr[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
using ll = int64_t;
using Pii = pair<int, int>;
using ull = uint64_t;
using Vi = vector<int>;
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
run();
return 0;
}
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run() {
int n, m;
string pattern;
Vi valid;
cin >> n >> pattern;
m = int((pattern).size());
for (int i = (0); i < (n); i++) {
bool ok = true;
for (int j = (0); j < (m); j++) {
int k = (i + j) % n;
if (k < m && pattern[j] != pattern[k]) {
ok = false;
break;
}
}
if (ok) valid.push_back(i);
}
ll ans = 0;
vector<ll> dp(n);
dp[0] = 1;
for (auto& k : (valid)) {
if (k > 0) {
for (auto& j : (valid)) {
int i = (k + j) % n;
if (i < k) {
dp[k] -= dp[i] << max(0, k - i - m);
}
}
}
ans += (dp[k] * (n - k)) << max(0, n - k - m);
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0LL);
cin.tie(0LL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
cout << ((n / k) * k) + min(k / 2, (n % k)) << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Stair {
Stair(int h_, int start_) : h(h_), start(start_) {}
int h;
int start;
};
struct Range {
Range(int h_, int l_, int r_) : h(h_), l(l_), r(r_) {}
int h;
int l;
int r;
};
int main() {
int n;
cin >> n;
stack<Stair> stairs;
stairs.push(Stair(0, 0));
stack<Range> output;
int currTop = 0;
int totalSteps = 0;
for (int i = 1; i <= n + 1; i++) {
int a;
if (i <= n)
cin >> a;
else
a = 0;
if (a > currTop) {
stairs.push(Stair(a, i));
currTop = a;
} else if (a < currTop) {
while (1) {
Stair stair = stairs.top();
stairs.pop();
Stair top = stairs.top();
if (top.h > a) {
output.push(Range(stair.h - top.h, stair.start, i - 1));
totalSteps += stair.h - top.h;
} else {
output.push(Range(stair.h - a, stair.start, i - 1));
totalSteps += stair.h - a;
if (a > top.h) {
stairs.push(Stair(a, stair.start));
}
break;
}
}
currTop = a;
}
}
cout << totalSteps << endl;
while (!output.empty()) {
Range range = output.top();
output.pop();
for (int i = 0; i < range.h; i++) {
cout << range.l << " " << range.r << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[200007];
map<int, bool> vis;
queue<int> q;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (vis[arr[i]]) continue;
vis[arr[i]] = true;
if (q.size() == k) {
vis[q.front()] = false;
q.pop();
}
q.push(arr[i]);
}
vector<int> v;
while (!q.empty()) {
v.push_back(q.front());
q.pop();
}
cout << (int)v.size() << endl;
for (int i = (int)v.size() - 1; i >= 0; i--) {
cout << v[i] << ' ';
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = 0) {
freopen("in", "r", stdin);
if (outToFile) freopen("out", "w", stdout);
}
int n, m;
vector<int> odd;
vector<int> even;
vector<int> v[2 * (100 * 1035)];
int dist[2 * (100 * 1035)];
void bfs(int node) {
queue<int> q;
odd.clear();
even.clear();
q.push(0);
dist[node] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
if (dist[x] % 2)
odd.push_back(x);
else
even.push_back(x);
for (int i = 0; i < v[x].size(); i++) {
if (dist[v[x][i]] == -1) {
dist[v[x][i]] = dist[x] + 1;
q.push(v[x][i]);
}
}
}
}
int main() {
int tc;
cin >> tc;
while (tc--) {
cin >> n >> m;
for (int i = 0; i < n; i++) v[i].clear(), dist[i] = -1;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
bfs(0);
if (even.size() < odd.size()) {
cout << even.size() << endl;
for (int i = 0; i < even.size(); i++) {
printf("%d ", even[i] + 1);
}
printf("\n");
} else {
cout << odd.size() << endl;
for (int i = 0; i < odd.size(); i++) {
printf("%d ", odd[i] + 1);
}
printf("\n");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
char str[1005];
int freq[26] = {0};
int k, n, i, c;
cin >> str;
cin >> k;
n = strlen(str);
for (i = 0; i < n; i++) {
freq[str[i] - 'a'] += 1;
}
c = 0;
for (i = 0; i < 26; i++) {
if (freq[i] >= 1) c++;
}
if (c >= k) {
cout << "0\n";
} else {
if (k > n)
cout << "impossible\n";
else {
cout << k - c << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int dp[N][N], opt[N][N];
vector<int> day[N];
int main() {
int n, m, p;
scanf("%d %d %d", &n, &m, &p);
for (int i = 1; i <= n; i++) {
char s[m];
scanf("%s", s);
for (int j = 0; j < strlen(s); j++) {
if (s[j] == '1') day[i].push_back(j + 1);
}
}
memset(dp, 0x3f, sizeof(dp));
memset(opt, 0x3f, sizeof(opt));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= p; j++) {
if (day[i].size() && j < day[i].size())
opt[i][j] = 0x3f3f3f3f;
else
opt[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
int sz = day[i].size();
for (int j = 0; j < sz; j++) {
for (int k = j; k < sz; k++) {
opt[i][j + sz - k - 1] =
min(opt[i][j + sz - k - 1], day[i][k] - day[i][j] + 1);
}
}
}
for (int i = 1; i <= p; i++) dp[0][i] = opt[0][i];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= p; j++) {
if (dp[i][j] != 0x3f3f3f3f) {
for (int k = 0; j + k <= p; k++) {
dp[i + 1][j + k] = min(dp[i + 1][j + k], dp[i][j] + opt[i + 1][k]);
}
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i <= p; i++) ans = min(ans, dp[n][i]);
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int a[4], temp, j, i;
scanf("%d%d%d%d", &a[0], &a[1], &a[2], &a[3]);
for (j = 1; j < 4; j++) {
temp = a[j];
i = j - 1;
while (temp < a[i] && i >= 0) {
a[i + 1] = a[i];
i--;
}
a[i + 1] = temp;
}
if (a[0] + a[1] > a[2] || a[1] + a[2] > a[3] || a[0] + a[2] > a[3])
printf("TRIANGLE");
else if (a[0] + a[1] == a[2] || a[1] + a[2] == a[3] || a[0] + a[2] == a[3])
printf("SEGMENT");
else
printf("IMPOSSIBLE");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(12);
solve();
return 0;
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void pr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void pr(const Head& head, const Tail&... tail) {
cout << head << ' ';
pr(tail...);
}
const int MAX_SUM = 5e5 + 10;
bool vis[MAX_SUM];
void solve() {
fill(vis, vis + MAX_SUM, false);
int n, d;
sc(n, d);
vector<int> oks;
oks.push_back(0);
for (int i = 0; i < n; i++) {
int x;
sc(x);
for (int j = ((int)oks.size()) - 1; j >= 0; j--) {
if (x + oks[j] < MAX_SUM && !vis[x + oks[j]]) {
oks.push_back(x + oks[j]);
vis[x + oks[j]] = true;
}
}
}
sort(oks.begin(), oks.end());
int ans = 0, cur = 0;
while (true) {
int idx =
upper_bound(oks.begin(), oks.end(), oks[cur] + d) - oks.begin() - 1;
if (idx >= ((int)oks.size()) || idx == cur) {
break;
}
ans++;
cur = idx;
}
pr(oks[cur], ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d %d", &a, &b);
int rx = abs(a - b);
int so = 0;
for (int i = 0; i <= 50000; ++i) {
so += i;
if (so >= rx) {
if ((so - rx) % 2 == 0) {
printf("%d\n", i);
break;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int M = 1e5 + 5;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long lINF = 0x3f3f3f3f3f3f3f3fLL;
const int sINF = 0xcfcfcfcf;
char s[M * 2], s1[M];
int mx, tmp, len;
int main() {
scanf("%s", s1);
len = strlen(s1);
mx = tmp = 1;
strcpy(s, s1);
strcat(s + len, s1);
for (int i = 1; i < len * 2; i++) {
if (s[i] == s[i - 1]) {
mx = max(mx, tmp);
tmp = 1;
} else {
tmp++;
mx = max(mx, tmp);
}
}
mx = min(mx, len);
printf("%d\n", mx);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool comparator(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) {
return a.second >= b.second;
} else
return a.first <= b.first;
}
int main() {
int n;
cin >> n;
vector<pair<int, int>> s;
for (auto i = 1; i <= 9; ++i) {
s.push_back(make_pair(n % i, i));
}
sort(s.begin(), s.end(), comparator);
pair<int, int> p = s[0];
cout << (n / p.second) << endl;
for (auto i = 0; i < n / p.second; ++i) {
cout << p.second << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
if (n < 26)
cout << -1;
else {
string temp = "";
int curr = 0, idx;
for (int i = 0; i < n; i++) {
idx = (int)(s[i] - 'a');
if (idx <= curr && curr < 26) {
temp += (char)(curr + 'a');
curr++;
} else
temp += s[i];
}
if (curr > 25)
cout << temp;
else
cout << -1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mas[30000][20];
int chat[20];
int men[30000];
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
men[i] = 0;
for (int j = 0; j < m; ++j) {
scanf("%d", &mas[i][j]);
chat[j] = 0;
}
}
int x, y;
for (int i = 0; i < k; ++i) {
scanf("%d %d", &x, &y);
chat[y - 1]++;
men[x - 1]++;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = 0;
for (int j = 0; j < m; ++j) {
if (mas[i][j]) ans += chat[j];
}
ans -= men[i];
printf("%d ", ans);
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.