solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1 << 29;
int n, k;
string s[2];
int cost[2][200000];
struct state {
int r, c, cst;
state() {}
state(int x, int y, int z) {
r = x;
c = y;
cst = z;
}
bool valid() {
if (c < 0) return false;
if (c < s[r].size() && s[r][c] == 'X') return false;
if (cost[r][c] <= cst) return false;
if (cst > c) return false;
if (c >= n) {
puts("YES");
exit(0);
}
return true;
}
};
void Dijkstra() {
queue<state> q;
for (int i = 0; i < 200000; ++i)
for (int j = 0; j < 2; ++j) cost[j][i] = oo;
if (s[0][0] == '-') {
q.push(state(0, 0, 0));
cost[0][0] = 0;
}
while (!q.empty()) {
state s = q.front();
q.pop();
state ns(s.r, s.c + 1, s.cst + 1);
if (ns.valid()) {
cost[ns.r][ns.c] = ns.cst;
q.push(ns);
}
ns = state(s.r, s.c - 1, s.cst + 1);
if (ns.valid()) {
cost[ns.r][ns.c] = ns.cst;
q.push(ns);
}
ns = state(!s.r, s.c + k, s.cst + 1);
if (ns.valid()) {
cost[ns.r][ns.c] = ns.cst;
q.push(ns);
}
}
puts("NO");
}
int main() {
cin >> n >> k >> s[0] >> s[1];
Dijkstra();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 10;
int k;
int m;
string s;
int ans;
int main() {
int a[N], b[N];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof b);
int n, m;
cin >> n >> m;
for (int i = n; i >= 1; i--) {
char t;
cin >> t;
a[i] = t - '0';
}
for (int i = m; i >= 1; i--) {
char t;
cin >> t;
b[i] = t - '0';
}
for (int i = m; i >= 1; i--) {
b[i] += b[i + 1];
}
unsigned long long int ans = 0, w = 1;
for (int i = 1; i <= n; i++) {
ans = (ans + w * a[i] * b[i]) % 998244353;
w = (w * 2) % 998244353;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.141592653589793;
const long double eps = 1e-7;
const int MAXN = 2000000;
const int INF = 1e9 + 10;
const long long int LONGINF = 4e18;
const int mod = 1e9 + 7;
void solve() {
long long int n;
cin >> n;
if (n == 2) {
cout << 1;
return;
}
long long int a = 1, b = 2, c = 1;
while (b < n) {
long long int t = a + b + 1;
a = b;
b = t;
++c;
}
cout << c;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, q, fa[N];
double p[N], sum[N], ans;
vector<int> son[N];
void dfs(int x, int f) {
fa[x] = f;
for (int i = 0; i < son[x].size(); ++i) {
int y = son[x][i];
if (y == f) continue;
dfs(y, x);
sum[x] += 1 - p[y];
ans += p[x] * (1 - p[y]);
}
}
int main() {
scanf("%d", &n);
p[0] = 1;
for (int i = 1; i <= n; ++i) scanf("%lf", p + i);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
++u, ++v;
son[u].push_back(v);
son[v].push_back(u);
}
ans = 1 - p[1];
dfs(1, 0);
scanf("%d", &q);
while (q--) {
int k;
double p1;
scanf("%d%lf", &k, &p1);
++k;
sum[fa[k]] -= p1 - p[k];
ans += sum[k] * (p1 - p[k]) - (p1 - p[k]) * p[fa[k]];
p[k] = p1;
printf("%.5lf\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,fma")
const int N = 4e4 + 15;
int n, k, a[N], t[N << 3], add[N << 3];
void push(int v) {
add[v << 1] += add[v];
add[v << 1 | 1] += add[v];
t[v << 1] += add[v];
t[v << 1 | 1] += add[v];
add[v] = 0;
}
void mult(int v, int tl, int tr, int l, int r, int val) {
if (tl > r || tr < l || l > r) return;
push(v);
if (tl >= l && tr <= r) {
t[v] += val;
add[v] += val;
return;
}
int mid = tl + tr >> 1;
mult(v << 1, tl, mid, l, r, val);
mult(v << 1 | 1, mid + 1, tr, l, r, val);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
int get(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l || l > r) return 0;
push(v);
if (tl >= l && tr <= r) return t[v];
int mid = tl + tr >> 1;
return max(get(v << 1, tl, mid, l, r), get(v << 1 | 1, mid + 1, tr, l, r));
}
int dp[2][N], ind[N], lpos[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
lpos[i] = ind[a[i]];
ind[a[i]] = i;
}
for (int g = 1; g <= k; ++g) {
memset(t, 0, sizeof(t));
memset(add, 0, sizeof(add));
for (int i = 1; i <= n; ++i) mult(1, 0, n, i, i, dp[(g & 1) ^ 1][i]);
for (int i = 1; i <= n; ++i) {
mult(1, 0, n, lpos[i], i - 1, 1);
if (i == 1)
dp[g & 1][i] = get(1, 0, n, g - 1, i - 1);
else
dp[g & 1][i] = get(1, 1, n, g - 1, i - 1);
}
}
printf("%d", dp[k & 1][n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int N = 2e5 + 1e3;
using namespace std;
int s[N];
int aray[N];
int n;
char a;
int m;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> aray[i];
}
for (int i = 1; i < n; i++) {
cin >> a;
s[i] += a == '1';
s[i] += s[i - 1];
}
for (int i = 1; i <= n; i++) {
m = aray[i];
if (aray[i] == i) continue;
if (m > i && s[m - 1] - s[i - 1] != m - i) {
cout << "NO";
return 0;
} else if (m < i && s[i - 1] - s[m - 1] != i - m) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long N = 2e5;
long long a[N], b[N];
long long n, m, x, y, k;
long long solve(long long l, long long r, long long mx) {
if (l > r) return 0;
vector<long long> v;
for (long long i = l; i <= r; ++i) v.push_back(a[i]);
long long p = 0;
for (long long u : v) p = max(p, u);
if (v.size() < k) {
if (p > mx)
return -1;
else
return y * v.size();
}
long long ans = 0;
ans += (v.size() % k) * y;
long long sz = v.size() - v.size() % k;
if (y * k < x) {
if (p < mx)
return ans + sz * y;
else
return ans + (sz - k) * y + x;
} else {
return ans + sz / k * x;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
;
cin >> n >> m >> x >> k >> y;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < m; ++i) cin >> b[i];
vector<long long> ps;
long long pt = 0;
for (long long i = 0; i < n; ++i) {
if (pt == m) break;
if (b[pt] == a[i]) {
ps.push_back(i);
++pt;
}
}
if (pt != m) {
cout << -1;
return 0;
}
long long ans = 0;
for (long long i = 0; i < ps.size(); ++i) {
if (!i) {
long long sl = solve(0, ps[i] - 1, a[ps[i]]);
if (sl == -1) {
cout << -1;
return 0;
}
ans += sl;
} else {
long long sl =
solve(ps[i - 1] + 1, ps[i] - 1, max(a[ps[i]], a[ps[i - 1]]));
if (sl == -1) {
cout << -1;
return 0;
}
ans += sl;
}
}
long long sl = solve(ps[ps.size() - 1] + 1, n - 1, a[ps[ps.size() - 1]]);
if (sl == -1) {
cout << sl;
return 0;
}
ans += sl;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 5;
pair<pair<int, int>, int> e[MAXN];
pair<int, int> ans[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> e[i].first.first >> e[i].first.second;
e[i].first.second ^= 1;
e[i].second = i;
}
sort(e, e + m);
int v = 0, need = m - n + 1;
vector<pair<int, int> > ee;
for (int i = 0; i < m; i++)
if (e[i].first.second == 0) {
ans[e[i].second] = make_pair(v, v + 1);
for (int u = 0; u < v && (int)ee.size() < need; u++)
ee.push_back(make_pair(u, v + 1));
v++;
} else {
if (ee.empty()) {
cout << -1 << '\n';
return 0;
}
ans[e[i].second] = ee.back();
ee.pop_back();
need--;
}
for (int i = 0; i < m; i++)
cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t;
while (cin >> n >> k >> t) {
if (t <= k)
cout << t << endl;
else if (t > n)
cout << n + k - t << endl;
else
cout << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n, _m;
cin >> n >> _m;
map<string, string> m;
for (int i = 0; i < _m; i++) {
string a, b;
cin >> a >> b;
m[a] = b;
}
string s = "";
for (int i = 0; i < n; i++) {
string _;
cin >> _;
if (_.size() <= m[_].size())
s += _;
else
s += m[_];
s += " ";
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int e[120000], p[120000];
int GetP(int a) {
while (p[a] != 0) a = p[a] = GetP(p[a]);
return a;
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int K, I;
int x, y, py;
vector<int> curr_q, curr_p;
memset(p, 0, sizeof(p));
memset(e, 0, sizeof(e));
for (int i = 0; i < m; i++) {
scanf("%d", &K);
if (K == 1) {
scanf("%d%d", &x, &y);
e[x] = y;
p[x] = GetP(y);
} else if (K == 2) {
scanf("%d", &x);
curr_q.push_back(x);
curr_p.push_back(GetP(x));
} else if (K == 3) {
scanf("%d%d", &x, &I);
y = curr_q[I - 1];
py = curr_p[I - 1];
while (y != py) {
if (y == x) break;
y = e[y];
}
if (y == x)
printf("YES\n");
else
printf("NO\n");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 100100;
const int Q = 250200;
const long long mod = 1e9 + 7;
using namespace std;
int n;
int a[N];
int b[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
if (a[1] != b[1] || a[n] != b[n]) {
cout << "No"
<< "\n";
return 0;
}
for (int i = 1; i < n; i++) {
a[i] = a[i + 1] - a[i];
b[i] = b[i + 1] - b[i];
}
sort(a + 1, a + n);
sort(b + 1, b + n);
for (int i = 1; i < n; i++) {
if (a[i] != b[i]) {
cout << "No"
<< "\n";
return 0;
}
}
cout << "Yes"
<< "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 100011, inf = 0x3f3f3f3f3f3f3f3fLL;
struct P {
long long f, tg;
long long p, d;
};
P mn[MX << 2];
struct E {
long long t, w;
E(long long _t = 0, long long _w = 0) : t(_t), w(_w) {}
};
struct E2 {
long long l, r, w;
E2(long long _l = 0, long long _r = 0, long long _w = 0)
: l(_l), r(_r), w(_w) {}
};
vector<E> t[MX];
vector<E2> t2[MX];
vector<E> tg[MX << 2];
long long n, q, s;
void ins(long long no, long long l, long long r, long long ll, long long rr,
E x) {
if (ll <= l && rr >= r)
tg[no].push_back(x);
else {
long long mid = (l + r) >> 1;
if (ll <= mid) ins(no << 1, l, mid, ll, rr, x);
if (rr > mid) ins(no << 1 | 1, mid + 1, r, ll, rr, x);
}
}
void build(long long no, long long l, long long r) {
mn[no].f = mn[no].tg = inf;
if (l == r)
mn[no].p = l;
else {
long long mid = (l + r) >> 1;
build(no << 1, l, mid);
build(no << 1 | 1, mid + 1, r);
if (mn[no << 1 | 1].d ||
(!mn[no << 1].d && mn[no << 1].f < mn[no << 1 | 1].f))
mn[no].f = mn[no << 1].f, mn[no].p = mn[no << 1].p,
mn[no].d = mn[no << 1].d;
else
mn[no].f = mn[no << 1 | 1].f, mn[no].p = mn[no << 1 | 1].p,
mn[no].d = mn[no << 1 | 1].d;
}
}
void psdw(long long no) {
if (mn[no].tg != inf) {
mn[no << 1].tg = min(mn[no << 1].tg, mn[no].tg);
mn[no << 1 | 1].tg = min(mn[no << 1 | 1].tg, mn[no].tg);
mn[no << 1].f = min(mn[no << 1].f, mn[no].tg);
mn[no << 1 | 1].f = min(mn[no << 1 | 1].f, mn[no].tg);
mn[no].tg = inf;
}
}
void upd(long long no, long long l, long long r, long long x, long long v) {
if (mn[no].d) return;
if (l == r)
mn[no].f = min(mn[no].f, v);
else {
psdw(no);
long long mid = (l + r) >> 1;
if (x <= mid)
upd(no << 1, l, mid, x, v);
else
upd(no << 1 | 1, mid + 1, r, x, v);
if (mn[no << 1 | 1].d ||
(!mn[no << 1].d && mn[no << 1].f < mn[no << 1 | 1].f))
mn[no].f = mn[no << 1].f, mn[no].p = mn[no << 1].p,
mn[no].d = mn[no << 1].d;
else
mn[no].f = mn[no << 1 | 1].f, mn[no].p = mn[no << 1 | 1].p,
mn[no].d = mn[no << 1 | 1].d;
}
}
void upd(long long no, long long l, long long r, long long ll, long long rr,
long long v) {
if (mn[no].d) return;
if (ll <= l && rr >= r)
mn[no].f = min(mn[no].f, v), mn[no].tg = min(mn[no].tg, v);
else {
psdw(no);
long long mid = (l + r) >> 1;
if (ll <= mid) upd(no << 1, l, mid, ll, rr, v);
if (rr > mid) upd(no << 1 | 1, mid + 1, r, ll, rr, v);
if (mn[no << 1 | 1].d ||
(!mn[no << 1].d && mn[no << 1].f < mn[no << 1 | 1].f))
mn[no].f = mn[no << 1].f, mn[no].p = mn[no << 1].p,
mn[no].d = mn[no << 1].d;
else
mn[no].f = mn[no << 1 | 1].f, mn[no].p = mn[no << 1 | 1].p,
mn[no].d = mn[no << 1 | 1].d;
}
}
void del(long long no, long long l, long long r, long long x) {
if (l == r)
mn[no].d = 1;
else {
psdw(no);
long long mid = (l + r) >> 1;
if (x <= mid)
del(no << 1, l, mid, x);
else
del(no << 1 | 1, mid + 1, r, x);
if (mn[no << 1 | 1].d ||
(!mn[no << 1].d && mn[no << 1].f < mn[no << 1 | 1].f))
mn[no].f = mn[no << 1].f, mn[no].p = mn[no << 1].p,
mn[no].d = mn[no << 1].d;
else
mn[no].f = mn[no << 1 | 1].f, mn[no].p = mn[no << 1 | 1].p,
mn[no].d = mn[no << 1 | 1].d;
}
}
void upd2(long long no, long long l, long long r, long long x, long long f) {
for (vector<E>::iterator it = tg[no].begin(); it != tg[no].end(); it++) {
upd(1, 1, n, it->t, f + it->w);
}
tg[no].clear();
if (l == r) return;
long long mid = (l + r) >> 1;
if (x <= mid)
upd2(no << 1, l, mid, x, f);
else
upd2(no << 1 | 1, mid + 1, r, x, f);
}
void dij(long long S) {
build(1, 1, n);
upd(1, 1, n, S, 0);
for (long long i = 1; i < n; i++) {
long long k = mn[1].p;
long long f = mn[1].f;
del(1, 1, n, k);
for (vector<E>::iterator it = t[k].begin(); it != t[k].end(); it++) {
upd(1, 1, n, it->t, f + it->w);
}
for (vector<E2>::iterator it = t2[k].begin(); it != t2[k].end(); it++) {
upd(1, 1, n, it->l, it->r, f + it->w);
}
upd2(1, 1, n, k, f);
}
}
void outp(long long no, long long l, long long r) {
if (l == r)
printf("%lld ", mn[no].f == inf ? -1 : mn[no].f);
else {
psdw(no);
long long mid = (l + r) >> 1;
outp(no << 1, l, mid);
outp(no << 1 | 1, mid + 1, r);
}
}
int main() {
scanf("%lld%lld%lld", &n, &q, &s);
for (long long i = 1; i <= q; i++) {
long long typ;
scanf("%lld", &typ);
if (typ == 1) {
long long v, u, w;
scanf("%lld%lld%lld", &v, &u, &w);
t[v].push_back(E(u, w));
} else if (typ == 2) {
long long v, l, r, w;
scanf("%lld%lld%lld%lld", &v, &l, &r, &w);
t2[v].push_back(E2(l, r, w));
} else {
long long v, l, r, w;
scanf("%lld%lld%lld%lld", &v, &l, &r, &w);
ins(1, 1, n, l, r, E(v, w));
}
}
dij(s);
outp(1, 1, n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
struct Edge {
int l, r, u, v;
Edge() { l = r = u = v = 0; }
Edge(int _l, int _r, int _u, int _v) {
l = _l;
r = _r;
u = _u;
v = _v;
}
void input(void) const { scanf("%d %d %d %d", &u, &v, &l, &r); }
bool operator<(const Edge &o) const {
if (l == o.l) return r < o.r;
return l < o.l;
}
};
Edge ed[N];
int n, m;
int p[N];
void init() {
for (int i = 0; i < N; i++) p[i] = i;
}
int Find(int u) {
if (u == p[u]) return u;
return p[u] = Find(p[u]);
}
bool isSameSet(int u, int v) { return Find(u) == Find(v); }
void Union(int u, int v) {
if (isSameSet(u, v)) return;
u = Find(u), v = Find(v);
p[u] = v;
}
int en[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
ed[i].input();
en[i] = ed[i].r;
}
sort(ed + 1, ed + 1 + m);
sort(en + 1, en + 1 + m);
int cnt = unique(en + 1, en + 1 + m) - en - 1;
int ans = 0;
for (int i = 1; i <= cnt; i++) {
init();
int R = en[i];
for (int j = 1; j <= m; j++) {
if (ed[j].r < R) continue;
Union(ed[j].u, ed[j].v);
if (isSameSet(1, n)) {
ans = max(ans, R - ed[j].l + 1);
}
}
}
if (ans == 0) {
printf("Nice work, Dima!");
} else
printf("%d", ans);
}
| 6 |
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f;
template <typename T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <typename T>
T read(T &first) {
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (first = 0; isdigit(ch); ch = getchar()) first = 10 * first + ch - '0';
return first *= f;
}
template <typename T>
void write(T first) {
if (first == 0) {
putchar('0');
return;
}
if (first < 0) {
putchar('-');
first = -first;
}
static char s[20];
int top = 0;
for (; first; first /= 10) s[++top] = first % 10 + '0';
while (top) putchar(s[top--]);
}
const int MAXN = 1e3 + 5, MAXM = 5e5 + 5, MAXQ = 5e5 + 5;
struct Query {
int l, r;
int s, t;
int id;
bool operator<(const Query &rhs) const { return l < rhs.l; }
};
int N, M, Q;
std::pair<int, int> E[MAXM];
Query QRY[MAXQ];
void input() {
read(N);
read(M);
read(Q);
for (int i = 1; i <= M; ++i) {
read(E[i].first);
read(E[i].second);
}
for (int i = 1; i <= Q; ++i) {
read(QRY[i].l);
read(QRY[i].r);
read(QRY[i].s);
read(QRY[i].t);
QRY[i].id = i;
}
}
void solve() {
std::sort(QRY + 1, QRY + Q + 1);
static int dp[MAXN][MAXN];
static bool ans[MAXQ];
memset(dp, +oo, sizeof(dp));
for (int i = 1; i <= N; ++i) {
dp[i][i] = 0;
}
for (int i = M, j = Q; i >= 1; --i) {
int u = E[i].first, v = E[i].second;
for (int k = 1; k <= N; ++k) {
chkmin(dp[u][k], std::max(i, dp[v][k]));
chkmin(dp[v][k], std::max(i, dp[u][k]));
}
for (; j >= 1 && QRY[j].l == i; --j) {
ans[QRY[j].id] = dp[QRY[j].s][QRY[j].t] <= QRY[j].r;
}
}
for (int i = 1; i <= Q; ++i) {
puts(ans[i] ? "Yes" : "No");
}
}
int main() {
input();
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
bool f = 0;
char c = getchar();
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 1005;
int n, m, q, mid;
bitset<N> a[N], b, A;
unordered_map<bitset<N>, int> mp;
void doit() {
int ans = m + 1, n, x;
read(n);
A.reset();
while (n--) A[read(x)] = 1;
for (int s = 0, c; s < 1 << m - mid; s++) {
b.reset();
c = 0;
for (int i = 0; i < m - mid; i++)
if (s >> i & 1) b ^= a[mid + i], c++;
if (mp.count(A ^ b)) ans = min(ans, c + mp[A ^ b]);
}
write(ans > m ? -1 : ans);
puts("");
}
signed main() {
read(n);
read(m);
read(q);
for (int i = 0, n, x; i < m; i++) {
read(n);
while (n--) a[i][read(x)] = 1;
}
mid = min(m, 20);
for (int s = 0, c; s < 1 << mid; s++) {
b.reset();
c = 0;
for (int i = 0; i < mid; i++)
if (s >> i & 1) b ^= a[i], c++;
if (mp.count(b))
mp[b] = min(mp[b], c);
else
mp[b] = c;
}
while (q--) doit();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m[11];
long long a[200005];
int main() {
long long n, k, ans = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
long long x = a[i];
for (int j = 1; j <= 10; j++) {
x = x * 10 % k;
m[j][x]++;
}
}
for (int i = 0; i < n; i++) {
int len = log10(a[i]) + 1;
ans += m[len][(k - a[i] % k) % k];
long long x = 1;
for (int j = 0; j < len; j++) x = x * 10 % k;
if ((a[i] * x % k + a[i] % k) % k == 0) ans--;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double doINF = 1.0 / 0.0;
ostream_iterator<int> outp(cout, " ");
inline long long modadd(long long n, long long m, long long mod) {
long long sum = ((n + m) % mod + mod) % mod;
return sum;
}
inline long long modsub(long long n, long long m, long long mod) {
long long diff = ((n - m + mod) % mod + mod) % mod;
return diff;
}
inline long long modpro(long long n, long long m, long long mod) {
long long pro = ((n * m) % mod + mod) % mod;
return pro;
}
inline long long pow(int x, int y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
inline long long powmod(long long x, long long y, long long mod) {
long long res = 1;
while (y > 0) {
if (y & 1) res = modpro(res, x, mod);
y = y >> 1;
x = modpro(x, x, mod);
}
return res;
}
bool pairdec(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first)
return (a.first > b.first);
else
return a.second > b.second;
}
long long power(long long x, long long y, long long mod) {
long long res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long modInverse(long long a, long long mod) {
return powmod(a, mod - 2, mod);
}
long long modFact(long long n, long long mod) {
if (n >= mod) return 0;
long long result = 1;
for (long long i = 1; i <= n; i++) result = (result * i) % mod;
return result;
}
const int N = 1e5;
int main() {
int t;
cin >> t;
set<long long> s;
for (int i = 1; i < 7; i++) s.insert(i);
while (t--) {
long long num;
cin >> num;
if (s.find(num % 14) != s.end() && num > 14)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int up = 707;
int n;
int arr[up];
int dp[2][up][up];
int gcd(int a, int b) {
if (a == 0 || b == 0) {
return a + b;
}
int r = a % b;
while (r) {
a = b;
b = r;
r = a % b;
}
return b;
}
int solve(int l, int r, int par, int child) {
if (l > r) return 1;
if (dp[child][l][r] != -1) return dp[child][l][r];
for (int i = l; i <= r; i++) {
if (gcd(par, arr[i]) != 1) {
if (solve(l, i - 1, arr[i], 0) && solve(i + 1, r, arr[i], 1))
return dp[child][l][r] = 1;
else
dp[child][l][r] = 0;
}
}
return 0;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof(dp));
if (solve(1, n, 0, 0)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n, m, c, p, a[1001];
int main() {
register int i;
scanf("%d%d%d", &n, &m, &c);
while (m--) {
scanf("%d", &p);
if (p <= c / 2) {
for (i = 1; i <= n; ++i)
if (a[i] > p || !a[i]) break;
a[i] = p;
printf("%d\n", i);
fflush(stdout);
} else {
for (i = n; i >= 1; --i)
if (a[i] < p || !a[i]) break;
a[i] = p;
printf("%d\n", i);
fflush(stdout);
}
register bool ok = 1;
for (i = 1; i <= n && ok; ++i) ok &= a[i];
for (i = 2; i <= n && ok; ++i) ok &= a[i] > a[i - 1];
if (ok) return 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
scanf("%d%d", &n, &k);
int kk = 0;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) ++kk;
if (n * (n - 1) / 2 <= k) {
printf("no solution\n");
return 0;
}
for (int i = 0; i < n; ++i) printf("%d %d\n", 0, i);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ask(int x) {
cout << "? " << x << endl;
cout << "? " << x + n / 2 << endl;
int a, b;
cin >> a >> b;
if (a == b) {
cout << "! " << x << endl;
exit(0);
}
return a < b;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
cerr << fixed << setprecision(6);
cin >> n;
if (n % 4 == 2) {
cout << "! -1\n";
return 0;
}
int po = 1;
int ko = 1 + n / 2;
int jak = ask(1);
while (1) {
int m = (po + ko) / 2;
if (ask(m) == jak) {
po = m;
} else {
ko = m;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 3)
cout << 1 << endl;
else if (n == 1)
cout << 2 << endl;
else if (n == 4)
cout << 2 << endl;
else if (n == 2)
cout << 3 << endl;
else if (n == 5)
cout << 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct func {
int numt;
int type[5];
};
struct templ {
int num;
func f[1500];
};
templ fff[1002];
func g_funtmp;
int g_now;
map<string, int> mapind;
map<string, int> can;
map<string, int> mapvari;
int g_ind;
char ss[20000];
char funname[2000], sztmpv[2000], vari[2000];
int g_type[5], g_tmpnum;
int getfirst(char *name) {
int i = 0;
while (name[i] == ' ') i++;
return i + 4;
}
void getfunname(char *sz, int iflg) {
int i = 0;
int ty[5], tmpind, tt;
while (sz[i] == ' ') i++;
int j;
for (j = 0; sz[i] != '(' && sz[i] != ' '; i++) {
funname[j++] = sz[i];
}
funname[j] = 0;
while (sz[i] == ' ' || sz[i] == '(') i++;
if (!mapind[funname]) {
if (iflg == 1)
mapind[funname] = ++g_ind;
else {
g_now = -1;
return;
}
}
g_now = mapind[funname];
memset(g_type, 0, sizeof(g_type));
g_tmpnum = 0;
int flg = 1;
int funnum = fff[g_now].num;
for (j = 0; sz[i]; i++) {
if (sz[i] == ' ') continue;
if (sz[i] == ',' || sz[i] == ')') {
sztmpv[j] = 0;
if (iflg == 1) {
g_type[g_tmpnum++] = can[sztmpv];
} else
g_type[g_tmpnum++] = mapvari[sztmpv];
if (sz[i] == ')') break;
j = 0;
} else {
sztmpv[j++] = sz[i];
}
}
}
int main() {
int n, m, t, itmp;
can["int"] = 1;
can["double"] = 2;
can["string"] = 3;
can["T"] = 4;
scanf("%d\n", &n);
int i, j, ind, tt;
for (tt = 0; tt < n; tt++) {
gets(ss);
j = getfirst(ss);
getfunname(ss + j, 1);
memcpy(fff[g_now].f[fff[g_now].num].type, g_type, sizeof(g_type));
fff[g_now].f[fff[g_now].num].numt = g_tmpnum;
fff[g_now].num++;
}
scanf("%d\n", &m);
for (tt = 0; tt < m; tt++) {
i = j = 0;
gets(ss);
while (ss[j] == ' ') j++;
while (ss[j] != ' ') sztmpv[i++] = ss[j++];
sztmpv[i] = 0;
i = 0;
while (ss[j] == ' ') j++;
while (ss[j] != ' ') vari[i++] = ss[j++];
vari[i] = 0;
mapvari[vari] = can[sztmpv];
}
scanf("%d\n", &t);
int ans, flg;
for (tt = 0; tt < t; tt++) {
gets(ss);
getfunname(ss, 0);
if (g_now == -1) {
puts("0");
continue;
}
ind = mapind[funname];
ans = 0;
for (i = 0; i < fff[ind].num; i++) {
if (g_tmpnum == fff[ind].f[i].numt) {
flg = 1;
for (j = 0; j < g_tmpnum; j++) {
if (g_type[j] & 0x4 || fff[ind].f[i].type[j] & 0x4 ||
g_type[j] == fff[ind].f[i].type[j])
continue;
flg = 0;
break;
}
if (flg) ans++;
}
}
printf("%d\n", ans);
}
}
| 5 |
#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<memory.h>
#include<cmath>
#include<fstream>
#define FAST ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
typedef long long ll;
const int Max = 1e6 + 5;
ll lst[Max];
int prim[Max], vis[Max], x = 0;
void eratos(int n)
{
for (int i = 2;i <= n;i++)
{
if (!vis[i])prim[++x] = i;
if (vis[i])continue;
for (int j = 2;j * i <= n;j++)
{
vis[i * j] = 1;
}
}
}
int main()
{
FAST;
int t;cin >> t;
eratos(100000);
while (t--)
{
int d;cin >> d;
int b = lower_bound(prim + 1, prim + 1 + x, 1 + d) - prim;
int c = lower_bound(prim + 1, prim + 1 + x, prim[b] + d) - prim;
cout << prim[b] * prim[c] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void answer() {
long long ans = 0, m, n;
cin >> n;
long long a[n + 2];
for (int i = 0; i < n; i++) cin >> a[i];
a[n] = 99999999999;
int p = 0, p1 = 0;
for (int i = 0; i < n; i++) {
if (a[i] < 0) {
ans += abs(a[i]) - 1;
p1++;
} else if (a[i] > 0)
ans += a[i] - 1;
else
p++;
}
if (p1 % 2 == 1 && p == 0) ans += 2;
ans += p;
cout << ans;
}
int main() {
int q;
answer();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string simplify(string s) {
string a;
for (int i = 0; i < s.length(); i++) {
if (isalpha(s[i])) {
s[i] = tolower(s[i]);
a.push_back(s[i]);
}
}
return a;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
s1 = simplify(s1);
s2 = simplify(s2);
s3 = simplify(s3);
int x = s1.length(), y = s2.length(), z = s3.length();
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
s = simplify(s);
if (s.length() == x + y + z &&
(s == s1 + s2 + s3 || s == s1 + s3 + s2 || s == s2 + s1 + s3 ||
s == s2 + s3 + s1 || s == s3 + s1 + s2 || s == s3 + s2 + s1))
cout << "ACC\n";
else
cout << "WA\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int n, m, k;
int arr[N][N];
int dfs(int i, int j) {
if (i == n) return j;
if (arr[i][j] == 1) {
arr[i][j] = 2;
return dfs(i, j + 1);
} else if (arr[i][j] == 2) {
return dfs(i + 1, j);
} else {
arr[i][j] = 2;
return dfs(i, j - 1);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
vector<int> ans;
while (k--) {
int a;
cin >> a;
a--;
ans.push_back(dfs(0, a));
}
for (int i : ans) cout << i + 1 << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double s, x1, x2;
cin >> s >> x1 >> x2;
double t1, t2;
cin >> t1 >> t2;
double p, d;
cin >> p >> d;
double igorTime = abs(x2 - x1) * t2, igorDir = (x2 - x1) / abs(x2 - x1),
tramTime, val = (d == 1 ? s : 0), otherVal = (d == 1 ? 0 : s);
if (t1 >= t2) {
cout << igorTime;
} else {
if (igorDir * d == -1) {
tramTime = (abs(p - val) + abs(x2 - val)) * t1;
} else if ((d == 1 && p <= x1) || (d == -1 && p >= x1)) {
tramTime = abs(x2 - p) * t1;
} else {
tramTime = (abs(p - val) + s + abs(x2 - otherVal)) * t1;
}
cout << min(igorTime, tramTime);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long n_ = 1e5 + 1000;
const long double PI = acos(-1.0);
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
class UnionFind {
private:
vector<long long> p, rank, setSize;
long long numSets;
public:
UnionFind(long long N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (long long i = 0; i < N; i++) p[i] = i;
}
long long findSet(long long i) {
return (p[i] == i) ? i : (p[i] = findSet(p[i]));
}
bool isSameSet(long long i, long long j) { return findSet(i) == findSet(j); }
void unionSet(long long i, long long j) {
if (!isSameSet(i, j)) {
numSets--;
long long x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
long long numDisjointSets() { return numSets; }
long long sizeOfSet(long long i) { return setSize[findSet(i)]; }
};
vector<long long> adj[100005];
vector<long long> vis(100005, 0);
vector<long long> p(100005, 0);
vector<long long> sz(100005, 0);
long long dfs(long long i) {
vis[i] = 1;
if (p[i]) sz[i] = 1;
for (long long j : adj[i]) {
if (!vis[j]) {
sz[i] += dfs(j);
}
}
return sz[i];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x, y, t;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> x >> y >> t;
adj[x].push_back(y);
adj[y].push_back(x);
if (t == 2) {
p[x] = 1;
p[y] = 1;
}
}
dfs(1);
vector<long long> ans;
for (long long i = 1; i <= n; i++)
if (sz[i] == 1) ans.push_back(i);
cout << ans.size() << "\n";
for (long long i : ans) cout << i << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int N;
scanf("%d", &N);
int i;
for (i = 0; i < N; i++) {
int p, t = 0;
scanf("%d", &p);
char s[p + 1];
scanf("%s", s);
int j, k = 0;
for (j = 0; j < p - 1; j++) {
if ((s[j] == 'A') && (s[j + 1] == 'P')) {
t++;
}
}
if (t == 0)
k = 0;
else {
t = 1;
while (t != 0) {
t = 0;
for (j = 0; j < p - 1; j++) {
if ((s[j] == 'A') && (s[j + 1] == 'P')) {
s[j + 1] = 'A';
j++;
}
}
k++;
for (j = 0; j < p - 1; j++) {
if ((s[j] == 'A') && (s[j + 1] == 'P')) {
t++;
}
}
}
}
printf("%d\n", k);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int d[1000011], a, b, n, m;
int main() {
memset(d, 0, sizeof(d));
scanf("%d%d", &n, &m);
long long r = n * (n - 1ll) * (n - 2) / 6;
while (m--) {
scanf("%d%d", &a, &b);
r -= n - (++d[a]) - (++d[b]);
}
printf("%I64d\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, n, b, c, i, j, x, y;
int main() {
scanf("%lld%lld%lld%lld", &n, &x, &y, &c);
b = x / 2 + y;
for (i = 0; i <= b; i++) {
for (j = 0; j <= c; j++) {
if (i + j * 2 == n) {
if (j * 2 == n) {
ans++;
continue;
}
if (max(x / 2, y) >= i)
ans += min(i + 1, min(x / 2, y) + 1);
else
ans += min(x / 2, y) - (i - max(x / 2, y)) + 1;
}
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const int mod = 998244353;
long long a[N];
long long rem[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long res = 0;
for (int j = 0; j < log2(1e7) + 2; ++j) {
int den = 1 << (j + 1);
for (int i = 0; i < n; ++i) {
rem[i] = (a[i] % den);
}
sort(rem, rem + n);
int cnt = 0;
for (int i = 0; i < n - 1; ++i) {
cnt += upper_bound(rem + i + 1, rem + n, (1 << (j + 2)) - 2 - rem[i]) -
lower_bound(rem + i + 1, rem + n,
(1 << (j + 1)) + (1 << (j)) - rem[i]) +
upper_bound(rem + i + 1, rem + n, (1 << (j + 1)) - rem[i] - 1) -
lower_bound(rem + i + 1, rem + n, (1 << (j)) - rem[i]);
}
if (cnt & 1) res |= 1 << (j);
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
long long T;
cin >> T;
while (T-- > 0) {
long long l, r;
cin >> n >> l >> r;
long long cnt = 0;
for (int i = 1; i <= n - 1; ++i) {
long long p = max(l, cnt + 1), q = min(cnt + 2 * (n - i), r);
p -= cnt, q -= cnt;
cnt += 2 * (n - i);
if (q < p) continue;
if (p % 2 == 0) cout << i + p / 2 << ' ', ++p;
for (int j = i + (p + 1) / 2; j <= i + q / 2; ++j)
cout << i << ' ' << j << ' ';
if (q & 1) cout << i << ' ';
}
if (r == n * (n - 1) + 1) cout << 1;
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
vector<ll> pos;
vector<ll> subt;
vector<ll> preord;
vector<vector<ll>> adj;
ll dfs(ll p, ll par) {
pos[p] = (ll)preord.size();
preord.push_back(p);
ll ret = 1;
for (ll i = 0; i < (ll)adj[p].size(); i++)
if (adj[p][i] != par) {
ret += dfs(adj[p][i], p);
}
subt[p] = ret;
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, q;
cin >> n >> q;
pos.resize(n);
subt.assign(n, 0);
adj.resize(n);
for (ll i = 0; i < (ll)n - 1; i++) {
ll p;
cin >> p;
p--;
adj[i + 1].push_back(p);
adj[p].push_back(i + 1);
}
for (ll i = 0; i < (ll)n; i++) sort(adj[i].begin(), adj[i].end());
dfs(0, -1);
for (ll i = 0; i < (ll)q; i++) {
ll u, k;
cin >> u >> k;
u--;
if (k > subt[u])
cout << -1 << endl;
else {
cout << preord[pos[u] + (k - 1)] + 1 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> a(n);
vector<int> s(m);
set<int> d;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < m; ++i) {
int mx = 0;
for (int j = 0; j < n; ++j) {
int temp = (int)(a[j][i] - '0');
mx = max(temp, mx);
}
s[i] = mx;
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
int temp = (int)(a[j][i] - '0');
if (s[i] == temp) d.insert(j);
}
}
cout << d.size();
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long oo = 1e18 + 7, mod = 1e9 + 7;
const long long N = 1e5 + 5;
string s;
string s2;
vector<long long> vc;
long long val(long long l, long long r) {
if (l > r) return 0;
long long ans = 0, temp = 1;
for (long long i = l; i <= r; i++) {
if (s[i] == '+') {
temp *= (s[i - 1] - '0');
ans += temp;
temp = 1;
} else if (s[i] == '*') {
temp *= (s[i - 1] - '0');
}
}
temp *= (s[r] - '0');
ans += temp;
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin >> s;
vc.push_back(-1);
for (long long i = 0; i < s.length(); i++) {
if (s[i] == '*') vc.push_back(i);
}
vc.push_back(s.length());
long long maxi = val(0, s.length() - 1);
for (long long i = 0; i < vc.size(); i++) {
for (long long j = i + 1; j < vc.size(); j++) {
long long itr1 = vc[i] + 1, itr2 = vc[j] - 1, pro = 1;
itr1--;
itr2++;
while (itr1 >= 0 && s[itr1] != '+') {
if (s[itr1] >= '1' && s[itr1] <= '9') pro *= (s[itr1] - '0');
itr1--;
}
while (itr2 < s.length() && s[itr2] != '+') {
if (s[itr2] >= '1' && s[itr2] <= '9') pro *= (s[itr2] - '0');
itr2++;
}
maxi = max(maxi, val(0, itr1 - 1) + pro * val(vc[i] + 1, vc[j] - 1) +
val(itr2 + 1, s.length() - 1));
}
}
cout << maxi;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 300010;
int v[MAXN][26];
int qtd[MAXN];
int ans[MAXN];
int dfs(int x) {
int ans = 1;
for (int i = 0; i < (26); ++i)
if (v[x][i]) ans += dfs(v[x][i]);
return qtd[x] = ans;
}
vector<pair<int, int> > newvtxs;
int beg;
int n;
void dfs2(int v1, int v2) {
for (int i = 0; i < (26); ++i)
if (v[v1][i]) {
if (!v[v2][i]) {
newvtxs.push_back(make_pair(v2, i));
v[v2][i] = beg++;
}
dfs2(v[v1][i], v[v2][i]);
}
}
int solve(int x) {
int maxvtx = -1, maxqtd = -1;
int oldtot = qtd[x];
for (int i = 0; i < (26); ++i) {
if (v[x][i] && qtd[v[x][i]] > maxqtd) {
maxqtd = qtd[v[x][i]];
maxvtx = i;
}
}
if (maxvtx == -1) return 0;
newvtxs.clear();
beg = n + 1;
for (int i = 0; i < (26); ++i)
if (i != maxvtx && v[x][i]) {
dfs2(v[x][i], v[x][maxvtx]);
}
int newtot = maxqtd + (int)((newvtxs).size());
for (int i = 0; i < ((int)((newvtxs).size())); ++i) {
v[newvtxs[i].first][newvtxs[i].second] = 0;
}
return newtot - oldtot;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < (n - 1); ++i) {
int x, y;
char w;
cin >> x >> y >> w;
v[x][w - 'a'] = y;
}
dfs(1);
queue<pair<int, int> > q;
q.push({1, 0});
for (int i = 0; i < (n); ++i) ans[i] = n;
int pans, minans = 0x3f3f3f3f;
while (!q.empty()) {
int lvl = q.front().second;
int vtx = q.front().first;
ans[lvl] += solve(vtx);
if (ans[lvl] < minans) {
minans = ans[lvl];
pans = lvl;
} else if (ans[lvl] == minans)
pans = min(pans, lvl);
q.pop();
for (int i = 0; i < (26); ++i)
if (v[vtx][i]) q.push({v[vtx][i], lvl + 1});
}
cout << minans << endl << pans + 1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-O2")
const int N = 1e5 + 5, MOD = 1e9 + 7;
int n;
int main() {
scanf("%d", &n);
if (n < 0) {
n = -n;
n = 10 * (n / 100) +
((n % 10) < ((n / 10) % 10) ? (n % 10) : ((n / 10) % 10));
n = -n;
}
printf("%d", n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct SEG {
int h, l, r, i;
SEG() {}
SEG(int a, int b, int c, int d) : h(a), l(b), r(c), i(d) {}
bool operator<(const SEG &x) const {
if (h != x.h) return h < x.h;
if (l != x.l) return l < x.l;
if (r != x.r) return r < x.r;
return 0;
}
};
SEG a[maxn];
struct SEGT {
int sz, arr[maxn << 2], lazy[maxn << 2];
void init(int _n) {
sz = 1;
while (sz <= _n) sz <<= 1;
memset(arr, -1, sizeof arr);
memset(lazy, -1, sizeof lazy);
}
inline void pushdown(int i) {
if (~lazy[i]) {
arr[i] = lazy[i];
if (i < sz) {
lazy[i << 1] = lazy[i];
lazy[i << 1 | 1] = lazy[i];
}
lazy[i] = -1;
}
}
void set(int a, int b, int i, int l, int r, int val) {
pushdown(i);
if (l <= a && b <= r) {
lazy[i] = val;
pushdown(i);
return;
}
if (r <= a || b <= l) {
return;
}
set(a, (a + b) >> 1, i << 1, l, r, val);
set((a + b) >> 1, b, i << 1 | 1, l, r, val);
if (!~arr[i << 1 | 1] || ::a[arr[i << 1]].h < ::a[arr[i << 1 | 1]].h)
arr[i] = arr[i << 1];
else
arr[i] = arr[i << 1 | 1];
}
int get(int a, int b, int i, int l, int r) {
pushdown(i);
if (l <= a && b <= r) return arr[i];
if (r <= a || b <= l) return -1;
int x = get(a, (a + b) >> 1, i << 1, l, r);
int y = get((a + b) >> 1, b, i << 1 | 1, l, r);
if (!~x) return y;
if (!~y) return x;
if (::a[x].h < ::a[y].h) return x;
return y;
}
};
SEGT segt;
vector<int> g[maxn];
int n, t, h[maxn], l[maxn], r[maxn], v[maxn], m, dp[maxn];
int solvedp(int u) {
if (~dp[u]) return dp[u];
int ans = 0;
for (int v : g[u]) {
int c = min(r[u], r[v]) - max(l[u], l[v]);
ans = max(ans, min(solvedp(v), c));
}
return dp[u] = ans;
}
int main() {
scanf("%d%d", &n, &t);
v[m++] = -1e9;
v[m++] = 1e9;
l[n] = l[n + 1] = -1e9;
r[n] = r[n + 1] = 1e9;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", h + i, l + i, r + i);
v[m++] = l[i];
v[m++] = r[i];
a[i] = SEG(h[i], l[i], r[i], i);
}
a[n] = SEG(0, -1e9, 1e9, n);
a[n + 1] = SEG(t, -1e9, 1e9, n + 1);
sort(a, a + n + 2);
sort(v, v + m);
m = unique(v, v + m) - v;
segt.init(m);
for (int i = 0; i <= n + 1; i++) a[i].h *= -1;
segt.set(0, segt.sz, 1, 0, m - 1, 0);
for (int i = 1; i <= n + 1; i++) {
int l = lower_bound(v, v + m, a[i].l) - v;
int r = lower_bound(v, v + m, a[i].r) - v;
int x;
x = segt.get(0, segt.sz, 1, l, l + 1);
if (~x) {
int l1 = lower_bound(v, v + m, a[x].l) - v;
int r1 = lower_bound(v, v + m, a[x].r) - v;
if (segt.get(0, segt.sz, 1, max(l1, l), min(r, r1)) == x)
g[a[i].i].push_back(a[x].i);
}
x = segt.get(0, segt.sz, 1, r, r + 1);
if (~x) {
int l1 = lower_bound(v, v + m, a[x].l) - v;
int r1 = lower_bound(v, v + m, a[x].r) - v;
if (segt.get(0, segt.sz, 1, max(l1, l), min(r, r1)) == x)
g[a[i].i].push_back(a[x].i);
}
segt.set(0, segt.sz, 1, l, r + 1, i);
}
for (int i = 0; i <= n + 1; i++) a[i].h *= -1;
segt.set(0, segt.sz, 1, 0, m - 1, n + 1);
for (int i = n; i >= 0; i--) {
int l = lower_bound(v, v + m, a[i].l) - v;
int r = lower_bound(v, v + m, a[i].r) - v;
int x;
x = segt.get(0, segt.sz, 1, l, l + 1);
if (~x) {
int l1 = lower_bound(v, v + m, a[x].l) - v;
int r1 = lower_bound(v, v + m, a[x].r) - v;
if (segt.get(0, segt.sz, 1, max(l1, l), min(r, r1)) == x)
g[a[x].i].push_back(a[i].i);
}
x = segt.get(0, segt.sz, 1, r, r + 1);
if (~x) {
int l1 = lower_bound(v, v + m, a[x].l) - v;
int r1 = lower_bound(v, v + m, a[x].r) - v;
if (segt.get(0, segt.sz, 1, max(l1, l), min(r, r1)) == x)
g[a[x].i].push_back(a[i].i);
}
segt.set(0, segt.sz, 1, l, r, i);
}
for (int i = 0; i <= n + 1; i++) {
sort(g[i].begin(), g[i].end());
g[i].erase(unique(g[i].begin(), g[i].end()), g[i].end());
}
memset(dp, -1, sizeof dp);
dp[n] = 2e9;
printf("%d\n", solvedp(n + 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
vector<int> v[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i <= n; i++) v[i].clear();
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
}
priority_queue<int, vector<int>, greater<int> > q;
long long ans = 0;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < v[i].size(); j++) q.push(v[i][j]);
while (q.size() > n - i) ans += q.top(), q.pop();
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<pair<long long, long long> > a;
void read() {
cin >> n;
a.resize(n);
for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
}
long long fo3(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return abs(a.first - b.first) + abs(a.second - b.second) +
abs(b.first - c.first) + abs(b.second - c.second) +
abs(a.first - c.first) + abs(a.second - c.second);
}
long long ans3, ans4;
void run() {
vector<pair<long long, long long> > op;
long long minx = 1e9, maxx = -1e9, miny = 1e9, maxy = -1e9;
sort(a.begin(), a.end());
for (auto i : a) {
maxx = max(maxx, i.first);
minx = min(minx, i.first);
maxy = max(maxy, i.second);
miny = min(miny, i.second);
}
for (auto i : a) {
if (i.first == minx || i.first == maxx || i.second == miny ||
i.second == maxy)
op.push_back(i);
}
pair<long long, long long> a1, a2, a3, a4;
a1.first = minx;
a1.second = miny;
a2.first = minx;
a2.second = maxy;
a3.first = maxx;
a3.second = miny;
a4.first = maxx;
a4.second = maxy;
bool f = false;
for (auto i : op) {
if (i == a1 || i == a2 || i == a3 || i == a4) {
f = true;
}
}
if (f) {
ans3 = (abs(maxx - minx) + abs(maxy - miny)) * 2;
ans4 = ans3;
} else {
ans3 = 0, ans4 = (abs(maxx - minx) + abs(maxy - miny)) * 2;
for (long long i = 0; i < op.size(); i++) {
for (long long j = i + 1; j < op.size(); j++) {
for (long long k = 0; k < a.size(); k++) {
ans3 = max(fo3(op[i], op[j], a[k]), ans3);
}
}
}
}
}
void write() {
cout << ans3 << " ";
for (long long i = 0; i < n - 3; i++) cout << ans4 << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
run();
write();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
vector<pair<long long, long long>> g[maxn];
long long rest = 0;
long long ans1 = 0, ans2 = 0;
bool dfs(long long v, long long p = -1) {
long long cnt = 1;
for (auto &[u, c] : g[v]) {
if (u == p) continue;
if (dfs(u, v)) {
ans1 += c;
cnt++;
}
}
return (cnt & 1);
}
long long dfs2(long long v, long long p = -1) {
long long cnt = 1;
for (auto &[u, c] : g[v]) {
if (u == p) continue;
long long res = dfs2(u, v);
ans2 += res * c;
cnt += res;
}
long long mn = min(cnt, rest - cnt);
rest -= (cnt - mn);
return mn;
}
void solve() {
long long k;
cin >> k;
rest = 2 * k;
for (long long i = 0; i < 2 * k - 1; i++) {
long long u, v, t;
cin >> u >> v >> t;
g[u].emplace_back(v, t);
g[v].emplace_back(u, t);
}
dfs(1);
dfs2(1);
cout << ans1 << " " << ans2 << "\n";
for (long long i = 1; i <= 2 * k; i++) {
g[i].clear();
}
ans1 = 0, ans2 = 0;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[11];
int i;
int main() {
bool ok = true;
for (i = 0; i < 8; i++) {
scanf("%s", s);
for (int j = 0; j < 7; j++)
if (s[j] == s[j + 1]) ok = false;
if (s[0] == s[7]) ok = false;
}
if (ok)
puts("YES");
else
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n;
string s;
string ans = "";
map<char, long long> m;
bool check(long long x) {
ans = "";
set<pair<long long, char> > st;
for (auto it : m) {
ans += it.first;
if (it.second - x > 0) st.insert({it.second - x, it.first});
}
while (ans.size() < n) {
if (!st.size()) break;
auto it = *st.begin();
st.erase(it);
ans += it.second;
it.first -= x;
if (it.first > 0) st.insert({it.first, it.second});
}
while (ans.size() < n) ans += 'a';
return (st.size() == 0);
}
long long binsearch(long long lo, long long hi) {
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (check(mid))
hi = mid;
else
lo = mid + 1;
}
check(lo);
return lo;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s >> n;
for (auto &it : s) m[it]++;
if (n < m.size()) {
cout << -1;
return 0;
}
long long answer = binsearch(1, 1e5);
cout << answer << "\n";
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
char c[1010][1010];
int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int vis[1010][1010];
struct s {
int x, y, st;
friend bool operator<(const s &a, const s &b) { return a.st > b.st; }
};
int main() {
int n, m, k, i, j, x1, y1, x2, y2, xx, yy;
while (~scanf("%d %d %d", &n, &m, &k)) {
for (i = 1; i <= n; i++) {
scanf("%s", c[i] + 1);
}
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (c[x1][y1] == '#' || c[x2][y2] == '#') {
printf("-1\n");
continue;
}
memset(vis, -1, sizeof(vis));
priority_queue<s> q;
q.push({x1, y1, 0});
vis[x1][y1] = 0;
while (!q.empty()) {
s pos = q.top();
q.pop();
for (i = 0; i < 4; i++) {
for (j = 1; j <= k; j++) {
xx = pos.x + dir[i][0] * j;
yy = pos.y + dir[i][1] * j;
if (xx >= 1 && xx <= n && yy >= 1 && yy <= m && c[xx][yy] == '.' &&
(pos.st + 1 < vis[xx][yy] || vis[xx][yy] == -1)) {
q.push({xx, yy, pos.st + 1});
vis[xx][yy] = pos.st + 1;
} else {
break;
}
}
}
}
printf("%d\n", vis[x2][y2]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 2e5 + 200;
int a[ms];
int del[ms];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int l = 0, r = 0;
int ans = 0, cnt = 0;
while (r < n) {
if (del[l]) {
l++;
cnt--;
continue;
}
while (r < n && a[r] - a[l] < m) {
if (r - l + 1 - cnt == k) {
cnt++;
ans++;
del[r] = 1;
}
r++;
}
if (del[l]) cnt--;
l++;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, cnt = 0;
cin >> n;
int a[n + 1][n + 1];
vector<int> v;
vector<int> v1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
int no = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1 || a[i][j] == 3) {
no = 1;
}
}
if (no != 1) {
v.push_back(i + 1);
}
no = 0;
}
if (v.size() == 0) {
cout << "0" << endl;
return 0;
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int R = 3005, C = 3005;
int r, c, n, K, sum[C], prv[C], nxt[C];
vector<int> vec[R];
long long ans, now;
void del(int pos) {
int val = sum[pos], p = pos;
while (nxt[p] <= c && val + sum[nxt[p]] <= K) p = nxt[p], val += sum[p];
if (val == K) now += 1ll * (pos - prv[pos]) * (nxt[p] - p);
for (int j = prv[pos]; j; j = prv[j]) {
val += sum[j];
while (val > K && p > pos) val -= sum[p], p = prv[p];
if (val == K) now += 1ll * (j - prv[j]) * (nxt[p] - p);
if (val > K) break;
}
if (!--sum[pos]) nxt[prv[pos]] = nxt[pos], prv[nxt[pos]] = prv[pos];
}
int main() {
scanf("%d%d%d%d", &r, &c, &n, &K);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
vec[x].push_back(y);
}
ans = 1ll * r * (r + 1) / 2 * c * (c + 1) / 2;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) sum[j] = 0;
for (int j = 1; j <= i; j++) {
for (int k = 0; k < vec[j].size(); k++) sum[vec[j][k]]++;
}
int pos = 0;
for (int j = 1; j <= c; j++) {
if (sum[j]) {
prv[j] = pos, nxt[pos] = j;
pos = j;
}
}
prv[c + 1] = pos, nxt[pos] = c + 1;
pos = 0, now = 0ll;
for (int j = 1, k = 0; j <= c; j++) {
k += sum[j];
while (k >= K) pos++, k -= sum[pos];
now += j - pos;
}
for (int j = 1; j <= i; j++) {
ans -= now;
for (int k = 0; k < vec[j].size(); k++) del(vec[j][k]);
}
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long A, cf, cm, M, c[100100], tot, num, mn, lo, hi, mid, x;
long long ans = -1, ansnum, ansmn, sum[100100], res[100100];
pair<long long, int> id[100100];
long long cost(int n, long long t) {
int j = (int)(lower_bound(c, c + n, t) - c);
return (((long long)j) * t) - (j ? sum[j - 1] : 0);
}
int main() {
scanf("%d %lld %lld %lld %lld", &N, &A, &cf, &cm, &M);
for (int i = 0; i < (N); i++) {
scanf("%lld", &c[i]);
id[i] = {c[i], i};
}
sort(c, c + N);
sort(id, id + N);
for (int i = 0; i < (N); i++) {
sum[i] = c[i];
if (i) sum[i] += sum[i - 1];
}
for (int i = 0; i < (N); i++) tot += A - c[i];
for (int i = 0; i < (N + 1); i++) {
if (tot <= M) {
x = M - tot;
lo = 0, hi = A, mn = 0;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (cost(i, mid) <= x) {
mn = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
num = N - i;
if (cm * mn + cf * num > ans) {
ans = cm * mn + cf * num;
ansnum = num, ansmn = mn;
}
}
tot -= A - c[i];
}
printf("%lld\n", ans);
for (int i = 0; i < (N - ansnum); i++) res[id[i].second] = max(ansmn, c[i]);
for (long long i = N - ansnum; i < N; i++) res[id[i].second] = A;
for (int i = 0; i < (N); i++) printf("%lld ", res[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, i, poz = 1;
cin >> n;
string s = string(n * 2, '(');
for (int i = 0; i < n; i++) s[i * 2 + 1] = ')';
cout << s << '\n';
for (int i = 0; i < n - 1; i++) {
s[i * 2 + 1] = '(';
s[i * 2 + 2] = ')';
cout << s << '\n';
s[i * 2 + 1] = ')';
s[i * 2 + 2] = '(';
}
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
char s[21];
int num = 0, len;
int main() {
gets(s);
len = strlen(s);
printf("%d\n", (len + 1) * 25 + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q, m, in[N], vis[N];
vector<int> adj[N];
set<int> s;
struct edge {
int u, v;
} ed[N];
void readInput() {
cin >> n >> m;
for (int i = 0; i < n; i++) adj[i].clear(), in[i] = 0;
for (int i = 0; i < m; i++) {
int u, v;
bool d;
cin >> d >> u >> v;
ed[i].u = --u, ed[i].v = --v;
if (d) adj[u].push_back(v), in[v]++;
}
}
void solve() {
for (int i = 0; i < n; i++)
if (!in[i]) s.insert(i);
int num = 0;
while (!s.empty()) {
int u = *s.begin();
s.erase(s.begin());
vis[u] = num;
for (auto v : adj[u]) {
in[v]--;
if (!in[v]) s.insert(v);
}
num++;
}
if (num != n) {
cout << "NO" << endl;
return;
}
cout << "YES" << endl;
for (int i = 0; i < m; i++)
if (vis[ed[i].u] < vis[ed[i].v])
cout << ed[i].u + 1 << ' ' << ed[i].v + 1 << endl;
else
cout << ed[i].v + 1 << ' ' << ed[i].u + 1 << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> q;
while (q--) readInput(), solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
string s;
int main() {
cin >> n >> q;
int* servers = new int[n];
for (int i = 0; i < n; i++) servers[i] = 0;
int* t = new int[q];
int* k = new int[q];
int* d = new int[q];
for (int i = 0; i < q; i++) cin >> t[i] >> k[i] >> d[i];
int sumNumbers, free;
int* finish = new int[n];
for (int i = 0; i < n; i++) {
finish[i] = 0;
}
free = n;
for (int i = 0; i < q; i++) {
for (int j = 0; j < n; j++) {
if (finish[j] < t[i] && servers[j] == 1) {
free++;
servers[j] = 0;
}
}
if (free < k[i]) {
cout << -1 << endl;
} else {
sumNumbers = 0;
int count = k[i];
int index = 0;
while (count > 0) {
if (servers[index] == 0) {
count--;
servers[index] = 1;
free--;
sumNumbers += index + 1;
finish[index] = t[i] + d[i] - 1;
}
index++;
}
cout << sumNumbers << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
#define PB push_back
#define MP make_pair
#define REP(i,a,b) for (int i = a; i < b; i++)
#define REPL(i,a,b) for (ll i = a; i < b; i++)
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
// solution comes here
ll n;cin>>n;
array<ll, 2> a[n];
for(ll i=0;i<n;i++){
cin>>a[i][1]>>a[i][0];
}
sort(a,a+n);
ll l=0; ll r=n-1;ll p=0;ll ans=0;
while(l<=r){
if(a[l][0]<=p){
p+=a[l][1];
ans+=a[l][1];
l++;
}
else{
if(a[r][1]+p<=a[l][0]){
p+=a[r][1];
ans+=a[r][1]*2;
r--;
}
else{
a[r][1]-=(a[l][0]-p);
ans+=(a[l][0]-p)*2;
p=a[l][0];
}
}
}
cout<<ans<<endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace combo {
const long long MOD = 998244353;
vector<long long> inv = {-1, 1};
vector<long long> fact = {1, 1};
vector<long long> ifact = {1, 1};
int precalculated = 1;
void calc_factorials(int n) {
if (n <= precalculated) {
return;
}
fact.resize(n + 1);
inv.resize(n + 1);
ifact.resize(n + 1);
for (int i = precalculated + 1; i <= n; i++) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = -MOD / i * inv[MOD % i] % MOD;
ifact[i] = ifact[i - 1] * inv[i] % MOD;
}
precalculated = n;
}
long long choose(int n, int k) {
if (n < k) {
return 0;
}
calc_factorials(n);
return fact[n] * ifact[k] % MOD * ifact[n - k] % MOD;
}
long long permute(int n, int k) {
if (n < k) {
return 0;
}
calc_factorials(n);
return fact[n] * ifact[n - k] % MOD;
}
} // namespace combo
using namespace combo;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long d;
cin >> d;
vector<pair<long long, int>> f;
long long dd = d;
for (long long x = 2; x * x <= dd; x++) {
int e = 0;
while (d % x == 0) {
d /= x;
e++;
}
if (e > 0) {
f.emplace_back(x, e);
}
}
if (d > 1) {
f.emplace_back(d, 1);
}
int q;
cin >> q;
while (q--) {
long long u, v;
cin >> u >> v;
vector<pair<int, int>> exps;
vector<int> diffs;
for (const auto &p : f) {
int a = 0;
while (u % p.first == 0) {
u /= p.first;
a++;
}
int b = 0;
while (v % p.first == 0) {
v /= p.first;
b++;
}
exps.emplace_back(a, b);
diffs.emplace_back(a - b);
}
vector<int> pos, neg;
for (int d : diffs) {
if (d > 0) {
pos.push_back(d);
}
if (d < 0) {
neg.push_back(-d);
}
}
long long ans = 1;
for (int _ = 0; _ < 2; _++) {
int sum = accumulate(pos.begin(), pos.end(), 0);
calc_factorials(sum);
ans *= fact[sum];
ans %= MOD;
for (int d : pos) {
ans *= ifact[d];
ans %= MOD;
}
swap(pos, neg);
}
if (ans < 0) {
ans += MOD;
}
cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long a[maxn];
vector<int> v[maxn];
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = 1; i <= m; i++) {
scanf("%I64d", &a[i]);
if (i > 1) {
ans += abs(a[i] - a[i - 1]);
v[a[i - 1]].push_back(a[i]);
v[a[i]].push_back(a[i - 1]);
}
}
printf("%I64d ", ans);
for (int i = 2; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++) {
int tmp = v[i][j];
if (v[i][j] == i - 1 || v[i][j] == i) {
continue;
} else if (v[i][j] < i) {
ans = ans - (i - v[i][j] - 1) + v[i][j];
} else if (v[i][j] > i) {
ans += i - 1;
}
}
for (int j = 0; j < v[i - 1].size(); j++) {
if (v[i - 1][j] == i || v[i - 1][j] == i - 1) continue;
int tmp = v[i - 1][j];
if (v[i - 1][j] < i) {
ans = ans - v[i - 1][j] + (i - v[i - 1][j] - 1);
} else if (v[i - 1][j] >= i) {
ans -= (i - 1);
}
}
printf("%I64d ", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100001] = {0};
int b[100001] = {0};
vector<pair<int, int> > newlr;
int len;
int s[100001] = {0};
int B[1001] = {0};
void rewr(int idblock) {
if (B[idblock] == 0) return;
int l = idblock * len;
int r = (idblock + 1) * len - 1;
for (int i = l; i <= r; i++) {
s[i] = B[idblock];
}
B[idblock] = 0;
}
void mod(int l, int r, int u) {
int left = l / len;
int right = r / len;
if (left == right) {
rewr(left);
for (int i = l; i <= r; i++) s[i] = u;
} else {
int end = (left + 1) * len - 1;
if (l <= end) {
rewr(left);
for (int i = l; i <= end; i++) s[i] = u;
}
for (int i = left + 1; i <= right - 1; i++) B[i] = u;
if (right * len <= r) {
rewr(right);
for (int i = right * len; i <= r; i++) s[i] = u;
}
}
}
int get(int p) {
int ind = p / len;
if (B[ind] != 0) return B[ind];
return s[p];
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
int q, x, y, k;
int it = 1;
len = sqrt(double(n));
for (int i = 0; i < m; i++) {
scanf("%d", &q);
if (q == 2) {
scanf("%d", &q);
--q;
int v = get(q);
if (v == 0)
printf("%d\n", b[q]);
else {
int d = q - newlr[v - 1].second;
q = newlr[v - 1].first + d;
printf("%d\n", a[q]);
}
} else {
scanf("%d%d%d", &x, &y, &k);
int lb = y - 1;
int la = x - 1;
newlr.push_back(make_pair(la, lb));
int rb = lb + k - 1;
mod(lb, rb, it);
it++;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 10e5 + 5;
int a[N], n, ans[4];
bool judge(int m) {
ans[0] = a[0] + m;
ans[1] = ans[2] = 2000000000;
int i, t = 0;
for (i = 0; i < n; i++) {
if (t >= 3)
return false;
else if (ans[t] < a[i])
ans[++t] = a[i] + m;
}
return t < 3;
}
int main() {
int i;
while (~scanf("%d", &n)) {
for (i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int l = -1, r = a[n - 1] + 1;
while (l + 1 < r) {
int m = (l + r) >> 1;
if (judge(m))
r = m;
else
l = m;
}
judge(r);
printf("%.7lf\n%.7lf %.7lf %.7lf\n", r * 0.5, ans[0] - r * 0.5,
ans[1] - r * 0.5, ans[2] - r * 0.5);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e8 + 5;
const long long mod = 1e9 + 7;
long long n, x;
char s[N];
long long getans(long long ans) { return (ans % mod + mod) % mod; }
void solve() {
scanf("%lld%s", &x, s + 1);
long long now = 0, len = strlen(s + 1);
n = len;
while (len < x) {
++now;
long long x = s[now] - '0', tot = (x - 1) * (len - now);
long long l = now + 1, r = len;
for (int i = len + 1; i <= len + tot; i++) {
if (l > r) l = now + 1;
s[i] = s[l];
++l;
}
len += tot;
}
long long ans = 0;
for (int i = now + 1; i <= x; i++) {
ans = i + 1ll * (s[i] - '0') * (len - i) % mod;
len += 1ll * (s[i] - '0' - 1ll) * (len - i) % mod;
len = (len % mod + mod) % mod;
}
printf("%lld\n", (ans % mod + mod) % mod);
}
int main() {
int cs;
scanf("%d", &cs);
while (cs--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int l;
bool check(string s, int n, int k) {
string s1 = s;
for (int st = 0; st < l; st++) {
bool flag = true;
s = s1;
for (int i = 0; i < n; i++) {
if (st + i + n < l && s[st + i + n] != s[st + i]) {
flag = false;
break;
}
if (st + i + n >= l) {
s += s[st + i];
k--;
}
}
if (!flag) continue;
if (k >= 0) return true;
}
return false;
}
int main() {
string s;
int k, ans = 0;
cin >> s;
l = (int)s.length();
cin >> k;
for (int i = (l + k) >> 1;; i--) {
if (check(s, i, k)) {
ans = i;
break;
}
}
cout << 2 * ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int n;
cin >> n;
string s;
cin >> s;
int j = 1;
string sub = "";
while (j < n) {
sub = sub + s[j];
j++;
}
if (n == 2 && int(s[0]) >= int(s[1])) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << 2 << endl;
cout << s[0] << " " << sub << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
const int N = 1e6 + 10;
int n, m, c[N][26], fail[N], pos[N], idx, st[N], ed[N], cnt, vis[N], d[N];
char str[N];
vector<int> g[N];
void insert(int id) {
int p = 0;
for (int i = 1; str[i]; i++) {
int k = str[i] - 'a';
if (!c[p][k]) c[p][k] = ++idx;
p = c[p][k];
}
pos[id] = p;
}
void build() {
queue<int> q;
for (int i = 0; i < 26; i++)
if (c[0][i]) q.push(c[0][i]);
while (q.size()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; i++)
if (c[u][i])
q.push(c[u][i]), fail[c[u][i]] = c[fail[u]][i];
else
c[u][i] = c[fail[u]][i];
}
}
void dfs(int x) {
st[x] = ++cnt;
for (int to : g[x]) dfs(to);
ed[x] = cnt;
}
void ins(int x, int v) {
for (; x <= cnt + 1; x += x & (-x)) d[x] += v;
}
int ask(int x) {
int s = 0;
for (; x; x -= x & (-x)) s += d[x];
return s;
}
signed main() {
cin >> m >> n;
for (int i = 1; i <= n; i++) scanf("%s", str + 1), insert(i);
build();
for (int i = 1; i <= idx; i++) g[fail[i]].push_back(i);
dfs(0);
for (int i = 1; i <= n; i++)
ins(st[pos[i]], 1), ins(ed[pos[i]] + 1, -1), vis[i] = 1;
for (int i = 1; i <= m; i++) {
scanf("%s", str + 1);
if (str[1] == '+' || str[1] == '-') {
int sum = 0;
for (int j = 2; str[j]; j++) sum = sum * 10 + str[j] - '0';
if (str[1] == '+') {
if (!vis[sum])
ins(st[pos[sum]], 1), ins(ed[pos[sum]] + 1, -1), vis[sum] = 1;
} else {
if (vis[sum])
ins(st[pos[sum]], -1), ins(ed[pos[sum]] + 1, 1), vis[sum] = 0;
}
} else {
int p = 0, res = 0;
for (int j = 2; str[j]; j++) {
p = c[p][str[j] - 'a'];
res += ask(st[p]);
}
printf("%d\n", res);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
int n;
const int N = 2e5 + 2;
long long f[N][3];
long long modulo[3];
const long long mod = 1e9 + 7;
void slmod() {
int mod1 = l % 3;
int mod2 = r % 3;
int sl = (r - l) / 3 + 1;
int nr = (sl - 1) * 3 + l;
modulo[(mod1 + 1) % 3] = modulo[(mod1 + 2) % 3] = modulo[mod1] = sl;
if (nr + 1 > r) modulo[(mod1 + 1) % 3]--;
if (nr + 2 > r) modulo[(mod1 + 2) % 3]--;
}
int main() {
cin >> n >> l >> r;
slmod();
f[1][0] = modulo[0];
f[1][1] = modulo[1];
f[1][2] = modulo[2];
for (int i = 2; i <= n; ++i) {
f[i][0] = (f[i][0] + f[i - 1][0] * modulo[0] % mod +
f[i - 1][1] * modulo[2] % mod + f[i - 1][2] * modulo[1] % mod) %
mod;
f[i][1] = (f[i][1] + f[i - 1][0] * modulo[1] % mod +
f[i - 1][1] * modulo[0] % mod + f[i - 1][2] * modulo[2] % mod) %
mod;
f[i][2] = (f[i][2] + f[i - 1][0] * modulo[2] % mod +
f[i - 1][1] * modulo[1] % mod + f[i - 1][2] * modulo[0] % mod) %
mod;
}
cout << f[n][0];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
using ll = long long;
const int INF = 0x3f3f3f3f;
using pii = pair<int, int>;
using vi = vector<int>;
int n, k;
int a[200005];
int main() {
while (cin >> n) {
map<int, int> cnt;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
map<int, vector<int>> nxt;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 32; j++) {
long long cur = a[i] + (1ll << j);
if (cnt.find(cur) != cnt.end()) {
nxt[a[i]].push_back(cur);
}
}
}
vector<int> ans(1, a[0]);
for (int i = 0; i < n; i++) {
for (auto v : nxt[a[i]]) {
if (ans.size() < 2) {
ans = {a[i], v};
}
for (auto u : nxt[v]) {
int t = abs(u - a[i]);
if ((t & -t) == t) {
if (ans.size() < 3) {
ans = {a[i], u, v};
}
}
}
}
}
cout << ans.size() << endl;
for (auto v : ans) {
cout << v << " ";
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
int n, r;
scanf("%d", &test);
while (test--) {
scanf("%d%d", &n, &r);
int sum = 0;
for (int i = 1; i <= n - 1; i++) {
int x;
scanf("%d", &x);
sum += x;
}
for (int i = 1; i <= n; i++) {
if ((sum + i) % n == r - 1) {
printf("%d\n", i);
break;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
Edge(int v, int c) : v(v), c(c) {}
int v, c;
};
const int INF = numeric_limits<int>::max();
const int NMAX = 200000;
int n;
typedef vector<Edge> Graph[NMAX];
Graph g;
vector<int> ans;
int ppp[NMAX];
int dpp[NMAX];
void bfs(int s, const Graph& g, vector<int>& d, bool rem) {
queue<int> q, qq;
q.push(s);
qq.push(s);
d.resize(n, INF);
d[s] = 0;
if (rem)
while (!qq.empty()) {
int v = qq.front();
qq.pop();
for (size_t i = 0; i < g[v].size(); ++i) {
const Edge& e = g[v][i];
if (e.c == 0 && d[e.v] == INF) {
d[e.v] = 0;
q.push(e.v);
qq.push(e.v);
ppp[e.v] = v;
dpp[e.v] = dpp[v] + 1;
}
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (size_t i = 0; i < g[v].size(); ++i) {
const Edge& e = g[v][i];
if (d[e.v] == INF) {
d[e.v] = d[v] + 1;
q.push(e.v);
}
}
}
}
class ClearedUsed {
public:
ClearedUsed(size_t size) : curIdx_(0), used_(size, -1) {}
void use(int idx) { used_[idx] = curIdx_; }
bool isUsed(int idx) { return used_[idx] == curIdx_; }
void clear() { ++curIdx_; }
private:
int curIdx_;
vector<int> used_;
};
int layer[2][NMAX];
int pos[2];
void solve() {
vector<int> dFrom, dTo;
int s = 0, t = n - 1;
bfs(0, g, dFrom, true);
int dist = dFrom[t];
bfs(t, g, dTo, false);
vector<int> ans, path;
ClearedUsed used(n);
int ci = 0, ni = 1;
pos[ci] = 0;
for (int i = 0; i < n; i++)
if (dFrom[i] == 0) layer[ci][pos[ci]++] = i;
for (int curDist = 0; curDist < dist; ++curDist) {
int minColor = INF;
for (int vertexIter = 0; vertexIter < pos[ci]; ++vertexIter) {
int v = layer[ci][vertexIter];
for (size_t edgeIter = 0; edgeIter < g[v].size(); ++edgeIter) {
const Edge& e = g[v][edgeIter];
if (dTo[e.v] == dist - curDist - 1) {
if (e.c < minColor) {
minColor = e.c;
pos[ni] = 1;
layer[ni][0] = e.v;
ppp[e.v] = v;
dpp[e.v] = dpp[v] + 1;
used.clear();
used.use(e.v);
} else if (e.c == minColor) {
if (!used.isUsed(e.v)) {
layer[ni][pos[ni]++] = e.v;
used.use(e.v);
ppp[e.v] = v;
dpp[e.v] = dpp[v] + 1;
} else if (dpp[v] + 1 < dpp[e.v]) {
ppp[e.v] = v;
dpp[e.v] = dpp[v] + 1;
}
}
}
}
}
ans.push_back(minColor);
pos[ci] = 0;
swap(ci, ni);
}
path.push_back(t);
string res = "";
for (size_t i = 0; i < ans.size(); ++i) {
printf("%d", ans[i]);
}
if (ans.size() == 0) printf("0");
printf("\n");
reverse(path.begin(), path.end());
while (path.back() != s) {
int x = path.back();
path.push_back(ppp[x]);
}
printf("%d\n", (int)path.size());
for (size_t i = 0; i < path.size(); ++i) {
if (i > 0) putchar(' ');
printf("%d", n - path[i] - 1);
}
puts("");
}
void readdata() {
int m;
assert(scanf("%d%d", &n, &m) == 2);
for (int i = 0; i < m; ++i) {
int a, b, c;
assert(scanf("%d%d%d", &a, &b, &c) == 3);
a = n - a - 1;
b = n - b - 1;
g[a].push_back(Edge(b, c));
g[b].push_back(Edge(a, c));
}
}
int main() {
readdata();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long sol = 0;
vector<vector<int> > G;
vector<vector<pair<long long, int> > > d;
void dfs(int u, int from) {
d[u].resize(k);
d[u][0].second += 1;
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (v != from) {
dfs(v, u);
for (int l = 0; l < k; ++l) {
for (int p = 0; p < k; ++p) {
long long fv = d[v][l].first;
int cntv = d[v][l].second;
sol += fv * d[u][p].second + d[u][p].first * cntv;
if (l == 0 && p == 0)
sol += d[u][p].second * 1LL * cntv;
else if (l + p + 1 <= k && l > 0 && p > 0)
sol -= d[u][p].second * 1LL * cntv;
}
}
d[u][1 % k].first += d[v][0].second;
for (int j = 0; j < k; ++j) {
d[u][j].first += d[v][(j - 1 + k) % k].first;
d[u][j].second += d[v][(j - 1 + k) % k].second;
}
}
}
}
int main() {
cin >> n >> k;
G.resize(n);
d.resize(n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, -1);
cout << sol;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, head, tail;
long long a[maxn], sum[maxn], p[maxn];
int q[maxn];
long long y(long long x) { return p[x] - x * sum[x]; }
long long getdp(int i, int j) { return p[i] - p[j] - j * (sum[i] - sum[j]); }
double getgradient(int i, int j) {
double dy = y(i) - y(j);
double dx = i - j;
return dy / dx;
}
int solve(long long x) {
int l = head, r = tail - 1;
int res = l;
while (l <= r) {
int m = l + r >> 1;
if (getgradient(q[m], q[m - 1]) < -x)
l = m + 1, res = m;
else
r = m - 1;
}
return q[res];
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
sum[0] = p[0] = 0ll;
long long ans = 0ll;
for (int i = 1; i <= n; ++i)
cin >> a[i], sum[i] = sum[i - 1] + a[i],
p[i] = p[i - 1] + (long long)i * a[i];
head = tail = 0;
q[tail++] = 0;
for (int i = 1; i <= n; ++i) {
int j = solve(sum[i]);
ans = max(ans, getdp(i, j));
while (head < tail - 1 &&
getgradient(i, q[tail - 1]) < getgradient(q[tail - 1], q[tail - 2]))
--tail;
q[tail++] = i;
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct lut {
string name;
int cl;
int val;
int size;
};
struct an {
string name;
string whr;
int cl;
int val;
int num;
};
vector<lut> l;
vector<an> anim;
vector<an> d[3];
vector<bool> used;
int all_size;
void Inputdata() {
cin >> n;
l.resize(n);
for (int i = 0; i < n; i++) {
string name;
string cls;
int a, b, c, s;
cin >> name >> cls >> a >> b >> c >> s;
l[i].name = name;
l[i].size = s;
all_size += s;
if (cls == "weapon") {
l[i].cl = 0;
l[i].val = a;
}
if (cls == "armor") {
l[i].cl = 1;
l[i].val = b;
}
if (cls == "orb") {
l[i].cl = 2;
l[i].val = c;
}
}
cin >> m;
anim.resize(m);
used.resize(m);
for (int i = 0; i < m; i++) {
string name, type, whr;
int val;
cin >> name >> type >> val >> whr;
anim[i].name = name;
anim[i].whr = whr;
anim[i].val = val;
anim[i].num = i;
if (type == "gladiator") anim[i].cl = 0;
if (type == "sentry") anim[i].cl = 1;
if (type == "physician") anim[i].cl = 2;
d[anim[i].cl].push_back(anim[i]);
}
}
bool Comp(const an &a, const an &b) { return a.val > b.val; }
void Solve() {
sort(d[0].begin(), d[0].end(), Comp);
sort(d[1].begin(), d[1].end(), Comp);
sort(d[2].begin(), d[2].end(), Comp);
int ans[3];
int max_val[3];
for (int i = 0; i < 3; i++) max_val[i] = -10;
if (all_size > m) {
for (int i = 0; i < n; i++) {
int type = l[i].cl;
int now_val = l[i].val;
for (int j = 0; j < min(l[i].size, int(d[type].size())); j++)
now_val += d[type][j].val;
if (max_val[type] < now_val) {
max_val[type] = now_val;
ans[type] = i;
}
}
vector<string> ans_out[3];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < min(l[ans[i]].size, int(d[i].size())); j++) {
ans_out[i].push_back(d[i][j].name);
used[d[i][j].num] = true;
}
}
for (int i = 0; i < 3; i++) {
int cnt = int(ans_out[i].size());
for (int j = 0; j < m; j++) {
if (cnt >= l[ans[i]].size) break;
if (!used[j]) {
ans_out[i].push_back(anim[j].name);
used[j] = true;
cnt++;
}
}
}
for (int i = 0; i < 3; i++) {
cout << l[ans[i]].name << ' ';
cout << ans_out[i].size() << ' ';
for (int j = 0; j < ans_out[i].size(); j++) cout << ans_out[i][j] << ' ';
cout << endl;
}
} else {
int max_val[3];
int ans[3];
for (int i = 0; i < n; i++) {
int type = l[i].cl;
int now_val = l[i].val;
for (int j = 0; j < m; j++)
if (anim[j].whr == l[i].name && l[i].cl == anim[j].cl)
now_val += anim[j].val;
if (max_val[type] < now_val) {
max_val[type] = now_val;
ans[type] = i;
}
}
vector<string> ans_out[3];
for (int i = 0; i < 3; i++) {
int type = l[ans[i]].cl;
for (int j = 0; j < m; j++)
if (anim[j].whr == l[ans[i]].name) ans_out[i].push_back(anim[j].name);
}
for (int i = 0; i < 3; i++) {
cout << l[ans[i]].name << ' ';
cout << ans_out[i].size() << ' ';
for (int j = 0; j < ans_out[i].size(); j++) cout << ans_out[i][j] << ' ';
cout << endl;
}
}
}
int main() {
Inputdata();
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2017], b[2017], c[2017];
long long px[2017], qx[2017], py[2017], qy[2017];
long long gcd(long long x, long long y) { return x ? gcd(y % x, x) : y; }
long long ans = 0;
map<pair<long long, long long>, int> mmp;
int main() {
scanf("%d", &n);
int flag = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
if (!c[i]) ++flag;
px[i] = a[i] * c[i];
py[i] = b[i] * c[i];
qx[i] = qy[i] = a[i] * a[i] + b[i] * b[i];
}
for (int i = 1; i <= n; ++i) {
if (!c[i]) continue;
mmp.clear();
for (int j = 1; j < i; ++j) {
if (!c[j] || j == i) continue;
long long rx = px[j] * qx[i] - px[i] * qx[j];
long long ry = py[j] * qy[i] - py[i] * qy[j];
long long g = gcd(rx, ry);
rx /= g, ry /= g;
if (rx < 0 || rx == 0 && ry < 0) rx = -rx, ry = -ry;
ans += mmp[make_pair(rx, ry)];
mmp[make_pair(rx, ry)]++;
}
}
if (flag == 2) ans += n - 2;
printf("%lld", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
a %= m;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
int32_t main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if ((n == 1) or (n % 2 == 0 and n < 5)) {
cout << -1 << "\n";
} else {
if (n % 3 == 0) {
cout << (n / 3) << " 0 0"
<< "\n";
} else if (n % 3 == 1) {
cout << (n / 3) - 2 << " 0 1"
<< "\n";
} else {
cout << (n / 3) - 1 << " 1 0"
<< "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace ::std;
int inf = 1e9;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<pair<int, int> > a(2 * n);
int l, r;
for (int i = 0; i < n; ++i) {
cin >> l >> r;
a[2 * i] = {l, 1};
a[2 * i + 1] = {r + 1, -1};
}
sort(a.begin(), a.end());
vector<int> b(m + 2, 0);
for (int i = 0; i < 2 * n; ++i) {
b[a[i].first] += a[i].second;
}
for (int i = 1; i <= m; ++i) b[i] += b[i - 1];
vector<int> pl(m + 1, 0), pr(m + 1, 0);
vector<int> d(m + 2, inf);
d[0] = -inf;
for (int i = 1; i <= m; ++i) {
pl[i] = (upper_bound(d.begin(), d.end(), b[i]) - d.begin());
if (d[pl[i] - 1] <= b[i] && b[i] < d[pl[i]]) d[pl[i]] = b[i];
}
for (int i = 1; i < d.size(); ++i) d[i] = inf;
for (int i = m; i > 0; --i) {
pr[i] = (upper_bound(d.begin(), d.end(), b[i]) - d.begin());
if (d[pr[i] - 1] <= b[i] && b[i] < d[pr[i]]) d[pr[i]] = b[i];
}
int ans = 0;
for (int i = 1; i <= m; ++i) ans = max(ans, pl[i] + pr[i] - 1);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
long long mod = 998244353;
long double inf = 1e9;
long double eps = 1e-8;
long double pi = acos(-1);
ifstream in("input.txt");
ofstream out("output.txt");
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (k == 0) {
cout << s;
} else {
if (s.size() == 1) {
cout << 0;
return 0;
}
if (s[0] != '1') {
s[0] = '1';
k--;
}
for (int i = 1; i < n; i++) {
if (k == 0) break;
if (s[i] != '0') {
s[i] = '0';
k--;
}
}
cout << s;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
vector<long long> fact(1000006);
long long getPower(long long base, long long power) {
if (power == 0) return 1;
long long ret = getPower(base, power >> 1);
ret = ret * 1LL * ret % 1000000007;
if (power & 1) ret = ret * 1LL * base % 1000000007;
return ret;
}
long long modInv(long long den) { return getPower(den, 1000000007 - 2); }
long long divide(long long num, long long den) {
return num * 1LL * modInv(den) % 1000000007;
}
bool test(long long sum) {
while (sum != 0) {
if (sum % 10 != a && sum % 10 != b) return 0;
sum /= 10;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b >> n;
long long res = 0;
fact[0] = 1;
for (long long i = 1; i < fact.size(); i++) {
fact[i] = ((i % 1000000007) * (fact[i - 1] % 1000000007)) % 1000000007;
}
for (long long i = 0; i <= n; i++) {
if (test(i * a + (n - i) * b)) {
res += divide(divide(fact[n], fact[i]), fact[n - i]) % 1000000007;
res %= 1000000007;
}
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y, z;
void Read() { cin >> x >> y >> z; }
Point() {}
Point(double x, double y, double z) : x(x), y(y), z(z) {}
friend Point operator+(const Point &a, const Point &b) {
return Point(a.x + b.x, a.y + b.y, a.z + b.z);
}
friend Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y, a.z - b.z);
}
} v;
struct Circle {
Point o;
double R;
};
int nMine, nPoint;
double ans = 1 << 30;
double Equation(const Point &p, const Point &o, double r) {
double A = o.x - p.x, B = o.y - p.y, C = o.z - p.z, R = r * r;
double a = (v.x * v.x + v.y * v.y + v.z * v.z),
b = -(2 * A * v.x + 2 * B * v.y + 2 * C * v.z),
c = A * A + B * B + C * C - R;
double delta = b * b - 4 * a * c;
if (delta < -1e-10) return 1 << 30;
double t1 = (-b + sqrt(delta)) / a / 2, t2 = (-b - sqrt(delta)) / a / 2;
if (t1 > t2) swap(t1, t2);
if (t2 < -1e-10) return 1 << 30;
if (t1 < -1e-10) return t2;
return t1;
}
void read() {
Circle A, mine;
A.o.Read(), v.Read();
v.x *= -1, v.y *= -1, v.z *= -1;
cin >> A.R >> nMine;
Point v1;
Point p;
for (int i = 1, s; i <= nMine; i++) {
mine.o.Read();
cin >> mine.R >> s;
for (int j = 1; j <= s; j++) {
v1.Read();
p = mine.o + v1;
ans = min(ans, Equation(p, A.o, A.R));
}
ans = min(ans, Equation(mine.o, A.o, A.R + mine.R));
}
if (fabs(ans - (1 << 30)) < 1e-10)
printf("-1\n");
else
printf("%.10lf\n", ans);
}
int main() {
read();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template <class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< "}";
}
template <class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< ", " << get<3>(a) << "}";
}
template <class T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
for (long long i = 0; i < (long long)(a.size()); ++i)
out << a[i] << vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
ostream &operator<<(ostream &out, pair<long long, long long> a) {
cout << a.first << " " << a.second;
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
smain();
return 0;
}
const long long N = 4e5 + 100;
long long pref[N];
long long get(long long l, long long r) {
if (l > r) return 0;
if (l == 0) return pref[r];
return pref[r] - pref[l - 1];
}
long long solve() {
long long n;
cin >> n;
vector<long long> p(n);
for (long long i = 0; i < (long long)(n); ++i) {
cin >> p[i];
}
long long x, a, y, b;
cin >> x >> a >> y >> b;
long long k;
cin >> k;
sort(p.rbegin(), p.rend());
pref[0] = p[0];
for (long long i = 1; i < n; ++i) {
pref[i] = pref[i - 1] + p[i];
}
map<long long, long long> cnt;
for (long long i = 1; i <= n; ++i) {
if (i % a == 0 && i % b == 0) {
cnt[-(x + y)]++;
} else if (i % a == 0) {
cnt[-x]++;
} else if (i % b == 0) {
cnt[-y]++;
}
long long cur = 0;
long long gath = 0;
for (auto item : cnt) {
long long len = item.second;
gath += get(cur, min(i - 1, cur + len - 1)) * -item.first / 100;
cur += len;
}
if (gath >= k) return i;
}
return -1;
}
void smain() {
long long tests;
cin >> tests;
while (tests--) {
cout << solve() << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > adj[200000];
int nxt[200000];
bool v[200000];
vector<int> cycle;
void dfs(int now) {
v[now] = true;
while (nxt[now] < adj[now].size()) {
nxt[now]++;
dfs(adj[now][nxt[now] - 1].first);
}
cycle.push_back(now);
}
void dfs2(int now) {
v[now] = true;
for (int i = 0; i < adj[now].size(); i++) {
int to = adj[now][i].first;
if (!v[to]) {
dfs2(to);
}
}
}
vector<int> rev(vector<int> a) {
vector<int> b;
for (int i = a.size() - 1; i >= 0; i--) {
b.push_back(a[i]);
}
return b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, s;
cin >> n >> s;
vector<int> li;
vector<int> all;
for (int i = 0; i < n; i++) {
nxt[i] = 0;
v[i] = false;
int x;
cin >> x;
li.push_back(x);
all.push_back(x);
}
sort(all.begin(), all.end());
map<int, int> m;
int zone[n];
int point = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && all[i] == all[i - 1]) {
continue;
}
for (int j = i; j < n && all[i] == all[j]; j++) {
zone[j] = point;
}
m[all[i]] = point;
point++;
}
for (int i = 0; i < n; i++) {
int to = m[li[i]];
if (to == zone[i]) {
continue;
}
adj[zone[i]].push_back(make_pair(to, i + 1));
}
vector<vector<int> > ids;
map<pair<int, int>, int> m2;
int point2 = 0;
for (int i = 0; i < point; i++) {
for (int j = 0; j < adj[i].size(); j++) {
int ind = -1;
if (m2.find(make_pair(i, adj[i][j].first)) != m2.end()) {
ind = m2[make_pair(i, adj[i][j].first)];
} else {
m2[make_pair(i, adj[i][j].first)] = point2;
ind = point2++;
vector<int> x;
ids.push_back(x);
}
ids[ind].push_back(adj[i][j].second);
}
}
int comp = 0;
for (int i = 0; i < point; i++) {
if (!v[i] && adj[i].size() > 0) {
dfs2(i);
comp++;
}
}
for (int i = 0; i < point; i++) {
v[i] = false;
}
vector<vector<int> > ans;
int tot = 0;
for (int i = 0; i < point; i++) {
if (v[i] || adj[i].size() == 0) {
continue;
}
cycle.clear();
dfs(i);
cycle.pop_back();
cycle = rev(cycle);
tot += (int)cycle.size();
vector<int> c2;
for (int j = 0; j < cycle.size(); j++) {
int nxt = (j + 1) % cycle.size();
int ind = m2[make_pair(cycle[j], cycle[nxt])];
c2.push_back(ids[ind].back());
ids[ind].pop_back();
}
ans.push_back(c2);
}
for (int i = 0; i < point; i++) {
assert(nxt[i] == adj[i].size());
}
if (tot > s) {
cout << -1 << endl;
return 0;
}
int should = ans.size();
int red = (s - tot) - 2;
int comb = 0;
if (red > 0) {
comb = min(red + 2, comp);
}
if (comb > 1) {
vector<vector<int> > lis;
int sz = ans.size();
for (int i = 1; i <= comb; i++) {
lis.push_back(ans.back());
ans.pop_back();
}
vector<int> l1;
vector<int> l2;
for (int i = lis.size() - 1; i >= 0; i--) {
for (int j = 0; j < lis[i].size(); j++) {
l1.push_back(lis[i][j]);
}
}
for (int i = 0; i < lis.size(); i++) {
l2.push_back(lis[i][0]);
}
ans.push_back(l1);
ans.push_back(l2);
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].size() << endl;
cout << ans[i][0];
for (int j = 1; j < ans[i].size(); j++) {
cout << " " << ans[i][j];
}
cout << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using vi = vector<int>;
int n, q1[110], q2[110], ans[110], cnt;
signed main() {
cin >> n >> q1[n] >> q2[n];
for (int i = n - 1; i >= 0; i--) {
cout << "+ " << (i <= 2 ? i % 2 + 1 : i) << endl;
cin >> q1[i] >> q2[i];
}
for (int i = 0; i <= n - 1; i++) q1[i] -= q1[i + 1], q2[i] -= q2[i + 1];
ans[1] = q1[0] == 0 ? 0 : (int)ceil(sqrt(2 * q1[0])) - 1;
ans[3] = q2[0] - q2[2] - 1;
ans[2] = q2[2] / (ans[3] + 1);
ans[4] = (q2[1] - (ans[1] + 1) * (ans[3] + 1)) / (ans[3] + 1) - 1;
for (int i = 3; i <= n - 2; i++) {
ans[i + 2] =
(q2[i] - ans[i - 2] * ans[i - 1] - ans[i - 1] * (ans[i + 1] + 1)) /
(ans[i + 1] + 1) -
1;
}
cout << '!';
ans[n]++;
for (int i = 1; i <= n; i++) cout << ' ' << ans[i];
cout << '\n';
fprintf(stderr, "time=%.4f\n", (db)clock() / CLOCKS_PER_SEC);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
inline int Pow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = a * 1ll * a % n)
if (b & 1) c = c * 1ll * a % n;
return c;
}
inline bool cao(int x) {
int p = n - 1;
for (int i = 1; i * i <= n; i++)
if (p % i == 0) {
if (i < p && Pow(x, i) == 1) return 0;
if (p / i < p && Pow(x, p / i) == 1) return 0;
}
return 1;
}
int main() {
int x;
scanf("%d%d", &n, &x);
n++;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
printf("-1\n");
return 0;
}
for (x--; x > 1; x--)
if (cao(x)) {
printf("%d\n", x);
return 0;
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, a, sum;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> x;
cin >> sum;
for (long long i = 2; i <= n; ++i) {
++sum;
cin >> a;
sum += a;
}
if (x == sum) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[2];
int n, x;
int done[2][2010];
int go(int who) {
memset(done, 0, sizeof(done));
int ret = 0, cap = x;
while (1) {
int mx = -1, pos;
for (int i = 0; i < v[who].size(); i++) {
if (done[who][i]) continue;
if (v[who][i].first <= cap && v[who][i].second > mx) {
mx = v[who][i].second;
pos = i;
}
}
if (mx == -1) return ret;
ret++;
done[who][pos] = 1;
cap += mx;
who = 1 - who;
}
}
int main() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
int t, h, m;
cin >> t >> h >> m;
v[t].push_back(make_pair(h, m));
}
cout << max(go(0), go(1)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 1;
cin >> n;
long long int* arr = new long long int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (arr[i] > c) {
c++;
} else if (arr[i] == c) {
c++;
}
}
cout << c << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long k, n, s, p, x, y;
cin >> k >> n >> s >> p;
x = (n % s) ? (n / s + 1) : (n / s);
y = (x * k % p) ? (x * k / p + 1) : (x * k / p);
cout << y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
long long int mod(long long int x) { return (x % MOD + MOD) % MOD; }
const long long int first = 21;
long long int f[first];
void solve() {
long long int n;
cin >> n;
f[0] = 1;
for (long long int i = 1; i < first; i++) {
f[i] = f[i - 1] * i;
}
long long int ans = f[n] / (f[n / 2]) / f[n / 2];
ans = ans * f[n / 2 - 1] * f[n / 2 - 1];
ans /= 2;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (int)1e9 + 7;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, -1, 1, 1, -1, -1, 1};
const int MAX = (int)1e5 + 10;
using namespace std;
void Ka8eeM() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
}
map<char, bool> cnt;
int main() {
Ka8eeM();
string s;
cin >> s;
cnt['a'] = cnt['e'] = cnt['u'] = cnt['i'] = cnt['o'] = 1;
reverse(((s).begin()), ((s).end()));
if (s.front() != 'n' && !cnt[s.front()])
cout << "NO\n";
else {
reverse(((s).begin()), ((s).end()));
for (int i = 0; i < (int)s.size() - 1; i++) {
if (s[i] == 'n') continue;
if (!cnt[s[i]] && !cnt[s[i + 1]]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
const int64_t N = 2e5 + 5;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int64_t mpow(int64_t x, int64_t y) {
if (y == 0) return 1;
int64_t temp = mpow(x, y / 2);
temp *= temp;
temp %= MOD;
if (y & 1) return (x * temp) % MOD;
return temp;
}
int64_t inverse(int64_t x) { return mpow(x, MOD - 2); }
int64_t fact[N], ifact[N];
int64_t nCr(int64_t n, int64_t r) {
int64_t ans = fact[n];
ans *= ifact[r];
ans %= MOD;
ans *= ifact[n - r];
ans %= MOD;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fact[0] = 1;
ifact[0] = 1;
for (int64_t i = 1; i < N; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
ifact[i] = inverse(fact[i]);
}
int64_t n, k;
cin >> n >> k;
int64_t arr[n];
for (int64_t i = 0; i < n; i++) {
cin >> arr[i];
}
int64_t equal = 0;
for (int64_t i = 0; i < n; i++) {
if (arr[i] == arr[(i + 1) % n]) equal++;
}
int64_t ans = mpow(k, equal);
int64_t ans2 = 0;
for (int64_t i = 0; i <= n - equal - 1; i++) {
int64_t lol = mpow(k - 2, i);
if ((n - equal - i) % 2 == 1) {
lol *= mpow(2, n - equal - i - 1);
lol %= MOD;
} else {
int64_t rem = mpow(2, n - equal - i);
rem -= nCr(n - equal - i, (n - equal - i + 1) / 2);
rem = rem + 10 * MOD;
rem %= MOD;
rem *= inverse(2);
rem %= MOD;
lol *= rem;
lol %= MOD;
}
lol *= nCr(n - equal, i);
lol %= MOD;
ans2 += lol;
ans2 %= MOD;
}
ans *= ans2;
ans %= MOD;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace AC {
const long long N = 1e5 + 66;
long long BUGS = 1;
inline long long read() {
long long x = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
if (flag) return x;
return (~(x - 1));
}
inline void read(long long arr[], long long s, long long e) {
for (long long i = s; i <= e; ++i) arr[i] = read();
}
inline void write(long long x) {
if (x < 0) {
x = ~(x - 1);
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void print(long long x) {
write(x);
puts("");
}
inline void print(long long arr[], long long s, long long e) {
for (long long i = s; i <= e - 1; ++i) write(arr[i]), putchar(' ');
write(arr[e]);
puts("");
}
inline long long max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline long long min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline void debugNum(long long num, string ss) {
cout << "BUGS" << BUGS++ << " : " << ss << " : " << num << endl;
}
inline void debugArr(long long arr[], long long s, long long e, string ss) {
cout << "BUGS" << BUGS++ << " : " << ss << " : " << endl;
for (long long i = s; i <= e; ++i)
cout << "i : " << i << " val : " << arr[i] << endl;
}
inline void IO() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
} // namespace AC
using namespace AC;
long long n, arr[N];
bool use[N];
int main() {
long long T = read();
while (T--) {
n = read(), read(arr, 1, n);
for (long long i = 1; i <= n; ++i) {
use[i] = false;
}
use[1] = use[n] = true;
for (long long i = 2; i < n; ++i) {
if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) use[i] = true;
if (arr[i] < arr[i - 1] && arr[i] < arr[i + 1]) use[i] = true;
}
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
if (use[i] == true) ans++;
}
print(ans);
for (long long i = 1; i <= n; ++i) {
if (use[i] == true) printf("%lld ", arr[i]);
}
puts("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[19][2][10][10];
vector<long long int> v;
long long int solve(long long int pos, long long int flag, long long int f,
long long int l) {
if (pos == (long long int)v.size()) {
if (f == l && f != 0)
return 1;
else
return 0;
}
if (dp[pos][flag][f][l] != -1) return dp[pos][flag][f][l];
long long int res = 0;
long long int lim;
if (flag == 0)
lim = v[pos];
else
lim = 9;
for (long long int dig = 0; dig <= lim; dig++) {
long long int nflag = flag;
if (flag == 0 && dig < lim) nflag = 1;
long long int nf, nl;
if (f == 0)
nf = dig;
else
nf = f;
nl = dig;
res += solve(pos + 1, nflag, nf, nl);
}
return dp[pos][flag][f][l] = res;
}
long long int fun(long long int n) {
v.clear();
while (n > 0) {
long long int d = n % 10;
n = n / 10;
v.push_back(d);
}
reverse(v.begin(), v.end());
memset(dp, -1, sizeof dp);
long long int ans = solve(0, 0, 0, 0);
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
long long int l, r;
cin >> l >> r;
long long int i;
long long int ans = fun(r) - fun(l - 1);
cout << ans << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p = 0, q = 0, v = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
v++;
} else if (a[i] == 2) {
p++;
} else {
q++;
}
}
int w = max(v, max(p, q));
if (w == v) {
cout << p + q << endl;
} else if (w == p) {
cout << v + q << endl;
} else {
cout << p + v << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using i2 = pair<int, int>;
int max_digit(int n) {
int res = 0;
while (n > 0) {
res = max(res, n % 10);
n /= 10;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int res = 0;
while (n > 0) {
n -= max_digit(n);
res++;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int tot, n;
int vis[110];
int p[110];
int dp[2][262144], cs[110][262144], pre[110][262144];
int have[100];
int a[110], b[110];
string print(int sta) {
string x = "";
for (int i = tot - 1; i >= 0; i--) {
if (sta & (1 << i))
x += '1';
else
x += '0';
}
return x;
}
int main() {
for (int i = 2; i <= 59; i++) {
if (!vis[i]) p[tot++] = i;
for (int j = i; j <= 59; j += i) vis[j] = 1;
}
for (int i = 1; i <= 59; i++) {
for (int j = 0; j < tot; j++) {
if (i % p[j] == 0) have[i] |= (1 << j);
}
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
register int tmp;
register int nowt = 1, pret = 0;
for (int i = 1; i <= n; i++) {
for (int sta = 0; sta < (1 << tot); sta++) {
dp[nowt][sta] = 0x3f3f3f3f;
for (int j = 1; j <= 59; j++) {
if ((have[j] & sta) != have[j]) continue;
tmp = dp[pret][have[j] ^ sta] + abs(j - a[i]);
if (tmp < dp[nowt][sta]) {
dp[nowt][sta] = tmp;
pre[i][sta] = have[j] ^ sta;
cs[i][sta] = j;
}
}
}
nowt ^= 1;
pret ^= 1;
}
int mi = 0x3f3f3f3f;
for (int i = 0; i < (1 << tot); i++) {
mi = min(mi, dp[pret][i]);
}
int pp;
for (int i = 0; i < (1 << tot); i++) {
if (mi == dp[pret][i]) {
pp = i;
for (int now = n; now >= 1; now--) {
b[now] = cs[now][pp];
pp = pre[now][pp];
}
for (int now = 1; now <= n; now++) {
printf("%d ", b[now]);
}
puts("");
return 0;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
;
long long int a, b;
cin >> a >> b;
if ((b - a) > 1) {
cout << "-1" << endl;
} else if (b < a) {
if (a == 9 & b == 1) {
cout << a << "9 " << b << "00" << endl;
} else {
cout << "-1" << endl;
}
} else {
if (a == b) {
cout << a << "00 " << b << "01" << endl;
} else if ((b - a) == 1) {
cout << a << "9 " << b << "0" << endl;
} else {
cout << "-1" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 5000 + 10;
long long rd() {
long long x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int n, m, kk;
long long h[N], a[N], cv3;
struct node {
int x, t;
long long h, d;
bool operator<(const node &bb) const { return d > bb.d; }
};
priority_queue<node> hp;
int main() {
n = rd(), m = rd(), kk = rd(), cv3 = rd();
long long l = 0, r = (long long)1e9 * (m + 1);
for (int i = 1; i <= n; ++i) {
h[i] = rd(), a[i] = rd();
l = max(l, a[i]);
}
while (l <= r) {
long long mid = (l + r) >> 1;
while (!hp.empty()) hp.pop();
for (int i = 1; i <= n; ++i)
if (mid - a[i] * m < h[i]) hp.push((node){i, 1, mid - a[i], mid / a[i]});
bool ok = 1;
for (int i = 1; ok && i <= m; ++i) {
int rs = kk;
while (!hp.empty() && rs) {
node nw = hp.top();
hp.pop();
int x = nw.x;
if (nw.h - a[x] * (m - nw.t) >= h[x]) continue;
--rs;
nw.h -= a[x] * (i - nw.t);
if (nw.h < 0) {
ok = 0;
break;
}
nw.h += cv3;
hp.push((node){x, i, nw.h, i + nw.h / a[x]});
}
if (hp.empty()) break;
}
while (!hp.empty() &&
hp.top().h - a[hp.top().x] * (m - hp.top().t) >= h[hp.top().x])
hp.pop();
ok &= hp.empty();
if (ok)
r = mid - 1;
else
l = mid + 1;
}
printf("%lld\n", r + 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[200002];
int w[200002];
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < k; ++i) {
cin >> w[i];
}
sort(a, a + n);
sort(w, w + k);
long long int sol = 0;
for (int i = 0; i < k; ++i) {
sol += a[n - i - 1];
w[i]--;
if (w[i] == 0) sol += a[n - i - 1];
}
int curGive = k - 1;
for (int i = 0; i < n - k;) {
sol += a[i];
i += w[curGive--];
}
cout << sol << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (T e : v) {
os << e << ' ';
}
return os;
}
constexpr ll mod = 998244353;
constexpr int maxn = 502;
ll lte[maxn];
ll dp[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, k;
cin >> n >> k;
--k;
for (int i = 1; i <= n; ++i) {
ll total = 0;
for (int j = 1; j <= n; ++j) {
if (j <= i) {
dp[j] = total + 1;
total += dp[j];
total %= mod;
} else {
dp[j] = total;
total += dp[j];
total -= dp[j - i];
total %= mod;
}
}
lte[i] = (2 * dp[n] % mod + mod) % mod;
}
for (int i = n; i >= 1; --i) {
lte[i] = (lte[i] - lte[i - 1] + mod) % mod;
}
ll ans = 0;
for (int i = 1; i <= min(n, k); ++i) {
ll d = k / i;
for (int j = 1; j <= min(d, n); ++j) {
ans = (ans + lte[i] * lte[j]) % mod;
}
}
cout << ans * ((mod + 1) / 2) % mod << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void printAround(void* ptr) {
for (int i = -12; i < 48; i++) {
if (i == 0) printf("*");
printf("%x ", ((char*)ptr)[i]);
}
cout << endl;
}
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int powMod(long long int a, int p, long long int mod) {
long long int res = 1;
while (p > 0) {
if (p % 2 == 1) res *= a;
a *= a;
res %= mod;
a %= mod;
p /= 2;
}
return res;
}
unsigned long long extendedGcd(unsigned long long a, unsigned long long b,
long long& ca, long long& cb) {
if (a < b) {
return extendedGcd(b, a, cb, ca);
}
if (b == 0) {
ca = 1;
cb = 0;
return a;
} else {
unsigned long long g = extendedGcd(b, a % b, cb, ca);
cb -= ca * (a / b);
return g;
}
}
unsigned long long inverseModP(unsigned long long a, unsigned long long p) {
long long ca, cb;
extendedGcd(a % p, p, ca, cb);
return (ca + p) % p;
}
struct xll {
static const int inf = 10000000;
static long long int mod;
static int nPrimes;
static long long int primes[10];
static int cnts[10];
long long int storedRes;
long long int val;
int pv[10];
xll(long long int v = 0) {
storedRes = v % mod;
for (int i = 0; i < nPrimes; i++) {
pv[i] = 0;
while (v > 0 && v % primes[i] == 0) {
v /= primes[i];
pv[i] += 1;
}
if (v == 0) {
pv[i] = inf;
}
}
val = v;
}
xll(const xll& other) {
storedRes = other.storedRes;
val = other.val;
for (int i = 0; i < nPrimes; i++) {
pv[i] = other.pv[i];
}
}
void operator=(const xll& other) {
storedRes = other.storedRes;
val = other.val;
for (int i = 0; i < nPrimes; i++) {
pv[i] = other.pv[i];
}
}
void operator=(long long int v) {
xll xllV = v;
*this = xllV;
}
static void setup(long long int setMod) {
mod = setMod;
int p = 2;
while (setMod >= p * p) {
if (setMod % p == 0) {
primes[nPrimes] = p;
cnts[nPrimes] = 0;
while (setMod % p == 0) {
setMod /= p;
cnts[nPrimes]++;
}
nPrimes++;
}
p++;
}
if (setMod != 1) {
primes[nPrimes] = setMod;
cnts[nPrimes] = 1;
nPrimes++;
}
}
void updateStored() {
storedRes = val % mod;
for (int i = 0; i < nPrimes; i++) {
storedRes *= powMod(primes[i], pv[i], mod);
storedRes %= mod;
}
}
long long int toLL() const { return storedRes; }
long long int noMod() {
long long int res = val;
for (int i = 0; i < nPrimes; i++) {
for (int j = 0; j < pv[i]; j++) res *= primes[i];
}
return res;
}
void operator*=(long long int m) {
storedRes *= m;
storedRes %= mod;
for (int i = 0; i < nPrimes; i++) {
while (m % primes[i] == 0) {
m /= primes[i];
pv[i] += 1;
}
}
val *= m;
val %= mod;
}
void operator/=(long long int m) {
for (int i = 0; i < nPrimes; i++) {
while (m % primes[i] == 0) {
m /= primes[i];
pv[i] -= 1;
}
}
val *= inverseModP(m, mod);
val %= mod;
updateStored();
}
xll operator*=(const xll& other) {
storedRes *= other.storedRes;
storedRes %= mod;
val *= other.val;
val %= mod;
for (int i = 0; i < nPrimes; i++) {
pv[i] += other.pv[i];
}
}
};
long long int xll::mod = 0;
int xll::nPrimes = 0;
long long int xll::primes[10] = {};
int xll::cnts[10] = {};
class tree {
struct node {
long long int val;
xll mult;
node() {
val = 0;
mult = 1;
}
};
int n;
int depth;
long long int mod;
node* data;
void updateNode(int ind, const xll& m) {
data[ind].mult *= m;
data[ind].val *= m.toLL();
data[ind].val %= mod;
}
void updateNode(int ind, long long int m) {
data[ind].mult *= m;
data[ind].val *= m;
data[ind].val %= mod;
}
void updateDataInd(int i) {
data[i].val =
((data[2 * i].val + data[2 * i + 1].val) * data[i].mult.toLL()) % mod;
}
void updateFromDataInd(int i) {
while (true) {
i /= 2;
if (i == 0) break;
updateDataInd(i);
}
}
long long int getIntervalX(int l, int r, int ind, int layer) {
if (l == 0 && r == (1 << (this->depth - layer))) {
return data[ind].val;
}
int mid = (1 << (this->depth - layer - 1));
if (l >= mid) {
return (data[ind].mult.toLL() *
getIntervalX(l - mid, r - mid, 2 * ind + 1, layer + 1)) %
mod;
}
if (r <= mid) {
return (data[ind].mult.toLL() * getIntervalX(l, r, 2 * ind, layer + 1)) %
mod;
}
return (data[ind].mult.toLL() *
(getIntervalX(l, mid, 2 * ind, layer + 1) +
getIntervalX(0, r - mid, 2 * ind + 1, layer + 1))) %
mod;
}
public:
tree(int n, long long int mod) {
this->n = n;
this->mod = mod;
this->depth = 0;
while (n >= (1 << this->depth)) this->depth++;
data = new node[1 << (this->depth + 1)]();
}
~tree() { delete[] data; }
void setVal(int i, long long int v) {
data[(1 << this->depth) + i].mult *= v;
data[(1 << this->depth) + i].val = data[(1 << this->depth) + i].mult.toLL();
}
void setup() {
for (int i = (1 << this->depth) - 1; i >= 1; i--) {
data[i].val = (data[2 * i].val + data[2 * i + 1].val) % mod;
}
}
void printOut() {
for (int i = 1; i < (1 << (this->depth + 1)); i++) {
cout << "(" << data[i].val << ", " << data[i].mult.toLL() << ") ";
if (__builtin_popcount(i + 1) == 1) cout << endl;
}
}
void reduceInd(int i) {
int ind = (1 << this->depth) + i;
for (int layer = 0; layer < this->depth; layer++) {
int curInd = ind >> (this->depth - layer);
updateNode(2 * curInd, data[curInd].mult);
updateNode(2 * curInd + 1, data[curInd].mult);
data[curInd].mult = 1;
}
}
void divideInd(int i, int m) {
int newI = (1 << this->depth) + i;
data[newI].mult /= m;
data[newI].val = data[newI].mult.toLL();
updateFromDataInd(newI);
}
long long int getInterval(int l, int r) { return getIntervalX(l, r, 1, 0); }
void multInterval(int l, int r, int m, int ind = 1, int layer = 0) {
if (l == 0 && r == (1 << (this->depth - layer))) {
updateNode(ind, m);
return;
}
int mid = (1 << (this->depth - layer - 1));
if (l >= mid) {
multInterval(l - mid, r - mid, m, 2 * ind + 1, layer + 1);
} else if (r <= mid) {
multInterval(l, r, m, 2 * ind, layer + 1);
} else {
multInterval(l, mid, m, 2 * ind, layer + 1);
multInterval(0, r - mid, m, 2 * ind + 1, layer + 1);
}
updateDataInd(ind);
}
};
int main() {
int n, mod;
scanf("%d", &n);
scanf("%d", &mod);
xll::setup(mod);
tree a(n, mod);
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
a.setVal(i, ai);
}
a.setup();
int q;
scanf("%d", &q);
int comm, l, r, p, x;
for (int i = 0; i < q; i++) {
scanf("%d", &comm);
if (comm == 1) {
scanf("%d", &l);
scanf("%d", &r);
scanf("%d", &x);
l--;
a.multInterval(l, r, x);
} else if (comm == 2) {
scanf("%d", &p);
scanf("%d", &x);
p--;
a.reduceInd(p);
a.divideInd(p, x);
} else if (comm == 3) {
scanf("%d", &l);
scanf("%d", &r);
l--;
cout << a.getInterval(l, r) << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int T, n, x, y;
vector<int> res;
void solve() {
res.clear();
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i <= y - x; i++) {
if (0 != (y - x) % i) continue;
if ((y - x) / i + 1 > n) continue;
int cnt = 0;
for (int j = x; j <= y && cnt < n; j += i, cnt++) res.push_back(j);
for (int j = x - i; j > 0 && cnt < n; j -= i, cnt++) res.push_back(j);
for (int j = y + i; cnt < n; j += i, cnt++) res.push_back(j);
break;
}
for (int i = 0; i < res.size(); i++) {
printf("%d", res[i]);
printf(i == res.size() - 1 ? "\n" : " ");
}
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, c;
long long a[10];
bool check(long long k) {
if (k <= a[1]) {
long long tp = 2 * k * (k + 1) + 1;
return tp >= c;
}
if (k <= a[2]) {
long long tp = 2 * k * (k + 1) + 1;
tp -= (k - a[1]) * (k - a[1]);
return tp >= c;
}
if (k <= a[3]) {
long long tp = 2 * k * (k + 1) + 1;
tp -= (k - a[1]) * (k - a[1]);
tp -= (k - a[2]) * (k - a[2]);
if (a[1] + a[2] + 2 <= k)
tp += (k - a[1] - a[2]) * (k - a[1] - a[2] - 1) / 2;
return tp >= c;
}
if (k <= a[4]) {
long long tp = 2 * k * (k + 1) + 1;
tp -= (k - a[1]) * (k - a[1]);
tp -= (k - a[2]) * (k - a[2]);
tp -= (k - a[3]) * (k - a[3]);
if (a[1] + a[2] + 2 <= k)
tp += (k - a[1] - a[2]) * (k - a[1] - a[2] - 1) / 2;
if (a[3] + a[1] + 2 <= k)
tp += (k - a[3] - a[1]) * (k - a[3] - a[1] - 1) / 2;
return tp >= c;
}
if (k > a[4]) {
long long tp = 2 * k * (k + 1) + 1;
tp -= (k - a[1]) * (k - a[1]);
tp -= (k - a[2]) * (k - a[2]);
tp -= (k - a[3]) * (k - a[3]);
tp -= (k - a[4]) * (k - a[4]);
if (a[1] + a[2] + 2 <= k)
tp += (k - a[1] - a[2]) * (k - a[1] - a[2] - 1) / 2;
if (a[4] + a[2] + 2 <= k)
tp += (k - a[4] - a[2]) * (k - a[4] - a[2] - 1) / 2;
if (a[1] + a[3] + 2 <= k)
tp += (k - a[1] - a[3]) * (k - a[1] - a[3] - 1) / 2;
if (a[3] + a[4] + 2 <= k)
tp += (k - a[3] - a[4]) * (k - a[3] - a[4] - 1) / 2;
return tp >= c;
}
}
void solve() {
long long x, y;
scanf("%I64d%I64d%I64d%I64d", &n, &x, &y, &c);
a[1] = x - 1;
a[2] = y - 1;
a[3] = n - x;
a[4] = n - y;
sort(a + 1, a + 5);
long long l = 0, r = 2 * n;
while (l < r) {
long long mid = (l + r) / 2;
if (!check(mid))
l = mid + 1;
else
r = mid;
}
printf("%d\n", l);
}
int main() {
solve();
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.