solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, k, tot, cnt;
int to[2008611], nex[2008611], head[2008611];
int dep[2008611], fa[2008611][22];
bool tag[2008611];
void add(int x, int y) {
to[++tot] = y;
nex[tot] = head[x];
head[x] = tot;
}
void dfs(int now, int fat) {
dep[now] = dep[fat] + 1;
fa[now][0] = fat;
for (int i = 1; (1 << i) <= dep[now]; ++i)
fa[now][i] = fa[fa[now][i - 1]][i - 1];
for (int i = head[now]; i; i = nex[i]) {
int v = to[i];
if (v == fat) continue;
dfs(v, now);
}
}
int query(int now) {
int tmp = now;
for (int i = 20; i >= 0; --i) {
if ((1 << i) > dep[tmp]) continue;
if (fa[tmp][i] && !tag[fa[tmp][i]]) tmp = fa[tmp][i];
}
return dep[now] - dep[tmp] + 1;
}
void update(int now) {
while (tag[now] == 0) {
tag[now] = 1;
++cnt;
now = fa[now][0];
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(n, 0);
cnt = 1;
tag[n] = 1;
for (int i = n - 1; i; --i) {
if (tag[i]) continue;
int tmp = query(i);
if (tmp + cnt <= n - k) update(i);
if (n - k == cnt) break;
}
for (int i = 1; i <= n; ++i)
if (!tag[i]) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m, k;
bool flag = true;
cin >> n >> m >> k;
long long sum = m;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int i = 0;
while (sum >= 0 && i < n - 1) {
sum += a[i] - a[i + 1] + min(a[i + 1], k);
a[i] = max(0, a[i + 1] - k);
i++;
}
if (sum < 0)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000LL;
const int MAXN = 100005;
int n, k;
long long a[MAXN];
map<long long, long long> cnt;
int main(void) {
scanf("%d%d", &n, &k);
for (int i = (1); i < (n + 1); ++i) scanf("%lld", a + i);
for (int i = (0); i < (n); ++i) a[i + 1] += a[i];
vector<long long> powers;
if (k == 1) {
powers.push_back(1);
} else if (k == -1) {
powers.push_back(1);
powers.push_back(-1);
} else {
long long x = 1;
while (abs(x) < 1e17) {
powers.push_back(x);
x *= k;
}
}
long long sol = 0;
for (int i = (0); i < (n + 1); ++i) {
for (long long p : powers) {
sol += cnt[a[i] - p];
}
++cnt[a[i]];
}
printf("%lld\n", sol);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt = 0, a[10000000 + 5], k, m;
void dfs(int now, int sum, int p) {
if (cnt > 10000000) return;
if (now == 4) {
if (sum - k < 10000 && sum - k >= 0)
a[++cnt] = p * 10000 + abs(sum - k), a[++cnt] = p + abs(sum - k) * 10000;
if (sum + k < 10000 && sum + k >= 0)
a[++cnt] = p * 10000 + abs(sum + k), a[++cnt] = p + abs(sum + k) * 10000;
return;
}
if (now)
for (int i = 0; i <= 9; i++) dfs(now + 1, sum * i, p * 10 + i);
for (int i = 0; i <= 9; i++)
dfs(now + 1, sum + i, p * 10 + i), dfs(now + 1, sum - i, p * 10 + i);
}
int main() {
scanf("%d%d", &k, &m);
dfs(0, 0, 0);
sort(a + 1, a + 1 + cnt);
cnt = unique(a + 1, a + 1 + cnt) - a - 1;
for (int i = 1; i <= m; i++) printf("%08d\n", a[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, tot;
int p = 31;
long long gcd(long long x, long long y) {
while (y) {
long long r = x % y;
x = y;
y = r;
}
return x;
}
long long qpow(long long a, long long b, long long modp) {
long long ans;
for (ans = 1; b; b >>= 1, a = a * a % modp)
if (b & 1) ans = ans * a % modp;
return ans;
}
long long getc(long long n, long long m) {
if (n < m) return 0;
if (m > n - m) m = n - m;
long long s1 = 1, s2 = 1;
for (long long i = 0; i < m; i++) {
s1 = s1 * (n - i) % p;
s2 = s2 * (i + 1) % p;
}
return s1 * qpow(s2, p - 2, p) % p;
}
long long fact[20];
void extgcd(long long a, long long b, long long &x, long long &y) {
if (b != 0) {
extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
}
long long mod_inv(long long a, long long modp) {
long long x, y;
extgcd(a, modp, x, y);
return (modp + x % modp) % modp;
}
long long mod_fact(long long n, long long p, long long &e) {
e = 0;
if (n == 0) return 1;
long long res = mod_fact(n / p, p, e);
e += n / p;
if (n / p % 2 != 0) return res * (p - fact[n % p]) % p;
return res * fact[n % p] % p;
}
long long lucas(long long n, long long k) {
if (n < 0 || k < 0 || n < k) return 0;
long long e1, e2, e3;
long long a1 = mod_fact(n, p, e1), a2 = mod_fact(k, p, e2),
a3 = mod_fact(n - k, p, e3);
if (e1 > e2 + e3) return 0;
return a1 * mod_inv(a2 * a3 % p, p) % p;
}
const long double eps = 1e-14;
const long double pi = std::acos(-1.0);
pair<pair<int, int>, int> q[200007];
int v[200007], top;
pair<pair<int, int>, int> st[200007], st2[200007];
long double L[200007], R[200007];
long double calc(pair<pair<int, int>, int> &x, pair<pair<int, int>, int> &y) {
long double s1 = x.first.first;
long double r1 = x.first.second;
long double s2 = y.first.first;
long double r2 = y.first.second;
long double g = s1 * s2 * r1 * r2;
long double k = (g / s1 - g / s2) / (g / r1 - g / r2);
return k;
}
int chk(pair<pair<int, int>, int> &x, pair<pair<int, int>, int> &y,
pair<pair<int, int>, int> &z) {
long double xx = calc(x, y);
long double yy = calc(z, y);
if (fabs(xx - yy) < eps) return 0;
if (xx < yy)
return -1;
else
return 1;
}
int main() {
int T = 1;
while (scanf("%d", &n) != EOF) {
tot = 0;
if (!n) break;
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i].first = pair<int, int>(x, y);
q[i].second = i + 1;
}
sort(q, q + n);
m = n;
for (int i = 0; i < n; ++i) {
while (tot > 0 && (q[i].first.second > st[tot - 1].first.second ||
q[i].first.first > st[tot - 1].first.first &&
q[i].first.second == st[tot - 1].first.second)) {
--tot;
v[st[tot].second] = 1;
--m;
}
st[tot++] = q[i];
}
top = 0;
for (int i = 0; i < tot; ++i) {
while ((top > 0 && st[i].first == st2[top - 1].first ||
top > 1 && chk(st[i], st2[top - 1], st2[top - 2]) < 0))
--top;
st2[top++] = st[i];
if (top > 1)
L[i] = calc(st[i], st2[top - 2]);
else
L[i] = -((1 << 30) - 1);
}
top = 0;
for (int i = tot - 1; i >= 0; --i) {
while ((top > 0 && st[i].first == st2[top - 1].first ||
top > 1 && chk(st[i], st2[top - 1], st2[top - 2]) > 0))
--top;
st2[top++] = st[i];
if (top > 1)
R[i] = calc(st[i], st2[top - 2]);
else
R[i] = 0;
}
for (int i = 0; i < tot; ++i) {
if (!(L[i] < R[i] || fabs(L[i] - R[i]) < eps)) v[st[i].second] = 1, --m;
}
for (int i = 1, cnt = 0; i <= n; ++i) {
if (!v[i]) {
++cnt;
printf("%d%c", i, " \n"[cnt == m]);
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 + 5, inf = 100;
typedef int ary[maxn];
bitset<20000> ntp;
int s = 0, t, n, m = 1, tot = 0, prm[2600], stream = 0;
ary que, numb, a, head, neck;
struct node {
int don, nxt, rst;
void ins(int x, int y, int f) {
don = y;
rst = f;
nxt = head[x];
head[x] = m;
}
} star[maxn * maxn];
bool BFS() {
memset(numb, 0xff, sizeof(numb));
numb[que[0] = s] = 0;
for (int f = 0, r = 0, now = que[0]; f <= r; now = que[++f]) {
neck[now] = head[now];
for (int q = head[now]; q; q = star[q].nxt)
if (numb[star[q].don] < 0 && star[q].rst) {
numb[star[q].don] = numb[now] + 1;
que[++r] = star[q].don;
}
}
return numb[t] < 0 ? 0 : 1;
}
int DFS(int now, int lim) {
if (now == t) return lim;
int used = 0;
for (int q = neck[now]; q && lim > used || (neck[now] = q, 0);
q = star[q].nxt)
if (numb[now] + 1 == numb[star[q].don] && star[q].rst) {
int flow = DFS(star[q].don, min(lim - used, star[q].rst));
used += flow;
star[q].rst -= flow;
star[q ^ 1].rst += flow;
}
return used;
}
void prepare() {
for (int i = 2; i < 20000; i++) {
if (!ntp[i]) prm[++tot] = i;
for (int j = 1; j <= tot && i * prm[j] < 20000; j++) {
ntp[i * prm[j]] = 1;
if (i % prm[j] == 0) break;
}
}
scanf("%d", &n);
t = n + 1;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (!ntp[a[i] + a[j]]) {
if (a[i] & 1)
star[++m].ins(i, j, 1), star[++m].ins(j, i, 0);
else
star[++m].ins(j, i, 1), star[++m].ins(i, j, 0);
}
for (int i = 1; i <= n; i++)
if (a[i] & 1)
star[++m].ins(s, i, 2), star[++m].ins(i, s, 0);
else
star[++m].ins(i, t, 2), star[++m].ins(t, i, 0);
}
void cir(int now, int num, int ord) {
numb[now] = num * maxn * maxn + ord * maxn + now;
for (int q = head[now]; q; q = star[q].nxt)
if (!numb[star[q].don] &&
(a[now] & 1 && !star[q].rst || !(a[now] & 1) && star[q].rst))
cir(star[q].don, num, ord + 1);
}
bool cmp(int a, int b) { return a > b ? 1 : 0; }
int main() {
prepare();
while (BFS()) stream += DFS(s, inf);
if (stream < n) {
printf("Impossible\n");
return 0;
}
memset(numb, 0, sizeof(numb));
int cnt = 0;
for (int i = 1; i <= n; i++)
if (!numb[i]) cir(i, ++cnt, 1);
printf("%d\n", cnt);
sort(numb + 1, numb + n + 1, cmp);
for (int i = cnt, j = 1; i; i--) {
printf("%d", numb[j] / maxn % maxn);
for (; j <= n && numb[j] / maxn / maxn == i; j++)
printf(" %d", numb[j] % maxn);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int k = s.length();
int flag = 0;
for (int d = 0; d < k - 1; d++) {
if (s[d] == ' ') {
continue;
}
if (s[d] == 'a' || s[d] == 'e' || s[d] == 'i' || s[d] == 'o' ||
s[d] == 'u' || s[d] == 'y' || s[d] == 'A' || s[d] == 'E' ||
s[d] == 'I' || s[d] == 'O' || s[d] == 'U' || s[d] == 'Y') {
flag = 1;
} else {
flag = 0;
}
}
if (flag == 1) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long INF = 1e18;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<long long> v;
vector<long long> freq(k);
long long prev = -1;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
x--;
if (x != prev) {
v.push_back(x);
prev = x;
}
}
for (long long i = 0; i < v.size(); i++) freq[v[i]]++;
for (long long i = 1; i < v.size() - 1; i++) {
if (v[i + 1] == v[i - 1]) freq[v[i]]++;
}
long long maxi = 0;
for (long long i = 0; i < k; i++) {
if (freq[i] > freq[maxi]) maxi = i;
}
cout << maxi + 1 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
long long dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long dx4[] = {-1, 1, 0, 0};
long long dy4[] = {0, 0, 1, -1};
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
string fx(long long a) {
string s;
while (a != 0) {
s += '0' + a % 10;
a /= 10;
}
reverse(s.begin(), s.end());
return s;
}
vector<long long> pr;
long long rep[100005];
void pri() {
for (long long i = 2; i < (long long)100005; ++i) {
if (rep[i] == 0)
for (long long j = 2 * i; j < 100005; j += i) {
rep[j] = 1;
}
}
for (long long i = 2; i < (long long)100005; ++i)
if (rep[i] == 0) pr.push_back(i);
}
vector<long long> vt;
void st(long long curr, long long l, long long r, long long v, long long id) {
if (l == r) {
if (l == id) vt[curr] = v;
return;
}
if (r < id || id < l) return;
long long mid = l + r;
mid /= 2;
st(2 * curr + 1, l, mid, v, id);
st(2 * curr + 2, mid + 1, r, v, id);
vt[curr] = min(vt[2 * curr + 1], vt[2 * curr + 2]);
}
long long gt(long long curr, long long l, long long r, long long L,
long long R) {
if (l == r) {
if (l >= L && l <= R) return vt[curr];
return LLONG_MAX;
}
if (l > R || r < L) return LLONG_MAX;
if (l >= L && r <= R) return vt[curr];
long long mid = l + r;
mid /= 2;
return min(gt(2 * curr + 1, l, mid, L, R),
gt(2 * curr + 2, mid + 1, r, L, R));
}
long long a[20][20];
long long vis[20][20];
long long m, n, s;
long long rec(long long x, long long y, long long rem) {
if (rem == -1) return 0;
vis[x][y] = 1;
long long here = 0;
if (a[x][y] == 10) {
a[x][y] = 0;
here += 1;
}
long long mx = 0;
vector<pair<long long, long long>> vp, nvp;
for (long long i = 0; i < (long long)4; ++i) {
long long nx = x + dx4[i];
long long ny = y + dy4[i];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (a[nx][ny] == -1) continue;
if (vis[nx][ny] == 1)
vp.push_back({nx, ny});
else
nvp.push_back({nx, ny});
}
for (auto it : vp) mx = max(mx, rec(it.first, it.second, rem - 1));
for (auto it : nvp) mx = max(mx, rec(it.first, it.second, rem - 1));
if (here == 1) a[x][y] = 10;
vis[x][y] = 0;
return here + mx;
}
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long>> vt(n);
for (long long i = 0; i < (long long)n; ++i)
cin >> vt[i].first >> vt[i].second;
sort(vt.begin(), vt.end());
long long curr = -1;
for (long long i = 0; i < (long long)n; ++i) {
if (curr <= vt[i].second)
curr = vt[i].second;
else
curr = vt[i].first;
}
cout << curr << "\n";
return;
}
void input() {
long long t = 1;
for (long long T = 1; T < (long long)t + 1; ++T) solve();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 100000 + 9, M = 300000 + 9, lim = 314000000;
int monster[N], split[N], n, m, ec, nxt[M], lnk[M], f[N], g[N], sid[N], from[N],
ind[N], dis[N];
bool inst[N];
struct info {
int dis, mid;
info(const int _dis, const int _mid) : dis(_dis), mid(_mid) {}
bool operator<(const info &o) const { return dis > o.dis; }
};
std::priority_queue<info> q;
inline void addedge(int &x, int y) {
nxt[++ec] = x;
lnk[ec] = y;
x = ec;
}
int dfs(int u);
int calc(int x) {
int res = 0;
for (int i = monster[x]; i; i = nxt[i])
if (lnk[i] != -1 && f[lnk[i]] == -1) return -1;
for (int i = monster[x]; i; i = nxt[i])
if (lnk[i] == -1)
++res;
else if (dfs(lnk[i]) == -2)
return -2;
else
res = std::min(res + g[lnk[i]], lim);
return std::min(lim, res);
}
int dfs(int u) {
if (g[u] != 0xC0C0C0C0) return g[u];
if (f[u] == -1) return g[u] = -2;
if (inst[u]) return g[u] = -2;
inst[u] = true;
int res = 0xC0C0C0C0;
for (int i = sid[u]; i; i = nxt[i]) {
int t = calc(lnk[i]);
if (t == -2) return inst[u] = false, g[u] = -2;
res = std::max(res, t);
}
inst[u] = false;
return g[u] = res;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1, x, k; i <= m; ++i) {
scanf("%d%d", from + i, &k);
addedge(sid[from[i]], i);
while (k--) {
scanf("%d", &x);
addedge(monster[i], x);
if (x > 0)
addedge(split[x], i), ++ind[i];
else
++dis[i];
}
if (!ind[i]) q.push(info(dis[i], from[i]));
}
memset(f, -1, sizeof f);
memset(g, 0xC0, sizeof g);
while (!q.empty()) {
const info res = q.top();
q.pop();
if (f[res.mid] != -1) continue;
f[res.mid] = res.dis;
for (int i = split[res.mid]; i; i = nxt[i]) {
dis[lnk[i]] = std::min(dis[lnk[i]] + res.dis, lim);
if (!--ind[lnk[i]]) q.push(info(dis[lnk[i]], from[lnk[i]]));
}
}
for (int i = 1; i <= n; ++i) dfs(i);
for (int i = 1; i <= n; ++i)
printf("%d %d\n", f[i], (f[i] == -1) ? -1 : g[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1010], ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n - 1; i++)
if ((a[i] > a[i - 1] && a[i] > a[i + 1]) ||
(a[i] < a[i - 1] && a[i] < a[i + 1]))
ans++;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string arr0[] = {"C", "C#", "D", "D#", "E", "F",
"F#", "G", "G#", "A", "B", "H"};
int pos(string s1) { return find(arr0, arr0 + 12, s1) - arr0; }
int main() {
string arr[3];
string res = "strange\n";
cin >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
do {
int dist1 = (pos(arr[1]) - pos(arr[0]) + 12) % 12;
int dist2 = (pos(arr[2]) - pos(arr[1]) + 12) % 12;
if (dist1 == 4 && dist2 == 3) res = "major\n";
if (dist1 == 3 && dist2 == 4) res = "minor\n";
} while (next_permutation(arr, arr + 3));
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e4;
int n, ans[N][N / 50], mini;
vector<int> r, curR;
vector<pair<int, int> > rid, curAns, rid2;
struct Game {
int fid, sid, thid, cnt;
Game(){};
Game(int fid, int sid, int thid, int cnt)
: fid(fid), sid(sid), thid(thid), cnt(cnt){};
};
vector<Game> games;
void prepare() {}
void read() {
mini = N;
scanf("%d", &n);
for (auto i = (0); i < (n); ++i) {
int ri;
scanf("%d", &ri);
r.push_back(ri);
rid.push_back(make_pair(ri, i));
mini = min(mini, ri);
}
sort(rid.begin(), rid.end());
}
void printBad() {
int sz = 0;
for (auto i = (0); i < (n - 1); ++i) {
for (auto j = (0); j < (100); ++j) {
for (auto k = (0); k < (n); ++k) {
if (k == i || k - 1 == i) {
ans[sz][k] = 1;
} else {
ans[sz][k] = 0;
}
}
++sz;
}
}
printf("0\n");
printf("%d\n", sz);
for (auto i = (0); i < (sz); ++i) {
for (auto j = (0); j < (n); ++j) {
printf("%d", ans[i][j]);
}
printf("\n");
}
}
void printGames(int ans) {
printf("%d\n", ans);
int cnt = 0;
for (auto i = (0); i < ((int)(games.size())); ++i) {
cnt += games[i].cnt;
}
printf("%d\n", cnt);
for (auto i = (0); i < ((int)(games.size())); ++i) {
for (auto j = (0); j < (games[i].cnt); ++j) {
for (auto k = (0); k < (n); ++k) {
if (games[i].fid == k || games[i].sid == k || games[i].thid == k) {
printf("1");
} else {
printf("0");
}
}
printf("\n");
}
}
exit(0);
}
void solve() {
for (int curAns = mini; curAns > 0; --curAns) {
games.clear();
rid2 = rid;
int sum = 0;
for (auto i = (0); i < (n - 1); ++i) {
if (rid2[i].first != curAns) {
games.push_back(Game(rid2[i].second, rid2[i + 1].second, -1,
rid2[i].first - curAns));
}
rid2[i + 1].first -= (rid2[i].first - curAns);
}
int curId = rid2.back().second;
int rem = rid2.back().first - curAns;
int needGames = (rem / 2 + rem % 2);
for (auto i = (0); i < ((int)(games.size())); ++i) {
if (games[i].sid != curId) {
needGames -= games[i].cnt;
}
}
if (needGames > 0) {
continue;
}
int remPlay = rid2.back().first - curAns;
for (auto i = ((int)(games.size()) - 1); i >= (0); --i) {
if (games[i].fid != curId && games[i].sid != curId &&
games[i].thid != curId) {
if (remPlay % 2 == 1) {
--remPlay;
games[i].thid = curId;
if (games[i].cnt > 1) {
games.push_back(
Game(games[i].fid, games[i].sid, -1, games[i].cnt - 1));
}
games[i].cnt = 1;
break;
}
}
}
for (auto i = ((int)(games.size()) - 1); i >= (0); --i) {
if (games[i].fid != curId && games[i].sid != curId &&
games[i].thid != curId) {
int miniPlay = min(remPlay / 2, games[i].cnt);
games[i].cnt -= miniPlay;
remPlay -= miniPlay * 2;
games.push_back(Game(games[i].fid, curId, -1, miniPlay));
games.push_back(Game(games[i].sid, curId, -1, miniPlay));
}
}
printGames(curAns);
}
printBad();
}
int main() {
prepare();
read();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define F first
#define S second
#define endl "\n"
#define Endl "\n"
#define emdl "\n"
#define mod 1000000007
#define pb push_back
// #define mp make_pair
#define all(x) x.begin(),x.end()
using namespace std;
// bool sortBy(const pair<int,pair<int,int>> &a,const pair<int,pair<int,int>> &b){
// if(a.S.F==b.S.F)
// return a.F<b.F;
// return a.S.F<b.S.F;
// }
// #define MAXN 50003
// int pf[MAXN];
// vector<int> primes;
// void sieve(){
// long long int i,j;
// pf[1] = 1;
// for (i=2; i<MAXN; i++)
// pf[i] = i;
// for (i=2; i*i<MAXN; i++){
// if (pf[i] == i){
// for (j=i*i; j<MAXN; j+=i)
// if (pf[j]==j)
// pf[j] = i;
// }
// }
// for(int i=2;i<MAXN;i++){
// if(pf[i]==i){
// primes.push_back(i);
// }
// }
// }
// vector<int> factors(int x){
// vector<int> ret;
// while (x != 1){
// int fact=pf[x];
// ret.push_back(pf[x]);
// while(fact!=1&&x%fact==0)
// x/=fact;
// }
// return ret;
// }
// set<long long int>poww;
// void init(){
// long long int temp=1;
// for(int i=1;i<43;i++){
// poww.insert(temp);
// temp*=2;
// }
// }
// int summ(long long int n){
// int cnt=0;
// while(n){
// cnt+=n%10;
// n/=10;
// }
// return cnt;
// }
void init(){
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
int qwe=1;
cin>>qwe;
init();
//sieve();
while(qwe--){
int n;
cin>>n;
n+=n;
vector<int> v(n);
for(int i =0; i< n;i++){
cin>>v[i];
}
int flag = 0;
sort(all(v));
map<int,int> a;
for(int twerp =0;twerp<n-1;twerp++){
for(int i=0;i<n;i++){
a[v[i]]++;
}
a[v[twerp]]--;
int num = v[n-1];
a[num]--;
int p =n-2;
vector<pair<int,int>> pa;
while(true){
if(p<0){
break;
}
if(a[v[p]]==0){
p--;
continue;
}
if(a[num-v[p]]==0 ||(num-v[p]==v[p]&&a[num-v[p]]==1)){
break;
}
pa.pb({v[p],num-v[p]});
a[v[p]]--;
a[num-v[p]]--;
num = v[p];
p--;
}
int ans = 0;
for(int i =0;i<n;i++){
ans+=a[v[i]];
}
a.clear();
if(ans!=0){
continue;
}
flag = 1;
cout<<"YES"<<endl<<v[twerp]+v[n-1]<<endl<<v[n-1]<<" "<<v[twerp]<<endl;
for(auto j:pa){
cout<<j.F<<" "<<j.S<<endl;
}
break;
}
if(!flag){
cout<<"NO"<<endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x1, x2, y1, y2;
scanf("%d%d %d%d %d%d", &a, &b, &x1, &y1, &x2, &y2);
int i, j, ans;
int X3 = x1 + y1;
int X4 = x2 + y2;
i = (int)(X3) / (2 * a);
j = (int)(X4) / (2 * a);
if (X3 < 0) i--;
if (X4 < 0) j--;
ans = i - j;
if (ans < 0) ans = ans * (-1);
int y3 = x1 - y1;
int y4 = x2 - y2;
i = (int)(y3) / (2 * b);
j = (int)(y4) / (2 * b);
if (y3 < 0) i--;
if (y4 < 0) j--;
i = i - j;
if (i < 0) i = -i;
if (ans < i) ans = i;
printf("%d", ans);
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// - - - - - - Data Types - - - - - - //
typedef long int LI;
typedef long long LL;
// - - - - - - Vectors - - - - - - //
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<string> VS;
typedef vector<double> VD;
typedef vector<VI> VVI;
#define scanVI(v, n) for(int i=0; i<n; i++){ int x; cin >> x; v.PB(x); }
#define scanVLLI(v, n) for(int i=0; i<n; i++){ LLI x; cin >> x; v.PB(x); }
#define scanVS(v, n) for(int i=0; i<n; i++){ string x; cin >> x; v.PB(x); }
#define scanVD(v, n) for(int i=0; i<n; i++){ double x; cin >> x; v.PB(x); }
// - - - - - - Maps - - - - - - //
typedef map<int, int> MII;
typedef map<int, string> MIS;
typedef map<int, char> MIC;
typedef map<string, int> MSI;
typedef map<char, int> MCI;
typedef map<int, VI> MIVI;
// - - - - - - Pairs - - - - - - //
typedef pair<int, int> PII;
typedef pair<string, string> PSS;
typedef pair<char, char> PCC;
typedef pair<int, string> PIS;
typedef pair<int, char> PIC;
typedef pair<string, char> PSC;
// - - - - - - Sets - - - - - - //
typedef set<int> SI;
typedef set<LL> SLL;
typedef set<string> SS;
typedef set<char> SC;
// - - - - - - - - - - - - - - - - - - //
#define PF printf
#define SF scanf
#define PB push_back
#define POP pop_back()
#define PP prev_permutation
#define NP next_permutation
#define MP make_pair
#define CLRN(a, b) memset(a, b, sizeof(a))
#define CLR(a) memset(a, 0, sizeof(a))
#define ALL(a) a.begin(), a.end()
#define ALLN(a, n) (a, a+n)
#define BSRCN(a, n, x) binary_search(ALLN(a, n), x)
#define BSRC binary_search
#define MAX 10000007
#define MIN -10000007
#define inf int(1e6+9)
#define PI acos(-1)
#define BR PF("\n")
#define FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define READ() freopen("input.txt", "r", stdin)
#define WRITE() freopen("output.txt", "w", stdout)
#define len(a) a.length()
#define rsort(a) sort(a.rbegin(), a.rend())
#define pvec(v) for(auto x: v) cout<<x<<" "
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
/*----------------------Graph Moves----------------*/
int ROW[]={+1,-1,+0,+0};
int COL[]={+0,+0,+1,-1};
int X[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
int Y[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
int KX[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
int KY[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*------------------------------------------------*/
// ---------------------DEBUG---------------------//
#ifdef WOLF
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
template < typename Arg1 >
void __f(const char* name, Arg1&& arg1){
cout << name << " = " << arg1 << std::endl;
}
template < typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names, ',');
cout.write(names, comma - names) << " = " << arg1 <<" | ";
__f(comma+1, args...);
}
#else
#define debug(...)
#endif
//------------------------------------------------//
void fastscan(int &number)
{
bool negative = false;
int c;
number = 0;
c = getchar();
if (c=='-')
{
negative = true;
c = getchar();
}
for (; (c>47 && c<58); c=getchar())
number = number *10 + c - 48;
if (negative)
number *= -1;
}
LL GCD(LL a, LL b) { return b == 0 ? a : GCD(b , a % b); }
int LCM(int a, int b) { return a * (b/GCD(a, b)); }
bool CMP(int a, int b) { return a>b; }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - END - - - - - - - - - - - - - - - - - - - - - - - - - //
int main()
{
// FastIO;
#ifdef WOLF
clock_t Start=clock();
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
int t, ca = 1;
cin>>t;
while (t--) {
int n;
cin>>n;
if (n & 1) {
cout<<"3 1 2";
for (int i=4; i<=n; i++) {
cout<<" "<<i+1<<" "<<i;
i++;
}
cout<<endl;
}
else {
cout<<"2 1";
for (int i=3; i<=n; i++) {
cout<<" "<<i+1<<" "<<i;
i++;
}
cout<<endl;
}
}
END:
#ifdef WOLF
fprintf(stderr, "\n>>Runtime: %.10fs\n", (double) (clock() - Start) / CLOCKS_PER_SEC);
#endif
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 105;
long double chance[N][M];
long double jie[M];
long double ans = 0.0;
int cc[N];
int data[N];
int n, m;
long double zuhe(int x, int y) {
long double now = 1.0;
int i;
for (i = x; i > x - y; i--) now *= i;
for (i = 1; i <= y; i++) now /= i;
return now;
}
long double calc(int a, int b, int c, int d) {
long double now = zuhe(b, d);
now *= zuhe(a - b, c - d);
now /= zuhe(a, c);
return now;
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &data[i]);
cc[i] = data[i];
chance[i][data[i]] = 1.0;
if (!data[i]) ans += 1.0;
}
scanf("%d", &m);
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
memset(jie, 0, sizeof jie);
for (i = min(data[a], cc[a]); i >= 0; i--) {
int l = max(0, c - cc[a] + i);
int r = min(c, i);
for (j = l; j <= r; j++)
jie[i - j] += chance[a][i] * calc(cc[a], i, c, j);
}
ans -= chance[a][0];
for (i = 0; i <= data[a]; i++) chance[a][i] = jie[i];
ans += chance[a][0];
cc[a] -= c;
cc[b] += c;
double ansx = ans;
printf("%.12f\n", ansx);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, x, a, b, m, l = 1002;
void center(int a, int b, int &m, int &l) {
m = max(m, a);
l = min(l, b);
}
int main() {
cin >> n >> x;
while (n--) {
cin >> a >> b;
if (a > b) swap(a, b);
center(a, b, m, l);
}
cout << (m > l ? -1 : x < m ? m - x : x > l ? x - l : 0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100 + 10];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
const int mo = 811287553;
int n, m, s, t;
struct Graph {
struct edge {
edge *next;
int y, l;
};
edge *first[100005], e[100005], *etot = e;
inline void addedge(int x, int y, int l) {
*++etot = (edge){first[x], y, l};
first[x] = etot;
}
long long dist[100005];
int cnt[100005];
long long T[131072 << 1];
inline void mod(int x, long long val) {
T[x += 131072] = val;
while (x ^ 1) T[x >> 1] = std::min(T[x], T[x ^ 1]), x >>= 1;
}
inline int getpos() {
long long mi = T[1];
int p = 1;
while (p < 131072) {
p <<= 1;
if (T[p] != mi) ++p;
}
return p - 131072;
}
inline void solve(int S) {
memset(T, 0x3f, sizeof(T));
memset(dist, 0x3f, sizeof(dist));
mod(S, 0);
dist[S] = 0;
cnt[S] = 1;
while (T[1] != 0x3f3f3f3f3f3f3f3fLL) {
long long mi = T[1];
int x = getpos();
dist[x] = mi;
mod(x, 0x3f3f3f3f3f3f3f3fLL);
for (edge *e = first[x]; e; e = e->next) {
int y = e->y;
long long tmp = mi + e->l;
if (tmp < dist[y]) {
dist[y] = tmp;
mod(y, tmp);
cnt[y] = cnt[x];
} else if (tmp == dist[y]) {
cnt[y] = (cnt[y] + cnt[x]) % mo;
}
}
}
}
};
Graph g1, g2;
int _x[100005], _y[100005], _l[100005];
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t);
int i;
for (i = 1; i <= m; i++) {
int x, y, l;
scanf("%d%d%d", &x, &y, &l);
_x[i] = x;
_y[i] = y;
_l[i] = l;
g1.addedge(x, y, l);
g2.addedge(y, x, l);
}
g1.solve(s);
g2.solve(t);
long long D = g1.dist[t];
for (i = 1; i <= m; i++) {
int x = _x[i], y = _y[i], l = _l[i];
long long tmp = D - g1.dist[x] - g2.dist[y] - 1;
bool Y = 1LL * g1.cnt[x] * g2.cnt[y] % mo == g1.cnt[t] &&
(g1.dist[x] + g2.dist[y] + l == D);
if (Y) {
puts("YES");
continue;
}
if (tmp < 1) {
puts("NO");
} else if (l - tmp > 0) {
printf("CAN %I64d\n", l - tmp);
} else {
puts("NO");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int mod = inf + 7;
struct Edge {
int to, cost, cap, id;
Edge(int a1, int a2, int a3, int a4) {
to = a1;
cost = a2;
cap = a3;
id = a4;
}
};
int A, B, n, b[300100], qe[300100], T, x, Ta, Res, S, m, d[300100], inq[300100],
len, c[30];
vector<Edge> g[300100];
string second, t;
pair<int, int> p[300100];
void add(int u, int v, int cost, int cap) {
Edge e1(v, cost, cap, (int)g[v].size());
Edge e2(u, -cost, 0, (int)g[u].size());
g[u].push_back(e1);
g[v].push_back(e2);
}
bool djikstra() {
for (int i = 0; i <= T; i++) d[i] = inf, inq[i] = 0;
d[S] = 0;
int l = 0, r = 0;
qe[0] = S;
while (l <= r) {
int v = qe[l];
l++;
inq[v] = 0;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i].to;
int cost = g[v][i].cost;
int cap = g[v][i].cap;
int id = g[v][i].id;
if (cap > 0 && d[to] > d[v] + cost) {
d[to] = d[v] + cost;
p[to] = make_pair(v, i);
if (!inq[to]) inq[to] = 1, qe[++r] = to;
}
}
}
return d[T] != inf;
}
int pref = 0;
void upd() {
int v = T;
int curf = inf;
while (v != S) {
int u = p[v].first;
int id = p[v].second;
curf = min(curf, g[u][id].cap);
v = u;
}
v = T;
while (v != S) {
int u = p[v].first;
int id = p[v].second;
int rev = g[u][id].id;
g[u][id].cap -= curf;
Res += curf * g[u][id].cost;
g[v][rev].cap += curf;
v = u;
}
pref += curf;
}
int main() {
cin >> second;
cin >> m;
int o = (m + 5) * 26;
S = 0, T = o + 50;
for (int z = 1; z <= m; z++) {
cin >> t >> x;
len = t.size();
memset(c, 0, sizeof c);
add(0, z, z, x);
for (int i = 0; i < len; i++) c[t[i] - 'a' + 1]++;
for (int i = 1; i <= 26; i++) {
add(z, m + (z - 1) * 26 + i, 0, c[i]);
add(m + (z - 1) * 26 + i, o + i, 0, inf);
}
}
len = second.size();
memset(c, 0, sizeof c);
for (int i = 0; i < len; i++) c[second[i] - 'a' + 1]++;
for (int i = 1; i <= 26; i++) add(o + i, T, 0, c[i]);
while (djikstra()) {
upd();
}
if (pref < len) {
cout << -1;
return 0;
}
printf("%d", Res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node *left, *right;
int expanded;
node() {
expanded = 0;
left = nullptr;
right = nullptr;
}
void expand() {
if (!expanded) {
if (left == nullptr) left = new node();
if (right == nullptr) right = new node();
expanded = 1;
}
}
};
const int maxn = 200200;
const int mod = 998244353;
node *t[maxn];
int sum[maxn << 2], mul[maxn << 2], add[maxn << 2];
void push(int id, int l, int r) {
if (mul[id] != 1) sum[id] = 1ll * sum[id] * mul[id] % mod;
if (add[id]) sum[id] += (1ll * (r - l + 1) * add[id] % mod);
if (sum[id] >= mod) sum[id] -= mod;
if (l != r) {
int nd = id << 1;
for (int rot = 0; rot < 2; rot++) {
nd ^= 1;
if (mul[id] != 1) {
mul[nd] = 1ll * mul[nd] * mul[id] % mod;
add[nd] = 1ll * add[nd] * mul[id] % mod;
}
add[nd] += add[id];
if (add[nd] >= mod) add[nd] -= mod;
}
}
mul[id] = 1;
add[id] = 0;
}
void addOne(int id, int l, int r, int x, int y) {
push(id, l, r);
if (l > y || r < x) return;
if (x <= l && r <= y) {
add[id] += 1;
push(id, l, r);
return;
}
int mid = (l + r) >> 1;
addOne(id << 1, l, mid, x, y);
addOne(id << 1 | 1, mid + 1, r, x, y);
sum[id] = sum[id << 1] + sum[id << 1 | 1];
if (sum[id] >= mod) sum[id] -= mod;
}
void mulTwo(int id, int l, int r, int x, int y) {
push(id, l, r);
if (l > y || r < x) return;
if (x <= l && r <= y) {
mul[id] = mul[id] << 1;
if (mul[id] >= mod) mul[id] -= mod;
add[id] = add[id] << 1;
if (add[id] >= mod) add[id] -= mod;
push(id, l, r);
return;
}
int mid = (l + r) >> 1;
mulTwo(id << 1, l, mid, x, y);
mulTwo(id << 1 | 1, mid + 1, r, x, y);
sum[id] = sum[id << 1] + sum[id << 1 | 1];
if (sum[id] >= mod) sum[id] -= mod;
}
int get(int id, int l, int r, int x, int y) {
push(id, l, r);
if (l > y || r < x) return 0;
if (x <= l && r <= y) return sum[id];
int mid = (l + r) >> 1;
int re = get(id << 1, l, mid, x, y);
re += get(id << 1 | 1, mid + 1, r, x, y);
if (re >= mod) re -= mod;
return re;
}
int n;
void upd(node *&root, int l, int r, int x, int y) {
if (l > y || r < x) return;
if (root == nullptr) {
mulTwo(1, 1, n, max(l, x), min(r, y));
return;
}
if (x <= l && r <= y) {
if (!root->expanded) {
addOne(1, 1, n, l, r);
delete root;
root = nullptr;
return;
}
}
root->expand();
int mid = (l + r) >> 1;
upd(root->left, l, mid, x, y);
upd(root->right, mid + 1, r, x, y);
if (root->left == nullptr && root->right == nullptr) {
delete root;
root = nullptr;
}
}
int main() {
for (int e = 0; e < maxn * 4; e++) mul[e] = 1;
int q;
scanf("%d %d", &n, &q);
for (int e = 1; e <= n; e++) t[e] = new node();
for (int e = 1; e <= q; e++) {
int ty, l, r;
scanf("%d %d %d", &ty, &l, &r);
if (ty == 2) {
printf("%d\n", get(1, 1, n, l, r));
} else {
int x;
scanf("%d", &x);
upd(t[x], 1, n, l, r);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
const long long int INF = 1011111111;
const long long int LLINF = 1000111000111000111LL;
const long double EPS = 1e-10;
const long double PI = 3.14159265358979323;
using namespace std;
long long int power(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return power((x * x), n / 2);
else
return x * power((x * x), (n - 1) / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, i, j, k;
cin >> n >> m >> k;
vector<long long int> v(n);
for (i = 0; i < n; i++) cin >> v[i];
long long int ans = -INF;
for (i = 0; i < m; i++) {
long long int temp = 0;
for (j = 0; j < n; j++) {
if (j % m == i) {
temp += (v[j] - k);
} else
temp += v[j];
temp = max(temp, 0LL);
if (j % m == i) ans = max(ans, temp);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sort_arra[1000010];
int starting_permutation[1000010];
int vertexlist[1000010];
vector<int> adjancylist[1000010];
vector<int> arra;
void dfs(int i) {
int x;
arra.push_back(i);
vertexlist[i] = 1;
x = adjancylist[i].size();
for (int j = 0; j < x; ++j)
if (vertexlist[adjancylist[i][j]] == 0) dfs(adjancylist[i][j]);
}
int main() {
int n, m, first, second, x;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", starting_permutation + i);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &first, &second);
adjancylist[first - 1].push_back(second - 1);
adjancylist[second - 1].push_back(first - 1);
}
for (int i = 0; i < n; ++i)
if (vertexlist[i] == 0) {
arra.clear();
dfs(i);
sort(arra.begin(), arra.end());
x = arra.size();
for (int j = 0; j < x; ++j) sort_arra[j] = starting_permutation[arra[j]];
sort(sort_arra, sort_arra + x, greater<int>());
for (int j = 0; j < x; ++j) starting_permutation[arra[j]] = sort_arra[j];
}
for (int i = 0; i < n; ++i) printf("%d ", starting_permutation[i]);
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long LL_INF = LLONG_MAX;
void print_vector(vector<int>& v) {
for (int i : v) cout << i << " ";
cout << '\n';
}
void print_array(int a[], int s, int e) {
for (int i = s; i < e; ++i) cout << a[i] << " ";
cout << '\n';
}
int lc(int n) { return n << 1; }
int rc(int n) { return (n << 1) + 1; }
int avg(int a, int b) { return (a + b) / 2; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) cin >> A[i];
if (n == 1) {
if (A[0] & 1)
cout << "-1\n";
else
cout << 1 << '\n' << 1 << '\n';
} else {
int no1 = A[0], no2 = A[1];
if (no1 & 1) {
if (no2 & 1)
cout << "2\n" << 1 << " " << 2 << '\n';
else
cout << "1\n" << 2 << '\n';
} else
cout << "1\n" << 1 << '\n';
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int power(int n, int p) {
if (p == 0) return 1;
if (p == 1) return n % 1000003;
if (p % 2 == 0) {
long long int k = (power(n, p / 2) % 1000003);
return (k * k) % 1000003;
} else {
long long int k = (power(n, p / 2) % 1000003);
k = (k * k) % 1000003;
k = k * n;
return k % 1000003;
}
return -1;
}
int main() {
string str;
string s;
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str[i] == '>') {
s = s + "1000";
continue;
}
if (str[i] == '<') {
s = s + "1001";
continue;
}
if (str[i] == '+') {
s = s + "1010";
continue;
}
if (str[i] == '-') {
s = s + "1011";
continue;
}
if (str[i] == '.') {
s = s + "1100";
continue;
}
if (str[i] == ',') {
s = s + "1101";
continue;
}
if (str[i] == '[') {
s = s + "1110";
continue;
}
if (str[i] == ']') {
s = s + "1111";
continue;
}
}
reverse(s.begin(), s.end());
int k = 0;
len = s.length();
for (int i = 0; i < len; i++) {
if (s[i] == '1') {
k = k + power(2, i);
k = k % 1000003;
}
}
cout << k << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> con[100000];
long long cost[100000];
long long pcost[100000];
long long ncost[100000];
int mark[100000] = {0};
long long ans = 0;
void dfs(int i) {
int j;
mark[i] = 1;
for (j = 0; j < con[i].size(); j++) {
if (!mark[con[i][j]]) {
dfs(con[i][j]);
pcost[i] = max(pcost[i], pcost[con[i][j]]);
ncost[i] = max(ncost[i], ncost[con[i][j]]);
}
}
cost[i] += pcost[i];
cost[i] -= ncost[i];
if (cost[i] < 0) {
pcost[i] += abs(cost[i]);
} else {
ncost[i] += abs(cost[i]);
}
return;
}
int main() {
int n;
cin >> n;
int i;
int p, q;
for (i = 0; i < n - 1; i++) {
cin >> p >> q;
con[p - 1].push_back(q - 1);
con[q - 1].push_back(p - 1);
}
for (i = 0; i < n; i++) {
cin >> cost[i];
}
dfs(0);
ans += pcost[0] + ncost[0];
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[5005];
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int temp1 = 0, temp2 = 0, temp3 = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (temp1 == 0)
temp1 = i;
else if (a[i] != a[temp1])
temp2 = i;
}
if (temp2 == 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 2; i <= n; i++) {
if (a[i] != a[temp1])
cout << i << ' ' << temp1 << endl;
else
cout << i << ' ' << temp2 << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 510;
int dis[MAXN][MAXN], n, X, col[MAXN];
int head[MAXN], nxt[MAXN << 1], to[MAXN << 1], val[MAXN << 1], tot;
void addedge(int b, int e, int v) {
nxt[++tot] = head[b];
to[head[b] = tot] = e;
val[tot] = v;
nxt[++tot] = head[e];
to[head[e] = tot] = b;
val[tot] = v;
}
void dfs(int u, int rt, int fa = 0, long long d = 0) {
if (d <= X) dis[u][rt] = dis[rt][u] = 1;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) dfs(to[i], rt, u, d + val[i]);
}
namespace Simplex {
const double eps = 1e-6;
double A[MAXN][MAXN * 2], *B = A[0];
int base[MAXN * 2];
int n, m;
void debug() {
std::cout << "Maximize ";
std::cout << B[0];
for (int i = 1; i <= n + m; ++i)
if (fabs(B[i])) {
std::cout << " + ";
std::cout << B[i] << " x" << i;
}
int fir = 0;
std::cout << std::endl << "s.t." << std::endl;
for (int i = 1; i <= m; ++i) {
fir = 0;
int ax = 0;
for (int j = 1; j <= n + m; ++j)
if (base[j] == i) ax = j;
std::cout << "x" << ax << " = ";
for (int j = 1; j <= n + m; ++j) {
if (fabs(A[i][j])) {
if (fir) std::cout << " + ";
std::cout << A[i][j] << " x" << j;
fir = true;
}
}
std::cout << " + " << A[i][0] << std::endl;
}
std::cout << std::endl;
}
void append(double* src, double tar, int typ) {
if (typ == 2)
append(src, tar, 0), append(src, tar, 1);
else if (typ == 1) {
tar = -tar;
for (int i = 1; i <= n; ++i) src[i] = -src[i];
append(src, tar, 0);
} else {
++m;
base[m + n] = m;
A[m][0] = tar;
memcpy(A[m] + 1, src + 1, n << 3);
for (int i = 1; i <= n + m; ++i) A[m][i] = -A[m][i];
}
}
bool errtag;
void pivot(int x, int y) {
int at = base[x];
double coef = 1 / A[at][y];
A[at][y] = 0, A[at][x] = -1;
for (int i = 0; i <= n + m; ++i) A[at][i] *= -coef;
for (int i = 0; i <= m + 1; ++i) {
for (int j = 0; j <= n + m; ++j) A[i][j] += A[i][y] * A[at][j];
A[i][y] = 0;
}
std::swap(base[x], base[y]);
}
double simplex() {
while (true) {
int at = 0;
double v = -1e20;
for (int i = 1; i <= n + m; ++i)
if (!base[i] && B[i] > eps && B[i] > v) v = B[i], at = i;
if (!at) return *B;
int a2 = 0;
double vx = 1e20;
for (int i = 1; i <= n + m; ++i)
if (int b = base[i])
if (A[b][at] < -eps && A[b][0] < vx * -A[b][at])
a2 = i, vx = -A[b][0] / A[b][at];
if (!a2) {
errtag = true;
return 1e20;
}
pivot(a2, at);
}
}
void init() {
int at = 0;
double tv = -eps;
for (int i = 1; i <= n + m; ++i)
if (int b = base[i])
if (A[b][0] < tv) tv = A[b][0], at = i;
if (!at) return;
std::swap(A[0], A[m + 1]);
++n;
B[n + m] = -1;
for (int i = 1; i <= m; ++i) A[i][n + m] = 1;
pivot(at, n + m);
simplex();
if (fabs(B[0]) > eps) {
errtag = true;
return;
}
std::swap(A[0], A[m + 1]);
++m;
base[n + m] = m;
}
} // namespace Simplex
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> X;
int m = 0;
for (int i = 1; i <= n; ++i) std::cin >> col[i], m += col[i];
for (int i = 1; i < n; ++i) {
int t1, t2, t3;
std::cin >> t1 >> t2 >> t3;
addedge(t1, t2, t3);
}
for (int i = 1; i <= n; ++i) dfs(i, i);
static double tmp[MAXN];
memset(tmp, 0, sizeof tmp);
Simplex::n = n;
for (int i = 1; i <= n; ++i) Simplex::B[i] = col[i];
for (int i = 1; i <= n; ++i) tmp[i] = 1;
Simplex::append(tmp, m, 2);
for (int i = 1; i <= n; ++i) {
memset(tmp, 0, sizeof tmp);
for (int j = 1; j <= n; ++j) tmp[j] = dis[i][j];
Simplex::append(tmp, 1, 1);
}
Simplex::init();
double res = Simplex::errtag ? 0 : Simplex::simplex();
int ans = m - floor(res + 0.1);
if (Simplex::errtag) ans = -1;
std::cout << ans << std::endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << '\n';
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
const int MOD = 1e9 + 7;
const int INF = 1e9;
int n, flag, ans = 1;
set<int> buy, sell, middle;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int max_buy = -INF, min_sell = INF;
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
string s;
cin >> s >> x;
if (flag) continue;
if (s == "ADD") {
if (x <= max_buy) buy.insert(x);
if (x >= min_sell) sell.insert(x);
if (x > max_buy && x < min_sell) middle.insert(x);
} else {
if (x < max_buy || x > min_sell) {
cout << 0 << '\n';
flag = 1;
continue;
}
if (x > max_buy && x < min_sell) ans = (ans + ans) % MOD;
for (auto val : middle) {
if (val < x)
buy.insert(val);
else
sell.insert(val);
}
middle.clear();
if (buy.find(x) != buy.end())
buy.erase(x);
else
sell.erase(x);
max_buy = -INF;
min_sell = INF;
if (!buy.empty()) max_buy = (*prev(buy.end()));
if (!sell.empty()) min_sell = (*sell.begin());
}
}
if (flag) return 0;
ans = ((long long)ans * (long long)(middle.size() + 1)) % (long long)MOD;
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxx = 1e5 + 20, inf = 1e13 + 2;
vector<pair<long long, long long> > adj[maxx];
set<pair<long long, long long> > s;
long long n, d[maxx], m;
pair<long long, long long> dad[maxx];
pair<pair<long long, long long>, long long> e[maxx];
bool mark[maxx];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
x--, y--;
e[i] = make_pair(make_pair(x, y), z);
adj[x].push_back(make_pair(y, i));
adj[y].push_back(make_pair(x, i));
}
fill(d, d + maxx, inf);
s.insert(make_pair(0, 0));
d[0] = 0;
while (s.size()) {
pair<long long, long long> x = *s.begin();
s.erase(s.begin());
for (pair<long long, long long> y : adj[x.second]) {
long long e1 = y.first, e2 = y.second;
long long tool = maxx + (1 - e[e2].second);
if (d[e1] > tool + d[x.second]) {
s.erase(make_pair(d[e1], e1));
d[e1] = tool + d[x.second];
s.insert(make_pair(d[e1], e1));
dad[e1] = make_pair(x.second, e2);
}
}
}
long long k = n - 1, t = 0;
while (k != 0) {
mark[dad[k].second] = true;
k = dad[k].first;
}
for (int i = 0; i < m; i++) {
if (mark[i] && e[i].second == 0 || !mark[i] && e[i].second == 1) t++;
}
cout << t << '\n';
for (int i = 0; i < m; i++) {
if (mark[i] && e[i].second == 0 || !mark[i] && e[i].second == 1)
cout << e[i].first.first + 1 << " " << e[i].first.second + 1 << " "
<< 1 - e[i].second << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500001;
const int sq = 800;
int A[maxn];
int B[sq][sq];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
memset(A, 0, sizeof(A));
;
memset(B, 0, sizeof(B));
;
while (q--) {
int Q, x, y;
cin >> Q >> x >> y;
if (Q == 1) {
A[x] += y;
for (int i = 1; i < sq; i++) {
B[i][x % i] += y;
}
} else {
if (x < sq) {
cout << B[x][y] << '\n';
} else {
int ans = 0;
for (int i = y; i < maxn; i += x) ans += A[i];
cout << ans << '\n';
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int modpow(int x, int n) {
if (!n) return 1 % 1000000007;
int u = modpow(x, n / 2);
u = (u * u) % 1000000007;
if (n % 2) u = (u * x) % 1000000007;
return u;
}
int inv(int x) { return modpow(x, 1000000007 - 2); }
void seive(long long n) {
bool prim[n + 1];
memset(prim, (true), sizeof prim);
for (long long i = 2; i * i <= n; i++) {
if (prim[i]) {
for (long long j = i * 2; j <= n; j += i) {
prim[j] = false;
}
}
}
}
float area(int x0, int y0, int x1, int y1, int x2, int y2) {
return float(abs(x0 * (y1 - y2) + x1 * (y2 - y0) + x2 * (y0 - y1))) / 2;
}
int gcd(int a, int b) {
if (b % a == 0) return a;
if (!a || !b) return a | b;
return gcd(b % a, a);
}
int main() {
long long n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
int i = -1;
for (long long p = 0, _n = (n); p < _n; p++) {
if (s[p] == '*') i = p;
}
if (i != -1) {
if ((n - 1) <= m) {
if (s.substr(0, i) == t.substr(0, i)) {
if (s.substr(i + 1, n - i - 1) ==
t.substr(m - (n - i - 1), n - i - 1)) {
cout << "Yes";
} else {
cout << "No";
}
} else {
cout << "No";
}
} else {
cout << "No";
}
} else {
if (s == t)
cout << "Yes";
else
cout << "No";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
long long int inf = 0x3f3f3f3f3f3f3f3f;
const long long int mod = 1e9 + 7;
const long long int mx = 5 * 1000000;
vector<vector<long long int>> ans;
bool ok[mx];
vector<long long int> find(vector<long long int> a, long long int cur) {
if (cur >= a.size()) return a;
long long int index2, index1;
long long int n = a.size();
for (long long int i = 0; i < n; i++) {
if (a[i] == cur + 1) index2 = i;
if (a[i] == cur) index1 = i;
}
if (index1 > index2) {
long long int a1 = 0, a2 = 0, a3 = 0, a4 = 0;
vector<long long int> new_a;
for (long long int i = index1 + 1; i < n; i++) new_a.push_back(a[i]), a1++;
long long int ii = index1;
long long int index11 = ii;
for (long long int i = ii - 1; i > index2; i--) {
if (a[i] + 1 == a[i + 1])
index11 = i;
else
break;
}
for (long long int i = index11; i <= ii; i++) new_a.push_back(a[i]), a2++;
for (long long int i = index2; i < index11; i++)
new_a.push_back(a[i]), a3++;
for (long long int i = 0; i < index2; i++) new_a.push_back(a[i]), a4++;
ans.push_back({a4, a3, a2, a1});
return new_a;
} else {
return find(a, cur + 1);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> a(n);
for (auto &i : a) cin >> i;
if (is_sorted(a.begin(), a.end())) {
cout << "0\n";
return 0;
}
for (long long int ii = 1; ii <= 3; ii++) {
for (long long int i = 2; i <= n; i++) {
vector<long long int> b = find(a, i - 1);
a = b;
}
}
cout << ans.size() << endl;
for (long long int i = 0; i < ans.size(); i++) {
long long int cnt = 0;
for (long long int j = 0; j < ans[i].size(); j++) {
if (ans[i][j] != 0) cnt++;
}
cout << cnt << " ";
for (long long int j = 0; j < ans[i].size(); j++) {
if (ans[i][j] != 0) cout << ans[i][j] << " ";
}
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<bool> hasPrevious(n, false);
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] > 0) {
hasPrevious[a[i] - 1] = true;
}
}
vector<int> queues(n, 0);
int next = 0;
for (int i = 0; i < n; i++) {
if (!hasPrevious[i]) {
int j = i;
while (true) {
queues[next]++;
if (j == x - 1) {
queues[next] = 0;
next--;
break;
}
if (a[j] == 0) {
break;
}
j = a[j] - 1;
}
next++;
}
}
int j = x - 1;
int smartPos = 1;
while (true) {
if (a[j] == 0) {
break;
}
j = a[j] - 1;
smartPos++;
}
vector<bool> possible(n, false);
vector<bool> selected(next, false);
int actual = 0;
int k = 1 << next;
while (actual < k) {
int aux = actual;
int sum = 0;
for (int i = 0; i < next; i++) {
if ((aux & 1) == 1) {
sum += queues[i];
}
aux = aux >> 1;
}
possible[sum + smartPos - 1] = true;
actual++;
}
for (int i = 0; i < n; i++) {
if (possible[i]) {
cout << (i + 1) << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > v;
vector<pair<int, int> > e[100005];
int n, c[100005];
void dfs(int v, int n) {
c[v] = n;
for (int i = 0; i < e[v].size(); i++) {
if (c[e[v][i].first] == -1) {
dfs(e[v][i].first, (n ^ e[v][i].second));
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
v.push_back(make_pair(a, make_pair(0, i)));
v.push_back(make_pair(b, make_pair(1, i)));
}
sort(v.begin(), v.end());
for (int i = 0; i < 2 * n; i += 2) {
int x = (v[i].second.first == v[i + 1].second.first);
e[v[i].second.second].push_back(make_pair(v[i + 1].second.second, x));
e[v[i + 1].second.second].push_back(make_pair(v[i].second.second, x));
}
memset(c, -1, sizeof(c));
for (int i = 0; i < n; i++) {
if (c[i] != -1) continue;
dfs(i, 0);
}
for (int i = 0; i < n; i++) printf("%d ", c[i]);
puts("");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) {
pos = 0, len = fread(buf, 1, buf_size, stdin);
}
if (pos == len) {
return -1;
}
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) {
c = getChar();
}
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int MAXN = 8001;
int len;
string s;
int getlen[MAXN];
int dp[MAXN];
int pr[MAXN];
int main() {
cin >> s;
len = (int)(s).size();
for (int i = 1; i <= len; i++) {
int t = i;
while (t > 0) {
getlen[i]++;
t /= 10;
}
}
for (int i = 1; i <= len; i++) {
dp[i] = 200 * len;
}
for (int i = 0; i < len; i++) {
string a;
for (int j = i; j < len; j++) {
a += s[j];
}
int n = (int)(a).size();
for (int j = 1; j < n; j++) {
int k = pr[j - 1];
while (k > 0 && a[j] != a[k]) {
k = pr[k - 1];
}
if (a[j] == a[k]) {
k++;
}
pr[j] = k;
}
for (int j = i; j < len; j++) {
int per = j - i + 1 - pr[j - i];
int ss;
if ((j - i + 1) % per == 0) {
ss = per;
} else {
ss = j - i + 1;
}
int ns = dp[i] + getlen[(j - i + 1) / ss] + ss;
if (dp[j + 1] > ns) {
dp[j + 1] = ns;
}
}
}
cout << dp[len] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> left_less(n), left_more(n), right_less(n), right_more(n);
map<int, vector<int> > inc, dec;
for (int i = 0; i < n; i++) {
inc[a[i]].push_back(i);
dec[-a[i]].push_back(i);
}
{
set<int> r;
r.insert(-1);
r.insert(n);
for (auto f : inc) {
for (int x : f.second) {
auto z = r.lower_bound(x);
right_less[x] = *z;
left_less[x] = *prev(z);
}
for (int x : f.second) r.insert(x);
}
}
{
set<int> r;
r.insert(-1);
r.insert(n);
for (auto f : dec) {
for (int x : f.second) {
auto z = r.lower_bound(x);
right_more[x] = *z;
left_more[x] = *prev(z);
}
for (int x : f.second) r.insert(x);
}
}
vector<pair<int, vector<int> > > closest3(n, {n, {}}), closest4(n, {n, {}});
for (int i = 0; i < n; i++) {
if (left_less[i] >= 0 && right_less[i] < n) {
closest3[left_less[i]] =
min(closest3[left_less[i]],
{right_less[i], {left_less[i], i, right_less[i]}});
}
if (left_more[i] >= 0 && right_more[i] < n) {
closest3[left_more[i]] =
min(closest3[left_more[i]],
{right_more[i], {left_more[i], i, right_more[i]}});
}
}
vector<vector<int> > ins_where(n);
for (int i = 0; i < n; i++) {
int f = min(left_less[i], left_more[i]);
if (f == -1) continue;
ins_where[f].push_back(i);
}
set<int> ok;
ok.insert(n);
for (int i = n - 1; i >= 0; i--) {
for (int x : ins_where[i]) {
ok.insert(x);
}
int f = max(right_less[i], right_more[i]);
int g = *ok.lower_bound(f);
if (g == n) continue;
int v = right_less[i];
int w = right_more[i];
if (a[v] > a[left_less[g]]) v = left_less[g];
if (a[w] < a[left_more[g]]) w = left_more[g];
closest4[i] = {g, {i, v, w, g}};
}
for (int i = n - 1; i > 0; i--) {
closest3[i - 1] = min(closest3[i - 1], closest3[i]);
closest4[i - 1] = min(closest4[i - 1], closest4[i]);
}
for (int _ = 0; _ < q; _++) {
int l, r;
cin >> l >> r;
l--;
r--;
vector<int> ans;
if (closest4[l].first <= r) {
ans = closest4[l].second;
} else if (closest3[l].first <= r) {
ans = closest3[l].second;
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int x : ans) {
cout << x + 1 << ' ';
}
cout << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
long m, n, arr[9];
char matRes[9][9];
char mat[9][9];
long res = 10000000000, max, min, b, maxi, mini, a;
using namespace std;
int main() {
scanf("%ld%ld", &m, &n);
for (a = 0; a < m; a++) scanf("%s", mat[a]);
for (a = 1; a <= n; a++) {
arr[a - 1] = a;
}
maxi = -1;
mini = 100000000;
for (b = 0; b < m; b++) {
if (atoi(mat[b]) > maxi) maxi = atoi(mat[b]);
if (atoi(mat[b]) < mini) mini = atoi(mat[b]);
}
if (res > maxi - mini) res = maxi - mini;
while (next_permutation(arr, arr + n)) {
maxi = -1;
mini = 100000000;
for (a = 0; a < n; a++) {
for (b = 0; b < m; b++) {
matRes[b][a] = mat[b][arr[a] - 1];
}
}
for (b = 0; b < m; b++) {
if (atoi(matRes[b]) > maxi) maxi = atoi(matRes[b]);
if (atoi(matRes[b]) < mini) mini = atoi(matRes[b]);
}
if (res > maxi - mini) res = maxi - mini;
}
printf("%ld\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i, j = -1, n = s.length();
i = 0;
while (i < n && s[i] == 'a') i++;
int k = i;
for (i; i < n; i++) {
if (s[i] == 'a') {
j = i - 1;
break;
}
}
if (j == -1) j = n - 1;
for (int l = 0; l < n; l++) {
if (k == n && l == n - 1)
cout << "z";
else if (l >= k && l <= j)
cout << (char)(s[l] - 1);
else
cout << s[l];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long l[500001];
long long r[500001];
long long arr[500001];
int n;
int main() {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
cin >> n;
l[1] = r[1] = 1, l[n] = r[n] = n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
l[i] = i - 1;
r[i] = i + 1;
Q.push({arr[i], i});
}
pair<int, int> tmp;
long long ans = 0, le, ri;
long long lol = 0;
while (Q.size() > 2) {
tmp = Q.top();
Q.pop();
le = l[tmp.second];
ri = r[tmp.second];
ans += (arr[tmp.second] - lol) * (Q.size() - 1);
lol = tmp.first;
ans += max(0LL, min(arr[le], arr[ri]) - lol);
l[ri] = le;
r[le] = ri;
}
cout << ans;
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std ;
int solve(int key)
{
if(key==0 || key==100)
{
return 1 ;
}
int a = key ;
int b = 100-key ;
int tt = min(a , b);
for(int i=2 ; i<=tt ;)
{
if(a%i==0 && b%i==0)
{
a = a/i ;
b = b/i ;
}
else
{
i++ ;
}
}
return a+b ;
}
int main()
{
int t ;
int aa ;
cin >> t ;
vector<int> arr ;
for (int i=0 ; i<t ; i++)
{
cin >> aa ;
arr.push_back(aa);
}
for(int i=0 ; i<t ; i++)
{
int ans = solve(arr[i]);
cout << ans ;
cout << endl ;
}
return 0 ;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300 * 1000 + 5, mod = 998244353;
long long dp[N][3];
int c[N];
vector<int> adj[N];
int par[N];
long long po(long long x, long long y) {
if (y == 0) {
return 1;
}
x %= mod;
long long ans = po(x, y / 2);
ans *= ans;
ans %= mod;
if (y % 2) {
ans *= x;
ans %= mod;
}
return ans;
}
void dfs(int v) {
dp[v][0] = dp[v][2] = 1;
for (auto u : adj[v]) {
if (u != par[v]) {
par[u] = v;
dfs(u);
dp[v][0] *= dp[u][1] * 2 + dp[u][2];
dp[v][2] *= dp[u][1] + dp[u][2];
dp[v][0] %= mod;
dp[v][2] %= mod;
}
}
for (auto u : adj[v]) {
if (u != par[v]) {
long long x = 1ll * dp[v][0] * po(dp[u][1] * 2 + dp[u][2], mod - 2);
x %= mod;
x *= dp[u][0];
x %= mod;
dp[v][1] += x;
dp[v][1] %= mod;
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
cout << (dp[1][1] + dp[1][2]) % mod;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int v[110000] = {0};
int main() {
int n, k, m, a[100010], t = 0, p, g = 0;
cin >> n >> k >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
v[a[i] % m]++;
if (v[a[i] % m] == k) {
t = 1;
p = a[i] % m;
}
}
if (!t)
cout << "No";
else {
cout << "Yes" << endl;
for (int i = 0; i < n; i++)
if (a[i] % m == p) {
cout << a[i] << " ";
g++;
if (g == k) break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int len, cnt = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0, i, p;
char s[100000], s2[10000], s3[10000];
cin >> len >> s;
if (len == 1)
cout << "1\n" << s;
else {
for (i = 0; i < len / 2; i++) {
s2[i] = s[i];
if (s2[i] == '1')
cnt++;
else
cnt2++;
}
s2[i] = '\0';
for (i = len / 2, p = 0; i < len; i++, p++) {
s3[p] = s[i];
if (s3[p] == '1')
cnt3++;
else
cnt4++;
}
s3[p] = '\0';
if ((cnt == cnt3) && (cnt2 == cnt4) && (cnt + cnt3) == (cnt4 + cnt2)) {
for (int i = 0; i < len - 1; i++) {
s2[i] = s[i];
}
s2[i + 1] = '\0';
s3[0] = s[len - 1];
s3[1] = '\0';
cout << "2\n" << s2 << " " << s3;
} else if ((cnt + cnt3) == (cnt4 + cnt2)) {
cout << "2\n" << s2 << " " << s3;
} else {
cout << "1\n" << s;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long visit[4007], possibleLen, dp[4007][4007];
vector<long long> v, lenStore;
bool go(long long pos, long long len) {
if (len == possibleLen) return 1;
if (pos == lenStore.size() || len > possibleLen) return 0;
if (dp[pos][len] != -1) return dp[pos][len];
return dp[pos][len] = go(pos + 1, len) | go(pos + 1, len + lenStore[pos]);
}
void solve() {
long long n, i, a, large, pos, j;
cin >> n;
n *= 2;
v.clear();
for (i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
pos = n - 1;
while (pos >= 0) {
for (i = n; i >= 1; i--) {
if (visit[i] == 0) {
large = i;
break;
}
}
long long newPos;
for (i = 0; i <= pos; i++) {
if (v[i] == large) {
newPos = i;
break;
}
}
for (i = newPos; i <= pos; i++) visit[v[i]] = 1;
lenStore.push_back(pos - newPos + 1);
pos = newPos - 1;
}
possibleLen = n / 2;
reverse(lenStore.begin(), lenStore.end());
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) dp[i][j] = -1;
}
bool ok = go(0, 0);
cout << (ok ? "YES" : "NO") << "\n";
lenStore.clear();
memset(visit, 0, sizeof(visit));
}
int main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
int arr[n];
std::set<int> res;
std::set<int> last;
std::set<int> temp;
std::vector<std::bitset<100000> > bits(20);
for (int i = 0; i < n; i++) {
int a;
std::cin >> a;
arr[i] = a;
res.insert(a);
for (std::set<int>::iterator ite = last.begin(); ite != last.end(); ite++) {
res.insert((*ite) | a);
temp.insert((*ite) | a);
}
last.clear();
last.insert(temp.begin(), temp.end());
temp.clear();
last.insert(a);
}
std::cout << res.size() << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000006;
int ile[2 * M], tab[M];
void jebaj() {
int n, m = 1000006, res = 0;
cin >> n;
for (auto i = (0); i <= ((n)-1); ++i) {
cin >> tab[i];
ile[tab[i]]++;
m = max(m, tab[i]);
}
for (auto i = (0); i <= ((m + 50) - 1); ++i) {
ile[i + 1] += (ile[i] / 2);
ile[i] &= 1;
res += ile[i];
}
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int t = 1;
for (auto i = (0); i <= ((t)-1); ++i) {
jebaj();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> s;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x) s.insert(x);
}
cout << s.size();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
inline bool isprime(ll num)
{if(num==2||num==3)return true;
if(num%6!=1&&num%6!=5)return false;
for(int i=5;1ll*i*i<=num;i+=6){if(num%i==0||num%(i+2)==0)return false;}
return true;}
const int mod = 1e9+7;
inline ll mul(ll a,ll b,ll c){return (a*b-(ll)((ld)a*b/c)*c+c)%c;}
inline ll exgcd(ll a,ll b,ll &x,ll &y){if(!b){x=1;y=0;return a;}ll g = exgcd(b,a%b,y,x);y-=a/b*x;return g;}
inline ll quick_pow(ll a,ll b,ll mod){ll res=1;while(b){if(b&1)res=mul(res,a,mod);a=mul(a,a,mod);b>>=1;}return res;}
inline ll quick_pow(ll a,ll b){ll res=1;while(b){if(b&1)res=mul(res,a,mod);a=mul(a,a,mod);b>>=1;}return res;}
inline ll inv(ll x){return quick_pow(x,mod-2);}
inline ll inv(ll x,ll mod){return quick_pow(x,mod-2,mod);}
inline ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
const int N = 3e5+10;
vector<int>g[N];
vector<int>ans;
queue<int>q;
int f[N];
int color[N];
int vis[N];
void add(int u,int v){
g[u].push_back(v);
g[v].push_back(u);
}
int find(int x){
return f[x]==x?x: f[x]=find(f[x]);
}
void dfs(int u,int fa){
vis[u]=1; color[u]=!color[fa];
for(auto v:g[u])if(vis[v])color[u]&=!color[v];
for(auto v:g[u])if(!vis[v]&&v!=fa)dfs(v,u);
}
int main(){
int T;
scanf("%d",&T);
while(T--){
int n,m;
scanf("%d %d",&n,&m);
ans.clear();
for(int i=1;i<=n;i++){
f[i]=i;
g[i].clear();
color[i]=0;
vis[i]=0;
}
int cnt = n;
for(int i=1;i<=m;i++){
int s,t;
scanf("%d%d",&s,&t);
if(find(s)!=find(t)) {
cnt--;
f[find(s)]=find(t);
}
add(s, t);
}
dfs(1,0);
if(cnt!=1)printf("NO\n");
else {
for(int i=1;i<=n;i++)if(color[i])ans.push_back(i);
printf("YES\n%d\n",ans.size());
for(auto k : ans)printf("%d ",k);
printf("\n");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, i, j, k, x = 0, sum = 0;
map<long, long> m;
cin >> n;
long a[n], b[n], c[n];
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (i = n - 1; i >= 0; i--) {
sum = sum + (x * b[i] + 1);
x++;
}
cout << sum << endl;
j = 0;
for (i = n - 1; i >= 0; i--) {
if (m[b[i]] == 0) {
for (k = 0; k < n; k++) {
if (a[k] == b[i]) {
c[j] = k + 1;
j++;
}
}
m[b[i]] = 1;
}
}
for (i = 0; i < n; i++) cout << c[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T checkmin(T &a, T b) {
return (a < b) ? a : a = b;
}
template <class T>
inline T checkmax(T &a, T b) {
return (a > b) ? a : a = b;
}
template <class T>
T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (a == 0) ? b : GCD(b % a, a);
}
template <class T>
T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return (a == 0 || b == 0) ? 0 : a / GCD(a, b) * b;
}
template <class T>
inline T sqr(T X) {
return X * X;
}
namespace Poor {
const int MaxiN = 105;
const long long Infinity = 2000000000000000000LL;
int N, M;
long long K;
int C[MaxiN][MaxiN];
int Weight[MaxiN + MaxiN];
pair<int, int> List[MaxiN + MaxiN];
char St[MaxiN + MaxiN];
inline void Inc(long long &a, long long b) {
a += b;
if (a > Infinity) a = Infinity;
}
long long DP() {
map<int, long long> Now, Suc;
Now.clear();
Now[0] = 1;
for (int i = 0; i < N + M - 1; ++i) {
for (typeof(Now.begin()) it = Now.begin(); it != Now.end(); ++it) {
if (St[i] != ')') Inc(Suc[it->first + 1], it->second);
if (St[i] != '(' && it->first > 0) Inc(Suc[it->first - 1], it->second);
}
Now = Suc;
Suc.clear();
}
return Now[0];
}
void Run() {
cin >> N >> M >> K;
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) cin >> C[i][j];
fill(Weight, Weight + N + M - 1, INT_MAX);
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) checkmin(Weight[i + j], C[i][j]);
for (int i = 0; i < N + M - 1; ++i) List[i] = make_pair(Weight[i], i);
sort(List, List + N + M - 1);
fill(St, St + N + M - 1, '?');
for (int i = 0; i < N + M - 1; ++i) {
int p = List[i].second;
St[p] = '(';
long long dp = DP();
if (dp < K) {
K -= dp;
St[p] = ')';
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) putchar(St[i + j]);
puts("");
}
}
} // namespace Poor
int main() {
Poor::Run();
return 0;
}
| 7 |
#include<iostream>
#include<vector>
#include<string>
#include<queue>
#include<map>
#include<algorithm>
#include<iomanip>
#include <stdio.h>
#include<memory.h>
#include<cstdio>
#include<math.h>
#include <fstream>
#include<stack>
using namespace std;
typedef long long ll;
ll dp[100005]={0};
struct aa
{
ll x;
ll y;
}p[100005]={0};
bool cmp(aa a,aa b)
{
if(a.x==b.x) return a.y<b.y;
return a.x<b.x;
}
ll vis[100005]={0},n,ans=0;
int main()
{
ll t,i,j,z1,z2,maxnow,ans=0;
cin>>n;
for(i=0;i<n;i++)
scanf("%lld %lld",&p[i].x,&p[i].y);
z1=p[0].x;z2=p[0].y;
sort(p,p+n,cmp);
maxnow=p[0].x+p[0].y;
for(i=0;i<n;i++)
{
ans+=p[i].y;
if(maxnow<p[i].x)
ans+=p[i].x-maxnow;
maxnow=max(maxnow,p[i].x+p[i].y);
}
printf("%lld",ans);
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long W, H, x1, y1, x2, y2, w, h;
cin >> W >> H >> x1 >> y1 >> x2 >> y2 >> w >> h;
long long th = abs(y2 - y1), tw = abs(x1 - x2);
if (tw + w > W && th + h > H)
cout << -1 << endl;
else {
long long m = 1000000000000000000;
if (tw + w <= W) {
m = min(m, w - x1);
m = min(m, w - (W - x2));
}
if (th + h <= H) {
m = min(m, h - y1);
m = min(m, h - (H - y2));
}
double res = (double)(max(m, 0LL));
printf("%.9lf\n", res);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s[3005], c[3005];
int dp[3005][3];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &s[i]);
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
dp[0][0] = c[0];
dp[0][1] = dp[0][2] = 0x3f3f3f3f;
for (int i = 1; i < n; i++) {
dp[i][0] = c[i];
dp[i][1] = dp[i][2] = 0x3f3f3f3f;
for (int j = 0; j < i; j++) {
if (s[j] < s[i]) dp[i][1] = min(dp[i][1], dp[j][0] + c[i]);
if (s[j] < s[i]) dp[i][2] = min(dp[i][2], dp[j][1] + c[i]);
}
}
int best = 0x3f3f3f3f;
for (int i = 0; i < n; i++) best = min(best, dp[i][2]);
printf("%d\n", (best < 0x3f3f3f3f) ? best : -1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
char grid[2003][2003];
long long dp[2003][2003];
long long dx[] = {1, -1, 0, 0};
long long dy[] = {0, 0, 1, -1};
queue<pair<long long, long long> > qq;
long long n, m;
bool solve(pair<long long, long long> cord) {
for (long long i = 0; i < 4; i++) {
long long x = cord.first + dx[i];
long long y = cord.second + dy[i];
if (x > n || y > m) return 0;
if (x < 1 || y < 1) return 0;
if (grid[cord.first][cord.second] != grid[x][y]) return 0;
if (dp[cord.first][cord.second] > dp[x][y]) return 0;
}
return 1;
}
bool tri(pair<long long, long long> top) {
for (long long i = 0; i < 4; i++) {
long long x = top.first + dx[i];
long long y = top.second + dy[i];
if (x < 1 || x > n) return 0;
if (y < 1 || y > m) return 0;
if (grid[x][y] != grid[top.first][top.second]) return 0;
}
return 1;
}
int main() {
long long i, j, k, l, o, r, q;
long long testcase;
long long input, flag, tag, ans;
while (cin >> n >> m) {
for (long long i = 1; i <= n; i++) cin >> grid[i] + 1;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (tri({i, j})) {
dp[i][j] = -1;
} else {
dp[i][j] = 1;
qq.push({i, j});
}
}
ans = 0;
while (!qq.empty()) {
pair<long long, long long> top = qq.front();
qq.pop();
ans += dp[top.first][top.second];
for (long long i = 0; i < 4; i++) {
long long nx = top.first + dx[i];
long long ny = top.second + dy[i];
if (grid[top.first][top.second] == grid[nx][ny] && dp[nx][ny] == -1) {
qq.push({nx, ny});
dp[nx][ny] = 1 + dp[top.first][top.second];
}
}
}
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double PI = acos(-1);
const long long MOD = 1000000007;
const long long FMOD = 998244353;
const long double eps = 1e-9;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
long long a[300];
signed main() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < 256; i++) a[i] = -1;
while (n--) {
long long x;
cin >> x;
if (a[x] == -1) {
for (long long i = max(0ll, x - k + 1); i <= x; i++) {
if (a[i] == -1 || a[i] == i) {
for (long long j = i; j <= x; j++) a[j] = i;
break;
}
}
}
cout << a[x] << ' ';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int ans = 0;
for (int i = 0; i < n && m && arr[i] < 0; i++, m--) ans += arr[i];
cout << -ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int dp[50][2000], r[50], n;
const int inf = 1e6;
int abs(int a) { return a > 0 ? a : -a; }
int getTime(int id, int k) {
if (k <= 0) return 0;
if (dp[id][k]) return dp[id][k];
dp[id][k] = inf;
for (int i = 0; i < n; i++) {
if (s[i] == s[id] or r[i] <= r[id]) continue;
dp[id][k] = min(dp[id][k], abs(i - id) + getTime(i, k - r[i]));
}
return dp[id][k];
}
int solve(int st, int k) {
int ans = inf;
for (int id = 0; id < n; id++)
ans = min(ans, abs(st - id) + getTime(id, k - r[id]));
return ans == inf ? -1 : ans;
}
int main() {
int st, k;
cin >> n >> st >> k;
for (int i = 0; i < n; i++) cin >> r[i];
cin >> s;
cout << solve(st - 1, k) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e9;
int m, n, k, a[1000010], t, x, y, u, v, f[42][1000010], s[1000010], ans, g[42];
vector<int> z[42];
void bfs(int mau) {
deque<int> d;
for (int i = 1; i <= m * n; i++) s[i] = 0;
for (int i = 1; i <= k; i++) g[i] = 0;
for (int ar : z[mau]) {
d.push_back(ar);
f[mau][ar] = 0;
s[ar] = 1;
}
g[mau] = 1;
while (!d.empty()) {
int mc = d.front();
d.pop_front();
if (mc < m * n && s[mc + 1] == 0 && mc % n) {
s[mc + 1] = 1;
f[mau][mc + 1] = f[mau][mc] + 1;
d.push_back(mc + 1);
}
if (mc > 1 && s[mc - 1] == 0 && mc % n != 1) {
s[mc - 1] = 1;
f[mau][mc - 1] = f[mau][mc] + 1;
d.push_back(mc - 1);
}
if (mc <= (m - 1) * n && s[mc + n] == 0) {
s[mc + n] = 1;
f[mau][mc + n] = f[mau][mc] + 1;
d.push_back(mc + n);
}
if (mc >= n + 1 && s[mc - n] == 0) {
s[mc - n] = 1;
f[mau][mc - n] = f[mau][mc] + 1;
d.push_back(mc - n);
}
if (g[a[mc]] == 0) {
g[a[mc]] = 1;
for (int ar : z[a[mc]]) {
if (ar != mc && s[ar] == 0) {
s[ar] = 1;
f[mau][ar] = f[mau][mc] + 1;
d.push_back(ar);
}
}
}
}
}
int main() {
cin >> m >> n >> k;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[(i - 1) * n + j];
z[a[(i - 1) * n + j]].push_back((i - 1) * n + j);
}
}
for (int i = 1; i <= k; i++) {
bfs(i);
}
cin >> t;
while (t--) {
cin >> x >> y >> u >> v;
ans = abs(x - u) + abs(y - v);
for (int i = 1; i <= k; i++) {
if (x == u && y == v)
ans = 0;
else
ans = min(ans, f[i][(x - 1) * n + y] + f[i][(u - 1) * n + v] + 1);
}
cout << ans << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long lg(long long x, int k) {
int cnt = 0;
while (1) {
if (x >= k) {
x /= k;
cnt++;
}
if (x < k) return cnt;
}
}
int main() {
int t;
cin >> t;
while (t--) {
vector<long long> v;
int n, k;
cin >> n >> k;
bool flag = true;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
map<int, int> mp;
for (int i = 0; i < n; i++) {
long long tmp, ans;
ans = v[i];
while (1) {
if (ans == 0) break;
tmp = lg(ans, k);
if (!mp[tmp]) {
ans -= pow(k, tmp);
mp[tmp] = 1;
} else {
flag = false;
break;
}
if (ans < 0) {
flag = false;
break;
}
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wwrite-strings"
using namespace std;
template <class T, class U>
ostream &operator<<(ostream &out, const pair<T, U> &A) {
out << A.first << "_" << A.second;
return out;
}
template <template <typename, typename> class ContainerT, typename ValueT>
ostream &operator<<(ostream &out,
const ContainerT<ValueT, std::allocator<ValueT> > &A) {
for (__typeof((A).begin()) i = (A).begin(); i != (A).end(); ++i)
out << *i << " ";
return out;
}
template <template <typename, typename> class ContainerT, typename ValueT,
typename ValueU>
ostream &operator<<(
ostream &out, const ContainerT<pair<ValueT, ValueU>,
std::allocator<pair<ValueT, ValueU> > > &A) {
for (__typeof((A).begin()) i = (A).begin(); i != (A).end(); ++i)
out << *i << " ";
return out;
}
template <class T>
void mini(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
void maxi(T &a, const T &b) {
if (b > a) a = b;
}
int N, M, K, ans;
vector<vector<int> > A;
int dist(const vector<int> &standard, const vector<int> &target) {
assert(standard.size() == target.size() and standard.size() == M);
int ret = 0;
for (int i = 0; i < (M); ++i) ret += standard[i] != target[i];
return min(ret, M - ret);
}
bool noHope(const vector<int> &standard) {
int curAns = 0;
for (int i = 0; i < (N); ++i) {
int diff = 0;
for (int j = 0; j < (standard.size()); ++j) diff += A[i][j] != standard[j];
curAns += min(diff, (int)standard.size() - diff);
if (curAns > K or curAns >= ans) return true;
}
return false;
}
void dfs(vector<int> &standard) {
if (standard.size() == M) {
int curAns = 0;
for (int j = 0; j < (N); ++j) curAns += dist(standard, A[j]);
mini(ans, curAns);
} else {
standard.push_back(0);
dfs(standard);
standard.pop_back();
standard.push_back(1);
dfs(standard);
standard.pop_back();
}
}
long long solve() {
cin >> N >> M >> K;
A = vector<vector<int> >(N, vector<int>(M));
ans = INT_MAX;
for (int i = 0; i < (N); ++i)
for (int j = 0; j < (M); ++j) cin >> A[i][j];
if (N < M) {
vector<vector<int> > A_(M, vector<int>(N));
for (int i = 0; i < (N); ++i)
for (int j = 0; j < (M); ++j) A_[j][i] = A[i][j];
A = A_;
int tmp = N;
N = M;
M = tmp;
}
if (M <= 10) {
vector<int> start;
dfs(start);
} else {
for (int i = 0; i < (N); ++i) {
vector<int> standard = A[i];
int curAns = 0;
for (int j = 0; j < (N); ++j) curAns += dist(standard, A[j]);
mini(ans, curAns);
}
}
if (ans == INT_MAX or ans > K) return -1;
return ans;
}
int main() {
cout << solve() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N, M, Q;
cin >> N >> M >> Q;
array<string, 2> A;
cin >> A[0] >> A[1];
array<string, 2> B;
cin >> B[0] >> B[1];
int64_t ans = 2 * N + 2 * M;
for (int flip_nm = 0; flip_nm < 2; flip_nm++, swap(N, M), swap(A, B)) {
int64_t dp[2] = {0, 0};
for (int i = 0; i < N; i++) {
bool v = (A[0][i] == 'R');
dp[!v]++;
}
dp[0] = min(dp[0], dp[1] + N);
dp[1] = min(dp[1], dp[0] + N);
for (int j = 0; j < M; j++) {
bool x = (B[0][j] == 'R');
bool y = (B[1][j] == 'R');
dp[!x]++;
dp[!y]++;
dp[0] = min(dp[0], dp[1] + N);
dp[1] = min(dp[1], dp[0] + N);
}
for (int i = 0; i < N; i++) {
bool v = (A[1][i] == 'R');
dp[!v]++;
}
ans = min(ans, min(dp[0], dp[1]));
}
cout << ans << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int m;
int vt = 0;
int main() {
cin >> m;
int d = 0;
int i;
for (i = 1; i <= 1000000; i++) {
int x = i;
while (x % 5 == 0) {
x /= 5;
d++;
}
if (d == m) {
vt = 5;
break;
}
if (d > m) break;
}
cout << vt << endl;
for (int j = 0; j < vt; j++) {
cout << i + j << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, t, a[300][300] = {0};
void ans(int x, int y) {
if (a[x][y] < 4) return;
int t = a[x][y] / 4;
a[x][y + 1] += t;
a[x][y - 1] += t;
a[x + 1][y] += t;
a[x - 1][y] += t;
a[x][y] %= 4;
ans(x, y + 1);
ans(x, y - 1);
ans(x + 1, y);
ans(x - 1, y);
}
int main() {
scanf("%d%d", &n, &t);
a[150][150] = n;
ans(150, 150);
int x, y;
for (int i = 0; i < t; i++) {
scanf("%d%d", &x, &y);
if (x + 150 > 300 || y + 150 > 300 || y + 150 < 0 || x + 150 < 0)
printf("0\n");
else
printf("%d\n", a[x + 150][y + 150]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll INF = (ll)1e18;
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
void p() { std::cout << '\n'; }
template <typename Head, typename... Tail>
void p(Head head, Tail... tail) {
std::cout << head << (sizeof...(tail) ? " " : "");
p(tail...);
}
template <typename T>
inline void pv(std::vector<T>& v) {
for (ll i = 0, N = v.size(); i < N; i++)
std::cout << v[i] << " \n"[i == N - 1];
}
template <typename T>
inline bool chmax(T& a, T b) {
return a < b && (a = b, true);
}
template <typename T>
inline bool chmin(T& a, T b) {
return a > b && (a = b, true);
}
template <typename T>
inline void uniq(std::vector<T>& v) {
v.erase(std::unique(v.begin(), v.end()), v.end());
}
void solve() {
ll N, K;
cin >> N >> K;
vector<ll> a(N);
for (ll i = 0, i_length = (N); i < i_length; ++i) cin >> a[i];
map<ll, ll> m;
for (ll i = 0, i_length = (N); i < i_length; ++i) m[a[i]]++;
ll size = m.size();
if (K == 1) {
if (size == 1)
p(1);
else
p(-1);
return;
}
ll ans = (size - 1) / (K - 1) + !!((size - 1) % (K - 1));
ans = max(ans, 1LL);
p(ans);
}
signed main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
ll Q;
cin >> Q;
while (Q--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long x, k, y;
cin >> x >> k >> y;
vector<long long> a(n + 2, 0), b(m + 2, 0);
for (long long i = 1; i <= n; ++i) cin >> a[i];
for (long long i = 1; i <= m; ++i) cin >> b[i];
vector<long long> t;
long long answer = 0;
long long left = 0, right = b[1], right_index = 1;
for (long long i = 1; i <= n + 1; ++i) {
if (a[i] == right) {
long long length = t.size();
if (length != 0) {
long long berserks, fireballs;
if (x <= k * y) {
fireballs = length / k;
berserks = length % k;
} else {
fireballs = 0;
berserks = length;
}
long long maximal = *max_element(t.begin(), t.end());
if (maximal > left && maximal > right) {
if (length < k) {
cout << "-1\n";
return 0;
}
if (fireballs == 0) {
fireballs += 1;
berserks -= k;
}
}
answer += fireballs * x + berserks * y;
}
t.clear();
left = right;
if (right_index != m + 1) right_index += 1;
right = b[right_index];
} else
t.push_back(a[i]);
}
if (right != 0)
cout << "-1\n";
else
cout << answer << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a[5];
int i, r = 0, s = 0, p = 0;
for (i = 0; i < 3; i++) {
cin >> a[i];
if (a[i] == "rock") r++;
if (a[i] == "paper") p++;
if (a[i] == "scissors") s++;
}
if (r == 1 && s == 2) {
if (a[0] == "rock") cout << "F" << endl;
if (a[1] == "rock") cout << "M" << endl;
if (a[2] == "rock") cout << "S" << endl;
} else if (s == 1 && p == 2) {
if (a[0] == "scissors") cout << "F" << endl;
if (a[1] == "scissors") cout << "M" << endl;
if (a[2] == "scissors") cout << "S" << endl;
} else if (p == 1 && r == 2) {
if (a[0] == "paper") cout << "F" << endl;
if (a[1] == "paper") cout << "M" << endl;
if (a[2] == "paper") cout << "S" << endl;
} else
cout << "?" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25, P = 1000000007;
using ll = long long;
int n, m, q, l;
struct Matrix {
ll a[N][N] = {};
ll *operator[](const size_t &s) { return a[s]; }
const ll *operator[](const size_t &s) const { return a[s]; }
};
Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix c;
for (int i = 1; i <= l; i++)
for (int j = 1; j <= l; j++)
for (int k = 1; k <= l; k++)
c[i][j] = (c[i][j] + a[i][k] * b[k][j] % P) % P;
return c;
}
inline void output(Matrix &a) {
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= l; j++) cout << a[i][j] << ' ';
cout << endl;
}
}
Matrix qpow(Matrix a, int b) {
Matrix ret;
for (int i = 1; i <= l; i++) ret[i][i] = 1;
while (b) {
if (b & 1) {
ret = ret * a;
}
a = a * a;
b >>= 1;
}
return ret;
}
bool vis[N][N];
int main() {
cin >> n >> m >> q;
l = n * m;
Matrix ans, cur;
ans[1][1] = 1;
int tp, x, y, t, lt = 1;
for (int _ = 1; _ <= q; _++) {
cin >> tp >> x >> y >> t;
for (int i = 1; i <= l; i++)
for (int j = i; j <= l; j++) {
int x1 = (i - 1) / m + 1, y1 = (i - 1) % m + 1;
int x2 = (j - 1) / m + 1, y2 = (j - 1) % m + 1;
if (!vis[x1][y1] && !vis[x2][y2] && abs(x1 - x2) + abs(y1 - y2) < 2)
cur[i][j] = cur[j][i] = 1;
else
cur[i][j] = cur[j][i] = 0;
}
ans = ans * qpow(cur, t - lt);
if (tp == 1)
cout << ans[1][(x - 1) * m + y] << endl;
else if (tp == 2)
ans[1][(x - 1) * m + y] = 0, vis[x][y] = 1;
else if (tp == 3)
ans[1][(x - 1) * m + y] = 0, vis[x][y] = 0;
lt = t;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int *ei[5000 + 1], eo[5000 + 1];
void append(int a, int i) {
int o = eo[a]++;
if (o >= 2 && (o & o - 1) == 0)
ei[a] = (int *)realloc(ei[a], o * 2 * sizeof *ei[a]);
ei[a][o] = i;
}
int main() {
static int ii[8192], bb[8192], bb_[8192];
static char in[8192];
int n, h, h_, i, a, b, o, cnt;
scanf("%d", &n);
for (a = 0; a <= 5000; a++) ei[a] = (int *)malloc(2 * sizeof *ei[a]);
for (i = 0; i < n; i++) {
scanf("%d", &a);
append(a, i);
}
for (b = 0; b < 8192; b++) ii[b] = n, bb[b] = b;
ii[0] = -1;
for (a = 1; a <= 5000; a++) {
memset(in, 0, 8192 * sizeof *in);
cnt = 0;
for (o = 0, h = 0; o <= eo[a]; o++, h = h_) {
i = o == eo[a] ? n + 1 : ei[a][o];
h_ = h;
while (h_ < 8192 && ii[bb[h_]] < i) {
if (!in[b = bb[h_]]) in[b] = 1, bb_[cnt++] = b;
h_++;
}
h_ = h;
while (h_ < 8192 && ii[bb[h_]] < i) {
if (in[bb[h_]] == 1 && !in[b = bb[h_] ^ a])
in[b] = 2, ii[b] = i, bb_[cnt++] = b;
h_++;
}
}
memcpy(bb, bb_, 8192 * sizeof *bb_);
}
cnt = 0;
for (b = 0; b < 8192; b++)
if (ii[b] != n) cnt++;
printf("%d\n", cnt);
for (b = 0; b < 8192; b++)
if (ii[b] != n) printf("%d ", b);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int N;
struct Node {
long long a;
long long b;
} node[maxn];
bool cmp(const Node &n, const Node &m) { return (n.a - n.b) > (m.a - m.b); }
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) cin >> node[i].a >> node[i].b;
sort(node + 1, node + 1 + N, cmp);
long long ans = 0;
for (int i = 1; i <= N; i++)
ans += (node[i].a * (i - 1) + node[i].b * (N - i));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long s[300001];
long long sum = 0, mod = 998244353;
long long ny(int n);
long long qmksm(long long a, long long b, long long m);
long long zhs(long long n) {
long long i, j, zc = 1;
for (i = 1; i <= n; i++) {
zc *= ((i + n) % mod) * (ny(i) % mod) % mod;
zc %= mod;
}
return zc;
}
long long ny(int n) {
int i;
return qmksm(n, mod - 2, mod) % mod;
}
long long qmksm(long long a, long long b, long long m) {
long long s = 1, z = a % m;
while (b > 0) {
if (b & 1 == 1) {
s *= z;
s %= m;
}
z *= z;
z %= m;
b >>= 1;
}
return s;
}
int main() {
long long n, i, j;
cin >> n;
for (i = 1; i <= n * 2; i++) cin >> s[i];
sort(s + 1, s + 1 + n * 2);
for (i = 1, sum = 0; i <= n; i++) {
sum += (s[i + n] - s[i]) % mod;
sum %= mod;
}
cout << ((zhs(n) % mod) * sum) % mod;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int cnta = 0, cntb = 0;
for (int i = 0; i < b.size(); i++) {
if (a[i] == '1') cnta += 1;
if (b[i] == '1') cntb += 1;
}
int ans = 0;
int l = a.size() - b.size();
for (int i = 0; i < (l + 1); i++) {
if (cnta % 2 == cntb % 2) ans++;
if (i < l) cnta += ((a[i + b.size()] - 48) - (a[i] - 48));
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float a, b, l, s = 0;
cin >> a >> b >> l;
s = (b * a) / (b + l);
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> nums;
int n, t, ac;
cin >> n;
for (int i = max(n - 100, 0); i <= n; i++) {
ac = i, t = i;
while (t) {
ac += t % 10;
t /= 10;
}
if (ac == n) {
nums.push_back(i);
}
}
cout << nums.size() << endl;
for (int i = 0; i < nums.size(); i++) {
cout << nums[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
inline void debug_vi(vector<int> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void debug_vll(vector<long long> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void print_case(int tn) { cout << "Case #" << tn << ": "; }
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxpq = priority_queue<T>;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
cin >> q;
while (q--) {
string s;
cin >> s;
vector<int> freq(26);
for (char c : s) {
freq[c - 'a']++;
}
int m;
cin >> m;
vector<int> b(m);
bool used[m];
int dc = 0;
memset(used, false, sizeof(used));
vector<int> zeroes;
for (long long i = (long long)(0); i < (long long)(m); i++) {
cin >> b[i];
if (!b[i]) zeroes.push_back(i);
}
string res(m, '-');
char c = 'z';
while (dc < m) {
while (freq[c - 'a'] < zeroes.size()) c--;
vector<int> newz;
for (int z : zeroes) {
dc++;
res[z] = c;
used[z] = true;
for (long long i = (long long)(0); i < (long long)(m); i++) {
b[i] -= abs(z - i);
}
}
for (long long i = (long long)(0); i < (long long)(m); i++) {
if (!b[i] && !used[i]) newz.push_back(i);
}
swap(zeroes, newz);
c--;
}
cout << res << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7, p = 1e9 + 7;
bool fl[N], us[N];
long long ans = 0, sum = 0;
int n, m, k, pt, l[N], r[N], siz[N];
long long len[N], alt[N];
vector<int> v[N], vh[N], vc[N], vw[N], vq[N], dis[N];
inline void dfsit(int u) {
us[u] = 1, siz[u] = 1;
for (int i = 0; i < len[u]; i++) {
int x = v[u][i];
if (us[x] || fl[x]) continue;
dfsit(x);
siz[u] += siz[x];
}
k++;
us[u] = 0;
}
inline void getct(int u) {
us[u] = 1;
int xt = 0;
for (int i = 0; i < len[u]; i++) {
int x = v[u][i];
if (us[x] || fl[x]) continue;
getct(x);
xt = max(xt, siz[x]);
}
xt = max(xt, k - siz[u]);
if (xt < m) pt = u, m = xt;
us[u] = 0;
}
inline int getroot(int u) {
k = 0, dfsit(u);
m = n, pt = u;
getct(u);
return pt;
}
inline void pushnode(int c, int t, int u, int dit) {
us[u] = 1;
for (int i = 0; i < len[u]; i++) {
int x = v[u][i];
if (us[x] || fl[x]) continue;
pushnode(c, t, x, dit + 1);
}
us[u] = 0;
vw[u].push_back(c), vq[u].push_back(t), dis[u].push_back(dit);
}
inline void dfs(int u) {
int x = getroot(u);
fl[x] = 1;
for (int i = 0; i < len[x]; i++) {
u = v[x][i];
if (fl[u]) continue;
pushnode(x, i, u, 1), dfs(u);
}
vw[x].push_back(x), vq[x].push_back(len[x]), dis[x].push_back(0);
}
struct post {
int pot, dit, pos;
} e[N];
inline bool cmp(post a, post b) { return a.pot < b.pot; }
inline long long pows(long long u, int v) {
long long ans = 1;
while (v > 0) {
if (v & 1) ans = ans * u % p;
u = u * u % p, v = v >> 1;
}
return ans;
}
inline void addit(int u) {
long long t = pows(r[u] - l[u] + 1, p - 2);
int x = vw[u].size();
for (int i = 0; i < x; i++) {
int s = vw[u][i], g = vq[u][i];
siz[s] += t, alt[s] += (dis[u][i] * t) % p;
vh[s][g] += t, vc[s][g] += (dis[u][i] * t) % p;
siz[s] %= p, vh[s][g] %= p, vc[s][g] %= p, alt[s] %= p;
ans = (ans + t * alt[s] % p - t * vc[s][g] % p +
1ll * (siz[s] - vh[s][g]) * dis[u][i] % p * t) %
p;
}
}
inline void delit(int u) {
long long t = pows(r[u] - l[u] + 1, p - 2);
int x = vw[u].size();
for (int i = 0; i < x; i++) {
int s = vw[u][i], g = vq[u][i];
ans = (ans - alt[s] * t % p + vc[s][g] * t % p -
1ll * (siz[s] - vh[s][g]) * dis[u][i] % p * t) %
p;
siz[s] -= t, alt[s] -= ((dis[u][i] * t) % p);
vh[s][g] -= t, vc[s][g] -= ((dis[u][i] * t) % p);
siz[s] %= p, vh[s][g] %= p, vc[s][g] %= p, alt[s] %= p;
}
}
inline void del(int u) {
if (e[u].dit == 1)
addit(e[u].pos);
else
delit(e[u].pos);
}
int main() {
cin >> n;
int u, t;
int let = 0;
long long cq = 1;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
let++, e[let].pos = i, e[let].dit = 1, e[let].pot = l[i];
let++, e[let].pos = i, e[let].dit = 2, e[let].pot = r[i] + 1;
cq = cq * (r[i] - l[i] + 1) % p;
}
for (int i = 1; i < n; i++)
scanf("%d%d", &u, &t), v[u].push_back(t), v[t].push_back(u), len[u]++,
len[t]++;
for (int i = 1; i <= n; i++)
vh[i].resize(len[i] + 1), vc[i].resize(len[i] + 1);
dfs(1);
memset(siz, 0, sizeof(siz));
sort(e + 1, e + let + 1, cmp);
for (int i = 1; i <= let; i++) {
int x = e[i].pot - e[i - 1].pot, t = i;
while (e[t].pot == e[i].pot) del(t), t++;
x = e[t].pot - e[i].pot;
if (i == 1) x += e[1].pot - 1;
i = t - 1;
ans = (ans % p + p) % p, sum = (sum + x * ans) % p;
}
cout << sum * cq % p << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:667772160")
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
vector<int> graph[100000 + 7], ans, color[100000 + 7], part[3];
int visit[100000 + 7];
bool dfs(int u, int grp, int cl) {
if (visit[u]) return (bool)(visit[u] == grp);
part[grp].push_back(u);
visit[u] = grp;
int v, cr;
for (int i = 0; i < graph[u].size(); i++) {
v = graph[u][i];
cr = color[u][i];
if (!dfs(v, cr == cl ? grp : grp ^ 3, cl)) return 0;
}
return true;
}
bool cal(int cl, int n) {
memset(visit, 0, sizeof(visit));
ans.clear();
for (int i = 1; i <= n; i++) {
if (visit[i]) continue;
part[1].clear();
part[2].clear();
if (!dfs(i, 1, cl)) return 0;
if (part[1].size() < part[2].size())
ans.insert(ans.end(), part[1].begin(), part[1].end());
else
ans.insert(ans.end(), part[2].begin(), part[2].end());
}
return true;
}
int main() {
int n, m, u, v;
char ch;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %c", &u, &v, &ch);
graph[u].push_back(v);
graph[v].push_back(u);
int col = (ch == 'B');
color[u].push_back(col);
color[v].push_back(col);
}
vector<int> res;
bool isok = true;
if (cal(1, n)) {
isok = false;
res = ans;
}
if (cal(0, n)) {
if (isok or ans.size() < res.size()) res = ans;
isok = false;
}
if (!isok) {
deb(res.size());
for (int i = 0; i < res.size(); i++) {
if (i) printf(" ");
printf("%d", res[i]);
}
printf("\n");
} else
deb(-1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e9;
bool isLucky(long long n) {
while (n > 0) {
long long x = n % 10;
if (x != 4 && x != 7) return false;
n /= 10;
}
return true;
}
vector<vector<pair<long long, bool>>> g;
vector<long long> dp, s;
vector<bool> used;
void dfs(long long v) {
used[v] = true;
s[v] = 1;
for (auto& p : g[v]) {
long long u = p.first;
bool lucky = p.second;
if (!used[u]) {
dfs(u);
s[v] += s[u];
if (lucky)
dp[v] += s[u];
else
dp[v] += dp[u];
}
}
}
long long ans = 0;
void dfs(long long v, long long up) {
used[v] = true;
long long x = dp[v] + up;
ans += x * (x - 1);
for (auto& p : g[v]) {
long long u = p.first;
bool lucky = p.second;
if (!used[u]) {
if (lucky)
dfs(u, g.size() - s[u]);
else
dfs(u, dp[v] - dp[u] + up);
}
}
}
void solve() {
long long n;
cin >> n;
g.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long from, to, num;
cin >> from >> to >> num;
from--;
to--;
bool lucky = isLucky(num);
g[from].push_back(make_pair(to, lucky));
g[to].push_back(make_pair(from, lucky));
}
used.resize(n);
dp.resize(n);
s.resize(n);
dfs(0);
used.clear();
used.resize(n);
dfs(0, 0);
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(12);
solve();
}
| 5 |
#include <bits/stdc++.h>
int main() {
unsigned long long n, r;
scanf("%lld", &n);
printf("25");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 4010, INF = 1e18;
int n, m, a[MAXN];
int st[MAXN], top;
int root, lc[MAXN], rc[MAXN];
int sz[MAXN];
long long f[MAXN][MAXN], ans;
void build() {
for (int i = (1); i <= (n); i++) {
int j = 0;
while (top && a[st[top]] > a[i]) {
j = st[top];
top--;
}
if (!top)
root = i;
else
rc[st[top]] = i;
lc[i] = j;
st[++top] = i;
}
}
void dfs1(int u) {
if (!u) return;
sz[u] = 1;
dfs1(lc[u]);
dfs1(rc[u]);
sz[u] += sz[lc[u]];
sz[u] += sz[rc[u]];
}
void dfs2(int u) {
if (!u) return;
dfs2(lc[u]);
dfs2(rc[u]);
for (int i = (0); i <= (min(m, sz[lc[u]])); i++) {
for (int j = (0); j <= (min(m - i, sz[rc[u]])); j++) {
f[u][i + j] = max(
f[u][i + j], f[lc[u]][i] + f[rc[u]][j] - (long long)i * j * 2 * a[u]);
}
}
for (int i = (m); i >= (1); i--) {
f[u][i] = max(f[u][i], f[u][i - 1] + (long long)(m - 1) * a[u] -
(long long)(i - 1) * 2 * a[u]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
build();
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) f[i][j] = -INF;
dfs1(root);
dfs2(root);
for (int i = (1); i <= (n); i++) ans = max(ans, f[i][m]);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, i, temp, a1, a2, nr, dr = 0;
double ans;
int z[] = {-1, 1};
cin >> a >> b >> c >> d;
nr = fabs(a * d - b * c);
for (int k1 = 0; k1 < 2; k1++)
for (int k2 = 0; k2 < 2; k2++)
for (int k3 = 0; k3 < 2; k3++)
for (int k4 = 0; k4 < 2; k4++)
if (z[k1] * z[k4] == z[k2] * z[k3]) {
temp = fabs(z[k1] * a + z[k2] * b + z[k3] * c + z[k4] * d);
dr = max(dr, temp);
}
ans = 0;
if (dr != 0) ans = nr / (double)dr;
cout << fixed << setprecision(17) << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 505;
const long long mod = 1000000007;
const long double eps = 1e-9;
const long long inf = ((1ll << 31ll) - 1ll);
const long long INF = 2000000000000000000ll;
const long double pi = acos(-1);
long long qpow(long long b, long long e) {
if (!e) return 1;
if (e & 1) return qpow(b, e - 1) * b % mod;
long long pwur = qpow(b, e >> 1);
return pwur * pwur % mod;
}
long long modinv(long long x) { return qpow(x, mod - 2); }
long long mat[maxn][maxn], prv[maxn][maxn];
vector<pair<long long, pair<long long, long long>>> v;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(0);
srand(time(NULL));
long long tc;
cin >> tc;
while (tc--) {
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) mat[i][j] = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < n; j++) {
if (k == 0) break;
long long nx = i + j;
if (nx > n) nx -= n;
long long ny = 1 + j;
mat[nx][ny] = 1;
k--;
}
}
long long rmin = mod, rmax = 0;
for (long long i = 1; i <= n; i++) {
long long row = 0;
for (long long j = 1; j <= n; j++) {
row += mat[i][j];
}
rmin = min(rmin, row);
rmax = max(rmax, row);
}
long long cmin = mod, cmax = 0;
for (long long i = 1; i <= n; i++) {
long long col = 0;
for (long long j = 1; j <= n; j++) {
col += mat[j][i];
}
cmin = min(cmin, col);
cmax = max(cmax, col);
}
cout << (rmax - rmin) * (rmax - rmin) + (cmax - cmin) * (cmax - cmin)
<< '\n';
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
cout << mat[i][j];
}
cout << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
vector<int> divisors(int n) {
vector<int> div;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
div.push_back(i);
} else {
div.push_back(i);
div.push_back(n / i);
}
}
}
return div;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> p(n), c(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
}
int col;
for (int i = 0; i < n; i++) {
cin >> col;
c[p[i]] = col;
}
vector<vector<int>> cycles;
vector<int> cycle;
vector<bool> visit(n, false);
for (int i = 0; i < n; i++) {
int s = p[i];
if (visit[s]) {
continue;
}
cycle.clear();
while (!visit[s]) {
cycle.push_back(s);
visit[s] = true;
s = p[s];
}
cycles.push_back(cycle);
}
int _min = INT_MAX;
for (auto cycle : cycles) {
int len = cycle.size();
for (int val = 1; val <= len; val++) {
if (len % val != 0) {
continue;
}
for (int i = 0; i < val; i++) {
int elem = cycle[i];
int col = c[elem];
bool ok = true;
int ind = i;
while (ind + val < len) {
ind += val;
elem = cycle[ind];
if (col != c[elem]) {
ok = false;
break;
}
}
if (ok) {
_min = min(_min, val);
break;
}
}
}
}
cout << _min << endl;
};
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXS = 1 << 11;
int N, S, A[MAXS], res;
int main() {
cin >> N;
S = 1 << N;
for (int i = 2; i < 2 * S; i++) {
cin >> A[i];
}
for (int i = S - 1; i >= 1; i--) {
int l = A[2 * i], r = A[2 * i + 1];
A[i] += max(l, r);
res += max(l, r) - min(l, r);
}
cout << res << '\n';
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 100020;
struct node {
unsigned long long st;
unsigned long long x0;
unsigned long long x1;
};
node s[maxn];
unsigned long long a[maxn];
unsigned long long t[maxn];
int main() {
std::ios::sync_with_stdio(false);
unsigned long long n, m;
cin >> n >> m;
int kt = 1;
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
t[i] = kt;
kt = 1 - kt;
}
t[n + 1] = kt;
a[n + 1] = m;
n = n + 1;
unsigned long long s0 = 0;
unsigned long long s1 = 0;
for (int i = n; i >= 1; i--) {
if (t[i] == 0) {
s0 += a[i] - a[i - 1];
} else {
s1 += a[i] - a[i - 1];
}
s[i - 1].x0 = s0;
s[i - 1].x1 = s1;
s[i - 1].st = 1 - t[i];
}
s[n].st = 1 - t[n - 1];
s[n].x0 = 0;
s[n].x1 = 0;
unsigned long long mx = s[0].x1;
for (int i = 1; i <= n; i++) {
if (a[i] - a[i - 1] <= 1) continue;
if (s[i].st == 1) {
unsigned long long sm = s[0].x1 - s[i - 1].x1;
unsigned long long tmp = s[i - 1].x1 - s[i].x1;
mx = max(mx, sm + tmp - 1 + s[i].x0);
} else {
unsigned long long sm = s[0].x1 - s[i - 1].x1;
unsigned long long tmp = s[i - 1].x0 - s[i].x0;
mx = max(mx, sm + tmp - 1 + s[i].x0);
}
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct len {
int l, x, y;
} q[5000010];
struct point {
int x, y;
} p[3010];
int ord[5000010], n;
unsigned one = 1;
struct Bit {
unsigned a[94];
inline void Add(int x) { a[x >> 5] |= one << (x & 31); }
} B[3010];
inline void read(int& x) {
char ch = getchar();
int mk = 1;
for (; (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') mk = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mk;
}
int sqr(int x) { return x * x; }
int dis(int x1, int y1, int x2, int y2) { return sqr(x1 - x2) + sqr(y1 - y2); }
inline bool cmp(const int& a, const int& b) { return q[a].l > q[b].l; }
bool Merge_empty(int x, int y) {
for (int i = 0; i <= (n >> 5); i++) {
int z = B[x].a[i] & B[y].a[i];
if (z) return 1;
}
return 0;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(p[i].x), read(p[i].y);
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
q[++cnt].x = i;
q[cnt].y = j;
q[cnt].l = dis(p[i].x, p[i].y, p[j].x, p[j].y);
ord[cnt] = cnt;
}
sort(ord + 1, ord + cnt + 1, cmp);
for (int i = 1; i <= cnt; i++) {
int x = q[ord[i]].x, y = q[ord[i]].y;
if (Merge_empty(x, y)) {
printf("%.10lf\n", sqrt(q[ord[i]].l) / 2);
break;
}
B[x].Add(y);
B[y].Add(x);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2002], n, t[2002], c[2002];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long i = 0; i < 2002; ++i) dp[i] = 1e18;
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> t[i] >> c[i];
t[i]++;
}
for (long long i = 1; i <= n; ++i) {
for (long long j = n; j >= 0; --j) {
if (j <= t[i])
dp[j] = min(dp[j], c[i]);
else
dp[j] = min(dp[j], dp[j - t[i]] + c[i]);
}
}
cout << dp[n];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[150], b[150];
void put(int x, int y[]) {
if (x == 1)
y[1] = 1;
else if (x == 2) {
y[1] = 3;
y[2] = 4;
} else {
for (int i = 1; i <= x - 1; i++) y[i] = 2;
y[x] = x - 2;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
put(n, a);
put(m, b);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
printf("%d", a[i] * b[j]);
if (j == m)
printf("\n");
else
printf(" ");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
long long INF = 1e18;
int n, d, h;
int solve() {
cin >> n >> d >> h;
int k = d - h;
if (k > h || n > 2 && h == 1 && k == 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < h; i++) cout << i + 1 << ' ' << i + 1 + 1 << endl;
if (k > 0) {
cout << 0 + 1 << ' ' << h + 1 + 1 << endl;
for (int i = h + 1; i < d; i++) cout << i + 1 << ' ' << i + 1 + 1 << endl;
}
for (int i = d + 1; i < n; i++) cout << (h > 1) + 1 << ' ' << i + 1 << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long l, r;
scanf("%lld%lld", &l, &r);
printf("YES\n");
for (long long i = l; i <= r - 1; i += 2) {
printf("%lld %lld\n", i, i + 1);
}
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int aracheck[100] = {0};
int n, m, i, j, k, l;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
int n1;
scanf("%d", &n1);
for (j = 0; j < n1; j++) {
int phi;
scanf("%d", &phi);
aracheck[phi] = 1;
}
}
int count = 0;
for (i = 1; i <= m; i++)
if (aracheck[i] == 1) {
count++;
}
if (count == m)
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace SHENZHEBEI {
static const int GYN = 2333333;
char SZB[GYN], *SS = SZB, *TT = SZB;
inline char gc() {
if (SS == TT) {
TT = (SS = SZB) + fread(SZB, 1, GYN, stdin);
if (SS == TT) return '\n';
}
return *SS++;
}
inline long long read() {
long long x = 0, g = 1;
char ch = gc();
for (; !isdigit(ch); ch = gc())
if (ch == '-') g = -1;
for (; isdigit(ch); ch = gc()) x = x * 10 - 48 + ch;
return x * g;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline char readchar() {
char ch = gc();
for (; isspace(ch); ch = gc())
;
return ch;
}
inline long long readstr(char *s) {
char ch = gc();
int cur = 0;
for (; isspace(ch); ch = gc())
;
for (; !isspace(ch); ch = gc()) s[cur++] = ch;
s[cur] = '\0';
return cur;
}
void Print(long long *a, int s, int t) {
for (int i = (long long)(s); i <= (long long)(t); ++i) printf("%lld ", a[i]);
}
void Print(int *a, int s, int t) {
for (int i = (long long)(s); i <= (long long)(t); ++i) printf("%d ", a[i]);
}
void Print(char *a, int s, int t) {
for (int i = (long long)(s); i <= (long long)(t); ++i) putchar(a[i]);
}
void writeln(long long x) {
write(x);
puts("");
}
void Min(long long &x, long long y) { x = x < y ? x : y; }
void Max(long long &x, long long y) { x = x > y ? x : y; }
} // namespace SHENZHEBEI
using namespace SHENZHEBEI;
const long long mod = 1e9 + 7;
long long ans, n, k, f[550][550], bin[250050];
int main() {
n = read(), k = read();
bin[0] = 1;
for (int i = (long long)(1); i <= (long long)(250000); ++i)
bin[i] = bin[i - 1] * 2 % mod;
f[0][0] = 1;
for (int i = (long long)(1); i <= (long long)(k); ++i)
for (int j = (long long)(1); j <= (long long)(n); ++j)
for (int k = (long long)(0); k < (long long)(j); ++k)
((f[j][i]) = ((f[j][i]) + (f[k][i - 1] * (bin[j - k] - 1) % mod *
bin[(n - j) * (j - k)])) %
mod);
for (int i = (long long)(0); i <= (long long)(n); ++i)
((ans) = ((ans) + (f[i][k])) % mod);
writeln(ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct DATA {
int x, y;
DATA(int _x, int _y) : x(_x), y(_y) {}
};
const int dx[] = {0, -1, 1};
const int dy[] = {3, 3, 3};
int t, row = 3, col, k;
char m[3][110];
bool visited[3][110];
bool isPossible(int hx, int hy, int d) {
int nx = hx + dx[d], ny = hy + dy[d];
if (nx < 0 || nx >= row || ny < 0 || ny >= col) return false;
for (int i = hy + 1; i <= ny; ++i)
if (m[nx][i] != '.') return false;
if (m[hx][hy + 1] != '.') return false;
return true;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &col, &k);
memset(visited, false, sizeof(visited));
int sx, sy;
for (int i = 0; i < row; ++i) {
scanf("%s", m[i]);
for (int j = 0; j < col; ++j) {
if (m[i][j] == 's') {
sx = i;
sy = j;
m[sx][sy] = '.';
}
}
}
int r = (col - 1) % 3;
for (int i = 0; i < 3; ++i) {
for (int j = col; j < col + (3 - r); ++j) m[i][j] = '.';
}
col += (3 - r);
queue<DATA> q;
q.push(DATA(sx, sy));
visited[sx][sy] = true;
while (q.size()) {
const DATA& d = q.front();
int hx = d.x, hy = d.y;
q.pop();
for (int i = 0; i < 3; ++i) {
int nx = hx + dx[i], ny = hy + dy[i];
if (isPossible(hx, hy, i) && !visited[nx][ny]) {
visited[nx][ny] = true;
q.push(DATA(nx, ny));
}
}
}
bool flag = false;
for (int i = 0; i < 3; ++i) {
flag |= visited[i][col - 1];
}
printf("%s\n", flag ? "YES" : "NO");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int root[100005], a[100005], cnt, pre[100005], n;
struct node {
int l, r, sum;
} T[(100005) * 40];
void update(int l, int r, int &x, int y, int pos, int val) {
T[++cnt] = T[y];
T[x = cnt].sum += val;
if (l == r) return;
int mid = l + r >> 1;
if (mid >= pos)
update(l, mid, T[x].l, T[y].l, pos, val);
else
update(mid + 1, r, T[x].r, T[y].r, pos, val);
}
int query(int l, int r, int x, int k) {
if (l == r) return l;
int mid = l + r >> 1;
if (k <= T[T[x].l].sum)
return query(l, mid, T[x].l, k);
else
return query(mid + 1, r, T[x].r, k - T[T[x].l].sum);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = n; i > 0; i--) {
update(1, n, root[i], root[i + 1], i, 1);
if (pre[a[i]]) update(1, n, root[i], root[i], pre[a[i]], -1);
pre[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int now = 1, ans = 0;
while (now <= n) {
if (T[root[now]].sum > i)
now = query(1, n, root[now], i + 1);
else
now = n + 1;
ans++;
}
printf("%d ", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
char ar[n][m];
int a = 0, b = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> ar[i][j];
if (ar[i][j] == '*') {
a ^= i;
b ^= j;
}
}
}
cout << a + 1 << " " << b + 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100][2];
int n, arr[101];
long long rec(int idx, int f) {
if (idx == n) {
return 1;
}
if (dp[idx][f] != -1) return dp[idx][f];
int cnt = 0, i;
long long ret = 0;
for (int i = idx; i < n; i++) {
if (arr[i]) cnt++;
if (cnt == 2) break;
if (cnt == 0) continue;
ret += rec(i + 1, 0);
}
return dp[idx][f] = ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int i = 0;
while (arr[n - 1] == 0) {
n--;
}
while (arr[i] == 0) i++;
memset(dp, -1, sizeof dp);
cout << rec(i, 0) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, A, cf, cm;
pair<int, int> a[100010];
long long sum[100010], m;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
int getPos(int l, int r, int val) {
int ret = r + 1;
while (l <= r) {
int mid = l + r >> 1;
if (a[mid].first >= val) {
ret = mid;
r = mid - 1;
} else
l = mid + 1;
}
return ret;
}
int cal(int Lim) {
int l = 0, r = A;
long long cur = A * 1ll * (n - Lim) - (sum[n] - sum[Lim]);
if (cur > m) return -1;
int score = -1;
while (l <= r) {
int mid = l + r >> 1;
int pos = getPos(0, Lim - 1, mid);
if (cur + (pos * 1ll * mid - sum[pos]) <= m) {
score = mid;
l = mid + 1;
} else
r = mid - 1;
}
return score;
}
long long getPoint(int score, int r) {
return score * 1ll * cm + (n - r) * 1ll * cf;
}
void solve() {
int l = 0, r = n, cur = m, score = 0;
int ansR, ansScore;
long long ans = -1;
for (int r = n; r >= 0; r--) {
score = cal(r);
if (score < 0) break;
if (getPoint(score, r) >= ans) {
ans = getPoint(score, r);
ansR = r;
ansScore = score;
}
}
cout << ans << endl;
for (int i = 0; i < (n); i++) {
if (a[i].first < ansScore) a[i].first = ansScore;
if (i >= ansR) a[i].first = A;
}
sort(a, a + n, cmp);
for (int i = 0; i < (n); i++)
printf("%d%c", a[i].first, i == n - 1 ? '\n' : ' ');
}
int main() {
cin >> n >> A >> cf >> cm >> m;
for (int i = 0; i < (n); i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
for (int i = 0; i < (n); i++) sum[i + 1] = sum[i] + a[i].first;
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
char Buf[1 << 23], *P1 = Buf, *P2 = Buf;
template <typename Tp = int>
inline Tp read() {
Tp x = 0;
bool f = false;
char ch =
(P1 == P2 && (P2 = (P1 = Buf) + fread(Buf, 1, 1 << 23, stdin), P1 == P2)
? EOF
: *P1++);
while (ch < '0' || ch > '9')
f |= (ch == '-'),
ch = (P1 == P2 && (P2 = (P1 = Buf) + fread(Buf, 1, 1 << 23, stdin),
P1 == P2)
? EOF
: *P1++);
while (ch >= '0' && ch <= '9')
x = x * 10 + (ch ^ 48),
ch =
(P1 == P2 && (P2 = (P1 = Buf) + fread(Buf, 1, 1 << 23, stdin), P1 == P2)
? EOF
: *P1++);
return f ? -x : x;
}
template <typename Tp>
inline void read(Tp &x) {
x = read<Tp>();
}
template <typename Tp1, typename... Tp2>
inline void read(Tp1 &x, Tp2 &...y) {
read(x), read(y...);
}
constexpr int Max = 1e5 + 100;
constexpr int max_num = 8192;
int n, x;
bool can[max_num];
vector<int> f[max_num];
int pre[max_num];
signed main() {
read(n);
for (int i = 0; i < max_num; ++i) f[i].emplace_back(0), pre[i] = max_num;
can[0] = 1;
while (n--) {
int i;
read(i);
for (int x : f[i]) {
const int y = x ^ i;
can[y] = true;
while (pre[y] > i) {
--pre[y];
if (pre[y] > i) f[pre[y]].emplace_back(y);
}
}
f[i].clear();
}
int ans = 0;
for (int i = 0; i < max_num; ++i) ans += can[i];
printf("%d\n", ans);
for (int i = 0; i < max_num; ++i)
if (can[i]) printf("%d ", i);
putchar('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
int Compare(std::string a, std::string b) {
if (a.size() != b.size()) {
return -1;
}
int k = 0;
for (int i = 0; i < a.size(); i++) {
k += a[i] == b[i];
}
return k;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
int n;
std::cin >> n;
std::string a;
std::string variants[] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
std::cin >> a;
int maximal = -1, var, k = 0;
for (int i = 0; i < 8; i++) {
k = Compare(a, variants[i]);
if (k >= maximal) {
maximal = k;
var = i;
}
}
std::cout << variants[var];
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.