solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
struct tree {
int lt, rt;
int pos[2][21];
int val[2][21];
int l, r;
long long ans;
} a[N << 2];
int n, m, x;
void update(tree &a, tree &b, tree &c) {
a.lt = b.lt;
a.rt = c.rt;
for (int i = 0; i < b.l; i++) {
a.pos[0][i] = b.pos[0][i];
a.val[0][i] = b.val[0][i];
}
a.l = b.l;
int y = b.val[0][b.l - 1];
for (int i = 0; i < c.l; i++)
if ((y | c.val[0][i]) != y) {
a.pos[0][a.l] = c.pos[0][i];
y |= c.val[0][i];
a.val[0][a.l++] = y;
}
a.r = c.r;
for (int i = 0; i < c.r; i++) {
a.pos[1][i] = c.pos[1][i];
a.val[1][i] = c.val[1][i];
}
y = c.val[1][c.r - 1];
for (int i = 0; i < b.r; i++) {
if ((y | b.val[1][i]) != y) {
a.pos[1][a.r] = b.pos[1][i];
y |= b.val[1][i];
a.val[1][a.r++] = y;
}
}
a.ans = b.ans + c.ans;
for (int i = b.r - 1, j = 0; i >= 0; i--) {
long long lenx =
i == b.r - 1 ? b.pos[1][i] - b.lt + 1 : b.pos[1][i] - b.pos[1][i + 1];
while (j < c.l && (b.val[1][i] | c.val[0][j]) < x) j++;
if (j == c.l) continue;
long long leny = c.rt - c.pos[0][j] + 1;
a.ans += lenx * leny;
}
}
void init(int lt, int rt, int step) {
a[step].lt = lt;
a[step].rt = rt;
if (lt == rt) {
int y;
scanf("%d", &y);
a[step].ans = x <= y;
a[step].pos[0][0] = a[step].pos[1][0] = lt;
a[step].val[0][0] = a[step].val[1][0] = y;
a[step].l = a[step].r = 1;
return;
}
int mid = (lt + rt) >> 1;
init(lt, mid, step << 1);
init(mid + 1, rt, step << 1 | 1);
update(a[step], a[step << 1], a[step << 1 | 1]);
}
void modify(int pos, int step, int y) {
if (a[step].lt == a[step].rt) {
a[step].ans = x <= y;
a[step].val[0][0] = a[step].val[1][0] = y;
a[step].l = a[step].r = 1;
return;
}
if (pos <= a[step << 1].rt)
modify(pos, step << 1, y);
else
modify(pos, step << 1 | 1, y);
update(a[step], a[step << 1], a[step << 1 | 1]);
}
tree query(int lt, int rt, int step) {
if (a[step].lt == lt && a[step].rt == rt) {
return a[step];
}
if (rt <= a[step << 1].rt)
return query(lt, rt, step << 1);
else if (lt > a[step << 1].rt)
return query(lt, rt, step << 1 | 1);
else {
tree l = query(lt, a[step << 1].rt, step << 1);
tree r = query(a[step << 1 | 1].lt, rt, step << 1 | 1);
tree ans;
update(ans, l, r);
return ans;
}
}
int main() {
scanf("%d%d%d", &n, &m, &x);
init(1, n, 1);
while (m--) {
int cd, x, y;
scanf("%d%d%d", &cd, &x, &y);
if (cd == 1) {
modify(x, 1, y);
} else {
tree ans = query(x, y, 1);
printf("%I64d\n", ans.ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int MAX_E2 = 1 << 19;
const long long LINF = 1LL << 62;
template <typename T, const int MAX_E2>
struct SegTreeMin {
int n, e2;
T nodes[MAX_E2], tinf;
SegTreeMin() {}
void init(int _n, T _tinf) {
n = _n, tinf = _tinf;
for (e2 = 1; e2 < n; e2 <<= 1)
;
fill(nodes, nodes + MAX_E2, tinf);
}
T &get(int i) { return nodes[e2 - 1 + i]; }
void set(int i, T v) { get(i) = v; }
void setall() {
for (int j = e2 - 1; j >= 0; j--)
nodes[j] = min(nodes[j * 2 + 1], nodes[j * 2 + 2]);
}
T min_range(int r0, int r1, int k, int i0, int i1) {
if (r1 <= i0 || i1 <= r0) return tinf;
if (r0 <= i0 && i1 <= r1) return nodes[k];
int im = (i0 + i1) / 2;
T v0 = min_range(r0, r1, k * 2 + 1, i0, im);
T v1 = min_range(r0, r1, k * 2 + 2, im, i1);
return min(v0, v1);
}
T min_range(int r0, int r1) { return min_range(r0, r1, 0, 0, e2); }
};
int as[MAX_N], bs[MAX_N], ans[MAX_N];
SegTreeMin<long long, MAX_E2> st;
bool oks[MAX_N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", as + i);
for (int i = 0; i < n; i++) scanf("%d", bs + i);
st.init(n * 2 + 1, LINF);
for (int i = 0; i < n; i++) {
long long d = st.get(i) + as[i] - bs[i];
st.set(i + 1, d);
st.set(i + 1 + n, d);
}
st.setall();
for (int i = 0; i < n; i++)
if (st.min_range(i, i + n) >= st.get(i)) oks[i] = true;
for (int i = 0; i < n; i++) {
long long d = st.get(i) + as[(n - i) % n] - bs[n - 1 - i];
st.set(i + 1, d);
st.set(i + 1 + n, d);
}
st.setall();
for (int i = 0; i < n; i++)
if (st.min_range(i, i + n) >= st.get(i)) oks[(n - i) % n] = true;
int m = 0;
for (int i = 0; i < n; i++)
if (oks[i]) ans[m++] = i;
printf("%d\n", m);
for (int i = 0; i < m; i++) {
if (i) putchar(' ');
printf("%d", ans[i] + 1);
}
putchar('\n');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[200005], s[4 * 200005], n;
void build(int id = 1, int l = 0, int r = n) {
if (r - l < 2) {
s[id] = a[l];
return;
}
int mid = (l + r) >> 1;
build(2 * id, l, mid);
build(2 * id + 1, mid, r);
s[id] = max(s[2 * id], s[2 * id + 1]);
return;
}
int maxx(int b, int e, int id = 1, int l = 0, int r = n) {
if (b >= r || e <= l) return -1000000000;
if (l >= b && r <= e) return s[id];
int mid = (l + r) >> 1;
return max(maxx(b, e, 2 * id, l, mid), maxx(b, e, 2 * id + 1, mid, r));
}
char str[200005];
int main() {
scanf("%s", str);
n = strlen(str);
int c = 0, v = 0, i, ans = 0, cnt, tmp = 0;
for (i = 0; i < n; i++) {
if (str[i] > 'Z') str[i] -= 32;
if (str[i] == 'A' || str[i] == 'E' || str[i] == 'I' || str[i] == 'O' ||
str[i] == 'U')
v++;
else
c++;
a[i] = 2 * c - v;
}
build();
for (i = 0; i < n; i++) {
int now = maxx(i, n);
if (now < tmp) {
if (str[i] == 'A' || str[i] == 'E' || str[i] == 'I' || str[i] == 'O' ||
str[i] == 'U')
tmp -= 1;
else
tmp += 2;
continue;
}
int l = 0, r = n, id = 1;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (s[2 * id + 1] >= tmp) {
l = mid;
id = 2 * id + 1;
} else {
r = mid;
id = 2 * id;
}
}
if (r - i > ans) {
ans = r - i;
cnt = 1;
} else if (r - i == ans)
cnt++;
if (str[i] == 'A' || str[i] == 'E' || str[i] == 'I' || str[i] == 'O' ||
str[i] == 'U')
tmp -= 1;
else
tmp += 2;
}
if (!ans) {
printf("No solution\n");
return 0;
}
printf("%d %d\n", ans, cnt);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x < y ? x : y;
}
template <typename T>
void read(T &x) {
x = 0;
bool w = 0;
char ch = 0;
for (; !isdigit(ch); ch = getchar()) w |= ch == '-';
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
x *= w ? -1 : 1;
}
template <typename T>
void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void write(T x, char ch) {
write(x);
putchar(ch);
}
int n, k;
int a[N], d[N];
int main() {
read(n);
read(k);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i < n; i++) d[i] = a[i] - a[i + 1];
sort(d + 1, d + n);
long long ans = a[n] - a[1];
for (int i = 1; i < k; i++) ans += d[i];
write(ans, '\n');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 500000 + 7;
const int mod = INF;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = mod) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
int n;
set<int> not_sure;
set<int> sell, buy;
void add(set<int>& a, set<int>& b) {
while (!b.empty()) {
int u = *b.begin();
b.erase(u);
a.insert(u);
}
}
void solve() {
cin >> n;
long long ans = 1;
for (int i = 0; i < n; ++i) {
string s;
int u;
cin >> s >> u;
if (s[1] == 'D') {
if (!buy.empty() && u < *buy.rbegin())
buy.insert(u);
else if (!sell.empty() && u > *sell.begin())
sell.insert(u);
else
not_sure.insert(u);
} else {
if (buy.count(u)) {
if (u != *buy.rbegin()) {
cout << 0;
return;
}
buy.erase(u);
add(sell, not_sure);
} else if (sell.count(u)) {
if (u != *sell.begin()) {
cout << 0;
return;
}
sell.erase(u);
add(buy, not_sure);
} else {
assert(not_sure.count(u));
ans = ans * 2 % INF;
for (auto p : not_sure) {
if (p < u)
buy.insert(p);
else if (p > u)
sell.insert(p);
}
not_sure.clear();
}
}
}
ans = ans * (not_sure.size() + 1) % INF;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
string a, b;
cin >> a >> b;
bool check = false;
for (char i : a) {
for (char j : b) {
if (i == j) {
check = true;
}
}
}
if (check) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long bb = 22; bb >= 0; bb--) {
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (a[i] >> bb & 1) cnt++;
}
for (long long i = 0; i < cnt; i++) {
b[i] |= (1LL << bb);
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += b[i] * b[i];
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const bool debug = false;
const long long p = 37;
using namespace std;
struct pt {
int l, r;
};
long long h[200000], st[200000];
pt hp[200000];
string s;
int k, kol;
void no() {
cout << "No such line.";
exit(0);
}
void swp(pt &x, pt &y) {
pt t = x;
x = y;
y = t;
}
long long hesh(int l, int r) { return h[r + 1] - (h[l] * st[r - l + 1]); }
int bin(pt x, pt y) {
int l = 1;
int r = min(x.r - x.l, y.r - y.l) + 1;
int res = 0;
while (l <= r) {
int m = (l + r) / 2;
if (hesh(x.l, x.l + m - 1) == hesh(y.l, y.l + m - 1)) {
res = m;
l = m + 1;
} else
r = m - 1;
}
return res;
}
bool cmp(pt x, pt y) {
if (debug) printf("%d %d %d %d \n", x.l, x.r, y.l, y.r);
int len = min(x.r - x.l, y.r - y.l);
if (hesh(x.l, x.l + len) == hesh(y.l, y.l + len))
return (x.r - x.l < y.r - y.l);
int ln = bin(x, y);
return (s[x.l + ln] < s[y.l + ln]);
}
void add(int l, int r) {
kol++;
hp[kol].l = l;
hp[kol].r = r;
int x = kol;
while (x > 1 && cmp(hp[x], hp[x / 2])) {
swp(hp[x], hp[x / 2]);
x /= 2;
}
}
pt ext() {
if (debug) {
printf("Ext begins\n");
}
swap(hp[kol], hp[1]);
kol--;
if (kol == 1) return hp[kol + 1];
int x = 1;
while (2 * x < kol && (cmp(hp[2 * x], hp[x]) | cmp(hp[2 * x + 1], hp[x])))
if (cmp(hp[2 * x], hp[2 * x + 1])) {
swap(hp[2 * x], hp[x]);
x = 2 * x;
} else {
swap(hp[2 * x + 1], hp[x]);
x = 2 * x + 1;
}
if (2 * x == kol && cmp(hp[2 * x], hp[x])) swap(hp[2 * x], hp[x]);
return hp[kol + 1];
}
void wr() {
printf("Len_Heap = %d\n", kol);
for (int i = 1; i <= kol; i++)
printf("%d element = %d %d\n", i, hp[i].l, hp[i].r);
printf("Wr ends\n");
}
int main() {
cin >> s >> k;
int len = s.size();
st[0] = 1;
for (int i = 1; i <= len; i++) st[i] = st[i - 1] * p;
long long sum = len;
kol = 0;
sum = (sum * (sum + 1)) / 2;
if (k > sum) no();
h[0] = 0;
for (int i = 0; i < len; i++) {
h[i + 1] = h[i] * p + (s[i] - 'a' + 1);
add(i, i);
}
pt x;
for (int i = 1; i <= k; i++) {
if (debug) {
printf("Iteration %d starts\n", i);
wr();
}
x = ext();
if (debug) {
printf("Extract %d %d\n", x.l, x.r);
}
if (x.r < len - 1) {
add(x.l, x.r + 1);
if (debug) printf("Add %d %d\n", x.l, x.r + 1);
}
if (debug) {
wr();
printf("Iteration %d finishes\n", i);
cout << cmp(hp[2], hp[4]) << endl;
}
}
for (int i = x.l; i <= x.r; i++) cout << s[i];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
char s[N][N];
bool del[N];
set<char> ch[N];
char pat[N];
int main() {
int n, m, len = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < m; i++) {
int k;
scanf("%d", &k);
k--;
del[k] = true;
if (len == 0)
len = strlen(s[k]);
else if (len != strlen(s[k])) {
puts("No");
return 0;
}
for (int j = 0; j < len; j++) ch[j].insert(s[k][j]);
}
for (int i = 0; i < len; i++)
if (ch[i].size() > 1)
pat[i] = '?';
else
pat[i] = *ch[i].begin();
for (int i = 0; i < n; i++)
if (!del[i]) {
if (strlen(s[i]) != len) continue;
bool ok = true;
for (int j = 0; j < len; j++)
if (pat[j] != '?' && pat[j] != s[i][j]) ok = false;
if (ok) {
puts("No");
return 0;
}
}
puts("Yes");
puts(pat);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool com(long long a, long long b) { return a < b; }
int main() {
long long n;
cin >> n;
long long a[n], s;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) {
s = 1;
for (long long j = 0; j < n; j++) {
if (a[j] > a[i]) s++;
}
cout << s << " ";
}
cout << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt[200000][26];
string str;
int fn(int start, int end, char ch) {
int len = end - start + 1;
if (len == 1) {
int ans = 1;
if (str[start] == ch) ans = 0;
return ans;
}
int mid = (start + end) / 2;
int curr1 = cnt[mid][ch - 'a'] - cnt[start - 1][ch - 'a'];
int curr2 = cnt[end][ch - 'a'] - cnt[mid][ch - 'a'];
curr1 = len / 2 - curr1;
curr2 = len / 2 - curr2;
int next1 = fn(start, mid, ch + 1);
int next2 = fn(mid + 1, end, ch + 1);
int ans = min(curr1 + next2, curr2 + next1);
return ans;
}
void TestingChaluKarEyy() {
int n;
cin >> n;
string xx;
cin >> xx;
str = "1";
str += xx;
for (int i = 0; i <= 25; ++i) cnt[0][i] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= 25; ++j) cnt[i][j] = cnt[i - 1][j];
++cnt[i][str[i] - 'a'];
}
cout << fn(1, n, 'a') << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int TestingKaravvuChhe;
cin >> TestingKaravvuChhe;
while (TestingKaravvuChhe--) {
TestingChaluKarEyy();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = (20 + 10), INF = 0x3f3f3f3f3f3f3f3f;
struct node {
int x, y;
} p[5];
int per[5];
int solve() {
auto lu = p[per[1]], ru = p[per[2]], ld = p[per[3]], rd = p[per[4]];
int lx1 = min(ld.x, rd.x), rx1 = max(ld.x, rd.x), lx2 = min(lu.x, ru.x),
rx2 = max(lu.x, ru.x);
int ly1 = min(lu.y, ld.y), ry1 = max(lu.y, ld.y), ly2 = min(ru.y, rd.y),
ry2 = max(ru.y, rd.y);
int lx = max(0ll, max(lx1, lx2) - min(rx1, rx2)),
rx = rx1 - lx1 + rx2 - lx2 - (min(rx1, rx2) - max(lx1, lx2));
int ly = max(0ll, max(ly1, ly2) - min(ry1, ry2)),
ry = ry1 - ly1 + ry2 - ly2 - (min(ry1, ry2) - max(ly1, ly2));
return rx1 - lx1 + ry1 - ly1 + rx2 - lx2 + ry2 - ly2 +
2 * max(0ll, max(lx, ly) - min(rx, ry));
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
for (int i = 1; i <= 4; i++) cin >> p[i].x >> p[i].y, per[i] = i;
int ans = INF;
do {
ans = min(ans, solve());
} while (next_permutation(per + 1, per + 1 + 4));
cout << ans << "\n";
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int f = 1;
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] == 1) {
cout << 2 << endl;
f = 0;
break;
}
}
if (f == 1) {
cout << 1 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 5e5 + 5;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
namespace input {
template <class T>
void re(complex<T>& x);
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
void re(long double& x) {
string t;
re(t);
x = stold(t);
}
template <class T, class... Ts>
void re(T& t, Ts&... ts) {
re(t);
re(ts...);
}
template <class T>
void re(complex<T>& x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = (0); i < ((int)a.size()); ++i) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = (0); i < (SZ); ++i) re(a[i]);
}
} // namespace input
using namespace input;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(long long x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(long double x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template <class T>
void pr(const complex<T>& x) {
cout << x;
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T>
void pr(const T& x);
template <class T, class... Ts>
void pr(const T& t, const Ts&... ts) {
pr(t);
pr(ts...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void pr(const T& x) {
pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
void ps() { pr("\n"); }
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(" ");
ps(ts...);
}
void pc() { pr("]\n"); }
template <class T, class... Ts>
void pc(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(", ");
pc(ts...);
}
} // namespace output
using namespace output;
namespace io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
cin.sync_with_stdio(0);
cin.tie(0);
if ((int)second.size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace io
using namespace io;
template <class T>
struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
modular(const long long& v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0) val += MOD;
}
friend void pr(const modular& a) { pr(a.val); }
friend void re(modular& a) {
long long x;
re(x);
a = modular(x);
}
friend bool operator==(const modular& a, const modular& b) {
return a.val == b.val;
}
friend bool operator!=(const modular& a, const modular& b) {
return !(a == b);
}
friend bool operator<(const modular& a, const modular& b) {
return a.val < b.val;
}
modular operator-() const { return modular(-val); }
modular& operator+=(const modular& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
modular& operator-=(const modular& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
modular& operator*=(const modular& m) {
val = (long long)val * m.val % MOD;
return *this;
}
friend modular pow(modular a, long long p) {
modular ans = 1;
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend modular inv(const modular& a) {
assert(a != 0);
return pow(a, MOD - 2);
}
modular& operator/=(const modular& m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular& b) { return a += b; }
friend modular operator-(modular a, const modular& b) { return a -= b; }
friend modular operator*(modular a, const modular& b) { return a *= b; }
friend modular operator/(modular a, const modular& b) { return a /= b; }
};
void fin(modular<int> x) {
ps(x);
exit(0);
}
template <int SZ>
struct Tree {
int n, depth[MX], par[MX];
vector<int> adj[MX];
void dfs(int x) {
depth[x] = depth[par[x]] + 1;
for (auto& t : adj[x])
if (t != par[x]) {
par[t] = x;
dfs(t);
}
}
void init() {
re(n);
for (int i = (0); i < (n - 1); ++i) {
int u, v;
re(u, v);
adj[u].push_back(v), adj[v].push_back(u);
}
dfs(1);
}
map<int, int> nex[MX], pre[MX];
void setNex(int a, int b, int c) {
if (nex[a].count(b)) fin(0);
nex[a][b] = c;
}
void setPre(int a, int b, int c) {
if (pre[a].count(b)) fin(0);
pre[a][b] = c;
}
void genPath(int a, int b) {
vector<int> p0 = {-MOD}, p1 = {MOD};
while (a != b) {
if (depth[b] > depth[a]) {
p1.push_back(b);
b = par[b];
} else {
p0.push_back(a);
a = par[a];
}
}
reverse(begin(p1), end(p1));
p0.push_back(a);
p0.insert(end(p0), begin(p1), end(p1));
for (int i = (1); i < ((int)p0.size() - 1); ++i) {
setNex(p0[i], p0[i - 1], p0[i + 1]);
setPre(p0[i], p0[i + 1], p0[i - 1]);
}
}
bool existsCyc(int x) {
map<int, int> vis;
int co = 0;
for (auto& t : nex[x])
if (!vis.count(t.first)) {
int z = t.first;
vis[z] = ++co;
while (nex[x].count(z)) {
z = nex[x][z];
if (vis.count(z)) {
if (vis[z] != co) break;
return 1;
}
vis[z] = co;
}
}
return 0;
}
bool existsPath(int x) {
int a = -MOD, len = 0;
while (nex[x].count(a)) {
a = nex[x][a];
len++;
}
if (a == MOD) {
if (len - 1 != (int)adj[x].size()) fin(0);
return 1;
}
return 0;
}
};
Tree<MX> T;
int a[MX];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
T.init();
for (int i = (1); i < (T.n + 1); ++i) {
re(a[i]);
if (a[i] == i) fin(0);
if (a[i]) T.genPath(a[i], i);
}
modular<int> ans = 1;
for (int i = (1); i < (T.n + 1); ++i) {
if (T.existsPath(i)) continue;
if (T.existsCyc(i)) fin(0);
int x = (int)T.adj[i].size() - (int)T.pre[i].size();
for (int i = (1); i < (x + 1); ++i) ans *= i;
}
fin(ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n;
while (n--) {
cin >> a;
if (a == 1) {
cout << -1;
return 0;
}
}
cout << 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long A[1005], B[1005];
int main() {
long long n, max = 0;
cin >> n;
for (int i = 0; i < n; ++i) cin >> A[i];
for (int i = 0; i < n; ++i) cin >> B[i];
for (int i = 0; i < n; ++i) {
long long tempA = 0, tempB = 0;
for (int j = 0; j <= i; ++j) tempA |= A[j], tempB |= B[j];
if (tempA + tempB > max) max = tempA + tempB;
}
cout << max;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == '@' || s[s.size() - 1] == '@') {
cout << "No solution";
return 0;
}
vector<int> idxs;
for (int i = 0; i < s.size(); i++)
if (s[i] == '@') idxs.push_back(i);
if (idxs.size() == 0) {
cout << "No solution";
return 0;
}
for (int i = 0; i < idxs.size() - 1; i++)
if (idxs[i + 1] - idxs[i] <= 2) {
cout << "No solution";
return 0;
}
int st = 0;
for (int i = 0; i < s.size(); i++) {
cout << s[i];
if (s[i] == '@') {
cout << s[i + 1];
if (i != idxs[idxs.size() - 1]) cout << ",";
i = i + 1;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b[] = {1, 2, 3, 4, 5};
int a[6][6];
int max = 0;
int sum = 0;
for (int i = 1; i < 6; i++) {
for (int j = 1; j < 6; j++) cin >> a[i][j];
}
do {
sum = a[b[0]][b[1]] + a[b[1]][b[0]] + a[b[2]][b[3]] + a[b[3]][b[2]] +
a[b[2]][b[1]] + a[b[1]][b[2]] + a[b[4]][b[3]] + a[b[3]][b[4]] +
a[b[2]][b[3]] + a[b[3]][b[2]] + a[b[4]][b[3]] + a[b[3]][b[4]];
if (sum > max) max = sum;
} while (next_permutation(b, b + 5));
cout << max;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 305;
int p[N][N], o[N][N], r[N];
int main() {
int n, i, j, p1, p2, t;
scanf("%d", &n);
for (i = 1; i <= n + 1; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &p[i][j]);
}
p[i][n + 1] = n + 1;
}
for (i = 1; i <= n + 1; i++)
for (j = 1; j <= n + 1; j++) o[i][p[i][j]] = j;
for (i = 1; i <= n; i++) r[i] = n + 1;
p1 = p2 = n + 1;
for (i = 1; i <= n; i++) {
if (o[n + 1][i] < o[n + 1][p1]) {
p2 = p1;
p1 = i;
} else if (o[n + 1][i] < o[n + 1][p2]) {
p2 = i;
}
for (j = 1; j <= n; j++) {
if (p1 == j)
t = p2;
else
t = p1;
if (o[j][t] < o[j][r[j]]) r[j] = t;
}
}
for (i = 1; i < n; i++) printf("%d ", r[i]);
printf("%d\n", r[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 1) {
result = (result * base);
}
base = (base * base);
power /= 2;
}
return result;
}
bool visited[100100];
vector<long long> adj[100100];
int main() {
long long n, m;
cin >> n >> m;
long long i, j, x, ans = 0;
for (i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(visited, 0, sizeof(visited));
for (i = 1; i <= n; i++) {
if (visited[i] == false) {
long long edgeno = 0, nodes = 0;
queue<long long> Q;
Q.push(i);
while (!Q.empty()) {
long long nodeQ = Q.front();
Q.pop();
nodes++;
visited[nodeQ] = true;
for (j = 0; j < adj[nodeQ].size(); j++) {
long long to = adj[nodeQ][j];
if (visited[to] == false) {
Q.push(to);
}
edgeno++;
}
}
edgeno /= 2;
if (edgeno == nodes - 1) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
void solve() {
long long a, b, c, m;
cin >> a >> b >> c >> m;
vector<long long> v{a, b, c};
sort((v).begin(), (v).end());
long long total = a + b + c - 3;
if (total < m) {
cout << "NO" << endl;
} else {
long long k = v[2] - (v[1] + v[0] + 1);
if (m >= k) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (int it = 1; it <= t; it++) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 20;
int d[M], k, n, p, d1[M], d2[M], odd, even, cnt;
vector<int> vct[M];
int main() {
scanf("%d %d %d", &n, &k, &p);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
if (d[i] % 2)
d1[odd++] = d[i];
else
d2[even++] = d[i];
}
int t = k - p;
bool flag = false;
if (t % 2 == odd % 2 && odd >= t) flag = true;
if (!flag) {
puts("NO");
return 0;
}
int c1 = 0, c2 = 0;
for (int i = 0; i < t; i++) vct[cnt++].push_back(d1[c1++]);
for (int i = 0; i < p - 1; i++) {
if (c2 >= even && c1 < odd) {
vct[cnt].push_back(d1[c1++]);
vct[cnt++].push_back(d1[c1++]);
if (c1 >= odd) {
flag = false;
break;
}
continue;
}
if (c2 < even) vct[cnt++].push_back(d2[c2++]);
}
if (p == 0) cnt--;
if (odd == c1 && even == c2 && cnt + 1 != k || !flag) {
puts("NO");
return 0;
} else {
while (c1 < odd) vct[cnt].push_back(d1[c1++]);
while (c2 < even) vct[cnt].push_back(d2[c2++]);
}
cnt++;
puts("YES");
for (int i = 0; i < cnt; i++) {
printf("%d", vct[i].size());
for (int j = 0; j < vct[i].size(); j++) printf(" %d", vct[i][j]);
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const int maxn = 1e5 + 10;
vector<int> vec[maxn];
int a[maxn];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
vec[a[i]].push_back(i);
}
long long ans = 0, dis = 1, p = 0;
for (int i = 1; i < maxn; ++i) {
if (vec[i].empty()) continue;
vector<int>::iterator iter = lower_bound(vec[i].begin(), vec[i].end(), p);
ans += dis * (vec[i].end() - iter);
p = vec[i].back();
vec[i].erase(iter, vec[i].end());
if (vec[i].size()) {
p = 0;
dis++;
i--;
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,unroll-loops")
#pragma target optimize("avx2,bmi,bmi2,lzcnt,popcnt")
template <class T>
bool chmin(T &a, T b) {
return b < a and (a = b, true);
}
template <class T>
bool chmax(T &a, T b) {
return b > a and (a = b, true);
}
const int maxn = 2e5 + 5;
vector<int> vec;
vector<int> stk;
int ch[maxn][2];
bool add[maxn];
bool dub[maxn];
int n, m;
void dfs(int u) {
if (!u) return;
dfs(ch[u][0]);
vec.emplace_back(u);
((void)0);
dfs(ch[u][1]);
}
void dfs2(int u) {
if (!u) return;
stk.emplace_back(u);
dfs2(ch[u][0]);
if (m >= stk.size() and add[u] and !dub[u]) {
for (int v : stk) dub[v] = 1;
m -= stk.size();
stk.clear();
}
if (add[u] or dub[u]) dfs2(ch[u][1]);
if (!stk.empty() and stk.back() == u) stk.pop_back();
}
void solve() {
string str, tmp;
cin >> n >> m;
cin >> str;
str = "@" + str;
for (int i = 1; i <= n; i++) cin >> ch[i][0] >> ch[i][1];
dfs(1);
for (int i = n - 2; ~i; i--)
add[vec[i]] = (str[vec[i]] < str[vec[i + 1]]) or
(str[vec[i]] == str[vec[i + 1]] and add[vec[i + 1]]);
dfs2(1);
((void)0);
((void)0);
((void)0);
string ans;
for (int v : vec) {
ans.push_back(str[v]);
if (dub[v]) ans.push_back(str[v]);
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, R, r;
cin >> n >> R >> r;
if (n == 1 && r <= R) return cout << "YES", 0;
double a = (R - r) * sin(PI / n);
if (a + 0.0000001 >= r)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, m;
cin >> n >> k >> m;
double a[n];
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> a[i];
sort(a, a + n);
double sum = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
sum += a[i];
double dp[n + 1];
dp[n] = sum;
for (long long i = n - 1; i > 0; i--) {
sum = sum - a[n - 1 - i];
dp[i] = sum;
}
long long x = min(m, n - 1);
double ans = 0;
for (__typeof(x + 1) i = (0) - ((0) > (x + 1));
i != (x + 1) - ((0) > (x + 1)); i += 1 - 2 * ((0) > (x + 1))) {
double avg = (dp[n - i] + min(m - i, k * (n - i)));
avg = avg / (n - i);
ans = max(ans, avg);
}
cout << setprecision(15) << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
string prefix;
int dep;
int next[4];
node(void) {
dep = 0;
for (int i = 0; i < 4; i++) next[i] = -1;
}
};
node V[2000];
string S[10];
set<string> PRE;
map<pair<int, string>, int> M;
int main(int argc, char *argv[]) {
int i, j, k, n, m, t;
cin >> m >> n;
for (i = 0; i < n; i++) {
cin >> S[i];
for (j = 0; S[i][j]; j++) {
if (S[i][j] == 'C')
S[i][j] = 'B';
else if (S[i][j] == 'G')
S[i][j] = 'C';
else if (S[i][j] == 'T')
S[i][j] = 'D';
}
}
PRE.insert("");
for (i = 0; i < n; i++)
for (j = 1; j <= S[i].size(); j++) {
PRE.insert(S[i].substr(0, j));
}
int head = 0, tail = 1;
M[pair<int, string>(0, "")] = 0;
while (head < tail) {
for (char c = 'A'; c <= 'D'; c++) {
string str = V[head].prefix + c;
for (t = 0; t < str.size(); t++)
if (PRE.find(str.substr(t, str.size() - t)) != PRE.end()) break;
if (t <= V[head].dep) {
string sub = str.substr(t, str.size() - t);
for (k = 0; k < n; k++) {
if (S[k].size() <= sub.size() &&
S[k].size() + V[head].dep - t >= sub.size() &&
S[k] == sub.substr(sub.size() - S[k].size(), S[k].size()))
break;
}
if (k < n) {
if (M.find(pair<int, string>(sub.size(), sub)) != M.end())
V[head].next[c - 'A'] = M[pair<int, string>(sub.size(), sub)];
else {
V[tail].prefix = sub;
V[tail].dep = sub.size();
V[head].next[c - 'A'] = tail;
M.insert(pair<pair<int, string>, int>(
pair<int, string>(sub.size(), sub), tail));
tail++;
}
} else {
if (M.find(pair<int, string>(V[head].dep - t, sub)) != M.end())
V[head].next[c - 'A'] = M[pair<int, string>(V[head].dep - t, sub)];
else {
V[tail].prefix = sub;
V[tail].dep = V[head].dep - t;
V[head].next[c - 'A'] = tail;
M.insert(pair<pair<int, string>, int>(
pair<int, string>(V[head].dep - t, sub), tail));
tail++;
}
}
}
}
head++;
}
int *pre = new int[head];
int *next = new int[head];
for (i = 1; i < head; i++) pre[i] = 0;
pre[0] = 1;
for (k = 0; k < m; k++) {
for (i = 0; i < head; i++) next[i] = 0;
for (i = 0; i < head; i++)
for (j = 0; j < 4; j++)
if (V[i].next[j] >= 0)
next[V[i].next[j]] = (next[V[i].next[j]] + pre[i]) % 1000000009;
int *tmp = pre;
pre = next;
next = tmp;
}
int res = 0;
for (i = 0; i < head; i++)
if (V[i].dep == V[i].prefix.size()) res = (res + pre[i]) % 1000000009;
delete[] pre;
delete[] next;
cout << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint linf = 1e18 + 7;
const lint inf = 1e9 + 7;
const int MOD = 1000000007;
void press(vector<long long>& x) {
map<int, int> memo;
int n = x.size();
for (int i = 0; i < n; ++i) {
memo[x[i]] += 1;
}
int cur = 1;
for (auto& val : memo) {
val.second = cur;
++cur;
}
for (int i = 0; i < n; ++i) {
x[i] = memo[x[i]];
}
}
void solve() {
int n;
cin >> n;
vector<lint> a(n, 0);
for (int i = 0; i < n; ++i) cin >> a[i];
auto b = a;
press(b);
vector<vector<int>> dp(n + 5, vector<int>(3, 0));
vector<int> cnt(n + 5, 0);
for (int i = 0; i < n; ++i) cnt[b[i]] += 1;
int res = n - 1;
for (int i = 0; i < n; ++i) {
if (dp[b[i]][0] == 0) {
dp[b[i]][0] = max(dp[b[i] - 1][1], dp[b[i] - 1][2]) + 1;
}
if (dp[b[i]][1] + 1 < cnt[b[i]]) {
++dp[b[i]][1];
} else {
dp[b[i]][2] = dp[b[i]][0] + dp[b[i]][1];
dp[b[i]][1] += 1;
}
int hoge = dp[b[i]][1] + cnt[b[i] + 1] - dp[b[i] + 1][1];
res = min(res, n - hoge);
hoge = cnt[b[i]] - dp[b[i]][1] + dp[b[i] - 1][2] + 1;
res = min(res, n - hoge);
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
res = min(res, n - dp[i][j]);
}
}
cout << res << "\n";
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char StrA[200100];
char StrB[200100];
long long CountP[26][200100];
long long CountE[26][200100];
int main() {
int N;
scanf("%d", &N);
scanf("%s", &StrA[1]);
scanf("%s", &StrB[1]);
for (int i = 1; i <= N; i++) {
int A = StrA[i] - 'A';
CountP[A][i] = i;
}
for (int i = N; i >= 1; i--) {
int A = StrA[i] - 'A';
CountE[A][i] = N + 1 - i;
}
for (int i = 1; i <= N; i++)
for (int j = 0; j < 26; j++) CountP[j][i] += CountP[j][i - 1];
for (int i = N - 1; i >= 1; i--)
for (int j = 0; j < 26; j++) CountE[j][i] += CountE[j][i + 1];
double Sum = 0;
for (int i = 1; i <= N; i++) {
int A = StrB[i] - 'A';
Sum += CountP[A][i] * (N + 1 - i);
Sum += CountE[A][i + 1] * i;
}
double Ans = Sum;
double Temp = N;
Ans = Ans / (Temp * (Temp + 1) * (2 * Temp + 1) / 6);
printf("%.9f\n", Ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long int w[n];
set<pair<long long int, long long int> > s1;
for (int i = 0; i < n; i++) {
cin >> w[i];
v.push_back(make_pair(w[i], i));
s1.insert(make_pair(w[i], i));
}
sort(v.begin(), v.end());
string s;
cin >> s;
set<pair<long long int, long long int> > s2;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
auto it = s1.begin();
cout << it->second + 1 << " ";
s2.insert(*it);
s1.erase(it);
} else {
auto it = s2.end();
it--;
cout << it->second + 1 << " ";
s2.erase(it);
}
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
class Scanner {
std::istream& os;
public:
Scanner(std::istream& os) : os(os) {}
int nextInt() const {
int n;
os >> n;
return n;
}
long long nextLong() const {
long long n;
os >> n;
return n;
}
std::string nextWord() const {
std::string s;
os >> s;
return s;
}
std::string nextLine() const {
std::string s;
std::getline(os, s);
return s;
}
};
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
Scanner sc(std::cin);
int n = sc.nextInt();
int m = sc.nextInt();
int tab[32][32] = {0};
int sum[32][32] = {0};
for (int i = 0; i < n; ++i) {
std::string s = sc.nextWord();
for (int j = 0; j < m; ++j) tab[i + 1][j + 1] = s[j] - '0';
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
sum[i][j] = 0;
for (int k = 1; k <= i; ++k)
for (int h = 1; h <= j; ++h) sum[i][j] += tab[k][h];
}
}
int max_sum = 0;
for (int x1 = 1; x1 <= n; ++x1) {
for (int y1 = 1; y1 <= m; ++y1) {
for (int x2 = x1; x2 <= n; ++x2) {
for (int y2 = y1; y2 <= m; ++y2) {
int s = sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] +
sum[x1 - 1][y1 - 1];
if (s == 0) {
int p = (x2 - x1 + 1) * 2 + (y2 - y1 + 1) * 2;
if (p > max_sum) max_sum = p;
}
}
}
}
}
std::cout << max_sum << std::endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
long long int power(long long int i, long long int j) {
long long int prod = 1;
while (j > 0) {
if (j & 1) {
prod = prod * i;
}
j = j >> 1;
i = i * i;
}
return prod;
}
string numtostring(long long int num) {
string s = "";
if (num == 0) {
return "0";
}
while (num > 0) {
if (num % 2 == 0) {
s += "0";
} else {
s += "1";
}
num = num / 2;
}
reverse(s.begin(), s.end());
return s;
}
long long int binarystringtonum(string s) {
string tmp = s;
long long int dec = 0;
long long int base = 1, i, j;
for (i = tmp.size() - 1; i >= 0; i--) {
if (tmp[i] == '1') {
dec += base;
}
base = 2 * base;
}
return dec;
}
void solve() {
long long int i, j, k, n, m, l, x;
cin >> n >> x;
if (n == 1 || n == 2) {
cout << "1\n";
return;
}
k = floor((n - 3) / x);
cout << k + 2 << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n;
cin >> a >> b;
if (a + b > n + 1)
cout << "Black" << endl;
else
cout << "White" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2197165;
const int C = 100;
const double PI = acos(-1);
struct cplx {
double r, i;
inline cplx() {}
inline cplx(const double _r, const double _i) {
r = _r;
i = _i;
}
inline cplx operator+(const cplx &w) const { return cplx(r + w.r, i + w.i); }
inline cplx operator-(const cplx &w) const { return cplx(r - w.r, i - w.i); }
inline cplx operator*(const cplx &w) const {
return cplx(r * w.r - i * w.i, r * w.i + i * w.r);
}
inline cplx operator+=(const cplx &w) { return *this = *this + w; }
inline cplx operator-=(const cplx &w) { return *this = *this - w; }
inline cplx operator*=(const cplx &w) { return *this = *this * w; }
} A[N], t[N];
int n, m, L = 1, _rev[N], lb[N];
inline void fft(cplx a[], int type, int len) {
for (int i = 0; i < len; i++) t[i] = a[(_rev[i] >> (lb[L] - lb[len]))];
for (int i = 0; i < len; i++) a[i] = t[i];
for (int i = 1; i < len; i <<= 1) {
cplx w = cplx(cos(PI / i), type * sin(PI / i));
for (int j = 0; j < len; j += (i << 1)) {
cplx wn = cplx(1.0, 0.0);
for (int k = j; k < j + i; k++) {
cplx tmp = a[k + i] * wn;
a[k + i] = a[k] - tmp;
a[k] = a[k] + tmp;
wn *= w;
}
}
}
if (type == -1)
for (int i = 0; i < len; i++) a[i].r /= len, a[i].r += 0.5;
}
inline void init_fft() {
while (L <= 1048576) L <<= 1;
for (int i = 1; i < L; i <<= 1)
for (int j = 0; j < i; j++) _rev[j + i] = _rev[j] + (L >> 1) / i;
for (int i = 2; i <= L; i <<= 1) lb[i] = lb[i >> 1] + 1;
}
struct bign {
long long a[N];
int len;
inline void update(int l) {
long long w = 0;
for (int i = 0; i <= l; i++) {
a[i] += w;
w = a[i] / C;
a[i] %= C;
}
while (a[l] == 0) l--;
len = l + 1;
}
inline void pow() {
int l = 1;
while (l <= len + len) l <<= 1;
for (int i = 0; i < l; i++) A[i] = cplx(a[i], 0.0);
fft(A, 1, l);
for (int i = 0; i < l; i++) A[i] = A[i] * A[i];
fft(A, -1, l);
for (int i = 0; i < l; i++) a[i] = (int)(A[i].r);
update(l << 1);
}
inline void multi(long long x) {
for (int i = 0; i < len; i++) a[i] *= x;
update(len + 3);
}
inline void div(long long x) {
long long w = 0;
for (int i = len - 1; i >= 0; i--) {
a[i] += w;
w = (a[i] % x) * C;
a[i] /= x;
}
update(len + 3);
}
inline bool operator>(const bign &w) const {
int l = ((w.len > len) ? w.len : len);
for (int i = l; i >= 0; i--) {
if (a[i] > w.a[i]) return true;
if (a[i] < w.a[i]) return false;
}
return false;
}
inline void display() {
for (int i = len; i >= 0; i--) {
printf("%lld ", a[i]);
}
printf("\n");
}
} D, E, F, G;
char str[N];
int exp3;
inline void msm(int x) {
if (x == 0) {
G.a[0] = 1;
return;
}
if (x == 1) return;
msm(x >> 1);
G.pow();
if (x & 1) G.multi(3);
}
inline int solve(bign &a) {
while (a > G) {
G.multi(3);
exp3++;
}
return 3 * exp3;
}
void init() {
int n1, n2, n3;
scanf("%s", str);
n = strlen(str);
str[n] = str[n + 1] = str[n + 2] = str[n + 3] = '0';
if (n == 1 && str[0] <= '3') {
printf("%d\n", str[0] - '0');
return;
}
init_fft();
for (int i = n - 1; i >= 0; i -= 2) {
int w = 0, base = 1;
for (int j = 0; j > -2; j--) {
if (i + j < 0) break;
w += (str[i + j] - '0') * base;
base *= 10;
}
F.a[m] = E.a[m] = D.a[m] = w;
m++;
}
F.len = E.len = D.len = m;
E.a[0] += 1;
E.update(n + 1);
E.div(2);
F.a[0] += 3;
F.update(n + 1);
F.div(4);
n1 = n2 = n3 = n - 1;
if (str[0] <= '1') {
n2--;
n3--;
} else if (str[0] <= '3') {
n3--;
}
exp3 = (double)n3 / log10(3);
G.a[0] = 3;
G.len = 1;
msm(exp3);
int res1, res2, res3;
res3 = solve(F);
res2 = solve(E);
res1 = solve(D);
printf("%d\n", min(min(res3 + 4, res2 + 2), res1));
}
int main(int argc, char **argv) {
init();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[101];
void initialize() {
for (int i = 1; i <= 100; i++) {
a[i] = i;
}
}
int set_of(int u) {
if (a[u] == u) {
return u;
} else {
return a[u] = set_of(a[u]);
}
}
void union_(int u, int v) { a[set_of(u)] = set_of(v); }
void solve() {
initialize();
int n;
cin >> n;
int p[n + 1];
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
int f[n + 1];
for (int i = 1; i <= n; i++) {
cin >> f[i];
if (i - f[i] >= 1 && set_of(i) != set_of(i - f[i])) {
union_(i - f[i], i);
}
if (i + f[i] <= n && set_of(i) != set_of(i + f[i])) {
union_(i + f[i], i);
}
}
vector<int> sets[n + 1];
for (int i = 1; i <= n; i++) {
sets[set_of(i)].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (sets[i].size() == 1) {
if (p[i] != i) {
cout << "NO\n";
return;
}
} else if (sets[i].size() > 1) {
vector<int> temp;
for (int j = 0; j < sets[i].size(); j++) {
temp.push_back(p[sets[i][j]]);
}
sort(temp.begin(), temp.end());
for (int j = 0; j < sets[i].size(); j++) {
if (sets[i][j] != temp[j]) {
cout << "NO\n";
return;
}
}
}
}
cout << "\nYES\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define ll long long
#define pii pair<int,int>
#define all(x) begin(x), end(x)
#define loop(i,n) for(int i=0; i<n; i++)
#define rep(i,a,b,c) for(int i=a; i<b; i+=c)
#define brep(i,a,b,c) for(int i=a; i>b; i-=c)
#define tc(t) int t; cin>>t; while(t--)
#define sz(v) int((v).size())
#define pb push_back
/*
Idea:
*/
vector<int> res;
set<int> st;
// bool getPerm (int k, int count, int idx) {
// if (count < 0) return false;
// if (count == 0 && idx>=k-1) return true;
// if (count == 0 || idx>=k-1) return false;
// for (int i=k; i>=1; i--) {
// if (st.count(i)) continue;
// st.insert(i);
// int n = ;
// if (getPerm(k, count - , idx+1)) {
// res[idx] = i;
// st.erase(i);
// return true;
// }
// st.erase(i);
// }
// }
int32_t main() {
IOS;
int t;
cin>>t;
while (t--) {
int n, k;
cin>>n>>k;
vector<int> res(k);
for (int i=0; i<k; i++)
res[i] = i+1;
int diff = k-(n-k);
if (diff>0) {
for (int i=diff-1, j=k-1; i<j; i++, j--)
swap(res[i], res[j]);
}
for (auto r : res)
cout<<r<<" ";
cout<<"\n";
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
void cout_v(vector<int>& a) {
long long n = a.size();
for (long long i = 0; i < n; i++) {
cout << a[i] << " ";
if (i != n - 1) {
continue;
} else
cout << endl;
}
}
void cin_v(vector<long long>& a) {
long long n = a.size();
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
}
long long factorial(long long n) {
long long c;
long long result = 1;
for (c = 1; c <= n; c++) result = result * c;
return result;
}
long long pow_mod(long long a, long long b, long long m) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) res = (res * a) % m;
b = b / 2;
a = (a * a) % m;
}
return res;
}
long long inv = 0;
void merge(vector<int>& a, int low, int mid, int high) {
int temp[100005];
int i = low;
int j = mid + 1;
int k = low;
while ((i <= mid) && (j <= high)) {
if (a[i] <= a[j]) {
inv += (high - j + 1);
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
}
while (i <= mid) temp[k++] = a[i++];
while (j <= high) temp[k++] = a[j++];
for (i = low; i <= high; i++) a[i] = temp[i];
}
void merge_sort(vector<int>& a, int low, int high) {
int mid;
if (low != high) {
mid = (low + high) / 2;
merge_sort(a, low, mid);
merge_sort(a, mid + 1, high);
merge(a, low, mid, high);
}
}
long long InverseEuler(long long n, long long m) {
return pow_mod(n, m - 2, m);
}
const int mod = 1000000007;
typedef struct ele {
int v1, v2;
} ele;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
stack<ele> s;
int maxa = 0;
for (int i = 0; i < n; i++) {
if (s.empty()) {
s.push({a[i], 0});
} else {
ele temp = s.top();
if (a[i] < temp.v1) {
int sc = 1;
maxa = max(maxa, sc);
s.push({a[i], sc});
} else {
ele v = s.top();
int pr = v.v2;
while (!s.empty() && v.v1 < a[i]) {
s.pop();
if (s.empty()) break;
pr = max(pr, v.v2);
v = s.top();
}
if (s.empty()) {
s.push({a[i], 0});
} else {
s.push({a[i], pr + 1});
maxa = max(maxa, pr + 1);
}
}
}
}
cout << maxa << endl;
}
| 5 |
#include <bits/stdc++.h>
int map[100000];
int tree[8 * 100000];
int left, righ, n;
void update(int pos, int l, int r, int x) {
if (l == r) {
tree[pos] = map[x];
return;
}
int mid = (l + r) / 2;
if (x <= mid)
update(2 * pos, l, mid, x);
else
update(2 * pos + 1, mid + 1, r, x);
tree[pos] = tree[2 * pos] + tree[2 * pos + 1];
}
void toleft(int x) {
righ -= x;
for (int i = 0; i < x; i++) {
map[righ - i] += map[righ + i + 1];
map[righ + i + 1] = 0;
update(1, 0, n - 1, righ - i);
}
}
void torigh(int x) {
left += x;
for (int i = 0; i < x; i++) {
map[left + i] += map[left - i - 1];
map[left - i - 1] = 0;
update(1, 0, n - 1, left + i);
}
}
void print() {
for (int i = 0; i < n; i++) printf(" %d", map[i]);
puts("");
}
int query(int pos, int l, int r, int dl, int dr) {
if (dl <= l && r <= dr) {
return tree[pos];
}
int sum = 0;
int mid = (l + r) / 2;
if (dl <= mid) sum += query(2 * pos, l, mid, dl, dr);
if (dr >= mid + 1) sum += query(2 * pos + 1, mid + 1, r, dl, dr);
return sum;
}
int main() {
int k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) map[i] = 1, update(1, 0, n - 1, i);
bool flag = false;
left = 0, righ = n - 1;
int op, l, r;
for (int i = 0; i < k; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &l);
if (l > (righ - left + 1) / 2) {
if (flag)
torigh((righ - left + 1) - l);
else
toleft((righ - left + 1) - l);
flag = !flag;
} else {
if (flag)
toleft(l);
else
torigh(l);
}
} else {
scanf("%d %d", &l, &r);
r--;
if (flag) {
int tl = l, tr = r;
l = righ - tr;
r = righ - tl;
} else {
l += left, r += left;
}
printf("%d\n", query(1, 0, n - 1, l, r));
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 4e5 + 100, OO = 1e6 + 1000, M = 1e9 + 7, P = 6151,
SQ = 1000, lg = 30;
vector<pair<long long, long long> > v[N];
long long cnt[N];
pair<long long, long long> a[N];
struct node {
long long num = 0, ans = 0;
} seg[N << 2];
void upd(long long c, long long b, long long e, long long l, long long r) {
if (e - b == 1) {
seg[c].ans = r;
seg[c].num = 1;
return;
}
long long mid = (b + e) >> 1;
if (l < mid)
upd(c << 1, b, mid, l, r);
else
upd(c << 1 | 1, mid, e, l, r);
seg[c].num = seg[c << 1].num + seg[c << 1 | 1].num;
}
long long get(long long c, long long b, long long e, long long l) {
if (e - b == 1) return seg[c].ans;
long long mid = (b + e) >> 1;
if (seg[c << 1].num >= l)
return get(c << 1, b, mid, l);
else
return get(c << 1 | 1, mid, e, l - seg[c << 1].num);
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = -1 * i;
}
sort(a, a + n);
long long m;
cin >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back({y, i});
}
for (long long i = n - 1; i >= 0; i--) {
long long j = n - i;
upd(1, 0, n, a[i].second * -1, a[i].first);
for (auto u : v[j]) cnt[u.second] = get(1, 0, n, u.first);
}
for (long long i = 0; i < m; i++) cout << cnt[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()
typedef long long ll;
typedef pair<int, int> pii;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
vector<int> d(n);
for (int i = 0; i < n; ++i) {
cin >> d[i];
}
sort(all(d));
ll ans = d[n - 1];
ll sum = 0;
for (int i = 0; i < n; ++i) {
ans += sum - d[i] * 1LL * i;
sum += d[i];
}
cout << ans << '\n';
}
} | 3 |
#include <bits/stdc++.h>
int main() {
int n, W[200005], H[200005], sw = 0, m1 = 0, m2 = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &W[i], &H[i]);
if (m1 <= H[i]) {
m2 = m1;
m1 = H[i];
} else if (m2 < H[i])
m2 = H[i];
sw += W[i];
}
for (int i = 0, t; i < n; i++) {
t = H[i] == m1 ? m2 : m1;
printf("%d%c", (sw - W[i]) * t, (i == n - 1) ? '\n' : ' ');
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long INF = (long long)(2 * 1e15);
vector<vector<int>> graph;
vector<long long> a;
vector<long long> dp1, dp2;
long long ans = -INF;
void dfs(int u, int pr) {
pair<long long, long long> now = make_pair(-INF, -INF);
long long curr = -INF;
dp1[u] = a[u];
for (const int& v : graph[u])
if (v != pr) {
dfs(v, u);
dp1[u] += dp1[v];
dp2[u] = max(dp2[u], max(dp1[v], dp2[v]));
curr = max(dp1[v], dp2[v]);
if (curr > now.first) {
now.second = now.first;
now.first = curr;
} else if (curr > now.second)
now.second = curr;
}
if ((graph[u].size() - (pr != -1)) > 1)
ans = max(now.first + now.second, ans);
}
int main() {
std::ios::sync_with_stdio(false);
int n, u, v;
cin >> n;
graph.resize(n);
a.resize(n);
dp1.resize(n);
dp2.assign(n, -INF);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
cin >> u >> v;
--u;
--v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs(0, -1);
if (ans == -INF) {
cout << "Impossible";
return 0;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
long long t, rr, i;
scanf("%lld", &t);
for (rr = 0; rr < t; rr++) {
scanf("%lld", &n);
printf("2\n");
for (i = n - 1; i; i--) {
printf("%lld %lld\n", i, min(i + 2, n));
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 2510;
int n, m;
char grid[maxN][maxN];
int cnt1[maxN][maxN], cnt2[maxN][maxN];
int main(int argc, char** argv) {
scanf("%d %d", &n, &m);
string x;
for (int i = 1; i <= n; i++) {
getline(cin >> ws, x);
for (int j = 1; j <= m; j++) grid[i][j] = x[j - 1];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt1[i][j] = cnt1[i - 1][j] + cnt1[i][j - 1] + (grid[i][j] == '0') -
cnt1[i - 1][j - 1];
cnt2[i][j] = cnt2[i - 1][j] + cnt2[i][j - 1] + (grid[i][j] == '1') -
cnt2[i - 1][j - 1];
}
}
int ans = INT_MAX;
for (int i = 2; i <= (max(n, m) << 1); i++) {
int res = 0;
for (int j = i;; j += i) {
for (int k = i;; k += i) {
int v1 = cnt1[min(j, n)][min(k, m)] - cnt1[j - i][min(k, m)] -
cnt1[min(j, n)][k - i] + cnt1[j - i][k - i];
int v2 = cnt2[min(j, n)][min(k, m)] - cnt2[j - i][min(k, m)] -
cnt2[min(j, n)][k - i] + cnt2[j - i][k - i];
if (k > m && j > n) {
res += i * i -
max(v2, v1 + (k - m) * i + (j - n) * i - (k - m) * (j - n));
break;
}
if (k > m) {
res += i * i - max(v2, v1 + (k - m) * i);
break;
}
if (j > n)
res += i * i - max(v2, v1 + (j - n) * i);
else
res += min(v2, v1);
}
if (j > n) break;
}
ans = min(ans, res);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 150001;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc;
cin >> tc;
while (tc--) {
long long b, p, f;
cin >> b >> p >> f;
long long h, c;
cin >> h >> c;
if (h > c) {
long long ham = 0;
for (long long i = 1; i <= p and b - 2 >= 0; i++) {
ham++;
b -= 2;
}
long long chick = 0;
for (long long i = 1; i <= f and b - 2 >= 0; i++) {
chick++;
b -= 2;
}
cout << h * ham + c * chick << endl;
} else {
long long chick = 0;
for (long long i = 1; i <= f and b - 2 >= 0; i++) {
chick++;
b -= 2;
}
long long ham = 0;
for (long long i = 1; i <= p and b - 2 >= 0; i++) {
ham++;
b -= 2;
}
cout << h * ham + c * chick << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k2, k3, k5, k6;
cin >> k2 >> k3 >> k5 >> k6;
int x = min(k2, min(k5, k6));
k2 = k2 - x;
int y = min(k3, k2);
cout << x * 256 + y * 32 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> connections[3002];
int parent[3001];
int dist[3001];
int visit[3001];
int V;
void dfs(int n, int f) {
if (visit[n] == 0) {
parent[n] = f;
visit[n] = 2;
for (int i = 0; i < connections[n].size(); i++) {
if (connections[n][i] != f) dfs(connections[n][i], n);
}
visit[n] = 1;
} else if (visit[n] == 2) {
int t = f;
while (t != n) {
dist[t] = 0;
t = parent[t];
}
dist[n] = 0;
}
}
int finddist(int n, int f) {
if (dist[n] != 50000) return dist[n];
for (int i = 0; i < connections[n].size(); i++) {
if (f != connections[n][i])
dist[n] = min(dist[n], finddist(connections[n][i], n) + 1);
}
return dist[n];
}
int main() {
cin >> V;
for (int i = 1; i <= V; i++) {
dist[i] = 50000;
int a, b;
cin >> a >> b;
connections[a].push_back(b);
connections[b].push_back(a);
}
dfs(1, -1);
for (int i = 1; i <= V; i++) {
cout << finddist(i, -1) << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, opt, x, y, Dfs_Clock, Num_Edge, a[200010], head[200010], dep[200010],
in[200010], out[200010];
struct Edge {
int v, nxt;
} E[400010];
void Add_Edge(int u, int v) {
E[++Num_Edge].v = v;
E[Num_Edge].nxt = head[u];
head[u] = Num_Edge;
}
struct BIT {
int n, T[200010];
void Add(int x, int y) {
for (int i = x; i <= n; i += (i & (-i))) T[i] += y;
}
int Qry(int x) {
int sum = 0;
for (int i = x; i; i -= (i & (-i))) sum += T[i];
return sum;
}
} T;
void DFS(int u, int fa) {
dep[u] = dep[fa] + 1;
in[u] = ++Dfs_Clock;
for (int i = head[u]; i; i = E[i].nxt)
if (E[i].v != fa) DFS(E[i].v, u);
out[u] = Dfs_Clock;
}
int main() {
scanf("%d%d", &n, &m);
T.n = n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
Add_Edge(x, y);
Add_Edge(y, x);
}
DFS(1, 0);
while (m--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d", &x, &y);
if (dep[x] & 1) {
T.Add(in[x], y);
T.Add(out[x] + 1, -y);
} else {
T.Add(in[x], -y);
T.Add(out[x] + 1, y);
}
} else {
scanf("%d", &x);
int tmp = T.Qry(in[x]);
if (dep[x] & 1)
printf("%d\n", a[x] + tmp);
else
printf("%d\n", a[x] - tmp);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 11;
const int maxm = 100050;
int n, m, q, cnt, fa[maxn * maxm * 8];
struct node {
int lef[maxn], rig[maxn];
int shit;
} t[maxm * 4];
int A[maxn][maxm];
void init(int a) { fa[a] = a; }
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void merge(node a, node b, int mid, node &c) {
for (int i = 1; i <= n; ++i) {
init(a.lef[i]);
init(a.rig[i]);
init(b.lef[i]);
init(b.rig[i]);
}
c.shit = a.shit + b.shit;
for (int i = 1; i <= n; ++i)
if (A[i][mid] == A[i][mid + 1]) {
int x = getfa(a.rig[i]), y = getfa(b.lef[i]);
if (x == y) continue;
--c.shit;
fa[x] = y;
}
for (int i = 1; i <= n; ++i)
c.lef[i] = getfa(a.lef[i]), c.rig[i] = getfa(b.rig[i]);
}
node ask(int l, int r, int L, int R, int k) {
if (l <= L && R <= r) return t[k];
int mid = L + R >> 1;
if (r <= mid)
return ask(l, r, L, mid, k << 1);
else if (l > mid)
return ask(l, r, mid + 1, R, k << 1 | 1);
else {
node bullshit;
merge(ask(l, mid, L, mid, k << 1), ask(mid + 1, r, mid + 1, R, k << 1 | 1),
mid, bullshit);
return bullshit;
}
}
void build(int l, int r, int k) {
if (l == r) {
for (int i = 1; i <= n; ++i) {
if (A[i][l] != A[i - 1][l]) {
t[k].lef[i] = t[k].rig[i] = ++cnt;
t[k].shit++;
} else
t[k].lef[i] = t[k].rig[i] = t[k].lef[i - 1];
}
return;
}
int mid = l + r >> 1;
build(l, mid, k << 1);
build(mid + 1, r, k << 1 | 1);
merge(t[k << 1], t[k << 1 | 1], mid, t[k]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &A[i][j]);
build(1, m, 1);
for (int i = 1; i <= q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", ask(l, r, 1, m, 1).shit);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool check(int t0, int t, int tp, int c0, int c, int cp) {
if ((t0 != t) && (c0 == c)) return false;
if ((t != tp) && (c == cp)) return false;
return true;
}
int main(void) {
long long q, n, t, t0, t_pred, c, k;
bool can_invert, need_invert;
cin >> q;
vector<long long> color(200000);
for (long long i = 0; i < q; ++i) {
cin >> n;
t0 = 0;
c = 0;
k = 1;
can_invert = false;
for (long long i = 0; i < n; ++i) {
cin >> t;
if (i == 0) {
t0 = t;
t_pred = t;
}
if (t != t_pred) {
c = 1 - c;
k = 2;
}
if ((t == t_pred) && (i > 0)) can_invert = true;
color[i] = c;
if (i == n - 1) {
for (c = 0; c < 3; ++c) {
if (check(t0, t, t_pred, color[0], c, color[n - 2])) {
if (c + 1 > k) k = c + 1;
color[i] = c;
need_invert = false;
break;
}
if (can_invert &&
check(t0, t, t_pred, color[0], c, 1 - color[n - 2])) {
color[i] = c;
need_invert = true;
break;
}
}
}
t_pred = t;
}
cout << k << endl;
bool invert = false;
for (long long i = 0; i < n; ++i) {
if (need_invert && (i > 0) && (color[i] == color[i - 1])) invert = true;
cout << (invert && (i < n - 1) ? 1 - color[i] : color[i]) + 1 << " ";
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<long long> > b(64, vector<long long>());
for (int i = 0; i < n; ++i) {
long long tmp;
cin >> tmp;
long long t = tmp;
int c = 0;
while ((t & 1ll) == 0ll) {
t >>= 1;
++c;
}
b[c].push_back(tmp);
}
int mx = 0;
for (int i = 1; i < b.size(); ++i) {
if (b[i].size() > b[mx].size()) mx = i;
}
vector<long long> ans;
for (int i = 0; i < 64; ++i) {
if (i == mx) continue;
for (auto j : b[i]) ans.push_back(j);
}
cout << ans.size() << endl;
for (auto i : ans) cout << i << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int bugf;
inline int in() {
scanf("%d", &bugf);
return bugf;
}
const double eps = 1e-7;
int round_(double a) {
if (a < eps)
return (int)(a - 0.5);
else
return (int)(a + 0.5);
}
double dist2(double x1, double y1, double x2, double y2) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
int f(double x) {
if (fabs(x) < eps) return 0;
if (x < 0) return -1;
return 1;
}
int main() {
int s = in(), n = in();
long long res = 0;
vector<pair<int, int> > a;
for (int i = 0; i < n; ++i) {
int di = in(), b = in();
pair<int, int> cur;
cur.first = di;
cur.second = b;
a.push_back(cur);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
if (a[j].first != -1 && a[j].first < s) {
a[j].first = -1;
++res;
s += a[j].second;
}
}
if (res == n) {
puts("YES");
} else
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
inline long long read(register long long a = 0, register char ch = getchar()) {
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
a = (a << 3) + (a << 1) + (ch ^ 48), ch = getchar();
return a;
}
long long inv[5000010 << 1], f[5000010 << 1], a[5000010], b[5000010], n, m, ans;
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read(), m += a[i];
inv[1] = inv[0] = 1;
for (long long i = 2; i <= max(n, m); i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
f[0] = f[1] = 23333;
for (long long i = 1; i < m; i++)
f[i + 1] = ((-1ll * (m - i) * (n - 2) % mod * inv[n - 1] % mod + mod + m) %
mod * f[i] % mod -
1ll * i * (f[i - 1] + 1) % mod + mod) %
mod * (n - 1) % mod * inv[m - i] % mod;
for (long long i = 1; i <= n; i++) ans = (0ll + ans + f[a[i]] + mod) % mod;
cout << ((ans - f[m] + mod) % mod - (n - 1) * f[0] % mod + mod) % mod << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> ob[1000];
pair<int, int> clues[1000];
for (int i = 0; i < n; i++) cin >> ob[i].first >> ob[i].second;
for (int i = 0; i < n; i++) cin >> clues[i].first >> clues[i].second;
map<pair<int, int>, int> mp;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
mp[{ob[j].first + clues[i].first, ob[j].second + clues[i].second}]++;
}
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it->second >= n) {
cout << (it->first).first << " " << (it->first).second;
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e4 + 10, MAXL = 800;
int dp[MAXN][MAXL];
int n, d;
int a[MAXN];
int find(int now, int dis) {
if (now > 30000 || dis == 0) return 0;
return dp[now][dis - d + 400];
}
int main() {
int a1;
cin >> n >> d;
for (int i = 1; i <= n; ++i) {
cin >> a1;
++a[a1];
}
for (int j = 30000; j >= d; --j)
for (int i = (d > 400 ? d - 400 : 1); i < d + 400; ++i) {
dp[j][i - d + 400] =
a[j] + max(find(j + i - 1, i - 1),
max(find(j + i, i), find(j + i + 1, i + 1)));
}
cout << dp[d][400];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
vector<long long> cifre;
for (char i : s) cifre.push_back(i - '0');
vector<long long> pref(cifre.size(), 0);
long long tren = 0;
for (long long i = 0; i < cifre.size(); i++) {
tren = tren * 10 + cifre[i];
tren %= mod;
pref[i] = tren;
if (i > 0) pref[i] += pref[i - 1];
pref[i] %= mod;
}
long long res = (cifre.size() > 1 ? pref[cifre.size() - 2] : 0);
tren = 0;
long long stepen = 1;
for (long long i = cifre.size() - 1; i > 0; i--) {
tren += cifre[i] * stepen;
stepen *= 10;
stepen %= mod;
tren %= mod;
res +=
(stepen * (i > 1 ? pref[i - 2] : 0) % mod + (i - 1) * tren % mod) % mod;
res += tren;
res %= mod;
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 7340033;
long long dp[35][1005];
long long f[1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
dp[1][0] = 1;
for (int i = 2; i <= 30; ++i) {
for (int j = 0; j <= 1000; ++j) f[j] = 0;
dp[i][0] = 1;
for (int j = 0; j <= 1000; ++j)
for (int k = 0; k <= 1000 - j; ++k)
f[j + k] += (dp[i - 1][j] * dp[i - 1][k]);
for (int j = 0; j <= 1000; ++j) f[j] %= md;
for (int j = 0; j <= 1000; ++j)
for (int k = 0; k <= 1000 - j - 1; ++k) dp[i][j + k + 1] += f[j] * f[k];
for (int j = 0; j <= 1000; ++j) dp[i][j] %= md;
}
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int sz = 1;
int x, y;
cin >> x >> y;
while (x > 2 && x % 2) {
x >>= 1;
++sz;
}
cout << dp[sz][y] << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
cin >> n;
char a[n][5];
string b = "NO";
for (i = 0; i < n; i++) {
for (j = 0; j < 5; j++) {
cin >> a[i][j];
if (b == "NO") {
if (a[i][0] == 'O' && a[i][1] == 'O') {
a[i][0] = '+';
a[i][1] = '+';
b = "YES";
} else if (a[i][3] == 'O' && a[i][4] == 'O') {
a[i][3] = '+';
a[i][4] = '+';
b = "YES";
}
}
}
}
cout << b << endl;
if (b == "YES") {
for (i = 0; i < n; i++) {
for (j = 0; j < 5; j++) {
cout << a[i][j];
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int p[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
string s;
int c = 0, flag = 0;
;
cin.ignore();
for (int i = 0; i < n; i++) {
getline(cin, s);
c = 0;
for (int j = 0; j < s.length(); j++) {
if (s[j] == 'a' || s[j] == 'e' || s[j] == 'i' || s[j] == 'o' ||
s[j] == 'u' || s[j] == 'y') {
c += 1;
}
}
if (c != p[i]) {
flag = 1;
break;
}
}
if (flag == 1) {
cout << "NO\n";
} else {
cout << "YES\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100039];
vector<int> wow[100039];
int main() {
int n, k, m, a, b, c;
scanf("%d%d%d", &n, &k, &m);
for (a = 1; a <= n; a++) {
scanf("%d", &b);
cnt[b % m]++;
wow[b % m].push_back(b);
}
for (a = 0; a < m; a++) {
if (cnt[a] >= k) {
printf("Yes\n");
for (b = 0; b < k; b++) {
printf("%d ", wow[a][b]);
}
return 0;
}
}
printf("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a, ans, x[100020];
int main() {
cin >> n >> a;
if (n == 1) {
cout << 0;
return 0;
}
for (int i = 1; i <= n; i++) cin >> x[i];
sort(x + 1, x + 1 + n);
if (a <= x[1])
ans = x[n - 1] - a;
else if (a >= x[n])
ans = a - x[2];
else {
ans = 0x3f3f3f3f;
if (a <= x[2])
ans = min(ans, x[n] - a);
else
ans = min(ans, x[n] - x[2] + min(x[n] - a, a - x[2]));
if (a >= x[n - 1])
ans = min(ans, a - x[1]);
else
ans = min(ans, x[n - 1] - x[1] + min(x[n - 1] - a, a - x[1]));
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, i = 0, tr = 0, tg = 0, tb = 0, t;
cin >> r >> g >> b;
if (r == 1) tr = 30;
if (g == 1) tg = 31;
if (b == 1) tb = 32;
if (r % 2 == 0 && r >= 2) tr = 30 + (r / 2 - 1) * 3;
if (g % 2 == 0 && g >= 2) tg = 31 + (g / 2 - 1) * 3;
if (b % 2 == 0 && b >= 2) tb = 32 + (b / 2 - 1) * 3;
if ((r % 2) != 0 && r >= 2) tr = 30 + (r / 2) * 3;
if ((g % 2) != 0 && g >= 2) tg = 31 + (g / 2) * 3;
if ((b % 2) != 0 && b >= 2) tb = 32 + (b / 2) * 3;
t = tr;
if (t <= tg) t = tg;
if (t <= tb) t = tb;
cout << t;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int data = 0, w = 1;
register char ch = 0;
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
return w * data;
}
const int MAX_N = 1e5 + 5;
const int Mod = 1e9 + 7;
int fpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % Mod;
x = 1ll * x * x % Mod;
y >>= 1;
}
return res;
}
struct Point {
int x, y, op, v;
};
bool operator<(const Point &l, const Point &r) {
return (l.x == r.x) ? (l.y < r.y) : (l.x < r.x);
}
struct Graph {
int to, cost, col, next;
} e[MAX_N << 1];
int fir[MAX_N], e_cnt = 0;
void clearGraph() {
memset(fir, -1, sizeof(fir));
e_cnt = 0;
}
void Add_Edge(int u, int v, int w, int c) {
e[e_cnt].to = v, e[e_cnt].cost = w, e[e_cnt].col = c, e[e_cnt].next = fir[u];
fir[u] = e_cnt++;
}
int N, ans = 1, size[MAX_N];
bool used[MAX_N];
int centroid, sz, rmx, c1[MAX_N << 2], c2[MAX_N << 2];
Point stk[MAX_N], q[MAX_N << 2];
int top, cnt;
inline int lb(int x) { return x & -x; }
void add(int x, int v) {
while (x <= N * 4 + 1) c1[x] = 1ll * c1[x] * v % Mod, c2[x]++, x += lb(x);
}
int Sum(int x) {
int res = 1;
while (x > 0) res = 1ll * c1[x] * res % Mod, x -= lb(x);
return res;
}
int Cnt(int x) {
int res = 0;
while (x > 0) res += c2[x], x -= lb(x);
return res;
}
void Set(int x) {
while (x <= N * 4 + 1) c1[x] = 1, c2[x] = 0, x += lb(x);
}
void search_centroid(int x, int fa) {
size[x] = 1;
int mx = 0;
for (int i = fir[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == fa || used[v]) continue;
search_centroid(v, x);
size[x] += size[v];
mx = max(mx, size[v]);
}
mx = max(mx, sz - size[x]);
if (mx < rmx) rmx = mx, centroid = x;
}
void dfs(int x, int fa, int R, int B, int val) {
stk[++top] = (Point){R, B, 0, val};
for (int i = fir[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == fa || used[v]) continue;
if (e[i].col == 0)
dfs(v, x, R + 1, B, 1ll * val * e[i].cost % Mod);
else if (e[i].col != 0)
dfs(v, x, R, B + 1, 1ll * val * e[i].cost % Mod);
}
}
void Div(int l, int r) {
if (l >= r) return;
int mid = (l + r) >> 1;
Div(l, mid);
Div(mid + 1, r);
int j = l;
for (int i = mid + 1; i <= r; i++) {
if (!q[i].op) continue;
while (q[j].x <= q[i].x && j <= mid) {
if (!q[j].op) add(q[j].y, q[j].v);
++j;
}
ans = 1ll * ans * Sum(q[i].y) % Mod * fpow(q[i].v, Cnt(q[i].y)) % Mod;
}
for (int i = l; i < j; i++)
if (!q[i].op) Set(q[i].y);
inplace_merge(&q[l], &q[mid + 1], &q[r + 1]);
}
void solve(int x) {
used[x] = 1;
cnt = 0;
int Pls = 2 * N + 1;
for (int i = fir[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (used[v]) continue;
top = 0;
if (e[i].col == 0)
dfs(v, x, 1, 0, e[i].cost);
else if (e[i].col == 1)
dfs(v, x, 0, 1, e[i].cost);
for (int j = 1; j <= top; j++) {
int a = stk[j].x, b = stk[j].y;
q[++cnt] = (Point){2 * a - b + Pls, 2 * b - a + Pls, 1, stk[j].v};
}
for (int j = 1; j <= top; j++) {
int a = stk[j].x, b = stk[j].y;
q[++cnt] = (Point){b - 2 * a + Pls, a - 2 * b + Pls, 0, stk[j].v};
if (2 * min(a, b) >= max(a, b)) ans = 1ll * ans * stk[j].v % Mod;
}
}
Div(1, cnt);
for (int i = fir[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (used[v]) continue;
sz = rmx = size[v];
search_centroid(v, x);
solve(centroid);
}
}
int main() {
clearGraph();
N = gi();
for (int i = 1; i < N; i++) {
int u = gi(), v = gi(), w = gi(), c = gi();
Add_Edge(u, v, w, c);
Add_Edge(v, u, w, c);
}
for (int i = 1; i <= 4 * N + 1; i++) c1[i] = 1, c2[i] = 0;
sz = rmx = N;
search_centroid(1, 0);
solve(centroid);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long arr[2000];
long long d[2000];
long long n, k;
int check(long long m) {
d[0] = 1;
for (int i = 1; i < n; i++) {
d[i] = 0;
for (int j = 0; j < i; j++)
if (m * (i - j) >= abs(arr[i] - arr[j]) && d[j] > d[i]) d[i] = d[j];
d[i]++;
}
long long mx = 0;
for (int i = 0; i < n; i++)
if (d[i] > mx) mx = d[i];
return n - mx;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
long long l = 0, r = 1e9 * 1LL * 4;
while (l != r) {
long long m = (l + r) / 2;
if (check(m) > k)
l = m + 1;
else
r = m;
}
cout << l << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int64_t mod = 1000000007;
int main(void) {
int64_t a, b;
cin >> a >> b;
int64_t ans = 0;
int64_t add = b + 1;
for (int64_t i = 0; i < a; ++i) {
ans = (ans + add) % mod;
add = (add + b) % mod;
}
int64_t tmp = ans;
int64_t ret = 0;
for (int64_t i = 1; i < b; ++i) {
ret = (ret + ans) % mod;
ans = (ans + tmp) % mod;
}
cout << ret << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000100];
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
long long mx = LONG_MIN;
for (long long i = 0; i < n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) a[i] /= 2;
while (a[i] % 3 == 0) a[i] /= 3;
}
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5, mod = 1e9 + 7;
long long dp[maxn][2];
int main() {
for (int i = 3; i < maxn; i++) {
dp[i][1] = (dp[i - 2][0] * 2 + dp[i - 1][0] + 1) % mod;
dp[i][0] = dp[i][1] + i % 3 - 1;
}
int t, n;
cin >> t;
while (t--) cin >> n, cout << max(dp[n][0], dp[n][1]) * 4 % mod << endl;
}
| 5 |
#include <bits/stdc++.h>
bool isFile;
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
void _();
void faster() {
_();
if (isFile) {
freopen(
"taskA"
".in",
"r", stdin);
freopen(
"taskA"
".out",
"w", stdout);
}
if (1) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
}
const long long INF = 9e18;
const int inf = 2e9;
const int MOD = 1e9 + 7;
const long double PI = acos(-1);
const long double EPS = 1e-7;
const int N = 1e5 + 5;
const int M = 1234;
set<int> g[N];
int res[N];
int tin[N];
int tout[N];
int up[18][N];
int depth[N];
int was[N];
int timer;
bool isLeaf(int v) { return g[v].size() == 1; }
void dfs(int v, int p) {
tin[v] = ++timer;
depth[v] = depth[p] + 1;
up[0][v] = p;
for (int i = 1; i < 18; i++) {
up[i][v] = up[i - 1][up[i - 1][v]];
}
for (int to : g[v]) {
if (to != p) dfs(to, v);
}
tout[v] = timer;
}
bool upper(int v, int u) { return tin[v] <= tin[u] && tin[u] <= tout[v]; }
int lca(int v, int u) {
if (upper(u, v)) return u;
if (upper(v, u)) return v;
for (int i = 17; i >= 0; i--) {
if (!upper(up[i][v], u)) {
v = up[i][v];
}
}
return up[0][v];
}
int dist(int v, int u) { return depth[u] + depth[v] - 2 * depth[lca(u, v)]; }
void solve() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
}
for (int i = 1; i <= n; i++) {
res[i] = i;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (isLeaf(i)) q.push(i);
}
dfs(1, 1);
while (!q.empty()) {
int v = q.front();
q.pop();
if (res[v] == v) {
for (int to : g[v]) {
swap(res[to], res[v]);
g[to].erase(v);
vector<int> who;
for (int fo : g[to]) {
who.push_back(fo);
}
for (int fo : who) {
if (!isLeaf(fo)) {
g[fo].erase(to);
}
g[to].erase(fo);
}
for (int fo : who) {
if (isLeaf(fo)) {
q.push(fo);
}
}
break;
}
}
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (res[i] == i) {
for (int to : g[i]) {
swap(res[i], res[to]);
break;
}
cnt++;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += dist(i, res[i]);
}
cout << ans << '\n';
for (int i = 1; i <= n; i++) {
cout << res[i] << ' ';
}
}
void prepare() {}
void stress() {}
void slow() {}
void _() {}
int main() {
faster();
int t = 1;
int id = 1;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int tot = (n * (n + 1)) / 2;
int x, ans;
x = ceil(n / 2.0);
ans = ((tot - x) / 2) + x;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
if (n <= 2 * k) {
cout << -1;
return 0;
}
cout << k * n << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
int next = (i + j + 1) % n;
cout << i + 1 << " " << next + 1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, i, flag = 0;
cin >> t;
while (t--) {
cin >> n;
long long int arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n - 1; i++) {
if ((arr[i] == n && arr[i + 1] == 1) || (arr[i] == 1 && arr[i + 1] == n))
continue;
else if (abs(arr[i + 1] - arr[i]) > 1) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
flag = 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k;
int adj[200][200];
void addEdge(int i, int j) {
adj[i][j] = 1;
adj[j][i] = 1;
}
int main() {
addEdge(1, 3);
for (int i = 3; i / 3 < 31; i += 3) {
addEdge(i, i + 1);
addEdge(i, i + 2);
}
for (int i = 6; i / 3 <= 31; i += 3) {
addEdge(i, i - 1);
addEdge(i, i - 2);
}
for (int i = 94; i < 154; i++) addEdge(i, i + 1);
addEdge(154, 2);
scanf("%d", &k);
printf("154\n");
for (int i = 0; i < 30; i++)
if (k & (1 << i)) addEdge(3 * (i + 1), 94 + 2 * i);
for (int i = 1; i <= 154; i++) {
for (int j = 1; j <= 154; j++) {
if (adj[i][j] == 1)
printf("Y");
else
printf("N");
}
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
long long a[n + 1], b[m + 1];
long long xo = 0;
for (long long i = 0; i < n; i++) cin >> a[i], xo ^= a[i];
for (long long i = 0; i < m; i++) cin >> b[i], xo ^= b[i];
if (xo != 0) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (i == n - 1 && j == m - 1)
cout << (a[n - 1] ^ xo);
else if (i == n - 1)
xo ^= b[j], cout << b[j] << " ";
else if (j == m - 1)
cout << a[i] << " ";
else
cout << "0 ";
}
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
getline(cin, str);
long long plus = 0, minus = 0;
plus++;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '+') plus++;
if (str[i] == '-') minus++;
}
string number;
for (int i = str.length() - 1; i >= 0; i--) {
if (str[i] == ' ') {
break;
} else
number.push_back(str[i]);
}
reverse(number.begin(), number.end());
long long n = stoi(number);
if ((plus * n - minus) < n) {
puts("Impossible");
return 0;
}
if ((plus - n * minus) > n) {
puts("Impossible");
return 0;
}
puts("Possible");
int now = 1;
long long req = plus * n - minus - n;
vector<long long> num;
int last = 1;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '=') break;
if (str[i] == '?') {
if (last == 1) {
num.push_back(n);
} else
num.push_back(-1);
} else if (str[i] == '+')
last = 1;
else if (str[i] == '-')
last = 0;
}
for (int i = 0; i < num.size(); i++) {
if (req == 0)
break;
else if (req > 0) {
if (num[i] == n) {
long long p = min(n - 1LL, req);
num[i] -= p;
req -= p;
} else {
long long p = min((n - 1), req);
num[i] += (-1 * p);
req -= p;
}
} else if (req < 0) {
if (num[i] == -1) {
long long p = max(req, -(n - 1));
num[i] += p;
req -= p;
} else {
long long p = min(-1 * req, n - 1);
num[i] += p;
req += p;
}
}
}
cout << num[0] << " ";
for (int i = 1; i < num.size(); i++) {
if (num[i] > 0) {
cout << "+ " << num[i] << " ";
} else
cout << "- " << abs(num[i]) << " ";
}
cout << "= " << n << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string a;
cin >> a;
deque<long long int> pos0;
deque<long long int> pos1;
vector<long long int> ans;
long long int j = 1;
for (long long int i = 0; i < n; i++) {
if (a[i] == '0' && pos1.size() != 0) {
ans.push_back(pos1.front());
pos0.push_back(pos1.front());
pos1.pop_front();
} else if (a[i] == '0') {
pos0.push_back(j);
ans.push_back(j);
j++;
} else if (a[i] == '1' && pos0.size() != 0) {
ans.push_back(pos0.front());
pos1.push_back(pos0.front());
pos0.pop_front();
} else {
pos1.push_back(j);
ans.push_back(j);
j++;
}
}
cout << --j << endl;
for (long long int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
long long powermod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool isprime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
vector<long long> a(n);
long long sum = 0;
long long maxi = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a.begin(), a.end());
if (a.size() == 1) {
cout << 0 << "\n";
return 0;
}
long long req = 0;
long long prev = 0;
for (long long i = 0; i < n; i++) {
req++;
if (a[i] > prev) prev++;
}
req += a[n - 1] - prev;
cout << sum - req;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int a, b, c, d, m, v;
cin >> a >> b >> c >> d;
m = max((3 * a) / 10, a - (a / 250) * c);
v = max((3 * b) / 10, b - (b / 250) * d);
if (m > v)
cout << "Misha";
else if (v > m)
cout << "Vasya";
else
cout << "Tie";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, m, n, cnt = 0, mem[105], def[105];
string s;
bool flag, found;
int main() {
cin >> t >> m;
memset(mem, 0, sizeof(mem));
for (int i = 0; i < t; i++) {
cin >> s;
if (s != "defragment") cin >> n;
if (s == "alloc") {
found = false;
for (int j = 0; j <= m - n; j++) {
flag = true;
for (int k = 0; k < n; k++) {
if (mem[j + k] != 0) {
flag = false;
break;
}
}
if (flag) {
found = true;
++cnt;
for (int k = 0; k < n; k++) {
mem[j + k] = cnt;
}
cout << cnt << endl;
break;
}
}
if (!found) cout << "NULL" << endl;
}
if (s == "erase") {
if (n == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
flag = true;
for (int j = 0; j < m; j++) {
if (mem[j] == n) flag = false, mem[j] = 0;
}
if (flag) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
if (s == "defragment") {
int ccnt = 0;
for (int j = 0; j < m; j++)
if (mem[j] != 0) def[ccnt++] = mem[j];
memset(mem, 0, sizeof(mem));
for (int j = 0; j < ccnt; j++) mem[j] = def[j];
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, num[70], cnt[100005][70], sta[100005];
char S[100005];
string out;
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << 6); j++)
if (j & (1 << (S[i] - 'a'))) num[j]++;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int id;
char s[10];
scanf("%d", &id);
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int j = 1; j <= len; j++) sta[id] |= (1 << (s[j] - 'a'));
}
for (int i = 1; i <= n; i++)
if (!sta[i]) sta[i] = 63;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 64; j++) {
cnt[i][j] = cnt[i + 1][j];
if ((j & sta[i]) == sta[i]) cnt[i][j]++;
}
}
for (int i = 1; i <= n; i++) {
bool can = 0;
for (int t = 0; t < 6; t++) {
if (num[1 << t] > 0 && (sta[i] & (1 << t)) > 0) {
bool can1 = 1;
for (int s = 0; s < 64; s++)
if (cnt[i + 1][s] > num[s] - (((s & (1 << t)) > 0))) {
can1 = 0;
break;
}
can = can1;
if (can) {
out += t + 'a';
for (int s = 0; s < 64; s++)
if ((s & (1 << t)) > 0) num[s]--;
break;
}
}
}
if (!can) {
printf("Impossible\n");
return 0;
}
}
cout << out << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,tune=native")
#pragma GCC target("avx,avx2")
using namespace std;
long long bp(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n);
vector<bool> u(200010);
for (long long i = 0; i < n; i++) cin >> a[i];
long long res = 1;
long long m = a[0];
while (m > 1) {
for (long long i = 2; i <= m; i++) {
long long e = 0;
while (m % i == 0) {
e++;
m /= i;
}
if (e > 0) {
vector<long long> all;
all.push_back(e);
for (long long j = 1; j < n; j++) {
long long q = a[j], er = 0;
while (q % i == 0) {
er++;
q /= i;
}
all.push_back(er);
}
sort(all.begin(), all.end());
if (all[1] != 0) u[i] = true;
res *= bp(i, all[1]);
}
}
}
m = a[1];
while (m > 1) {
for (long long i = 2; i <= m; i++) {
long long e = 0;
while (m % i == 0) {
e++;
m /= i;
}
if (e > 0) {
if (u[i]) continue;
vector<long long> all;
all.push_back(e);
for (long long j = 0; j < n; j++) {
if (j == 1) continue;
long long q = a[j], er = 0;
while (q % i == 0) {
er++;
q /= i;
}
all.push_back(er);
}
sort(all.begin(), all.end());
res *= bp(i, all[1]);
}
}
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
int ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
vector<int> G[1005];
int siz[1005];
void dfs(int u, int fa) {
siz[u] = 1;
int ss = G[u].size();
for (int i = 0; i < ss; i++) {
int to = G[u][i];
if (to == fa) continue;
dfs(to, u);
siz[u] += siz[to];
}
}
void print1(int u, int fa) {
int sum = 0, ss = G[u].size();
for (int i = 0; i < ss; i++) {
int to = G[u][i];
if (to == fa) continue;
print1(to, u);
printf("%d %d %d\n", u, to, sum + 1);
sum += siz[to];
}
}
void print2(int u, int fa, int x) {
int sum = 0, ss = G[u].size();
for (int i = 0; i < ss; i++) {
int to = G[u][i];
if (to == fa) continue;
print2(to, u, x);
printf("%d %d %d\n", u, to, (sum + 1) * x);
sum += siz[to];
}
}
vector<pair<int, int> > a;
signed main() {
int n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
G[u].push_back(v), G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
dfs(i, 0);
a.clear();
int ss = G[i].size();
for (int j = 0; j < ss; j++) {
a.push_back(make_pair(siz[G[i][j]], G[i][j]));
}
sort(a.begin(), a.end());
int sum = 0, st = a.size();
for (int j = st - 1; j >= 0; j--) {
sum += a[j].first;
if ((sum + 1) * (n - sum) - 1 >= 2 * n * n / 9) {
int s = 0;
for (int k = 0; k < j; k++) {
print2(a[k].second, i, sum + 1);
printf("%d %d %d\n", i, a[k].second, (s + 1) * (sum + 1));
s += a[k].first;
}
s = 0;
for (int k = j; k < st; k++) {
print1(a[k].second, i);
printf("%d %d %d\n", i, a[k].second, (s + 1));
s += a[k].first;
}
return 0;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double val[505];
struct node {
int a, b;
double val;
double quan;
} p[250005];
bool cmp(node x, node y) { return x.quan > y.quan; }
int main() {
int n, m, i, j;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) scanf("%lf", &val[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d%lf", &p[i].a, &p[i].b, &p[i].val);
p[i].quan = (val[p[i].a] + val[p[i].b]) / p[i].val;
}
sort(p + 1, p + 1 + m, cmp);
if (m == 0)
printf("%.10lf\n", 0);
else
printf("%.10lf\n", p[1].quan);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000;
int q;
int dp[201][201][5][5];
pair<int, int> rec[201][201][5][5];
void precompute() {
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
if (i == 15 && j <= 13) {
dp[i][j][4][2] = 1;
rec[i][j][4][2] = {i, j};
} else if (j == 15 && i <= 13) {
dp[i][j][4][2] = -1;
rec[i][j][4][2] = {i, j};
} else if (i > 15 && i - j == 2) {
dp[i][j][4][2] = 1;
rec[i][j][4][2] = {i, j};
} else if (j > 15 && j - i == 2) {
dp[i][j][4][2] = -1;
rec[i][j][4][2] = {i, j};
} else {
dp[i][j][4][2] = -inf;
}
dp[i][j][4][0] = -inf;
dp[i][j][4][1] = -inf;
dp[i][j][4][3] = -inf;
dp[i][j][4][4] = -inf;
if (i == 0 && j == 0) {
dp[i][j][4][1] = 0;
dp[i][j][4][3] = 0;
}
rec[i][j][4][0] = {0, 0};
rec[i][j][4][1] = {0, 0};
rec[i][j][4][3] = {0, 0};
rec[i][j][4][4] = {0, 0};
}
}
for (int k = 3; k >= 0; k--) {
for (int l = 0; l <= 4; l++) {
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
if (l > k) {
dp[i][j][k][l] = -inf;
continue;
}
if (k - l == 3 || l == 3) {
if (i == 0 && j == 0) {
dp[i][j][k][l] = 0;
rec[i][j][k][l] = {0, 0};
} else {
dp[i][j][k][l] = -inf;
}
continue;
}
if (k - l > 3 || l > 3) {
dp[i][j][k][l] = -inf;
continue;
}
int tmp = -inf;
for (int b = 0; b <= 23; b++) {
if (i >= 25 && j >= b &&
dp[i - 25][j - b][k + 1][l + 1] + 1 > tmp) {
tmp = dp[i - 25][j - b][k + 1][l + 1] + 1;
rec[i][j][k][l] = {25, b};
}
}
for (int b = 0; b <= 23; b++) {
if (i >= b && j >= 25 &&
dp[i - b][j - 25][k + 1][l + 0] - 1 > tmp) {
tmp = dp[i - b][j - 25][k + 1][l + 0] - 1;
rec[i][j][k][l] = {b, 25};
}
}
for (int b = 26; b <= i; b++) {
if (j >= b - 2 && dp[i - b][j - (b - 2)][k + 1][l + 1] + 1 > tmp) {
tmp = dp[i - b][j - (b - 2)][k + 1][l + 1] + 1;
rec[i][j][k][l] = {b, b - 2};
}
}
for (int b = 26; b <= j; b++) {
if (i >= b - 2 && dp[i - (b - 2)][j - b][k + 1][l + 0] - 1 > tmp) {
tmp = dp[i - (b - 2)][j - b][k + 1][l + 0] - 1;
rec[i][j][k][l] = {b - 2, b};
}
}
dp[i][j][k][l] = tmp;
}
}
}
}
}
void answer(int a, int b) {
if (dp[a][b][0][0] < -3) {
cout << "Impossible" << endl;
return;
} else {
int sets = 0;
vector<pair<int, int> > ans;
int i = a, j = b, k = 0, l = 0;
while (true) {
if (dp[i][j][k][l] < -3) break;
if (rec[i][j][k][l] == pair<int, int>{0, 0}) break;
if (k == 5) assert(false);
sets++;
ans.push_back(rec[i][j][k][l]);
int i1 = i, j1 = j;
i -= rec[i1][j1][k][l].first;
j -= rec[i1][j1][k][l].second;
if (rec[i1][j1][k][l].first > rec[i1][j1][k][l].second) l++;
k++;
}
cout << l << ":" << sets - l << "\n";
for (pair<int, int> p : ans) {
cout << p.first << ":" << p.second << " ";
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> q;
precompute();
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
answer(a, b);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int bit(int x, int i) { return (x >> i) & 1; }
int len[1000010], to[20][1000010];
string s[1000010];
char buf[5145140];
int main() {
int n, r, c;
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; i++) {
scanf("%s", buf);
s[i] = buf;
len[i] = s[i].size();
}
c++;
for (int i = 1; i <= n; i++) len[i]++;
int now = 0;
for (int i = n, j = n; i >= 1; i--) {
now += len[i];
while (now > c) now -= len[j--];
to[0][i] = j;
}
to[0][n + 1] = n;
for (int i = 1; i < 20; i++)
for (int j = 1; j <= n + 1; j++) to[i][j] = to[i - 1][to[i - 1][j] + 1];
int big = 0, pos = 1;
for (int i = 1; i <= n; i++) {
int p = i;
for (int j = 0; j < 20; j++)
if (bit(r, j)) p = to[j][p] + 1;
if (p - i > big) {
big = p - i;
pos = i;
}
}
for (int i = 0; i < r; i++) {
int npos = to[0][pos];
for (int j = pos; j <= npos; j++)
printf("%s%c", s[j].c_str(), j == npos ? '\n' : ' ');
pos = npos + 1;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const double EPS = (1e-7);
const int sz = 2e5 + 4;
const int mod = 998244353;
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
int arr[sz];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
double k, d, t, res = 0.0;
cin >> k >> d >> t;
long long times2 = ceil(k / d);
long long interval = k + times2 * d - k;
double cook = k + (times2 * d - k) / 2;
long long nint = t / cook;
t -= cook * nint, res += nint * interval;
if (t < k)
res += t;
else
res += k + (t - k) * 2;
printf("%.9lf\n", res);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, nums[202];
int dp[202][202][1002];
int solve(int ind, int act, int lft) {
if (dp[ind][act][lft] != -1) return dp[ind][act][lft];
if (ind > n) return act == 0;
int ret = 0, val = lft - act * (nums[ind] - nums[ind - 1]);
if (val >= 0) {
ret += solve(ind + 1, act + 1, val);
if (act) ret += (solve(ind + 1, act - 1, val) * 1ll * act) % 1000000007;
if (ret >= 1000000007) ret -= 1000000007;
ret += (solve(ind + 1, act, val) * 1ll * (act + 1)) % 1000000007;
if (ret >= 1000000007) ret -= 1000000007;
}
return dp[ind][act][lft] = ret;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &nums[i]);
sort(nums + 1, nums + n + 1);
memset(dp, -1, sizeof dp);
printf("%d\n", solve(1, 0, k));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
{
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
bool ron;
if (!d)
ron = false;
else if (!c)
ron = true;
else if (!b)
ron = false;
else if (!a)
ron = true;
else if (!f)
ron = false;
else if (!e)
ron = true;
else
ron = a * c * e < b * d * f;
printf("%s\n", ron ? "Ron" : "Hermione");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 10;
int n, m, init;
vector<int> e[MaxN];
bool vis[MaxN][2], stck[MaxN], win, draw;
int p[MaxN][2], last_x, last_q;
stack<int> sol;
void f(int x, int y, int q) {
stck[x] = false;
if (vis[x][q]) return;
stck[x] = true;
vis[x][q] = true;
p[x][q] = y;
if (q == 1 && e[x].size() == 0) {
win = true;
last_x = x;
last_q = 1;
}
for (int z : e[x]) {
if (stck[z]) draw = true;
f(z, x, 1 - q);
}
stck[x] = false;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
e[i].resize(c);
for (int j = 0; j < c; j++) cin >> e[i][j];
}
cin >> init;
f(init, init, 0);
if (win) {
cout << "Win\n";
do {
sol.push(last_x);
last_x = p[last_x][last_q];
last_q = 1 - last_q;
} while (last_x != init or p[last_x][last_q] != init);
cout << init;
for (; !sol.empty(); sol.pop()) cout << " " << sol.top();
cout << "\n";
} else if (draw)
cout << "Draw\n";
else
cout << "Lose\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
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 + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long t;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> s;
long long n = s.size();
long long maxi = n - 2;
for (long long i = 0; i < 100; i++) {
long long cur = 0, idx = 0;
char c1, c2;
if (i < 10) {
c1 = '0';
c2 = (char)(i + '0');
} else {
c2 = (char)(i % 10 + '0');
c1 = (char)((long long)(i / 10) + '0');
}
while (idx < n) {
if (cur % 2 == 0) {
while (idx < n and s[idx] != c1) idx++;
if (idx < n) cur++;
} else {
while (idx < n and s[idx] != c2) idx++;
if (idx < n) cur++;
}
idx++;
}
if (cur % 2 == 1 and c1 != c2) continue;
maxi = min(maxi, n - cur);
}
cout << maxi << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
cout << 4 << endl;
cout << "L " << n - 1 << endl;
cout << "L " << 2 << endl;
cout << "R " << 2 << endl;
cout << "R " << 4 * n - 5;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("03")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <class T, class T2>
T _f_pow(T a, T2 b) {
T res = 1LL;
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return (res);
}
template <class T>
T gcd(T a, T b) {
while (a && b)
if (a > b)
(a %= b);
else
(b %= a);
return a + b;
}
template <class T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
int n, m;
long long par[(int)2e6 + 5], sz[(int)2e6 + 5], cmp, mxComp;
void init() {
iota(par, par + n + 1, 0);
fill(sz, sz + n + 1, 1);
cmp = n;
mxComp = 1;
}
int Find(int u) { return u == par[u] ? u : par[u] = Find(par[u]); }
int join(int u, int v) {
u = Find(u);
v = Find(v);
if (u == v) return 0;
if (sz[u] > sz[v]) swap(u, v);
par[u] = v;
sz[v] += sz[u];
mxComp = max(mxComp, sz[v]);
cmp--;
return 1;
}
int from[(int)2e6 + 5], to[(int)2e6 + 5], cst[(int)2e6 + 5],
sorted[(int)2e6 + 5];
int f, s;
int krus() {
init();
sort(sorted, sorted + m, [](int a, int b) { return cst[a] < cst[b]; });
int ret = 0;
for (int k = 0; k < m; k++) {
int e = sorted[k];
if (join(from[e], to[e])) {
if (Find(f) == Find(s)) {
cout << cst[e] << endl;
return 0;
}
ret += cst[e];
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n >> m;
int tm;
m--;
cin >> f >> s >> tm;
for (int i = 0, _n = (m); i < _n; i++) {
cin >> from[i] >> to[i] >> cst[i];
sorted[i] = i;
}
if (krus()) cout << ((int)1e9) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[101], i, l, r, n, j, c44, c1, c4, c, k, x, ans, h, y, m, step[101],
v, b, d;
string s, ss, sss;
char ch;
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= m; i++) {
c = 0;
cin >> l >> r;
for (j = l; j <= r; j++) {
c += a[j];
}
if (c > 0)
for (j = l; j <= r; j++) {
step[j]++;
}
}
c = 0;
for (i = 1; i <= n; i++) {
c += step[i] * a[i];
}
cout << c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
long long n, p, k;
cin >> n >> p >> k;
long long ans = 0, pre = 0;
vector<long long> a(n, -1);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (long long i = 0; i <= k; ++i) {
long long sum = pre;
if (sum > p) break;
long long ct = i;
for (long long j = i + k - 1; j < n; j += k) {
if (sum + a[j] <= p) {
ct += k;
sum += a[j];
} else
break;
}
pre += a[i];
ans = max(ans, ct);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000 * 100 + 100;
int a[MAX], b[MAX];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + n);
int cnt = 0;
for (int i = 0; i < n; i++)
if (a[i] != b[i]) cnt++;
if (cnt <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int lcase = 0, ucase = 0, n;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
lcase++;
} else
ucase++;
}
if (lcase < ucase) {
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
n = s[i] - 96;
n = 64 + n;
char c = n;
s[i] = c;
}
}
} else {
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 65 && s[i] <= 90) {
n = s[i] - 65;
n = 97 + n;
char c = n;
s[i] = c;
}
}
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printvec(vector<T>& vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i] << " ";
}
cout << "\n";
}
void updateBIT(int BIT[][102 + 1], int x, int y, int val) {
int i, j;
for (i = x + 1; i <= 102; i += (i & (-1 * i))) {
for (j = y + 1; j <= 102; j += (j & (-1 * j))) BIT[i][j] += val;
}
return;
}
int getSum(int BIT[][102 + 1], int x, int y) {
int sum = 0;
int i, j;
for (i = x + 1; i > 0; i -= (i & (-1 * i))) {
for (j = y + 1; j > 0; j -= (j & (-1 * j))) {
sum += BIT[i][j];
}
}
return sum;
}
int main() {
int mat[11][102][102], BIT[11][102 + 1][102 + 1];
int n, q, c;
cin >> n >> q >> c;
int i, j, k;
for (i = 0; i < 11; i++) {
for (j = 0; j < 102; j++) {
for (k = 0; k < 102; k++) {
mat[i][j][k] = 0;
}
}
}
for (i = 0; i < 11; i++) {
for (j = 0; j < 102 + 1; j++) {
for (k = 0; k < 102 + 1; k++) {
BIT[i][j][k] = 0;
}
}
}
for (i = 0; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
mat[0][x][y] += z;
updateBIT(BIT[0], x, y, z);
int pre = z;
for (j = 1; j < 11; j++) {
pre++;
if (pre > c) pre = 0;
mat[j][x][y] += (pre);
updateBIT(BIT[j], x, y, pre);
}
}
for (i = 0; i < 102 + 1; i++) {
for (j = 0; j < 102 + 1; j++) {
}
}
for (int iii = 0; iii < q; iii++) {
int ti, x1, y1, x2, y2;
cin >> ti >> x1 >> y1 >> x2 >> y2;
int ans = 0;
ti = (ti % (c + 1));
if (ti <= 10) {
ans = getSum(BIT[ti], x2, y2) - getSum(BIT[ti], x2, y1 - 1) -
getSum(BIT[ti], x1 - 1, y2) + getSum(BIT[ti], x1 - 1, y1 - 1);
} else {
ans = getSum(BIT[10], x2, y2) - getSum(BIT[10], x2, y1 - 1) -
getSum(BIT[10], x1 - 1, y2) + getSum(BIT[10], x1 - 1, y1 - 1);
}
cout << ans << "\n";
}
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, a[100100], k;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= (n + 1); i++) {
if (i <= n) cin >> a[i];
if (i > 1) {
if (a[i] == a[i - 1] && i <= n) {
k++;
} else {
ans += (k * (k - 1) / 2);
k = 1;
}
} else
k++;
}
cout << ans + n;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
const lli g = 5;
const lli mod = 1e9 + 7;
lli powerMod(lli a, lli b, lli m) {
lli ans = 1;
while (b) {
if (b & 1) ans = ans * a % m;
b >>= 1;
a = a * a % m;
}
return ans % m;
}
lli discLog(lli a, lli b, lli m) {
lli order = m - 1;
lli n = sqrt(order) + 1;
lli a_n = powerMod(a, n, m);
lli ans = 0;
unordered_map<lli, lli> firstHalf;
lli current = a_n;
for (lli p = 1; p <= n; p++) {
firstHalf[current] = p;
current = (current * a_n) % m;
}
current = b % m;
for (lli q = 0; q <= n; q++) {
if (firstHalf.count(current)) {
lli p = firstHalf[current];
lli x = n * p - q;
return x % order;
}
current = (current * a) % m;
}
assert(0);
return -1;
}
lli rec(const vector<lli>& P, const vector<lli>& init, lli n) {
int deg = P.size();
vector<lli> ans(deg), R(2 * deg);
ans[0] = 1;
lli p = 1;
for (lli v = n; v >>= 1; p <<= 1)
;
do {
int d = (n & p) != 0;
fill(R.begin(), R.end(), 0);
for (int i = 0; i < deg; i++)
for (int j = 0; j < deg; j++) R[i + j + d] += ans[i] * ans[j] % (mod - 1);
for (int i = 0; i < 2 * deg; ++i) R[i] %= (mod - 1);
for (int i = deg - 1; i >= 0; i--) {
R[i + deg] %= (mod - 1);
for (int j = 0; j < deg; j++) R[i + j] += R[i + deg] * P[j] % (mod - 1);
}
for (int i = 0; i < deg; i++) R[i] %= (mod - 1);
copy(R.begin(), R.begin() + deg, ans.begin());
} while (p >>= 1);
lli nValue = 0;
for (int i = 0; i < deg; i++) nValue += ans[i] * init[i] % (mod - 1);
return nValue % (mod - 1);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
lli n, f1, f2, f3, c;
cin >> n >> f1 >> f2 >> f3 >> c;
--n;
lli d = discLog(g, c, mod);
lli ans = rec({1, 1, 1},
{(discLog(g, f1, mod) + d) % (mod - 1),
(discLog(g, f2, mod) + 2 * d) % (mod - 1),
(discLog(g, f3, mod) + 3 * d) % (mod - 1)},
n);
ans -= d * ((n + 1) % (mod - 1)) % (mod - 1);
if (ans < 0) ans += mod - 1;
cout << powerMod(g, ans, mod) << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans = n / 7 * 2, mn = ans, mx = ans;
int rem = n % 7;
if (rem > 5) {
mn += 1;
}
if (rem > 1) {
mx += 2;
}
if (rem == 1) {
mx += 1;
}
printf("%d %d\n", mn, mx);
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.