solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long fac[14];
vector<long long> lucky;
bool isLucky(long long n) {
int x;
while (n) {
x = n % 10;
n /= 10;
if (x == 4 || x == 7) continue;
return 0;
}
return 1;
}
void gen(long long n) {
long long x = n * 10;
if (x > 1000000000ll) return;
x += 4;
lucky.push_back(x);
gen(x);
x += 3;
lucky.push_back(x);
gen(x);
}
int main() {
int i, j, r, ans;
long long n, k, m;
cin >> n >> k;
fac[0] = 1;
for (i = 1; i < 14; i++) fac[i] = i * fac[i - 1];
if (n < 14 && fac[n] < k) {
cout << -1;
return 0;
}
gen(0);
lucky.push_back(4444444444ll);
sort(lucky.begin(), lucky.end());
m = max(n - 13, 0ll);
ans = upper_bound(lucky.begin(), lucky.end(), m) - lucky.begin();
vector<bool> used(n - m + 1, false);
for (i = n - m; i >= 1; i--) {
r = (k + fac[i - 1] - 1) / fac[i - 1];
k -= (r - 1) * fac[i - 1];
for (j = 1;; j++)
if (!used[j]) {
r--;
if (!r) break;
}
used[j] = 1;
if (isLucky(n - i + 1) && isLucky(m + j)) ans++;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m(0), a(0), b(0), c(0), x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (i % 3 == 0)
a += x;
else if (i % 3 == 1)
b += x;
else
c += x;
}
m = max(max(a, b), c);
if (m == a)
cout << "chest";
else if (m == b)
cout << "biceps";
else
cout << "back";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y, z, p, i, j;
cin >> n >> m >> x >> y >> z >> p;
int _n = n, _m = m;
for (i = 0; i < p; i++) {
n = _n;
m = _m;
int ans_x, ans_y, _x, _y;
scanf("%d", &ans_x);
scanf("%d", &ans_y);
_x = ans_x, _y = ans_y;
for (j = 0; j < x % 4; j++) {
ans_y = n - _x + 1;
ans_x = _y;
_x = ans_x;
_y = ans_y;
swap(n, m);
}
for (j = 0; j < y % 2; j++) {
ans_y = m - _y + 1;
_y = ans_y;
}
for (j = 0; j < z % 4; j++) {
ans_y = _x;
ans_x = m - _y + 1;
_x = ans_x;
_y = ans_y;
swap(n, m);
}
printf("%d %d\n", ans_x, ans_y);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long MOD = 1e9 + 7;
long long INF = 1e18;
const int N = 2001;
long long a[N][N];
long long b[N][N];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0),
cout << fixed << setprecision(20);
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
char c;
cin >> c;
a[i][j] = c - '0';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
long long aa;
char c;
cin >> c;
aa = c - '0';
a[i][j] ^= aa;
}
}
vector<long long> v(n);
for (int i = 0; i < n; i++) {
char c;
cin >> c;
v[i] = c - '0';
}
long long flll = 0;
for (int i = 0; i < n; i++) {
if (v[i]) {
flll = 1;
}
}
if (!flll) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
flll |= a[i][j];
}
}
if (flll) {
cout << -1;
} else {
cout << 0;
}
return 0;
}
vector<pair<string, long long> > ans;
long long j = 0;
while (!v[j]) {
long long fl = 0;
for (int i = 0; i < n; i++) {
if (a[j][i]) {
fl = 1;
}
}
if (fl) {
for (int i = 0; i < n; i++) {
a[j][i] ^= v[i];
}
fl = 0;
for (int i = 0; i < n; i++) {
if (a[j][i]) {
fl = 1;
}
}
if (fl) {
cout << -1;
return 0;
}
ans.push_back({"col", j + 1});
}
j++;
}
vector<pair<string, long long> > ans2 = ans;
for (int i = 0; i < n; i++) {
for (int u = 0; u < n; u++) {
b[i][u] = a[i][u];
}
}
long long hv = 1;
for (int i = 0; i < n; i++) {
if (a[j][i]) {
ans.push_back({"row", i + 1});
for (int u = 0; u < n; u++) {
a[u][i] ^= v[u];
}
}
}
for (int i = j + 1; i < n; i++) {
long long fl = 0;
for (int u = 0; u < n; u++) {
fl |= a[i][u];
}
if (fl) {
ans.push_back({"col", i + 1});
for (int u = 0; u < n; u++) {
a[i][u] ^= v[u];
if (a[i][u]) {
hv = 0;
}
}
}
}
if (hv) {
cout << ans.size() << "\n";
for (auto i : ans) {
if (i.first == "row")
i.first = "col";
else
i.first = "row";
cout << i.first << " " << i.second - 1 << "\n";
}
return 0;
}
for (int i = 0; i < n; i++) {
for (int u = 0; u < n; u++) {
a[i][u] = b[i][u];
}
}
ans = ans2;
for (int i = 0; i < n; i++) {
a[j][i] ^= v[i];
}
ans.push_back({"col", j + 1});
hv = 1;
for (int i = 0; i < n; i++) {
if (a[j][i]) {
ans.push_back({"row", i + 1});
for (int u = 0; u < n; u++) {
a[u][i] ^= v[u];
}
}
}
for (int i = j + 1; i < n; i++) {
long long fl = 0;
for (int u = 0; u < n; u++) {
fl |= a[i][u];
}
if (fl) {
ans.push_back({"col", i + 1});
for (int u = 0; u < n; u++) {
a[i][u] ^= v[u];
if (a[i][u]) {
hv = 0;
}
}
}
}
if (hv) {
cout << ans.size() << "\n";
for (auto i : ans) {
if (i.first == "row")
i.first = "col";
else
i.first = "row";
cout << i.first << " " << i.second - 1 << "\n";
}
return 0;
}
cout << -1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
void read(int& x) {
x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
int x[100005], y[100005], n;
double bit[100005], ans;
int abs(int x) { return (x < 0) ? -x : x; }
int gcd(int x, int y) { return (y == 0) ? x : gcd(y, x % y); }
int main() {
read(n);
for (int i = (1); i <= (n); i++) read(x[i]), read(y[i]);
bit[0] = 1.0;
for (int i = (1); i < (100005); i++) bit[i] = bit[i - 1] * 0.5;
ans = 0.0;
for (int i = (1); i <= (n); i++) {
for (int j = i % n + 1, t = 2; (j != i) && (t < 61); j = j % n + 1, t++)
ans +=
(bit[t] - bit[n]) * ((double)x[i] * y[j] - (double)x[j] * y[i] -
(double)gcd(abs(x[i] - x[j]), abs(y[i] - y[j])));
}
printf("%.10f\n",
ans * 0.5 / (1.0 - bit[n] * (1 + n + (double)n * (n - 1) / 2)) + 1.0);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
inline int GA(long long n, vector<long long> &vec) {
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
vec.push_back(x);
}
return 0;
}
inline int GAEG(long long m, vector<long long> vec[]) {
for (int i = 0; i < m; ++i) {
long long x, y;
cin >> x >> y;
x--, y--;
vec[x].push_back(y);
vec[y].push_back(x);
}
return 0;
}
const long long MD = (long long)1e9 + 7;
bool isvalid(long long xx, long long yy, long long n, long long m) {
return (xx >= 0 && xx < n && yy >= 0 && yy < m);
}
long long pw(long long x, long long y, long long dr) {
if (y == 0) return 1;
long long o = y / 2;
long long f = pw(x, o, dr) % dr;
if (y % 2) {
return (((f * f) % dr) * x) % dr;
} else
return (f * f) % dr;
}
vector<pair<long long, long long> > vv;
set<pair<long long, long long> > st;
set<pair<long long, long long> >::iterator it;
vector<long long> ans;
vector<pair<long long, pair<long long, long long> > > cc;
long long seg[5555555];
bool cmp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
long long pp[200005];
long long UP(long long k, long long l, long long h, long long r) {
if (h < k || k < l) return seg[r];
if (l == h) return ++seg[r];
long long m = (l + h) / 2;
return seg[r] = UP(k, l, m, r * 2 + 1) + UP(k, m + 1, h, r * 2 + 2);
}
long long GS(long long k, long long l, long long h, long long r) {
if (k <= 0 || k > seg[r]) return 0;
if (l == h) return l;
long long m = (l + h) / 2;
return GS(k, l, m, r * 2 + 1) + GS(k - seg[r * 2 + 1], m + 1, h, r * 2 + 2);
}
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> pp[i];
vv.push_back(make_pair(pp[i], i));
}
sort(vv.begin(), vv.end(), cmp);
long long q;
cin >> q;
ans.assign(q + 1, 0);
long long cnt = 0;
while (q--) {
long long x, y;
cin >> x >> y;
y--;
cc.push_back(make_pair(x, make_pair(y, cnt)));
cnt++;
}
sort((cc).begin(), (cc).end());
long long ff = 0;
for (int i = 0; i < cc.size(); ++i) {
long long x = cc[i].first, y = cc[i].second.first, z = cc[i].second.second;
while (ff != x) {
UP(vv[ff].second, 0, n - 1, 0);
ff++;
}
long long ind = GS(y + 1, 0, n - 1, 0);
ans[z] = pp[ind];
}
for (int i = 0; i < cnt; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline long long rand(long long x, long long y) {
return rng() % (y + 1 - x) + x;
}
string inline to_string(char c) {
string second(1, c);
return second;
}
template <typename T>
inline T gcd(T a, T b) {
return a == 0 ? llabs(b) : gcd(b % a, a);
}
using ll = int;
using ld = long double;
using pi = pair<ll, ll>;
using spi = pair<ll, pi>;
using dpi = pair<pi, pi>;
const ll sqn = 450;
const ll other = (100006) / sqn + 2;
ll n, q, A[(100006)], heavy[(100006)], head[(100006)], p[(100006)],
st[(100006)], co, depth[(100006)], bck[(100006)], ans;
bool off[(100006)];
vector<int> v[(100006)];
struct bkt {
ll second, e, co2[(100006) * 2], ofs = 0;
ll* co = co2 + (100006);
bkt() { second = e = 0, memset((co2), 0, sizeof((co2))), ofs = 0; }
void init(ll _s, ll _e) {
second = _s, e = _e, ofs = 0;
memset((co2), 0, sizeof((co2)));
for (ll i = second; i <= ll(e); ++i) {
++co[A[bck[i]]];
}
}
void up(ll x, ll y, ll val) {
if (x > e || y < second) return;
if (x <= second && e <= y) {
ofs += val;
return;
}
for (ll i = max(second, x); i <= ll(min(e, y)); ++i) {
if (!off[i]) --co[A[bck[i]]];
A[bck[i]] += val;
if (!off[i]) ++co[A[bck[i]]];
}
return;
}
ll query(ll x, ll y, ll val) {
if (x > e || y < second) return 0;
if (x <= second && e <= y) {
return co[val - ofs];
}
ll ans = 0;
for (ll i = max(second, x); i <= ll(min(e, y)); ++i)
if (!off[i]) ans += A[bck[i]] + ofs == val;
return ans;
}
void dir(ll x) {
assert(second <= x && x <= e);
co[A[bck[x]]] += off[x] ? 1 : -1;
ans += (A[bck[x]] + ofs < 0) * (off[x] ? 1 : -1);
off[x] ^= 1;
}
} bk[other];
ll query(ll x, ll y, ll val) {
ll ans = 0;
for (ll i = 0; i <= ll((n - 1) / sqn); ++i) ans += bk[i].query(x, y, val);
return ans;
}
void up(ll x, ll y, ll val) {
for (ll i = 0; i <= ll((n - 1) / sqn); ++i) bk[i].up(x, y, val);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
for (ll i = 2; i <= ll(n); ++i) {
cin >> p[i];
v[p[i]].emplace_back(i);
}
p[1] = 1;
for (ll i = 1; i <= ll(n); ++i) cin >> A[i];
function<ll(ll)> dfs = [&](ll x) {
ll sz = 1, mx_sz = 0;
for (auto i : v[x]) {
depth[i] = depth[x] + 1;
ll c_sz = dfs(i);
sz += c_sz;
if (c_sz > mx_sz) mx_sz = c_sz, heavy[x] = i;
}
return sz;
};
function<void(ll, ll)> hld = [&](ll x, ll h) {
head[x] = h, st[x] = co++, bck[st[x]] = x;
if (heavy[x]) hld(heavy[x], h);
for (auto i : v[x])
if (i ^ heavy[x]) hld(i, i);
};
dfs(1), hld(1, 1);
assert(co == n);
for (ll i = 0; i <= ll((n - 1) / sqn); ++i)
bk[i].init(i * sqn, min((i + 1) * sqn, n) - 1);
for (ll i = 0; i <= ll(q - 1); ++i) {
auto op = [&](ll x, ll val) {
if (x == 1) return;
x = p[x];
for (;; x = p[head[x]]) {
up(st[head[x]], st[x], val);
if (val == 1)
ans -= query(st[head[x]], st[x], 0);
else if (val == -1)
ans += query(st[head[x]], st[x], -1);
else
assert(0);
if (head[x] == 1) break;
}
};
ll x;
cin >> x;
if (x > 0) {
bk[st[x] / sqn].dir(st[x]);
op(x, -1);
} else {
x *= -1;
bk[st[x] / sqn].dir(st[x]);
op(x, 1);
}
cout << ans << ' ';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
long long a[N], parent[N], f[N], r[N];
bool vis[N], vis1[N];
vector<long long> v, v1;
pair<long long, string> p[N], p1[N];
set<long long> s, s1;
map<long long, long long> mp, mp1;
queue<long long> q;
long long mod = 1e9 + 7;
void make_set(int v) { parent[v] = v; }
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (r[a] < r[b]) swap(a, b);
parent[b] = a;
if (r[a] == r[b]) r[a]++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
int n, m, k;
cin >> n >> m;
for (int i = 1; i <= n; i++) make_set(i);
for (int i = 0; i < m; i++) {
cin >> k;
for (int j = 0; j < k; j++) {
cin >> a[j];
union_sets(a[0], a[j]);
}
}
for (int i = 1; i <= n; i++) f[find_set(i)]++;
for (int i = 1; i <= n; i++) cout << f[find_set(i)] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
int n, k;
int get_sg(int x) {
if (x < 2) return x;
if (k & 1) {
if (x % 2 == 0) {
if (x < 5) return x - 2;
int nowsg = get_sg(x >> 1);
if (nowsg > 1)
return 1;
else
return nowsg + 1;
} else {
if (x == 3) return 1;
return 0;
}
}
if (x == 2) return 2;
return !(x % 2 == 1);
}
int main() {
scanf("%d%d", &n, &k);
int ans = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
ans ^= get_sg(x);
}
if (ans)
printf("Kevin\n");
else
printf("Nicky\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
int comp(const void* p, const void* q) { return (*(int*)p - *(int*)q); }
int comp1(const void* p, const void* q) { return (*(int*)q - *(int*)p); }
int main() {
int n, a, i, b = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
b += (i * (n - i) + 1);
}
printf("%d\n", b);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 2e5 + 7;
int n, a[N], i, flag, pre, x, id = -1, sz, q[M], tmp1, tmp2, top;
void print(int pre, int id, int size) {
for (i = id; i <= n; ++i, pre = size)
for (x = a[i]; x--;) cout << pre << " ", ++size;
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
for (cin >> n, flag = true, i = 0; i <= n; ++i) {
cin >> a[i];
if (pre && a[i] > 1) flag = false;
if (pre && a[i] > 1 && id == -1) id = i - 1;
if (a[i] > 1)
pre = 1;
else
pre = 0;
}
if (flag)
cout << "perfect" << endl;
else {
for (cout << "ambiguous" << endl, pre = 0, i = 0; i < id; ++i, pre = sz)
for (; a[i]--;) q[++top] = pre, ++sz;
for (; a[id]--;) {
q[++top] = pre;
++sz;
if (!tmp1)
tmp1 = sz;
else if (!tmp2)
tmp2 = sz;
}
for (i = 1; i <= top; ++i) cout << q[i] << " ";
cout << tmp1 << " ";
a[id + 1]--;
print(tmp2, id + 1, sz + 1);
for (i = 1; i <= top; ++i) cout << q[i] << " ";
a[id + 1]++;
print(tmp2, id + 1, sz);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string FILE_NAME = "testcase.B";
string NAME;
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int main() {
ios_base::sync_with_stdio(0);
string str = "";
getline(cin, str);
stringstream ss(str);
string s = "";
string t = "";
string pre = "";
while (ss >> s) {
if (!pre.empty() && isdigit(pre[pre.size() - 1]) && isdigit(s[0])) {
t += ' ';
}
t += s;
pre = s;
}
int n = t.length();
string res = "";
int i = 0;
while (i < n) {
if (t[i] == ',' && i != n - 1) {
res += t[i];
res += ' ';
} else if (t[i] == '.' && i + 1 < n && t[i + 1] == '.' && i + 2 < n &&
t[i + 2] == '.') {
if (i != 0 && (i - 1 >= 0 && t[i - 1] != ',')) res += ' ';
res += "...";
i += 3;
continue;
} else {
res += t[i];
}
i++;
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<vector<int>> v(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> v[i][j];
vector<int> row(n);
for (int i = 0; i < n; i++) row[i] = i;
vector<int> col(m);
for (int i = 0; i < m; i++) col[i] = i;
while (k--) {
char ch;
int x, y;
cin >> ch >> x >> y;
x--;
y--;
if (ch == 'r') {
int temp = row[x];
row[x] = row[y];
row[y] = temp;
} else if (ch == 'c') {
int temp = col[x];
col[x] = col[y];
col[y] = temp;
} else
cout << v[row[x]][col[y]] << '\n';
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int pop;
int name;
int time;
} pp[110];
bool cmp(node a, node b) {
if (a.time == b.time) return a.pop < b.pop;
return a.time < b.time;
}
int main() {
int n, m, k, p = 0;
int x;
while (cin >> n >> m >> k) {
for (int i = 0; i < m; i++) {
scanf("%d", &pp[i].name);
pp[i].time = 0;
pp[i].pop = i + 1;
}
for (int i = 0; i < k; i++) {
scanf("%d", &x);
for (int j = 0; j < m; j++) {
if (x % pp[j].name == 0) pp[j].time++;
}
}
sort(pp, pp + m, cmp);
int ans = 1;
for (int i = 1; i < m; i++) {
if (pp[i].time == pp[i - 1].time)
ans++;
else
break;
}
printf("%d\n", ans);
for (int i = 0; i < ans; i++) {
if (p++ != 0) {
printf(" ");
}
printf("%d", pp[i].pop);
}
}
return 0;
}
| 2 |
// #pg199 aka Parth Gulati
#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define MOD (int) 1e9+7
#define all(a) a.begin(),a.end()
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define fo(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define forK(i,k,n) for (int i = k; i <= n; i++)
#define loop(i,a,b) for (int i = a; i < b; i++)
#define bloop(i,a,b) for (int i = a ; i>=b;i--)
#define tc(t) int t; cin >> t; while (t--)
#define int long long
#define pb emplace_back
#define prec(n, p) fixed<<setprecision(n)<<p
#define inf (int)(1e18)
#define ini(a, i) memset(a, i, sizeof(a))
#define vi vector<int>
#define fi first
#define se second
#define endl '\n'
#define pii pair<int, int>
#define deb(x) cout<<#x<<": "<<x<<" "<<endl;
#define vii vector<ii>
#define sz(s) s.size()
#define mInt map<int, int>
#define setbits(n) __builtin_popcount(n)
#define ll long long
#define sl(x) scanf("%lld", &x)
#define pl(x) printf("%lld\n", x)
#define ou cout<<'\n';
#define mp make_pair
//Policy based Data Structure
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
//insert
#define findElement(n) find_by_order(n)
#define findIndex(n) order_of_key(n)
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
int max(int a, int b) {if (a > b) return a; else return b;}
int min(int a, int b) {if (a < b) return a; else return b;}
template<typename... T>
void in(T&... args) {
((cin >> args), ...);
}
template<typename... T>
void out(T&&... args) {
((cout << args << " "), ...);
}
template<typename... T>
void outl(T&&... args) {
((cout << args << endl), ...);
}
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
tc(t){
int n, k;
in(n, k);
int x = k;
int y = 2*k-n;
vector<int> ans;
vector<int> ans2;
for(int i = 1;i<y;i++){
ans.pb(i);
}
int z = k;
for(int i = k;i>=y;i--){
ans.pb(i);
}
fo(i, k)out(ans[i]);
ou;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
template <typename S, typename T>
inline bool Min(S &a, const T &b) {
return a > b ? a = b, true : false;
}
template <typename S, typename T>
inline bool Max(S &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename S, typename T>
inline void Adm(S &a, const T &b) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
template <typename S, typename T>
inline void Mum(S &a, const T &b) {
a = 1LL * a * b % MOD;
}
template <typename T>
inline bool IsPri(T x) {
if (x < 2) return false;
for (T i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
template <typename T>
inline T Gcd(T a, T b) {
while (b) {
T t = b;
b = a % b;
a = t;
}
return a;
}
template <typename T>
inline int BtCnt(T x) {
int cnt = 0;
while (x) ++cnt, x &= x - 1;
return cnt;
}
inline long long Pow(long long a, long long n) {
long long t = 1;
while (n) {
if (n & 1) t = t * a % MOD;
a = a * a % MOD, n >>= 1;
}
return t;
}
inline int read() {
static char buf[1000000], *p1 = buf, *p2 = buf;
register int x = 0;
register char ch =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
register bool sgn = 0;
while (ch != '-' && (ch < '0' || ch > '9'))
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
if (ch == '-') sgn = 1;
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48),
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
return sgn ? -x : x;
}
const int N = 5e5 + 100;
struct node {
int u, v, w;
bool operator<(const node &o) const { return w < o.w; }
} e[N], p[N];
struct query {
int a, id;
bool operator<(const query &o) const {
if (e[a].w != e[o.a].w) return e[a].w < e[o.a].w;
return id < o.id;
}
} q[N];
bool ans[N];
struct dsu {
int fz[N], sz[N], tot;
pair<int, int> stk[N];
void Init() {
for (int i = 0; i < N; ++i) fz[i] = i, sz[i] = 1;
tot = 0;
}
void Cancel() {
while (tot) {
--tot;
int x = stk[tot].first, y = stk[tot].second;
sz[y] -= sz[x], fz[x] = x;
}
}
int Find(int x) {
while (x != fz[x]) x = fz[x];
return x;
}
bool Merge(int x, int y, int c = 0) {
x = Find(x), y = Find(y);
if (x == y) return false;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x], fz[x] = y;
if (c) stk[tot++] = {x, y};
return true;
}
} d;
int main() {
memset((ans), (1), sizeof(ans)), d.Init();
int n, m, Q, tot = 0;
cin >> n >> m;
for (int i = 1; i <= m; ++i)
scanf("%d%d%d", &p[i].u, &p[i].v, &p[i].w), e[i] = p[i];
sort(p + 1, p + m + 1);
cin >> Q;
for (int i = 1; i <= Q; ++i) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; ++j) ++tot, scanf("%d", &q[tot].a), q[tot].id = i;
}
sort(q + 1, q + tot + 1);
int k = 1;
for (int i = 1; i <= tot; ++i) {
while (k <= m && p[k].w < e[q[i].a].w) d.Merge(p[k].u, p[k].v), ++k;
int j = i;
for (; j <= tot; ++j) {
if (e[q[i].a].w != e[q[j].a].w || q[i].id != q[j].id) break;
if (!d.Merge(e[q[j].a].u, e[q[j].a].v, 1)) ans[q[j].id] = 0;
}
i = j - 1;
d.Cancel();
}
for (int i = 1; i <= Q; ++i) printf("%s\n", ans[i] ? "YES" : "NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, int> oc;
int main() {
int ret = 0, n;
cin >> n;
vector<pair<int, int> > male, female;
for (int i = 0; i < n; ++i) {
string gender;
int start, end;
cin >> gender >> start >> end;
if (gender == "M") {
male.push_back(make_pair(start, end));
continue;
}
female.push_back(make_pair(start, end));
}
for (int i = 0; i <= 366; ++i) {
int m = 0, f = 0;
for (int j = 0; j < male.size(); ++j) {
m += (male[j].first <= i && male[j].second >= i);
}
for (int j = 0; j < female.size(); ++j) {
f += (female[j].first <= i && female[j].second >= i);
}
ret = max(ret, min(f, m) * 2);
}
cout << ret << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 62);
const int inf = (1 << 30);
const int nmax = 1e5 + 50;
const int mod = 1e9 + 7;
using namespace std;
int n, i, j, cl[nmax], eq[nmax], eq1[nmax], t;
vector<int> nw, rs[5], vc;
string s;
string ask(vector<int> v) {
if (v.empty()) return "";
cout << "Q " << (int)v.size() / 2 << " ";
for (int i = 0; i < (int)v.size(); i++) cout << v[i] << " ";
cout << endl;
string s;
cin >> s;
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i <= n; i++) {
eq[i] = eq1[i] = 0;
cl[i] = 0;
}
for (i = 1; i <= 3; i++) rs[i].clear();
vc.clear();
for (i = 1; i < n; i += 2) {
vc.push_back(i);
vc.push_back(i + 1);
}
s = ask(vc);
for (i = 0; i < (int)s.size(); i++)
if (s[i] == '1') eq[vc[2 * i]] = 1;
vc.clear();
for (i = 2; i < n; i += 2) {
vc.push_back(i);
vc.push_back(i + 1);
}
s = ask(vc);
for (i = 0; i < (int)s.size(); i++)
if (s[i] == '1') eq[vc[2 * i]] = 1;
nw.clear(), nw.push_back(1);
for (i = 1; i < n; i++)
if (!eq[i]) nw.push_back(i + 1);
vc.clear();
for (i = 0; i < (int)nw.size() - 2; i += 4) {
vc.push_back(nw[i]);
vc.push_back(nw[i + 2]);
}
s = ask(vc);
for (i = 0; i < (int)s.size(); i++)
if (s[i] == '1') eq1[vc[2 * i]] = 1;
vc.clear();
for (i = 2; i < (int)nw.size() - 2; i += 4) {
vc.push_back(nw[i]);
vc.push_back(nw[i + 2]);
}
s = ask(vc);
for (i = 0; i < (int)s.size(); i++)
if (s[i] == '1') eq1[vc[2 * i]] = 1;
vc.clear();
for (i = 1; i < (int)nw.size() - 2; i += 4) {
vc.push_back(nw[i]);
vc.push_back(nw[i + 2]);
}
s = ask(vc);
for (i = 0; i < (int)s.size(); i++)
if (s[i] == '1') eq1[vc[2 * i]] = 1;
vc.clear();
for (i = 3; i < (int)nw.size() - 2; i += 4) {
vc.push_back(nw[i]);
vc.push_back(nw[i + 2]);
}
s = ask(vc);
for (i = 0; i < (int)s.size(); i++)
if (s[i] == '1') eq1[vc[2 * i]] = 1;
cl[nw[0]] = 1;
if ((int)nw.size() > 1) cl[nw[1]] = 2;
for (i = 0; i < (int)nw.size() - 2; i++) {
if (eq1[nw[i]])
cl[nw[i + 2]] = cl[nw[i]];
else
cl[nw[i + 2]] = 6 - cl[nw[i]] - cl[nw[i + 1]];
}
nw.push_back(n + 1);
for (i = 0; i < (int)nw.size() - 1; i++) {
for (j = nw[i]; j < nw[i + 1]; j++) rs[cl[nw[i]]].push_back(j);
}
cout << "A";
for (i = 1; i <= 3; i++) cout << " " << (int)rs[i].size();
cout << endl;
for (i = 1; i <= 3; i++) {
for (j = 0; j < (int)rs[i].size(); j++) cout << rs[i][j] << " ";
cout << endl;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int found = 0;
long long int n, v[4] = {0, -1, -1, -1}, nr;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> nr;
int j;
for (j = 1; j <= 3; ++j) {
if (v[j] == (-1) || v[j] == nr) {
v[j] = nr;
break;
}
}
if (j == 4) {
cout << "NO\n";
found = 1;
break;
}
}
if (found == 0) {
if (v[3] == (-1))
cout << "YES\n";
else if (abs(v[1] - v[2]) == abs(v[1] - v[3]) ||
abs(v[1] - v[2]) == abs(v[2] - v[3]) ||
abs(v[3] - v[2]) == abs(v[1] - v[3]))
cout << "YES\n";
else
cout << "NO\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void setmin(int &x, int y) {
if (y < x) x = y;
}
inline void setmax(int &x, int y) {
if (y > x) x = y;
}
inline void setmin(long long &x, long long y) {
if (y < x) x = y;
}
inline void setmax(long long &x, long long y) {
if (y > x) x = y;
}
const int N = 100000;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
int solve(string s) {
cout << s << endl;
int n = (int)s.size();
int dp[n][2];
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) dp[i][j] = inf;
if (s[0] == '0') dp[0][0] = 0;
for (int i = 1; i < n; i++) {
if (i - 2 < 0)
setmin(dp[i][1], 1 + 0);
else if (s[i - 2] == '0')
setmin(dp[i][1], 1 + min(dp[i - 2][0], dp[i - 2][1]));
else
setmin(dp[i][1], 1 + dp[i - 2][1]);
if (s[i - 1] == '0')
setmin(dp[i][0], min(dp[i - 1][0], dp[i - 1][1]));
else
setmin(dp[i][0], dp[i - 1][1]);
}
if (s[n - 1] == '0')
return min(dp[n - 1][0], dp[n - 1][1]);
else
return dp[n - 1][1];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < n; i++) cnt += i % 2 == s[i] - '0';
cout << min(cnt, n - cnt) << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int lost[500005];
int vv[500005];
int maxpos[500005];
int main() {
int n, m;
cin >> n >> m;
set<int> ss;
for (int i = 0; i < n; i++) ss.insert(i);
int l, r, x;
for (int i = 0; i < m; i++) {
cin >> l >> r >> x;
l--, r--, x--;
set<int>::iterator it = ss.lower_bound(l);
vector<int> dead;
while (it != ss.end()) {
int cur = *it;
if (cur > r) break;
if (cur != x) {
dead.push_back(cur);
lost[cur] = x + 1;
}
it++;
}
for (int j = 0; j < dead.size(); j++) ss.erase(dead[j]);
}
for (int i = 0; i < n; i++) {
cout << lost[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005];
long long dp[200005];
long long Pow(long long bas, int tms) {
long long res = 1;
while (tms) {
if (tms & 1) {
res = (res * bas) % 998244353;
}
tms >>= 1;
bas = (bas * bas) % 998244353;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
dp[i] = (1 + dp[i - 1]) * 100 % 998244353 * Pow(a[i], 998244353 - 2) %
998244353;
}
printf("%lld", dp[n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int main() {
long t;
cin >> t;
while (t--) {
long n;
cin >> n;
vector<int> a(n);
long long sum = 0;
long long an = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum == 0) {
cout << "NO"
<< "\n";
} else {
sort((a).begin(), (a).end());
cout << "YES"
<< "\n";
for (int i = 0; i < n; i++) {
an += a[i];
if (an == 0) {
sort((a).rbegin(), (a).rend());
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, e[1000005], i, n, ans, dp[1000005];
int main() {
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i <= n; ++i) cin >> e[i];
sort(e + 1, e + n + 1);
for (i = 1; i <= n; ++i) {
dp[i] = dp[i - 1];
if (i >= e[i]) dp[i] = max(dp[i], dp[i - e[i]] + 1);
}
cout << dp[n] << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
int t[6];
int maximum;
cin >> a >> b >> c;
t[0] = a + b + c;
t[1] = a + b * c;
t[2] = a * b + c;
t[3] = (a + b) * c;
t[4] = a * (b + c);
t[5] = a * b * c;
maximum = t[0];
for (int x = 0; x < 6; x++) {
if (t[x] > maximum) maximum = t[x];
}
cout << maximum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int x, y, z, k;
cin >> x >> y >> z >> k;
k = min(k, (x - 1) + (y - 1) + (z - 1));
int a, b, c;
a = b = c = 0;
long long Ans = 1;
for (int i = 0; i < k; i++) {
a++;
a = min(a, x - 1);
if (a + b + c <= k) {
Ans = max(Ans, (long long)(a + 1) * (long long)(b + 1) * (c + 1));
}
b++;
b = min(b, y - 1);
if (a + b + c <= k) {
Ans = max(Ans, (long long)(a + 1) * (long long)(b + 1) * (c + 1));
}
c++;
c = min(c, z - 1);
if (a + b + c <= k) {
Ans = max(Ans, (long long)(a + 1) * (long long)(b + 1) * (c + 1));
}
}
cout << Ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500007;
const int maxm = 40000007;
const int ooi = 1e9 + 7;
const long long ool = 1e18 + 7;
const int apsz = 26;
const long long mod = 998244353;
string s;
int ans[maxn];
int n;
int pre[apsz];
void init() {
cin >> s;
n = s.length();
fill(pre, pre + apsz, n);
for (int i = (n - 1); i >= (0); --i) {
int x = s[i] - 'a';
pre[x] = i;
}
}
void solve() {
for (int i = (0); i < (n); ++i) {
int x = s[i] - 'a';
int pos = n;
for (int j = (0); j < (x); ++j) pos = min(pos, pre[j]);
if (pos < i) ans[i] = 1;
}
for (int i = (0); i < (n); ++i) {
if (ans[i])
cout << "Ann\n";
else
cout << "Mike\n";
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
init();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, nex;
Edge(int _ = 0, int __ = 0) { to = _, nex = __; }
} e[100005 << 1];
int n, ans, cnt, hd[100005], dep[100005], du[100005], dp[100005][2];
int rd() {
int x = 0, tp = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') tp = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10 + c - '0');
c = getchar();
}
return x * tp;
}
void adde(int x, int y) {
e[++cnt] = Edge(y, hd[x]);
hd[x] = cnt;
}
void dfs(int now, int fa) {
dep[now] = dep[fa] + 1, dp[now][1] = 1;
for (int i = hd[now]; i; i = e[i].nex) {
if (e[i].to != fa) {
dfs(e[i].to, now);
ans = max(ans, max(dp[now][0] + max(dp[e[i].to][0], dp[e[i].to][1]),
dp[now][1] + dp[e[i].to][0]));
dp[now][0] =
max(dp[now][0], max(dp[e[i].to][0], dp[e[i].to][1]) + du[now] - 2);
dp[now][1] = max(dp[now][1], dp[e[i].to][0] + 1);
}
}
ans = max(ans, dp[now][1]);
}
int main() {
int x, y;
n = rd();
for (int i = 1; i < n; i++) {
x = rd(), y = rd();
adde(x, y), adde(y, x);
du[x]++, du[y]++;
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, s, d, m, n;
deque<int> f;
scanf("%d%d%d", &a, &s, &d);
for (int i = 0; i < a; i++) {
scanf("%d", &n);
f.push_back(n);
}
for (int i = 0; i < s; i++) {
m = *max_element(f.begin(), f.end());
for (int u = 0; u < a; u++) {
if (f[u] == m) {
f.erase(f.begin() + u);
break;
}
}
}
n = *max_element(f.begin(), f.end());
printf("%d", m - n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int a[maxn];
queue<int> q[maxn];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
q[a[i] % k].push(1);
}
int ans = q[0].size() / 2;
ans *= 2;
for (int i = 1; i <= k / 2; i++) {
if (i == k - i) {
ans += (q[i].size() / 2) * 2;
} else
ans += 2 * min(q[i].size(), q[k - i].size());
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (long long i = 0; i < n; i++) cin >> a[i].first;
for (long long i = 0; i < n; i++) cin >> a[i].second;
sort(a.begin(), a.end());
long long ans = 0;
priority_queue<pair<long long, long long> > q;
q.push({0, 0});
for (long long i = 0; i < n; i++) {
if (a[i].first != a[i - 1].first) {
if (q.size() == 1) {
q.pop();
q.push({a[i].second, a[i].first});
continue;
}
long long cur = a[i - 1].first;
while (q.size() > 0 && cur < a[i].first) {
pair<long long, long long> p = q.top();
q.pop();
ans += (cur - p.second) * p.first;
cur++;
}
q.push({a[i].second, a[i].first});
} else {
q.push({a[i].second, a[i].first});
}
}
long long cur = a[n - 1].first;
while (q.size() > 0) {
pair<long long, long long> p = q.top();
q.pop();
ans += (cur - p.second) * p.first;
cur++;
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
int head[1000010], e[1000010 << 1][2], f[1000010], dfn[1000010], deep[1000010],
son[1000010], ans[1000010], mx[1000010], n, i, x, y, t = 0, k = 0;
int getnum() {
int s = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); c = getchar()) s = s * 10 + c - '0';
return s;
}
void addedge(int x, int y) {
e[++t][1] = y;
e[t][0] = head[x];
head[x] = t;
}
void dfs1(int x, int y) {
int i;
for (i = head[x]; i; i = e[i][0])
if (e[i][1] != y) {
dfs1(e[i][1], x);
if (deep[e[i][1]] > deep[son[x]]) {
son[x] = e[i][1];
deep[x] = deep[e[i][1]] + 1;
}
}
}
void dfs2(int x, int y) {
int i;
dfn[x] = ++k;
if (son[x]) dfs2(son[x], x);
for (i = head[x]; i; i = e[i][0])
if ((e[i][1] != y) && (e[i][1] != son[x])) dfs2(e[i][1], x);
}
void dfs3(int x, int y) {
int i, j;
if (son[x]) {
dfs3(son[x], x);
mx[x] = mx[son[x]];
ans[x] = ans[son[x]] + 1;
}
f[dfn[x]] = 1;
if (f[dfn[x]] >= mx[x]) {
mx[x] = f[dfn[x]];
ans[x] = 0;
}
for (i = head[x]; i; i = e[i][0])
if ((e[i][1] != y) && (e[i][1] != son[x])) {
dfs3(e[i][1], x);
for (j = 0; j <= deep[e[i][1]]; j++) {
f[dfn[x] + j + 1] += f[dfn[e[i][1]] + j];
if ((f[dfn[x] + j + 1] > mx[x]) ||
((f[dfn[x] + j + 1] == mx[x]) && (j + 1 < ans[x]))) {
mx[x] = f[dfn[x] + j + 1];
ans[x] = j + 1;
}
}
}
}
int main() {
n = getnum();
for (i = 1; i < n; i++) {
x = getnum();
y = getnum();
addedge(x, y);
addedge(y, x);
}
deep[0] = -1;
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
for (i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MAX = 3000;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-7;
const long double PI = acos(-1.0);
using namespace std;
const int K = 100;
int logv[MAX + 1];
int st[MAX][K];
vector<vector<int> > grafo(1010, vector<int>());
void make() {
logv[1] = 0;
for (int i = 2; i <= MAX; i++) logv[i] = logv[i / 2] + 1;
}
void precompute(int N, int array[]) {
for (int i = 0; i < N; i++) st[i][0] = array[i];
int k = logv[N];
for (int j = 1; j <= k; j++)
for (int i = 0; i + (1 << j) <= N; i++)
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
int query(int L, int R) {
int j = logv[R - L + 1];
int minimum = min(st[L][j], st[R - (1 << j) + 1][j]);
return minimum;
}
int start[MAX + 1], dfs_time;
int tour[2 * MAX + 1], id[2 * MAX + 1];
void dfs(int u, int pai = -1) {
start[u] = dfs_time;
id[dfs_time] = u;
tour[dfs_time++] = start[u];
for (int v : grafo[u]) {
if (v == pai) continue;
dfs(v, u);
id[dfs_time] = u;
tour[dfs_time++] = start[u];
}
}
int LCA(int u, int v) {
if (start[u] > start[v]) swap(u, v);
return id[query(start[u], start[v])];
}
struct circle {
long long r, x, y;
};
bool comp(circle a, circle b) { return a.r < b.r; }
long long sq(long long a) { return a * a; }
bool inter(circle k, circle c) {
return (sq(k.x - c.x) + sq(k.y - c.y) <= sq(k.r - c.r));
}
int altura[1010];
void dfsh(int u, int pai, int h) {
altura[u] = h;
for (auto v : grafo[u]) {
if (v == pai) continue;
dfsh(v, u, h + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k, r, x, y, a, b;
vector<circle> vet, K;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> x >> y;
K.push_back({0, x, y});
}
for (int i = 0; i < m; i++) {
cin >> r >> x >> y;
vet.push_back({r, x, y});
}
sort(vet.begin(), vet.end(), comp);
for (int i = 0; i < m; i++) {
bool t = true;
for (int j = i + 1; j < m; j++) {
if (inter(vet[i], vet[j])) {
grafo[i + 2].push_back(j + 2);
grafo[j + 2].push_back(i + 2);
t = false;
break;
}
}
if (t) {
grafo[i + 2].push_back(1);
grafo[1].push_back(i + 2);
}
}
vector<int> no(1010, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (inter(K[i], vet[j])) {
no[i + 2] = j + 2;
break;
}
}
}
dfs(1);
make();
precompute(2 * (m + 2), tour);
dfsh(1, -1, 1);
for (int i = 0; i < k; i++) {
cin >> a >> b;
a++;
b++;
int lca = LCA(no[a], no[b]);
cout << altura[no[a]] + altura[no[b]] - 2 * altura[lca] << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long junger = 0, mid = 0, top = 0, bot = 0, result = 0, sum = 0, s = 0,
t = 0, d = 0, l = 0, sp = 0, k = 0, x, y, n, m, test;
bool kt = false;
string s1, s2;
long long a[256];
bool checkA() {
for (long long(i) = (0); (i) < (255); (i)++)
if (a[i] & 1) return false;
return true;
}
int countA() {
long long dem = 0;
for (long long(i) = (0); (i) < (255); (i)++)
if (a[i] & 1) dem++;
return dem;
}
int main() {
cin >> n;
vector<long long> le;
long long chan = 2;
for (long long(i) = (1); (i) < (n + 1); (i)++) {
if (n % i == 0) {
if (i & 1) le.push_back(i);
}
}
cin >> s1;
memset(a, 0, sizeof(a));
for (long long(i) = (0); (i) < (n); (i)++) a[s1[i]]++;
if (checkA()) {
cout << "1\n";
stack<char> st;
for (long long(i) = (0); (i) < (255); (i)++) {
while (a[i] > 0) {
printf("%c", (char)i);
a[i] -= 2;
st.push((char)i);
}
}
while (!st.empty()) {
printf("%c", st.top());
st.pop();
}
printf("\n");
return 0;
}
m = countA();
for (long long(j) = (le.size()) - 1; (j) >= 0; (j)--) {
d = n / le[j];
if (d < m)
continue;
else {
stack<char> st;
for (long long(i) = (0); (i) < (255); (i)++) {
if (a[i] & 1) {
st.push((char)i);
a[i]--;
d--;
}
}
for (long long(i) = (0); (i) < (255); (i)++) {
while (a[i] > 0 && d > 0) {
st.push((char)i);
a[i]--;
d--;
}
}
d = n / le[j];
printf("%lld\n", d);
for (long long(i) = (0); (i) < (d); (i)++) {
stack<char> st2;
l = le[j] / 2;
for (long long(k) = (0); (k) < (255); (k)++) {
while (a[k] > 0 && l > 0) {
printf("%c", (char)k);
a[k] -= 2;
st2.push((char)k);
l--;
}
}
printf("%c", st.top());
st.pop();
while (!st2.empty()) {
printf("%c", st2.top());
st2.pop();
}
printf(" ");
}
printf("\n");
return 0;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1010], b[1010];
int main(void) {
int i;
int n;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
if (a[i] != b[i]) {
cout << "rated" << endl;
return 0;
}
}
bool f = true;
for (i = 2; i <= n; i++) {
if (a[i - 1] < a[i]) f = false;
}
if (f)
cout << "maybe" << endl;
else
cout << "unrated" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)1e6 + 10;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)1e18;
const long double pi = acos(-1.0);
int n, x, y;
int a[maxN];
vector<int> f;
long long best = LLINF;
void add(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
f.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) f.push_back(x);
}
bool ok(int x, int y) {
if ((x - 0) % y == 0) return 1;
if ((x - 1) % y == 0) return 1;
if ((x - -1) % y == 0) return 1;
return 0;
}
long long solve(int x) {
vector<long long> suff(n + 2);
vector<long long> sumOn(n + 2);
vector<long long> suffmin(n + 2);
suff[n + 1] = n * 1LL * ::x;
for (int i = n; i >= 1; --i) {
suff[i] = (a[i] % x == 0 ? 0 : y);
sumOn[i] = suff[i] + sumOn[i + 1];
suff[i] += suff[i + 1];
suff[i] -= ::x;
suffmin[i] = suff[i];
if (i < n) suffmin[i] = min(suff[i], suffmin[i + 1]);
}
long long pref = 0;
long long ret = (n - 1) * 1LL * ::x;
for (int i = 0; i < n; ++i) {
if (i > 0 && a[i] % x != 0) pref += y;
ret = min(ret, pref + suffmin[i + 1] - i * 1LL * ::x);
ret = min(ret, pref + (n - i) * 1LL * ::x);
}
return ret;
}
long long update(int x) {
int l = 1, r = n;
while (l <= n && ok(a[l], x)) l++;
l--;
if (l == n) {
return solve(x);
} else {
while (r > 0 && ok(a[r], x)) r--;
r++;
}
vector<long long> pref(l + 1);
vector<long long> prefmin(l + 1);
prefmin[0] = l * 1LL * ::x;
for (int i = 1; i <= l; ++i) {
pref[i] = (a[i] % x == 0 ? 0 : y);
if (i >= 0) pref[i] += pref[i - 1];
prefmin[i] = pref[i] + (l - i) * 1LL * ::x;
}
vector<long long> suff(n - r + 2);
vector<long long> suffmin(n - r + 2);
suffmin[0] = (n + 1 - r) * 1LL * ::x;
for (int i = n; i >= r; --i) {
int idx = n - i + 1;
suff[idx] = (a[i] % x == 0 ? 0 : y);
suff[idx] += suff[idx - 1];
suffmin[idx] = suff[idx] + (i - r) * 1LL * ::x;
}
long long ret = LLINF;
if (suffmin.size() != 1)
ret =
min(ret, prefmin[0] + *min_element(suffmin.begin() + 1, suffmin.end()));
ret = min(ret, *min_element(prefmin.begin(), prefmin.end()) +
*min_element(suffmin.begin(), suffmin.end()));
ret += (r - l - 1) * 1LL * ::x;
return ret;
}
void solve() {
f.clear();
add(a[1]);
add(a[1] - 1);
add(a[1] + 1);
add(a[n]);
add(a[n] - 1);
add(a[n] + 1);
for (auto x : f) {
long long v = update(x);
best = min(best, v);
}
}
int main() {
n = nextInt<int>();
x = nextInt<int>();
y = nextInt<int>();
for (int i = 1; i <= n; ++i) {
a[i] = nextInt<int>();
}
solve();
cout << best << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int N, K;
int a, b;
cin >> a >> b;
int cont = 0;
int aa = 1;
int bb = 1;
int a1 = min(a, b);
int a2 = max(a, b);
while (a1 != a2) {
a1++;
cont += aa;
aa++;
if (a1 != a2) {
a1++;
cont += bb;
bb++;
}
}
cout << cont;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const unsigned int maxn = 1e6, maxq = 1e6, maxl = 19;
char inbuf[maxn * 10 + maxq * 20 + 1000],
*inpos = inbuf, outbuf[maxq * 10 + 1000], *outpos = outbuf;
inline char get() { return *(inpos++); }
inline unsigned int readUInt() {
char c = get();
unsigned int ret = 0;
while (!isdigit(c)) c = get();
while (isdigit(c)) {
ret = ret * 10 + c - '0';
c = get();
}
return ret;
}
void write(const unsigned long long v) {
outpos += sprintf(outpos, "%lld ", v);
}
unsigned int lg[maxn + 1], fa[maxn + 1][maxl + 1], dep[maxn + 1];
unsigned int p[maxn + 1];
unsigned int lc[maxn + 1], rc[maxn + 1], siz[maxn + 1];
long long sumL[maxn + 1], sumR[maxn + 1];
int depL[maxn + 1], depR[maxn + 1];
long long f[maxn + 1];
static void getLog(const unsigned int n) {
for (unsigned int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
}
static unsigned int build(const unsigned int n) {
static unsigned int stk[maxn + 1];
unsigned int *top = stk, root = 1;
*(top++) = 1;
for (unsigned int i = 2; i <= n; ++i) {
unsigned int* ptr = top;
while (ptr > stk && p[*(ptr - 1)] < p[i]) --ptr;
if (ptr > stk)
rc[*(ptr - 1)] = i;
else
root = i;
if (ptr < top) lc[i] = *ptr;
top = ptr;
*(top++) = i;
}
return root;
}
void dfs(const unsigned int x, const unsigned int father) {
if (!x) return;
dep[x] = dep[father] + 1;
fa[x][0] = father;
for (unsigned int i = 1; i <= lg[dep[x]]; ++i)
fa[x][i] = fa[fa[x][i - 1]][i - 1];
dfs(lc[x], x);
dfs(rc[x], x);
siz[x] = siz[lc[x]] + siz[rc[x]] + 1;
f[x] = siz[x] + f[lc[x]] + f[rc[x]];
}
void dfsPreSum(const unsigned int x, const unsigned int ddl = 0,
const unsigned int ddr = 0) {
const long long nsl = sumL[x] + f[rc[x]] + x + siz[rc[x]];
const long long nsr = sumR[x] + f[lc[x]] - (x - siz[lc[x]]);
depL[x] += ddl;
depR[x] += ddr;
if (lc[x]) {
sumL[lc[x]] = nsl;
depL[lc[x]] = depL[x];
sumR[lc[x]] = sumR[x];
depR[lc[x]] = depR[x];
dfsPreSum(lc[x], 1, 0);
}
if (rc[x]) {
sumL[rc[x]] = sumL[x];
depL[rc[x]] = depL[x];
sumR[rc[x]] = nsr;
depR[rc[x]] = depR[x];
dfsPreSum(rc[x], 0, 1);
}
sumL[x] = nsl;
sumR[x] = nsr;
}
unsigned int lca(unsigned int a, unsigned int b) {
if (dep[a] != dep[b]) {
if (dep[a] > dep[b]) swap(a, b);
for (unsigned int i = 0, d = dep[b] - dep[a]; d; d >>= 1, ++i)
if (d & 0x01) b = fa[b][i];
}
if (a == b) return a;
for (unsigned int i = lg[dep[a]]; i;) {
if (fa[a][i - 1] == fa[b][i - 1])
--i;
else {
a = fa[a][i - 1];
b = fa[b][i - 1];
}
}
return fa[a][0];
}
unsigned long long query(const int l, const int r) {
const unsigned int Lca = lca(l, r);
return (r + 1 - l) + sumL[l] - sumL[Lca] -
static_cast<long long>(depL[l] - depL[Lca]) * (l - 1) + sumR[r] -
sumR[Lca] + static_cast<long long>(depR[r] - depR[Lca]) * (r + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.read(inbuf, sizeof(inbuf));
const unsigned int n = readUInt(), q = readUInt();
generate_n(p + 1, n, readUInt);
const unsigned int root = build(n);
getLog(n);
dfs(root, 0);
dfsPreSum(root);
static unsigned int ls[maxq + 1];
generate_n(ls, q, readUInt);
for (unsigned int i = 0; i < q; ++i) {
const unsigned int r = readUInt();
write(query(ls[i], r));
}
cout.write(outbuf, outpos - outbuf);
cout.put('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a, b, t, n, cur, mn, ans;
int tmp[N], dp[N];
string s;
void read_input() {
cur = 0;
cin >> a >> b;
cin >> s;
n = s.size();
tmp[0] = 1;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
tmp[cur]++;
} else {
cur++;
tmp[cur]++;
}
}
}
void solve() {
int j;
if (s[0] == '1') {
j = 2;
dp[0] = a;
} else {
j = 3;
dp[1] = a;
}
for (int i = j; i <= cur; i += 2) {
dp[i] = dp[i - 2] + a;
dp[i] = min(dp[i], dp[i - 2] + (tmp[i - 1] * b));
}
ans = dp[cur];
if (cur > 0) {
ans = max(ans, dp[cur - 1]);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
memset(dp, 0, sizeof dp);
memset(tmp, 0, sizeof tmp);
read_input();
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 1e5;
long long int dp[MAX + 1][2][2] = {0};
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int j = 1; j <= n - 1; j++) cin >> v[j];
dp[n][1][1] = 0;
dp[n][1][0] = 0;
for (long long int j = n - 1; j >= 1; j--) {
dp[j][1][1] = (dp[j + 1][1][1] + (v[j] / 2) * 2) * (v[j] > 1);
dp[j][1][0] =
max(dp[j + 1][1][1] + v[j], dp[j + 1][1][0] + v[j] - (v[j] % 2 == 0));
}
dp[1][0][1] = 0;
dp[1][0][0] = 0;
for (long long int j = 2; j <= n; j++) {
dp[j][0][1] = (dp[j - 1][0][1] + (v[j - 1] / 2) * 2) * (v[j - 1] > 1);
dp[j][0][0] = max(dp[j - 1][0][0] + v[j - 1] - (v[j - 1] % 2 == 0),
dp[j - 1][0][1] + v[j - 1]);
}
long long int res = 0;
for (long long int j = 1; j < n; j++) {
res = max(dp[j][0][1] + max(dp[j][1][0], dp[j][1][1]), res);
res = max(dp[j][1][1] + max(dp[j][0][0], dp[j][0][1]), res);
}
cout << res << '\n';
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l;
long double a, d, t, n, s;
int main() {
cout << fixed << setprecision(10);
cin >> a >> d;
cin >> n;
for (i = 1; i <= n; i++) {
t = fmod(i * d, 4 * a);
if (t <= a)
cout << t << " " << s << endl;
else {
if (t <= 2 * a)
cout << a << " " << t - a << endl;
else {
if (t <= 3 * a)
cout << a * 3 - t << " " << a << endl;
else
cout << s << " " << 4 * a - t << endl;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ret = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
int n;
long long A, cf, cm;
long long m;
int a[100005], b[100005], id[100005], out[100005], rv[100005];
long long sum[100005];
bool cmp(int at, int bt) { return b[at] > b[bt]; }
int main() {
scanf("%d%I64d%I64d%I64d%I64d", &n, &A, &cf, &cm, &m);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; i++) a[i] = b[id[i]];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
long long ans = a[n] * cm, pos1 = 0, posp, mnv, p1 = 1;
for (int i = 0; i <= n; i++) {
if (i * A - sum[i] > m) break;
long long t = m - (i * A - sum[i]), mnt;
p1 = max(p1, (long long)i + 1);
while (p1 <= n && (a[p1] * (long long)(n - p1) - (sum[n] - sum[p1]) > t))
p1++;
t -= a[p1] * (long long)(n - p1) - (sum[n] - sum[p1]);
long long cost =
i * cf +
(p1 == n + 1 ? cm * A : cm * (mnt = min(A, a[p1] + t / (n - p1 + 1))));
if (cost >= ans) ans = cost, pos1 = i, posp = p1, mnv = mnt;
}
cout << ans << endl;
for (int i = 1; i <= pos1; i++) out[id[i]] = A;
for (int i = pos1 + 1; i < posp; i++) out[id[i]] = a[i];
for (int i = posp; i <= n; i++) out[id[i]] = mnv;
for (int i = 1; i <= n; i++) printf("%d ", out[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[345678];
int n, c1[26], c2[26], d1, d2, td;
int main() {
scanf("%s", a);
n = strlen(a);
for (int i = 0; i < n; i++) c1[a[i] - 'a']++;
for (int i = 0; i < 26; i++) td += (c1[i] > 0);
printf("%d\n", td);
for (int k = 1; k <= td; k++) {
long long ans = 0;
d1 = d2 = 0;
for (int i = 0; i < 26; i++) c1[i] = c2[i] = 0;
for (int i = 0, s = 0, e = -1; i < n; i++) {
while (s < n && d1 < k) {
d1 += !c1[a[s] - 'a'];
c1[a[s] - 'a']++;
s++;
}
while (e + 1 < n && d2 + (!c2[a[e + 1] - 'a']) <= k) {
d2 += !c2[a[e + 1] - 'a'];
c2[a[e + 1] - 'a']++;
e++;
}
if (d1 == k && d2 == k) ans += e - s + 2;
if (c1[a[i] - 'a']-- == 1) d1--;
if (c2[a[i] - 'a']-- == 1) d2--;
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
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...);
}
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& x) {
os << "{ ";
for (auto& y : x) os << y << " ; ";
return os << "}";
}
template <class X, class Y>
ostream& operator<<(ostream& os, pair<X, Y> const& p) {
return os << "[ " << p.first << ", " << p.second << "]";
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
const long long L = 5e5 + 5;
long long dp[L][2];
long long vis[L];
vector<pair<long long, long long> > ad[L];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
long long x, y, z;
while (m--) {
cin >> x >> y >> z;
ad[y].push_back({x, z});
}
for (long long i = 1; i <= n; i++) {
dp[i][0] = 1e9;
dp[i][1] = 1e9;
}
dp[n][0] = 0;
dp[n][1] = 0;
queue<long long> q;
q.push(n);
while (!q.empty()) {
long long ind = q.front();
q.pop();
vis[ind] = 1;
long long val = max(dp[ind][0], dp[ind][1]);
for (pair<long long, long long> it : ad[ind]) {
if (vis[it.first] == 1) continue;
if (val + 1 < dp[it.first][it.second]) {
dp[it.first][it.second] = val + 1;
long long cur = max(dp[it.first][0], dp[it.first][1]);
if (cur != 1e9) {
q.push(it.first);
}
}
}
}
long long ans = max(dp[1][0], dp[1][1]);
cout << (ans == 1e9 ? -1 : ans) << '\n';
for (long long i = 1; i <= n; i++) {
cout << (dp[i][0] > dp[i][1] ? 0 : 1);
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10, inf = 1e18, mod = 1e9 + 7;
long long n, m, dp[maxn];
vector<long long> g[maxn][2];
map<pair<long long, long long>, bool> c, cc;
long long km[maxn], gb[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
long long v, u, e;
for (int i = 0; i < m; i++) {
cin >> v >> u >> e;
c[make_pair(v, u)] = e;
g[v][e].push_back(u);
g[u][e].push_back(v);
}
memset(km, 63, sizeof(km));
memset(dp, 63, sizeof(dp));
deque<long long> q;
q.push_back(1);
dp[1] = 0;
km[1] = 0;
gb[1] = 0;
while (q.size()) {
v = q.back();
q.pop_back();
if (v == n) {
break;
}
for (auto u : g[v][1]) {
if (km[v] + 1 <= km[u] && dp[v] < dp[u]) {
km[u] = km[v] + 1;
dp[u] = dp[v];
gb[u] = v;
q.push_front(u);
}
}
for (auto u : g[v][0]) {
if (km[v] + 1 <= km[u] && dp[v] + 1 < dp[u]) {
km[u] = km[v] + 1;
dp[u] = dp[v] + 1;
gb[u] = v;
q.push_front(u);
}
}
}
v = n;
while (v != 0) {
cc[make_pair(v, gb[v])] = cc[make_pair(gb[v], v)] = 1;
v = gb[v];
}
vector<pair<long long, pair<long long, long long> > > jj;
for (auto it = c.begin(); it != c.end(); it++) {
if (cc[it->first]) {
if (!(it->second)) {
jj.push_back(
make_pair((it->first).first, make_pair((it->first).second, 1)));
}
} else if (it->second) {
jj.push_back(
make_pair((it->first).first, make_pair((it->first).second, 0)));
}
}
cout << jj.size() << endl;
for (auto pr : jj) {
cout << pr.first << ' ' << pr.second.first << ' ' << pr.second.second
<< endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int _;
const int MAXN = 100 * 1000 + 10;
int n;
string s;
unsigned int dp[MAXN][2];
void Upd(int idx, int val) {
bool now = idx % 2, pre = (idx + 1) % 2;
int mx = min(idx, n - idx) + 2;
int f = pre;
if (val == 1 && f == 0) {
dp[f][now] = 0;
f += 2;
}
if (val == 1)
for (int i = f; i <= mx; i += 2) dp[i][now] = dp[i - val][pre];
else
for (int i = f; i <= mx; i += 2) dp[i][now] += dp[i - val][pre];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> s;
if (n % 2) {
cout << 0 << endl;
return 0;
}
int x = 0;
dp[0][1] = 1;
for (int i = 0; i < n; ++i) {
if (isalpha(s[i])) {
Upd(i, 1);
++x;
} else {
Upd(i, 1);
Upd(i, -1);
}
}
unsigned int ans = dp[0][(n - 1) % 2];
int y = (n - 2 * x) / 2;
for (int i = 0; i < y; ++i) ans *= 25;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, a[15], t;
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], t = max(t, a[i]);
cout << (t ^ a[n]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
const long long int M = 1000000007;
void solve() {
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n - 1; ++i) {
s += '0';
}
long long int ans = 0;
for (int i = 0; i < 2 * (n - 1) + 1; ++i) {
ans += ans + s[i] - '0';
ans %= M;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve(), cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, flag = 0;
;
string s, ans;
cin >> s;
if (s[0] == '-') {
flag = 1;
}
ans = "$";
for (i = flag; i < s.length(); i++) {
if (s[i] == '.') {
ans = ans + s[i];
if (i + 1 < s.length()) {
ans = ans + s[i + 1];
} else {
ans = ans + '0';
}
if (i + 2 < s.length()) {
ans = ans + s[i + 2];
} else {
ans = ans + '0';
}
break;
}
ans = ans + s[i];
}
int flag1 = 0;
for (i = 0; i < ans.length(); i++) {
if (ans[i] == '.') {
flag1 = 1;
break;
}
}
if (flag1 == 0) {
ans = ans + '.' + '0' + '0';
}
flag1 = 0;
string ans1 = "";
int cnt = 0;
for (i = ans.length() - 1; i >= 0; i--) {
if (ans[i] == '.') {
flag1 = 1;
ans1 = ans[i] + ans1;
continue;
}
if (flag1) {
cnt++;
}
ans1 = ans[i] + ans1;
if ((cnt == 3) && (i > 1)) {
ans1 = ',' + ans1;
cnt = 0;
}
}
if (flag == 1) {
cout << '(' << ans1 << ')' << endl;
} else {
cout << ans1 << endl;
}
cin.get();
cin.get();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
string s;
cin >> s;
s[2] = ' ';
stringstream ss;
ss << s;
long double a, b;
ss >> a >> b;
long double res[2];
res[1] = b * 6;
if ((long long)a >= 12) a -= 12;
res[0] = a * 30 + res[1] / 12;
cout << res[0] << ' ';
cout << res[1] << ' ';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
char grid[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> grid[i][j];
}
}
int out = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == 0 or i == n - 1 or j == 0 or j == n - 1)
continue;
else if (grid[i][j] == 'X' and grid[i - 1][j - 1] == 'X' and
grid[i - 1][j + 1] == 'X' and grid[i + 1][j - 1] == 'X' and
grid[i + 1][j + 1] == 'X')
out++;
}
}
cout << out;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int _pow(int a, int b, int mo) {
int tmp = 1;
a %= mo;
for (; b; b >>= 1) {
if (b & 1) tmp = (long long)tmp * a % mo;
a = (long long)a * a % mo;
}
return tmp;
}
template <class T>
inline void R(T &xx) {
xx = 0;
char ch = getchar();
bool F = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') F = 1, ch = getchar();
while (ch >= '0' && ch <= '9')
xx = xx + xx + (xx << 3) + ch - 48, ch = getchar();
if (F) xx = -xx;
}
char ch[666];
bitset<2011> nw[2011], s[2011];
int n, p[2011], num[2011];
inline void init(int x) {
scanf("%s", ch);
int l = strlen(ch);
for (int i = 0; i < (int)l; i++) num[l - i] = ch[i] - '0';
for (int i = 0; i < (int)2000; i++) {
int res = 0, las;
for (int j = l; j >= 1; j--) {
las = res;
res = (res << 3) + (res << 1) + num[j];
num[j] = (las << 3) + (las << 1) + num[j] >> 1;
res &= 1;
}
nw[x][i] = res;
while (l >= 1 && num[l] == 0) l--;
if (!l) break;
}
s[x][x] = 1;
}
int main() {
memset(p, -1, sizeof(p));
R(n);
for (int i = 0; i < (int)n; i++) {
init(i);
bool F = 1;
for (int j = 0; j < (int)2000; j++)
if (nw[i][j]) {
if (!~p[j]) {
p[j] = i;
F = 0;
break;
}
nw[i] ^= nw[p[j]];
s[i] ^= s[p[j]];
}
if (!F) {
puts("0");
continue;
}
s[i][i] = 0;
printf("%d", s[i].count());
for (int j = 0; j < (int)i; j++)
if (s[i][j]) printf(" %d", j);
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 100;
long long n, m, mid, st, en = 1e9 + 100, h;
long long a[N][N], v[N];
bool b[N][N], c[N][N];
bool check(long long x) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) c[i][j] = (a[i][j] >= x);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) b[i][j] = false;
for (int i = 0; i < n; i++) {
h = 0;
for (int j = 0; j < m; j++) {
if (c[i][j]) v[h++] = j;
}
for (int j = 0; j < h; j++) {
for (int l = 0; l < j; l++) {
if (b[v[j]][v[l]]) return 1;
b[v[j]][v[l]] = 1;
}
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
while (en - st > 1) {
mid = (st + en) / 2;
if (check(mid)) {
st = mid;
} else {
en = mid;
}
}
cout << st;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, n, m, k;
int i, j, a[55];
bool f = 0;
cin >> n >> m >> k;
for (i = 0; i < n; i++) cin >> a[i];
sort(a + 0, a + n);
if (k >= m) {
cout << 0 << endl;
f = 1;
} else
for (i = n - 1, x = 0; i >= 0 && k > 0; i--) {
if (i < (n - 1))
x += (a[i] - 1);
else
x += a[i];
if ((x + k - 1) >= m) {
cout << (n - i) << endl;
f = 1;
break;
}
}
if (f == 0) cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, h, v, e, a, pi = 3.14159265359;
cin >> d >> h >> v >> e;
d /= (double)2;
if ((double)v / (pi * d * d) <= e)
return cout << "NO", 0;
else
return printf("YES\n%0.11lf", h / (v / (pi * d * d) - e)), 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const long long MOD = INF + 7;
const int MAXN = 1000100;
inline bool lucky(int x) {
while (x > 0) {
int t = x % 10;
if (t != 4 && t != 7) return false;
x /= 10;
}
return true;
}
inline long long bpow(long long a, long long b) {
long long ans = 1;
while (b > 0)
if (b % 2 == 1) {
ans = (ans * a) % MOD;
b--;
} else {
a = (a * a) % MOD;
b /= 2;
}
return ans;
}
inline long long rev(long long x) { return bpow(x, MOD - 2); }
long long f[MAXN], d[1100][1100];
int n, k, unlucky, num[MAXN];
map<int, int> ids;
long long solve(int minV, int k) {
if (k == 0) return 1;
if (k > (int)ids.size()) return 0;
if (minV == (int)ids.size()) return 0;
long long &ans = d[minV][k];
if (ans != -1) return ans;
ans = solve(minV + 1, k);
ans = (ans + solve(minV + 1, k - 1) * num[minV]) % MOD;
return ans;
}
long long C(int k, int n) {
if (k > n) return 0;
long long ans = f[n];
ans = (ans * rev(f[k])) % MOD;
ans = (ans * rev(f[n - k])) % MOD;
return ans;
}
void process(int x) {
if (!ids.count(x)) {
int ans = (int)ids.size();
ids[x] = ans;
}
num[ids[x]]++;
}
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < (int)(MAXN); i++) {
f[i] = 1;
if (i != 0) f[i] = (f[i - 1] * i) % MOD;
}
cerr << clock() << endl;
cin >> n >> k;
for (int i = 0; i < (int)(n); i++) {
int x;
scanf("%d", &x);
if (lucky(x))
process(x);
else
unlucky++;
}
long long ans = 0;
memset(d, 255, sizeof d);
for (int i = 0; i <= k; i++) {
long long cur = solve(0, k - i);
if (cur > 0) ans = (ans + C(i, unlucky) * cur) % MOD;
}
cout << ans << endl;
cerr << clock() << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
vector<int> g[N];
int n, a[N], mx, who;
void dfs(int v, int pr, int len, int lst) {
if (len > mx) {
mx = len;
who = v;
}
for (int u : g[v]) {
if (u == pr) continue;
if (a[u] == 0)
dfs(u, v, len, lst);
else
dfs(u, v, len + bool(lst != a[u]), a[u]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int qq;
cin >> qq;
for (; qq; qq--) {
cin >> n;
bool ok = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
ok &= bool(a[i] == 0);
g[i].clear();
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
if (ok) {
cout << "1\n";
continue;
}
int rt = 0;
while (a[rt] == 0) rt++;
mx = 1;
who = rt;
dfs(rt, -1, 1, a[rt]);
dfs(who, -1, 1, a[who]);
cout << (mx / 2) + 1 << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int color[100005];
int edge[100005][2];
vector<int> adj[100005];
bool visited[100005];
bool dfs(int c, int now) {
if (color[now] != c) return false;
for (int i = 0; i < adj[now].size(); i++) {
if (visited[adj[now][i]]) continue;
visited[adj[now][i]] = true;
if (!dfs(c, adj[now][i])) return false;
visited[adj[now][i]] = false;
}
return true;
}
int main() {
int n, i;
bool isPossible;
scanf("%d", &n);
for (i = 1; i <= n - 1; i++) {
scanf("%d %d", &edge[i][0], &edge[i][1]);
adj[edge[i][0]].push_back(edge[i][1]);
adj[edge[i][1]].push_back(edge[i][0]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &color[i]);
}
for (i = 1; i <= n - 1; i++) {
if (color[edge[i][0]] != color[edge[i][1]]) break;
}
if (i > n - 1) {
printf("YES\n1");
return 0;
}
int root1 = edge[i][0], root2 = edge[i][1];
visited[root1] = true;
isPossible = true;
for (i = 0; i < adj[root1].size(); i++) {
visited[adj[root1][i]] = true;
if (!dfs(color[adj[root1][i]], adj[root1][i])) isPossible = false;
visited[adj[root1][i]] = false;
}
if (isPossible) {
printf("YES\n%d", root1);
return 0;
}
for (int i = 0; i <= n; i++) visited[i] = false;
visited[root2] = true;
isPossible = true;
for (i = 0; i < adj[root2].size(); i++) {
visited[adj[root2][i]] = true;
if (!dfs(color[adj[root2][i]], adj[root2][i])) isPossible = false;
visited[adj[root2][i]] = false;
}
if (isPossible) {
printf("YES\n%d", root2);
return 0;
}
printf("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10;
int main() {
char ch;
int sum = 0, num = 1;
while (cin >> ch && ch == 'F')
;
while (cin >> ch) {
if (ch == 'F') {
if (num > sum)
sum = num;
else
++sum;
} else
++num;
}
cout << sum << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("fast-math")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int MAXN = 100;
const int INF = 1e9;
void solve() {
long long x;
cin >> x;
long long cur = 1LL;
int ans = 0;
auto cl = [](long long n) { return ((n) * (n + 1LL)) / 2LL; };
while (x >= cl(cur)) {
x -= cl(cur);
cur = cur * 2 + 1;
ans++;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int Q;
cin >> Q;
while (Q--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
int n, m;
int bit[303][400];
int get(int x, int i) {
int sum = 0;
for (i += 2; i; i -= (i & -i)) sum = (sum + bit[x][i]);
return sum;
}
int get(int x, int i, int j) { return get(x, j) - get(x, i - 1); }
void add(int x, int i, int v) {
for (i += 2; i < m + 5; i += (i & -i)) bit[x][i] = (bit[x][i] + v);
}
struct group {
int first_idx;
int size;
int cur_row;
};
int a[112345];
long long solve() {
scanf("%d %d", &n, &m);
map<int, group> mp;
for (int i = 0; i < n * m; i++) {
scanf("%d", &a[i]);
mp[a[i]].size++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m + 5; j++) bit[i][j] = 0;
int cur = 0;
for (auto& x : mp) {
x.second.first_idx = cur;
x.second.cur_row = cur / m;
cur += x.second.size;
}
long long tot = 0;
for (int i = 0; i < n * m; i++) {
group& d = mp[a[i]];
int& cur_row = d.cur_row;
int idx = max(d.first_idx - cur_row * m, 0);
((void)0);
add(cur_row, idx, 1);
tot += get(cur_row, idx - 1);
int oc = cur_row;
if (cur_row == d.first_idx / m) {
if (get(cur_row, idx, idx) == m - idx) cur_row++;
} else if (get(cur_row, idx, idx) == m)
cur_row++;
if (oc != cur_row) ((void)0);
assert(cur_row == mp[a[i]].cur_row);
}
return tot;
}
int main() {
int t;
scanf("%d", &t);
while (t--) printf("%lld\n", solve());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int inf = 1e9 + 1;
vector<pair<int, int> > adj[N];
int n, m, t, ans[N];
pair<int, int> trace[N][N];
queue<pair<pair<int, int>, int> > bell_lis;
int main() {
cin >> n >> m >> t;
int i, j, k, l, x, y;
for (i = 1; i <= m; i++) {
cin >> j >> k >> l;
adj[j].push_back({k, l});
}
bell_lis.push({{1, 0}, 1});
trace[1][1] = {0, 0};
ans[1] = 1;
while (bell_lis.size() != 0) {
j = bell_lis.front().first.first;
k = bell_lis.front().first.second;
for (i = 0; i < adj[j].size(); i++) {
if (k <= t - adj[j][i].second) {
if (ans[adj[j][i].first] < bell_lis.front().second + 1) {
ans[adj[j][i].first] = bell_lis.front().second + 1;
}
if (k + adj[j][i].second <
trace[adj[j][i].first][bell_lis.front().second + 1].first) {
trace[adj[j][i].first][bell_lis.front().second + 1].first =
k + adj[j][i].second;
trace[adj[j][i].first][bell_lis.front().second + 1].second = j;
bell_lis.push({{adj[j][i].first, k + adj[j][i].second},
bell_lis.front().second + 1});
}
if (trace[adj[j][i].first][bell_lis.front().second + 1].first == 0) {
trace[adj[j][i].first][bell_lis.front().second + 1].first =
k + adj[j][i].second;
trace[adj[j][i].first][bell_lis.front().second + 1].second = j;
bell_lis.push({{adj[j][i].first, k + adj[j][i].second},
bell_lis.front().second + 1});
}
}
}
bell_lis.pop();
}
cout << ans[n] << endl;
x = n;
y = ans[n];
t = ans[n];
while (y > 0) {
ans[y] = x;
x = trace[x][y].second;
y--;
}
for (i = 1; i <= t; i++) {
cout << ans[i] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sum, f1, s1, flg, f2, s2;
int main() {
cin >> sum;
for (s1 = 0; (sum - 7 * s1) >= 0; s1++) {
if ((sum - 7 * s1) % 4 == 0) {
flg = 1;
f1 = (sum - 7 * s1) / 4;
break;
}
}
for (f2 = 0; (sum - 4 * f2) >= 0; f2++) {
if ((sum - 4 * f2) % 7 == 0) {
s2 = (sum - 4 * f2) / 7;
break;
}
}
if ((s2 + f2) < (s1 + f1)) {
swap(s1, s2);
swap(f1, f2);
}
if (flg == 0)
cout << -1 << endl;
else {
for (int i = 0; i < f1; i++) cout << 4;
for (int i = 0; i < s1; i++) cout << 7;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int B = 5005;
const int P = 673;
vector<pair<int, int>> fac[B];
int prime_id[B];
array<int, P> pcnt[2 * B];
int ids[B + B];
int ne;
bool is_lca(int i, int j) {
int dif = 0;
while (dif < P and pcnt[i][dif] == pcnt[j][dif]) dif++;
if (dif >= P) return true;
if (pcnt[i][dif] > pcnt[j][dif]) return false;
for (int k = dif + 1; k < P; k++)
if (pcnt[i][k]) {
return false;
}
return true;
}
map<array<int, P>, int> go;
array<int, P> calc_lca(int i, int j) {
int dif = 0;
array<int, P> ans = {};
while (dif < P and pcnt[i][dif] == pcnt[j][dif]) {
ans[dif] = pcnt[i][dif];
dif++;
}
ans[dif] = min(pcnt[i][dif], pcnt[j][dif]);
return ans;
}
int calc_dist(int i, int j) {
int ans = 0;
for (int w = 0; w < P; w++) {
ans += abs(pcnt[i][w] - pcnt[j][w]);
}
return ans;
}
const int N = B + B;
vector<pair<int, int>> g[N];
int cnt[N];
vector<int> par[N];
int sub[N], tot;
using ll = long long;
ll cur;
int dp[N];
void prec(int u) {
sub[u] = cnt[u];
for (auto [v, w] : g[u]) {
prec(v);
sub[u] += sub[v];
cur += 1LL * sub[v] * w;
}
}
ll ans;
void solve(int u) {
ans = min(ans, cur);
for (auto [v, w] : g[u]) {
if (!sub[v]) continue;
cur += 1LL * (tot - sub[v]) * w;
cur -= 1LL * sub[v] * w;
solve(v);
cur += 1LL * sub[v] * w;
cur -= 1LL * (tot - sub[v]) * w;
}
}
int vis[N];
void dfs(int u) {
vis[u] = 1;
for (auto [v, w] : g[u]) {
dfs(v);
dp[u] = max(dp[u], dp[v]);
}
dp[u]++;
}
int main() {
for (int i = 2; i < B; i++) {
fac[i] = fac[i - 1];
}
for (int i = 2, me = 0; i < B; i++)
if (!prime_id[i]) {
prime_id[i] = ++me;
for (int j = i + i; j < B; j += i) {
prime_id[j] = -1;
}
}
for (int i = 2; i < B; i++) {
pcnt[i] = pcnt[i - 1];
int x = i;
for (int j = 2; j <= x; j++) {
while (x % j == 0) {
pcnt[i][prime_id[j]]++;
x /= j;
}
}
}
for (int i = 1; i < B; i++) {
ids[i] = i;
reverse(pcnt[i].begin(), pcnt[i].end());
go[pcnt[i]] = i;
}
sort(ids + 1, ids + B, [](int i, int j) { return pcnt[i] < pcnt[j]; });
for (int q = 1; q + 1 < B; q++) {
int i = ids[q];
assert(i == q);
int j = ids[q + 1];
int lca = i;
if (is_lca(i, j))
lca = i;
else if (is_lca(j, i))
lca = j;
else {
auto arr = calc_lca(i, j);
if (!go.count(arr)) {
go[arr] = ne + B;
pcnt[ne + B] = arr;
lca = ne + B;
ne++;
} else {
lca = go[arr];
}
}
}
for (int i = 1; i < B + ne; i++) ids[i] = i;
sort(ids + 1, ids + B + ne, [](int i, int j) { return pcnt[i] < pcnt[j]; });
stack<int> s;
for (int q = 1; q < B + ne; q++) {
int i = ids[q];
while (!s.empty() and !is_lca(s.top(), i)) {
int j = s.top();
s.pop();
g[s.top()].push_back({j, calc_dist(s.top(), j)});
}
s.push(i);
}
while ((int)s.size() >= 2) {
int j = s.top();
s.pop();
g[s.top()].push_back({j, calc_dist(s.top(), j)});
}
for (int i = 0; i < N; i++) {
sort(g[i].begin(), g[i].end());
g[i].resize(unique(g[i].begin(), g[i].end()) - g[i].begin());
}
dfs(1);
for (int i = 1; i < B; i++)
if (!vis[i]) {
printf("> %d\n", i);
break;
}
int n;
scanf("%d", &n);
tot = n;
while (n--) {
int k;
scanf("%d", &k);
k = max(1, k);
cnt[k]++;
}
prec(1);
assert(sub[1] == tot);
ans = cur;
solve(1);
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int c[110][110], a[11100], n, m;
long long p;
char s[210];
long long f[210][210];
inline void upd(long long &a, long long b) {
if (b == 1000000000000000001LL) {
a = 1000000000000000001LL;
return;
}
if (a >= 1000000000000000001LL - b) {
a = 1000000000000000001LL;
return;
}
a += b;
}
long long ff() {
memset(f, 0, sizeof f);
f[0][0] = 1;
for (int i = 0; i < n + m - 1; i++) {
bool f0, f1;
if (!s[i]) f0 = f1 = 1;
if (s[i] == '(') f0 = 1, f1 = 0;
if (s[i] == ')') f0 = 0, f1 = 1;
for (int j = 0; j < n + m; j++)
if (f[i][j]) {
if (f0) upd(f[i + 1][j + 1], f[i][j]);
if (f1 && j) upd(f[i + 1][j - 1], f[i][j]);
}
}
return f[n + m - 1][0];
}
int main() {
scanf("%d%d", &n, &m);
cin >> p;
p--;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &c[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) a[c[i][j] - 1] = i + j;
memset(s, 0, sizeof s);
for (int i = 0; i < n * m; i++)
if (!s[a[i]]) {
s[a[i]] = '(';
long long T = ff();
if (T > p) continue;
p -= T, s[a[i]] = ')';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(s[i + j]);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve();
long long ncr(long long n, long long k) {
long long res = 1;
for (long long i = 1; i <= k; ++i) res = (res * (n - k + i)) / i;
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) solve();
return 0;
}
void solve() {
string s;
cin >> s;
long long n = s.size();
long long res = 0;
long long ctb = 0;
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == 'a') {
long long steps = (ctb);
(res += ctb) %= 1000000007LL;
ctb = (2 * ctb) % 1000000007LL;
} else
(++ctb) %= 1000000007LL;
}
cout << res;
cout << "\n";
return;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int T, m, p, k, q;
long long n;
long long calc(long long x, long long k) { return (2 * x + k - 1) * k / 2; }
long long find(long long x, long long k) {
if (!x) return k * (k + 1) / 2;
long long tmp = find(x / k, k);
long long tmp2 = (x / k) * (k * k + 1) + (x % k) * k + 1;
if (tmp2 + k <= tmp)
return calc(tmp2, k);
else
return calc(tmp2, k) + min(k, tmp2 + k - tmp);
}
void solve() {
scanf("%lld%d", &n, &k);
long long cnt = (n - 1) / (1ll * k * k + 1), tmp = find(cnt, k);
if (tmp == n)
printf("%lld\n", (cnt + 1) * (k + 1)), void();
else
printf("%lld\n", n - cnt - 1 + (n < tmp) + cnt * k +
((n - 1) % (1ll * k * k + 1) - (n >= tmp)) / k);
}
int main() {
scanf("%d", &T);
while (T--) solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
char a[100][100];
bool ok[100];
int main() {
std::ios::sync_with_stdio(false);
;
int n, m;
cin >> n >> m;
for (int(i) = (int)1; (i) <= (int)n; ++(i)) {
for (int(j) = (int)1; (j) <= (int)m; ++(j)) {
cin >> a[i - 1][j - 1];
}
}
int res = 0;
for (int(i) = (int)1; (i) <= (int)m; ++(i)) {
bool no = 0;
for (int(j) = (int)1; (j) <= (int)n - 1; ++(j)) {
if (a[j - 1][i - 1] > a[j][i - 1] && !ok[j - 1]) no = 1;
}
res += no;
if (!no) {
for (int(j) = (int)1; (j) <= (int)n; ++(j)) {
if (a[j - 1][i - 1] < a[j][i - 1]) ok[j - 1] = 1;
}
}
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[300002], sv[300002], u, x, y;
struct fenw {
int x[300002], tag[300002];
void update(int now, int val) {
if (val == 1 && tag[now] == 0) {
tag[now] = 1;
for (int i = now; i <= n; i += (i & (-i))) x[i] += val;
} else if (val == -1 && tag[now] == 1) {
tag[now] = 0;
for (int i = now; i <= n; i += (i & (-i))) x[i] += val;
}
}
int find(int now) {
int s = 0;
for (int i = now; i > 0; i -= (i & (-i))) s += x[i];
return s;
}
void pr() {
for (int i = 1; i <= n; i++) printf("%d ", x[i]);
printf("\n");
for (int i = 1; i <= n; i++) printf("%d ", tag[i]);
printf("\n");
}
};
fenw f;
int main() {
scanf("%d", &n);
sv[n + 1] = n + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sv[a[i]] = i;
}
for (int i = 1; i <= n; i++)
if (sv[i] < sv[i - 1]) f.update(i - 1, 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &x, &y);
if (u == 1)
printf("%d\n", f.find(y - 1) - f.find(x - 1) + 1);
else {
swap(sv[a[x]], sv[a[y]]);
u = sv[a[x] - 1] > sv[a[x]] ? 1 : -1;
f.update(a[x] - 1, u);
u = sv[a[x]] > sv[a[x] + 1] ? 1 : -1;
f.update(a[x], u);
u = sv[a[y]] > sv[a[y] + 1] ? 1 : -1;
f.update(a[y], u);
if (x != y - 1) {
u = sv[a[y] - 1] > sv[a[y]] ? 1 : -1;
f.update(a[y] - 1, u);
}
swap(a[x], a[y]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int p[N];
vector<int> adj[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) p[i] = i, sort(adj[i].begin(), adj[i].end());
int tof = 0;
while (tof < 300) {
shuffle(p + 1, p + n + 1, rng);
bool f = 1;
for (int i = 1; i <= m; i++) {
int ind = lower_bound(adj[p[i]].begin(), adj[p[i]].end(), p[i % n + 1]) -
adj[p[i]].begin();
if (ind < adj[p[i]].size() && adj[p[i]][ind] == p[i % n + 1]) f = 0;
}
tof++;
if (!f) continue;
for (int i = 1; i <= m; i++) cout << p[i] << ' ' << p[i % n + 1] << '\n';
return 0;
}
cout << -1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303303;
int a[N], fac[N], ifac[N];
int n, m;
int T, tot, p = 998244353;
int power(long long a, long long b) {
long long sum = 1;
for (; b; b >>= 1) {
if (b & 1) sum = 1ll * sum * a % p;
a = 1ll * a * a % p;
}
return sum;
}
int C(int n, int m) { return 1ll * fac[n] * ifac[m] % p * ifac[n - m] % p; }
int main() {
scanf("%d", &n);
n *= 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % p;
ifac[n] = power(fac[n], p - 2);
for (int i = n; i >= 1; i--) ifac[i - 1] = 1ll * ifac[i] * i % p;
long long ans = 0;
for (int i = 1; i <= n / 2; i++) ans = (ans + a[i + n / 2] - a[i]) % p;
printf("%lld\n", ans * C(n, n / 2) % p);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int MAXX = 1e7 + 10;
int cnt[MAXX];
int A[MAXN];
int main() {
int n;
scanf("%d", &n);
int mx = -1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
A[i] = x;
cnt[x]++;
mx = max(mx, x);
}
long long ans = 1e18;
for (int i = 1; i <= mx; i++) {
long long n1 = -1, n2 = -1;
for (int j = i; j <= mx && (n1 == -1 || n2 == -1); j += i) {
for (int k = 0; k < min(2, cnt[j]) && (n1 == -1 || n2 == -1); k++) {
if (n1 == -1)
n1 = j;
else if (n2 == -1)
n2 = j;
}
}
if (n2 != -1) {
ans = min(ans, n1 / i * n2);
}
}
int rem = 2;
for (int i = 1; i <= n && rem > 0; i++) {
if (ans % A[i] == 0) {
printf("%d ", i);
rem--;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[500050], pre[500050], suf[500050], ma, now, ans[500050];
struct node {
long long no, val;
};
stack<node> st;
long long min(long long x, long long y) { return x < y ? x : y; }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
int x = 0;
while (!st.empty()) {
if (st.top().val >= a[i])
st.pop();
else {
x = st.top().no;
break;
}
}
if (st.empty())
pre[i] = i * a[i];
else
pre[i] = pre[x] + (i - x) * a[i];
node nd = {i, a[i]};
st.push(nd);
}
while (!st.empty()) st.pop();
for (int i = n; i >= 1; --i) {
int x = 0;
while (!st.empty()) {
if (st.top().val >= a[i])
st.pop();
else {
x = st.top().no;
break;
}
}
if (st.empty())
suf[i] = (n - i + 1) * a[i];
else
suf[i] = suf[x] + (x - i) * a[i];
node nd = {i, a[i]};
st.push(nd);
}
for (int i = 1; i <= n - 1; ++i)
if (pre[i] + suf[i + 1] > ma) ma = pre[i] + suf[i + 1], now = i;
long long mi = 1e18;
for (int i = now; i >= 1; --i) {
if (a[i] >= mi)
ans[i] = mi;
else
mi = min(mi, a[i]), ans[i] = mi;
}
mi = 1e18;
for (int i = now + 1; i <= n; ++i) {
if (a[i] >= mi)
ans[i] = mi;
else
mi = min(mi, a[i]), ans[i] = mi;
}
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m, b, c, d, r, a[501][501], sum = 0;
cin >> r >> c;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
cin >> a[i][j];
sum += a[i][j];
}
a[i][c] = INT_MAX;
}
for (i = 0; i <= c; i++) {
a[r][i] = INT_MAX;
}
for (i = c - 1; i >= 0; i--) {
for (j = r - 1; j >= 0; j--) {
if (a[j][i + 1] <= a[j][i] || a[j + 1][i] <= a[j][i]) {
cout << -1;
return 0;
} else {
if (a[j][i] == 0) {
a[j][i] = min(a[j + 1][i] - 1, a[j][i + 1] - 1);
sum += a[j][i];
}
}
}
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXPOW = 20;
const int MAXA = 1048577;
const int MAXN = 100009;
const int MAXM = 100009;
const int BITS = 32;
vector<int> getBitmask(int number) {
vector<int> bitmask;
for (int i = 0; i < BITS; ++i) {
bitmask.push_back(number & 1);
number >>= 1;
}
return bitmask;
}
int toNumber(const vector<int>& bitmask) {
int res = 0;
for (int i = bitmask.size(); i >= 0; --i) {
res *= 2;
res += bitmask[i] > 0;
}
return res;
}
vector<int> subBitmask(vector<int> sumBitmask, const vector<int>& bitmask) {
for (int i = 0; i < BITS; ++i) {
sumBitmask[i] -= bitmask[i];
}
return sumBitmask;
}
int main() {
ios::sync_with_stdio(false);
int n, k, x;
cin >> n >> k >> x;
vector<int> a(n);
vector<vector<int>> bitmasks;
vector<int> sumBitmasks(BITS, 0);
for (int i = 0; i < n; ++i) {
cin >> a[i];
auto bitmask = getBitmask(a[i]);
bitmasks.push_back(bitmask);
for (int i = 0; i < BITS; ++i) {
sumBitmasks[i] += bitmask[i];
}
}
long long xPow = 1;
for (int i = 0; i < k; ++i) {
xPow *= x;
}
long long maxResult = 0;
for (int i = 0; i < n; ++i) {
vector<int> withoutBitmask = subBitmask(sumBitmasks, bitmasks[i]);
long long number = toNumber(bitmasks[i]);
long long rest = toNumber(withoutBitmask);
number *= xPow;
long long result = number | rest;
if (result > maxResult) {
maxResult = result;
}
}
cout << maxResult << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, length, repeat, v, total = 0;
cin >> n >> m;
vector<int> songs;
songs.push_back(0);
for (int i = 0; i < n; i++) {
cin >> length >> repeat;
total += (length * repeat);
songs.push_back(total);
}
int ind = -1;
for (int i = 0; i < m; i++) {
cin >> v;
while (songs[ind + 1] < v) {
ind += 1;
}
cout << ind + 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const int iinf = 1 << 29;
const long long llinf = 1ll << 60;
const double PI = 3.14159265;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long mrand(long long B) { return (unsigned long long)rng() % B; }
long long cross(pair<long long, long long> p1, pair<long long, long long> p2) {
return p1.first * p2.second - p2.first * p1.second;
}
bool online(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
pair<long long, long long> p1{b.first - a.first, b.second - a.second};
pair<long long, long long> p2{c.first - a.first, c.second - a.second};
return cross(p1, p2) == 0;
}
const int mxn = 1000;
int n, k;
vector<pair<long long, long long>> v;
long double dp[mxn + 1][mxn + 1];
vector<long long> nones;
long long getOnes(long long a, long long b) {
long long tot = 0;
for (long long p = 1; p / 10LL <= 1e17; p *= 10) {
if (a < p) {
if (b < p) break;
if (b >= p + p) {
tot += p;
} else {
tot += b - p + 1LL;
break;
}
} else {
if (a >= p + p) continue;
tot += min(b, p + p - 1LL) - a + 1LL;
}
}
return tot;
}
void work() {
cin >> n;
v.resize(n);
for (auto &e : v) cin >> e.first >> e.second;
nones.resize(n);
for (int i = 0; i < n; ++i) {
nones[i] = getOnes(v[i].first, v[i].second);
}
cin >> k;
dp[0][0] = 1.0 - (long double)nones[0] / (v[0].second - v[0].first + 1LL);
dp[0][1] = (long double)nones[0] / (v[0].second - v[0].first + 1LL);
for (int i = 1; i < n; ++i) {
long double p_of_zero =
1.0 - (long double)nones[i] / (v[i].second - v[i].first + 1LL);
long double p_of_one =
(long double)nones[i] / (v[i].second - v[i].first + 1LL);
dp[i][0] = dp[i - 1][0] * p_of_zero;
for (int j = 1; j <= n; ++j) {
dp[i][j] = dp[i - 1][j] * p_of_zero + dp[i - 1][j - 1] * p_of_one;
}
}
int x = ceil(n * k / 100.0);
if (x > n) {
cout << "0\n";
return;
}
long double ans = 0;
for (int i = x; i <= n; ++i) ans += dp[n - 1][i];
cout << setprecision(17) << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int x, y;
if (a % c != 0 && b % d != 0) {
x = (a / c) + 1;
y = (b / d) + 1;
}
if (a % c == 0 && b % d == 0) {
x = (a / c);
y = (b / d);
}
if (a % c != 0 && b % d == 0) {
x = (a / c) + 1;
y = (b / d);
}
if (a % c == 0 && b % d != 0) {
x = a / c;
y = (b / d) + 1;
}
if (x + y <= k) {
cout << x << " " << y << "\n";
}
if (x + y > k) {
cout << -1 << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, a;
cin >> N;
vector<int> v, v1, v2;
for (int i = 0; i < N; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
int len = 0, prev = -1;
for (int i = 0; i < N; i++) {
len = v[i] == prev ? len + 1 : 1;
prev = v[i];
if (len > 2) {
cout << "NO" << endl;
exit(0);
}
if (len == 1)
v1.push_back(v[i]);
else
v2.push_back(v[i]);
}
cout << "YES" << endl;
sort(v2.rbegin(), v2.rend());
cout << v1.size() << endl;
for (int i : v1) cout << i << ' ';
cout << endl;
cout << v2.size() << endl;
for (int i : v2) cout << i << ' ';
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, i, j, maxe = -99999, x;
cin >> n;
int a[1000] = {0}, b[1000] = {0};
vector<int> v, vv;
for (i = 0; i < n; i++) {
cin >> x;
if (a[x] == 0) {
v.push_back(x);
a[x] = 1;
} else {
vv.push_back(x);
}
}
set<int> s(v.begin(), v.end());
set<int> ss(vv.begin(), vv.end());
int vt = 0, vvt = 0;
for (auto i : s) {
if (i != vt) {
break;
}
vt++;
}
for (auto i : ss) {
if (i != vvt) {
break;
}
vvt++;
}
cout << vt + vvt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int k, b, n, a[111111], s, o;
map<int, int> w;
long long ans = 0, aa;
int f(int x) {
if (x < k) return x;
return f(x / k + x % k);
}
int main() {
cin >> k >> b >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
w[0]++;
for (int i = 0; i < n; i++) {
s += a[i];
s = f(s);
o = s - b;
if (o < 0) o += k - 1;
if (o == 0) ans += w[k - 1];
ans += w[o];
w[s]++;
}
s = 0;
for (int i = 0; i < n; i++) {
if (a[i])
s = 0;
else
s++;
aa += s;
}
if (b == 0)
ans = aa;
else if (b == k - 1)
ans -= aa;
cout << (ans) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, x, y, a = 0, b = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h >> x >> y;
if (h == 1)
a += x - y;
else
b += x - y;
}
if (a >= 0)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (b >= 0)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int L, R;
} b[100005];
int i, j, k, l, s, n, m, d, a[100005], A[100005], ans;
inline bool check(int x) {
int L = (n + 1) / 2 - x + 1, R = (n + 1) / 2 + x - 1;
if (!(n & 1)) R++;
R = min(R, n);
int j = 1;
for (int i = 1; i <= n; i++) A[i] = a[i];
for (int i = L; i <= R; i++) {
int s = 0;
while (b[j].R < i && j <= n) j++;
if (j > n) return false;
while (s < m) {
if (s + A[j] < m) s += A[j], j++;
if (j > n) return false;
if (b[j].L > i) return false;
if (s + A[j] >= m) {
A[j] -= (m - s);
s = m;
}
}
}
return true;
}
int main() {
scanf("%d%d%d", &n, &d, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
b[i].L = (i - 1) / (d + 1) + 1;
b[i].R = n - (n - i) / (d + 1);
}
int l = 0, r = (n + 1) / 2;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d\n", (n + 1) / 2 - ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[101010 << 1];
int x[101010], y[101010];
bool vis[101010 << 1];
const int mod = 1e9 + 7;
int q[101010 << 1];
int go[101010 << 1];
bool hel[101010 << 1];
bool kick[101010 << 1];
map<int, bool> mp;
map<int, bool>::iterator it;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
v[y[i]].push_back(x[i]);
vis[x[i]] = 1;
go[x[i]] = y[i];
}
int ans = 1;
for (int i = 1; i <= n * 2; i++)
if (!vis[i]) {
int e = 0;
q[++e] = i;
for (int f = 1; f <= e; f++) {
int x = q[f];
for (int j = 0; j < v[x].size(); j++) {
int y = v[x][j];
q[++e] = y;
}
}
for (int f = 1; f <= e; f++) hel[q[f]] = 1;
ans = 1ll * ans * e % mod;
}
for (int i = 1; i <= n * 2; i++)
if (!hel[i] && go[i] != i) {
mp.clear();
mp[i] = 1;
int j = go[i];
bool bad = 0;
while (!mp[j]) {
if (hel[j] || go[j] == j) {
bad = 1;
break;
}
mp[j] = 1;
j = go[j];
}
for (it = mp.begin(); it != mp.end(); it++) {
hel[it->first] = 1;
}
if (!bad) ans = (ans << 1) % mod;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 1e9;
int main() {
printf("? 1 1\n");
fflush(stdout);
int a, b, c, d;
scanf("%d", &a);
printf("? 1 %d\n", MAXN);
fflush(stdout);
scanf("%d", &b);
printf("? %d 1\n", MAXN);
fflush(stdout);
scanf("%d", &c);
printf("? %d %d\n", MAXN, MAXN);
fflush(stdout);
scanf("%d", &d);
int x, y, p, q;
int l = 1, r = 1e9 + 1, mid, t;
while (l + 1 < r) {
mid = (l + r) / 2;
printf("? 1 %d\n", mid);
fflush(stdout);
scanf("%d", &t);
if (mid - 1 == a - t)
l = mid;
else
r = mid;
}
printf("? 1 %d\n", l);
fflush(stdout);
scanf("%d", &t);
x = t + 1;
y = a - t + 1;
q = 1e9 - b + x - 1;
p = 1e9 - c + y - 1;
printf("! %d %d %d %d\n", x, y, p, q);
fflush(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int p[m];
vector<int> cnt(n, 0), ans(26, 0);
cnt[n - 1] = 1;
for (int i = 0; i < m; i++) {
cin >> p[i];
cnt[p[i] - 1]++;
}
for (int i = n - 2; i >= 0; i--) cnt[i] += cnt[i + 1];
for (int i = 0; i < n; i++) ans[s[i] - 'a'] += cnt[i];
for (auto num : ans) cout << num << " ";
cout << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using uint = unsigned int;
using vi = vector<int>;
using pii = pair<int, int>;
ll gett(ll n, ll k) {
if (n == 0) return k * (k + 1) / 2;
ll num = gett(n / k, k);
ll t = n % k;
ll i = (num - 1) / k;
ll j = (num - 1) % k;
ll res = k * (k + 1) / 2 - t;
if (t > i) res += k;
if (t == i) res += k - j;
return res;
}
ll solve(ll n, ll k) {
ll x = k * k + 1;
ll ind = (n - 1) / x;
ll num = gett(ind, k);
ll rem = (n - 1) % x + 1;
if (rem == num) {
ll t = ind % k;
ll i = ind / k;
return k * (k + 1) * i + (t + 1) * (k + 1);
}
if (rem >= num) rem--;
return k * (k + 1) * ind + (rem - 1) / k * (k + 1) + (rem - 1) % k + 1;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int tn;
cin >> tn;
for (int tt = 0; tt < (tn); ++tt) {
ll n, k;
cin >> n >> k;
cout << solve(n, k) << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int ZIMAX = 3005;
int n, v;
int cnt[ZIMAX];
int main() {
cin >> n >> v;
for (int i = 1; i <= n; ++i) {
int ai, bi;
cin >> ai >> bi;
cnt[ai] += bi;
}
int ans = 0;
int before = 0;
for (int i = 0; i < ZIMAX; ++i) {
int azi = before;
int ramase = v - azi;
if (ramase < 0) {
ans += v;
before = cnt[i];
} else {
azi += (cnt[i] <= ramase ? cnt[i] : ramase);
ans += azi;
before = max(0, cnt[i] - ramase);
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m1 = -1, m2 = -1, x;
long long s = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
s += x;
}
for (int i = 0; i < n; i++) {
cin >> x;
if (x > m1) {
m2 = m1;
m1 = x;
} else if (x > m2) {
m2 = x;
}
}
cout << (s <= m1 + m2 ? "YES\n" : "NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
const double eps = 1e-9;
const int inf = 1e9;
int n, ans = inf;
int xx(int u, int v) {
int ret = 0;
while (1) {
if (u < 1 || v < 1) return inf;
if (u == 1 && v == 1) return ret;
ret++;
if (u >= v)
u -= v;
else
v -= u;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) ans = min(ans, xx(n, i));
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i1, j1, i2, j2;
scanf("%d %d %d %d", &i1, &j1, &i2, &j2);
if (i1 == i2 && j1 == j2) {
printf("0 0 0\n");
return 0;
}
if (i1 == i2 || j2 == j1)
printf("1 ");
else
printf("2 ");
if (((i1 + j1) & 1) == ((i2 + j2) & 1)) {
if (abs(i1 - i2) == abs(j1 - j2))
printf("1 ");
else
printf("2 ");
} else
printf("0 ");
printf("%d\n", max(abs(i1 - i2), abs(j1 - j2)));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 2 == 0) {
for (int i = 0; i < n / 2; i++) {
cout << 1;
}
} else {
cout << 7;
for (int i = 0; i < n / 2 - 1; i++) {
cout << 1;
}
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int st[100];
vector<int> v[100];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n * n; i++) {
int r = i % 16;
v[r].push_back(i);
}
int k = n / 4;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int r = i / k, s = j / k;
s += r * 4;
printf("%d ", v[s][st[s]]);
st[s]++;
}
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> a(n);
for (auto& s : a) cin >> s;
vector<int> pref(m);
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
if (a[i][j + 1] == 'X' and a[i + 1][j] == 'X') {
pref[j + 1] += 1;
}
}
}
for (int i = 1; i < m; i++) {
pref[i] += pref[i - 1];
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
--l, --r;
cout << (pref[r] != pref[l] ? "NO" : "YES") << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 1005, mod = 1e9 + 7;
int n, k;
long long f[maxn][maxn][3][3], c[maxn][maxn], fac[maxn], ans[maxn];
void init() {
fac[0] = 1;
for (int i = 1; i <= maxn; i++) fac[i] = (fac[i - 1] * i * 1ll) % mod;
for (int i = 1; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int main() {
scanf("%d%d", &n, &k);
init();
f[0][0][1][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i - 1; j++)
for (int k = 0; k <= 1; k++)
for (int l = 0; l <= 1; l++) {
(f[i][j][l][0] += f[i - 1][j][k][l]) %= mod;
if (!k) (f[i][j + 1][l][0] += f[i - 1][j][k][l]) %= mod;
if (i < n) (f[i][j + 1][l][1] += f[i - 1][j][k][l]) %= mod;
}
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= 1; k++)
for (int l = 0; l <= 1; l++) (ans[j] += f[n][j][k][l]) %= mod;
(ans[j] *= fac[n - j]) %= mod;
}
for (int i = k + 1, fl = -1; i <= n; i++) {
ans[k] = (ans[k] + fl * ans[i] * c[i][k] % mod + mod) % mod;
fl = -fl;
}
printf("%I64d\n", ans[k]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> match;
char bord[33][33];
int cnt[33][33];
int n, m, x;
int Hash[333];
int main() {
scanf("%d%d%d", &n, &m, &x);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) {
scanf("%s", bord[i]);
for (int j = 0; j < m; ++j) {
if (bord[i][j] == 'S') {
for (int l = 0; l < n; ++l) {
for (int k = 0; k < m; ++k) {
if ((l - i) * (l - i) + (k - j) * (k - j) <= x * x) cnt[l][k] = 1;
}
}
}
}
}
memset(Hash, -1, sizeof(Hash));
int num = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (bord[i][j] == 'S') {
num++;
continue;
}
if (Hash[bord[i][j] - 'a'] == -1) {
Hash[bord[i][j] - 'a'] = cnt[i][j];
} else
Hash[bord[i][j] - 'a'] |= cnt[i][j];
}
}
int q;
scanf("%d", &q);
int ans = 0;
bool f = true;
bool big = false;
while (q--) {
char ch;
cin >> ch;
if (ch <= 'Z' && ch >= 'A') {
big = true;
ch = ch - 'A' + 'a';
if (Hash[ch - 'a'] == -1) {
f = false;
break;
}
if (num == 0) break;
if (Hash[ch - 'a']) {
continue;
}
ans++;
} else if (Hash[ch - 'a'] == -1) {
f = false;
break;
}
}
if (!f || (num == 0 && big))
puts("-1");
else
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
inline int read() {
int x = 0, f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + s - '0';
s = getchar();
}
return x * f;
}
inline int power(int x, int c) {
int now = 1;
while (c) {
if (c & 1) now = 1ll * now * x % mod;
x = 1ll * x * x % mod;
c >>= 1;
}
return now;
}
int jc[200005], jcinv[200005], d[200005], sum[200005];
inline int C(int x, int y) {
if (x < y || y < 0) return 0;
return 1ll * jc[x] * jcinv[y] % mod * jcinv[x - y] % mod;
}
int main() {
int n = read(), q = read();
for (int i = 1; i <= n; ++i) d[i] = read();
sort(d + 1, d + 1 + n);
for (int i = n; i; --i) sum[i] = (sum[i + 1] + d[i]) % mod;
jc[0] = 1;
for (int i = 1; i <= n; ++i) jc[i] = 1ll * jc[i - 1] * i % mod;
jcinv[n] = power(jc[n], mod - 2);
for (int i = n - 1; i + 1; --i) jcinv[i] = 1ll * jcinv[i + 1] * (i + 1) % mod;
while (q--) {
int a = read(), b = read();
int l = 0, r = n;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (d[mid] >= b)
r = mid - 1;
else
l = mid;
}
int m = n - l, ans = 0;
if (m > a) {
ans = (ans + 1ll * sum[l + 1] * C(m - 1, a) % mod * jc[a] % mod *
jc[m - a] % mod * C(n, m) % mod * jc[n - m] % mod) %
mod;
}
if (m >= a && m < n) {
ans = (ans + 1ll * (sum[1] - sum[l + 1]) * C(m, a) % mod * jc[a] % mod *
jc[m - a + 1] % mod * C(n, m + 1) % mod * jc[n - m - 1] %
mod) %
mod;
}
ans = 1ll * ans * jcinv[n] % mod;
printf("%d\n", (ans + mod) % mod);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 2e5;
struct DSU {
int n, fa[kMaxN], rk[kMaxN], cnt;
stack<pair<int*, int> > stk;
void Init(int n) {
this->n = this->cnt = n;
for (int i = 1; i <= n; i++) fa[i] = i, rk[i] = 0;
while (!stk.empty()) stk.pop();
}
int Find(int x) { return fa[x] == x ? x : Find(fa[x]); }
void Union(int x, int y, int on) {
x = Find(x), y = Find(y);
if (x == y) return;
if (on) stk.push(make_pair(&cnt, cnt));
cnt--;
if (rk[x] <= rk[y]) {
if (on) stk.push(make_pair(&fa[x], fa[x]));
fa[x] = y;
if (rk[x] == rk[y]) {
if (on) stk.push(make_pair(&rk[y], rk[y]));
rk[y]++;
}
} else {
if (on) stk.push(make_pair(&fa[y], fa[y]));
fa[y] = x;
}
}
void Rollback() {
while (!stk.empty()) {
*stk.top().first = stk.top().second;
stk.pop();
}
}
} dsu;
int n, k, m, q;
vector<int> G[kMaxN];
vector<int> M[kMaxN / 100];
int l[kMaxN], r[kMaxN], ans[kMaxN];
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
scanf("%d", &q);
int block = sqrt(n);
for (int i = 0; i < q; i++) {
scanf("%d%d", &l[i], &r[i]);
int L = (l[i] - 1) / block, R = (r[i] - 1) / block;
if (L == R) {
dsu.Init(block);
int d = l[i] - 1;
for (int j = l[i]; j <= r[i]; j++) {
for (int k = 0; k < G[j].size(); k++) {
int u = j;
int v = G[j][k];
if (v < l[i] || v > r[i]) continue;
dsu.Union(u - d, v - d, 0);
}
}
ans[i] = r[i] - l[i] + 1 - (dsu.n - dsu.cnt);
} else {
M[L].push_back(i);
}
}
for (int i = 0; (i + 1) * block <= n; i++) {
sort(M[i].begin(), M[i].end(), [&](int a, int b) { return r[a] < r[b]; });
int nl = block * (i + 1), nr = nl - 1;
dsu.Init(n);
for (int j = 0; j < M[i].size(); j++) {
while (nr < r[M[i][j]]) {
nr++;
for (int k = 0; k < G[nr].size(); k++) {
int v = G[nr][k];
if (v < nl || v > nr) continue;
dsu.Union(nr, v, 0);
}
}
for (int k = l[M[i][j]]; k < nl; k++) {
for (int _ = 0; _ < G[k].size(); _++) {
int v = G[k][_];
if (v < l[M[i][j]] || v > r[M[i][j]]) continue;
dsu.Union(k, v, 1);
}
}
ans[M[i][j]] = r[M[i][j]] - l[M[i][j]] + 1 - (dsu.n - dsu.cnt);
dsu.Rollback();
nl = block * (i + 1);
}
}
for (int i = 0; i < q; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long INF = 1e9 + 100;
const long long LINF = 1e18 + 100;
long long n, w, k;
long long a[200100], t[200100];
long long ps[200100];
set<pair<long long, long long> > s;
set<pair<long long, long long> > ns;
long long ans;
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> w >> k;
for (long long i = (0); i < (n); i++) {
cin >> a[i];
ps[i + 1] = ps[i] + a[i];
}
for (long long i = (0); i < (n); i++) cin >> t[i];
;
;
long long r = 0;
long long cur = 0;
for (long long l = (0); l < (n); l++) {
while (r < n) {
if ((long long)s.size() < w) {
if (cur + (t[r] + 1) / 2 <= k) {
s.insert({t[r], r});
cur += (t[r] + 1) / 2;
r++;
} else
break;
} else {
if (s.begin()->first >= t[r]) {
if (cur + t[r] <= k) {
ns.insert({t[r], r});
cur += t[r];
r++;
} else
break;
} else {
long long mt = s.begin()->first;
if (cur + mt / 2 + (t[r] + 1) / 2 <= k) {
ns.insert(*s.begin());
s.erase(s.begin());
s.insert({t[r], r});
cur += (t[r] + 1) / 2 + mt / 2;
r++;
} else
break;
}
}
}
ans = max(ans, ps[r] - ps[l]);
if (l == r) {
r++;
continue;
}
if (s.count({t[l], l})) {
s.erase({t[l], l});
cur -= (t[l] + 1) / 2;
if (ns.size()) {
auto it = ns.end();
it--;
s.insert(*it);
cur -= it->first / 2;
ns.erase(it);
}
} else {
cur -= t[l];
ns.erase({t[l], l});
}
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300, P = 30, INF = 1e9;
struct edge {
int v, to, flow, cap, cost;
edge(int v, int to, int cost, int cap = 0)
: v(v), to(to), cost(cost), cap(cap), flow(0) {}
};
int S, T, num, from[N];
vector<edge> edges;
vector<int> g[N];
bool levit() {
vector<int> dist(N, INF), us(N, 0);
dist[S] = 0;
deque<int> d;
d.push_front(S);
while (!d.empty()) {
int v = d.front();
d.pop_front();
++us[v];
for (auto num : g[v]) {
edge it = edges[num];
if (it.cap - it.flow && dist[v] + it.cost < dist[it.to]) {
dist[it.to] = dist[v] + it.cost;
from[it.to] = num;
if (!us[it.to])
d.push_back(it.to);
else
d.push_front(it.to);
}
}
}
return dist[T] != INF;
}
int find_min_cost_flow() {
int ans = 0;
while (levit()) {
int v = T;
while (v != S) {
int num = from[v];
ans += edges[num].cost;
++edges[num].flow;
--edges[num ^ 1].flow;
v = edges[num].v;
}
}
return ans;
}
void add_edge(int v, int to, int cap, int cost) {
g[v].push_back(edges.size());
edges.push_back(edge(v, to, cost, cap));
g[to].push_back(edges.size());
edges.push_back(edge(to, v, -cost));
}
void solve() {
T = ++num;
char t[N];
vector<int> cnt(P, 0), key(P, 0);
scanf(" %s", t);
string st = t;
for (auto it : st) ++cnt[it - 'a'];
for (int i = 0; i < P; ++i) {
int v = ++num, to = T;
add_edge(v, to, cnt[i], 0);
key[i] = num;
}
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int k;
scanf(" %s%d", t, &k);
int v = ++num;
add_edge(S, v, k, 0);
st = t;
for (auto it : st) {
int num = it - 'a', to = key[num];
add_edge(v, to, 1, i + 1);
}
}
int ans = find_min_cost_flow();
for (int i = 0; i < P * 2; i += 2)
if (edges[i].cap - edges[i].flow) ans = -1;
printf("%d", ans);
}
int main() {
solve();
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.