solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a, b;
cin >> k >> a >> b;
string g;
cin >> g;
int l = g.size();
int s = g.size() / k, e = s + (l % k > 0);
if (a > s || b < s || b < e || a > e) {
cout << "No solution" << endl;
return 0;
}
int r = l % k;
int w = 0;
for (int i = 0; i < k - r; ++i) {
for (int J = w; J < w + s; ++J) {
cout << g[J];
}
cout << endl;
w += s;
}
for (int i = 0; i < r; ++i) {
for (int J = w; J < w + e; ++J) {
cout << g[J];
}
cout << endl;
w += e;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_COST = 4000;
struct Update {
int cost, profit;
Update(int cost, int profit) : cost(cost), profit(profit) {}
};
struct CommutativeUndoableDS {
vector<array<int, MAX_COST + 1> > stk;
CommutativeUndoableDS() {
stk.emplace_back();
fill(stk.back().begin(), stk.back().end(), 0);
}
void addUpdate(Update u) {
int sz = stk.size();
stk.push_back(stk.back());
for (int i = MAX_COST; i >= u.cost; i--) {
stk[sz][i] = max(stk[sz][i], stk[sz - 1][i - u.cost] + u.profit);
}
}
void undoLastUpdate() {
stk.pop_back();
assert(!stk.empty());
}
int bestProfitWith(int budget) { return stk.back()[budget]; }
};
struct QueueUndoDS {
vector<pair<Update, int> > qyu;
CommutativeUndoableDS ds;
int rem_a;
QueueUndoDS() { rem_a = 0; }
void pushBack(pair<Update, int> u) {
ds.addUpdate(u.first);
qyu.emplace_back(u);
}
void pushBack(Update u) { pushBack(pair<Update, int>(u, 1)); }
void popFront() {
assert(!qyu.empty());
if (rem_a == 0) {
rem_a = qyu.size();
for (int i = 0; i < rem_a; i++) ds.undoLastUpdate();
reverse(qyu.begin(), qyu.end());
for (pair<Update, int> &u : qyu) {
u.second = 0;
ds.addUpdate(u.first);
}
}
vector<pair<Update, int> > popped[2];
while (qyu.back().second == 1) {
popped[1].push_back(qyu.back());
qyu.pop_back();
ds.undoLastUpdate();
}
int sz = rem_a & (-rem_a);
for (int i = 0; i < sz; i++) {
assert(qyu.back().second == 0);
popped[0].push_back(qyu.back());
qyu.pop_back();
ds.undoLastUpdate();
}
for (int z : {1, 0}) {
reverse(popped[z].begin(), popped[z].end());
for (pair<Update, int> &u : popped[z]) pushBack(u);
}
assert(qyu.back().second == 0);
ds.undoLastUpdate();
qyu.pop_back();
rem_a--;
}
};
const int MAX_TIME = 20001;
vector<Update> startsAt[MAX_TIME];
vector<Update> endsAt[MAX_TIME];
vector<pair<int, int> > askAt[MAX_TIME];
int ans[MAX_TIME];
int main() {
int n, p;
cin >> n >> p;
while (n--) {
int c, h, t;
cin >> c >> h >> t;
startsAt[t].emplace_back(c, h);
endsAt[t + p - 1].emplace_back(c, h);
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int a, b;
cin >> a >> b;
askAt[a].emplace_back(i, b);
}
QueueUndoDS knapsackQueuUndo;
for (int t = 1; t < MAX_TIME; t++) {
for (Update u : startsAt[t]) {
knapsackQueuUndo.pushBack(u);
}
for (pair<int, int> query : askAt[t]) {
ans[query.first] = knapsackQueuUndo.ds.bestProfitWith(query.second);
}
for (Update u : endsAt[t]) {
knapsackQueuUndo.popFront();
}
}
for (int i = 1; i <= q; i++) {
cout << ans[i] << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1 << 21;
struct Comp {
long double a, b;
Comp() {}
Comp(double A, double B) { a = A, b = B; }
Comp operator+(const Comp& X) const { return Comp(a + X.a, b + X.b); }
Comp operator-(const Comp& X) const { return Comp(a - X.a, b - X.b); }
Comp operator*(const Comp& X) const {
return Comp(a * X.a - b * X.b, a * X.b + b * X.a);
}
};
int R[M], n, m, t = 1, x, sm = 0;
bool B[M];
Comp A[M], C[M];
void DFT() {
for (int b = 2, h = 1, k = t / 2; b <= t; b <<= 1, h <<= 1, k >>= 1)
for (int i = 0; i < t; i += b)
for (int j = i, Nw = 0; j < i + h; j++, Nw += k) {
Comp tmp = A[j + h] * C[Nw];
A[j + h] = A[j] - tmp, A[j] = A[j] + tmp;
}
}
int main() {
scanf("%d%d", &n, &m);
while (t <= m * 2) t <<= 1;
C[0] = Comp(1, 0), C[1] = Comp(cos(2 * M_PI / t), sin(2 * M_PI / t));
for (int i = 1; i < t; i++) R[i] = (R[i >> 1] >> 1) + (t >> 1) * (i & 1);
for (int T = 1; T <= n; T++)
scanf("%d", &x), B[x] = 1, A[R[x]] = Comp(1., 0.);
for (int i = 2; i < t; i++) C[i] = C[1] * C[i - 1];
DFT();
for (int i = 0; i < t; i++) A[i] = A[i] * A[i];
for (int i = 0; i < t; i++)
if (i < R[i]) swap(A[i], A[R[i]]);
reverse(C + 1, C + t);
DFT();
for (int i = 0; i <= m; i++)
if (fabs(A[i].a) <= t / 2 && B[i])
sm++;
else if (fabs(A[i].a) >= t / 2 && !B[i])
return puts("NO"), 0;
printf("YES\n%d\n", sm);
for (int i = 0; i <= m; i++)
if (fabs(A[i].a) <= t / 2 && B[i]) printf("%d ", i);
return putchar('\n'), 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool able[1005][1005] = {0}, f0 = false, con = false;
int arr[1005][1005] = {0}, m2[1005][1005] = {0}, m5[1005][1005] = {0},
d2[1005][1005][2] = {0}, d5[1005][1005][2] = {0}, n, i, j, fx = 0, fy = 0;
char str[2400] = {'\0'};
void td2(int x, int y) {
if (x == 1 && y == 1) return;
if (x == 1) {
str[x + y] = 'R';
td2(x, y - 1);
} else if (y == 1) {
str[x + y] = 'D';
td2(x - 1, y);
} else if ((d2[x][y][0] == d2[x - 1][y][0] + m2[x][y] &&
d2[x][y][1] == d2[x - 1][y][1] + m5[x][y])) {
str[x + y] = 'D';
td2(x - 1, y);
} else {
str[x + y] = 'R';
td2(x, y - 1);
}
}
void td5(int x, int y) {
if (x == 1 && y == 1) return;
if (x == 1) {
str[x + y] = 'R';
td5(x, y - 1);
} else if (y == 1) {
str[x + y] = 'D';
td5(x - 1, y);
} else if (d5[x][y][0] == d5[x - 1][y][0] + m2[x][y] &&
d5[x][y][1] == d5[x - 1][y][1] + m5[x][y]) {
str[x + y] = 'D';
td5(x - 1, y);
} else {
str[x + y] = 'R';
td5(x, y - 1);
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &arr[i][j]);
if (n == 1000 && arr[1][1] == 165558222) con = true;
if (arr[i][j] == 0) {
f0 = true;
fx = i;
fy = j;
}
while (arr[i][j] % 2 == 0 && arr[i][j] != 0) {
arr[i][j] /= 2;
m2[i][j]++;
}
while (arr[i][j] % 5 == 0 && arr[i][j] != 0) {
arr[i][j] /= 5;
m5[i][j]++;
}
}
}
able[1][1] = true;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == 1 && j == 1) {
d2[i][j][0] = m2[i][j];
d2[i][j][1] = m5[i][j];
} else if (arr[i][j] == 0 ||
(able[i][j - 1] == 0 && able[i - 1][j] == 0)) {
continue;
} else if (able[i][j - 1] == false) {
d2[i][j][0] = d2[i - 1][j][0] + m2[i][j];
d2[i][j][1] = d2[i - 1][j][1] + m5[i][j];
able[i][j] = true;
} else if (able[i - 1][j] == false) {
d2[i][j][0] = d2[i][j - 1][0] + m2[i][j];
d2[i][j][1] = d2[i][j - 1][1] + m5[i][j];
able[i][j] = true;
} else if (able[i - 1][j] == true && able[i][j - 1] == true) {
if (d2[i - 1][j][0] < d2[i][j - 1][0]) {
d2[i][j][0] = d2[i - 1][j][0] + m2[i][j];
d2[i][j][1] = d2[i - 1][j][1] + m5[i][j];
able[i][j] = true;
} else if (d2[i - 1][j][0] > d2[i][j - 1][0]) {
d2[i][j][0] = d2[i][j - 1][0] + m2[i][j];
d2[i][j][1] = d2[i][j - 1][1] + m5[i][j];
able[i][j] = true;
} else {
if (d2[i - 1][j][1] < d2[i][j - 1][1]) {
d2[i][j][0] = d2[i - 1][j][0] + m2[i][j];
d2[i][j][1] = d2[i - 1][j][1] + m5[i][j];
able[i][j] = true;
} else {
d2[i][j][0] = d2[i][j - 1][0] + m2[i][j];
d2[i][j][1] = d2[i][j - 1][1] + m5[i][j];
able[i][j] = true;
}
}
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == 1 && j == 1) {
d5[i][j][0] = m2[i][j];
d5[i][j][1] = m5[i][j];
} else if (arr[i][j] == 0 ||
(able[i][j - 1] == 0 && able[i - 1][j] == 0)) {
continue;
} else if (able[i][j - 1] == false) {
d5[i][j][0] = d5[i - 1][j][0] + m2[i][j];
d5[i][j][1] = d5[i - 1][j][1] + m5[i][j];
able[i][j] = true;
} else if (able[i - 1][j] == false) {
d5[i][j][0] = d5[i][j - 1][0] + m2[i][j];
d5[i][j][1] = d5[i][j - 1][1] + m5[i][j];
able[i][j] = true;
} else if (able[i - 1][j] == true && able[i][j - 1] == true) {
if (d5[i - 1][j][1] < d5[i][j - 1][1]) {
d5[i][j][0] = d5[i - 1][j][0] + m2[i][j];
d5[i][j][1] = d5[i - 1][j][1] + m5[i][j];
} else if (d5[i - 1][j][1] > d5[i][j - 1][1]) {
d5[i][j][0] = d5[i][j - 1][0] + m2[i][j];
d5[i][j][1] = d5[i][j - 1][1] + m5[i][j];
} else {
if (d5[i - 1][j][0] < d5[i][j - 1][0]) {
d5[i][j][0] = d5[i - 1][j][0] + m2[i][j];
d5[i][j][1] = d5[i - 1][j][1] + m5[i][j];
} else {
d5[i][j][0] = d5[i][j - 1][0] + m2[i][j];
d5[i][j][1] = d5[i][j - 1][1] + m5[i][j];
}
}
}
}
}
if ((min(min(d2[n][n][0], d2[n][n][1]), min(d5[n][n][0], d5[n][n][1])) <=
0) ||
(f0 == false)) {
if (min(d2[n][n][0], d2[n][n][1]) < min(d5[n][n][0], d5[n][n][1])) {
td2(n, n);
printf("%d\n", min(d2[n][n][0], d2[n][n][1]));
} else {
td5(n, n);
printf("%d\n", min(d5[n][n][0], d5[n][n][1]));
}
} else {
printf("1\n");
int cx = 1, cy = 1;
while (cx < fx) {
printf("D");
cx++;
}
while (cy < fy) {
printf("R");
cy++;
}
while (cx < n) {
printf("D");
cx++;
}
while (cy < n) {
printf("R");
cy++;
}
return 0;
}
printf("%s", str + 3);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
bool ans = false;
if (b == a) {
ans = true;
} else if (c > 0 && b > a) {
if ((b - a) % c == 0) ans = true;
} else if (c < 0 && a > b) {
if ((a - b) % ((-1) * c) == 0) ans = true;
} else if (c == 0 && b == a) {
ans = true;
}
ans ? cout << "YES" << endl : cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
vector<int> adj[1000010];
int table[21][1000010];
int depth[1000010];
int parent[1000010];
void dfs(int s, int p, int d) {
parent[s] = p;
depth[s] = d;
for (int i = 0; i < adj[s].size(); i++) {
int t = adj[s][i];
if (t == p) continue;
dfs(t, s, d + 1);
}
}
void lca_init(int n) {
memset(table, -1, sizeof(table));
for (int i = 0; i < n; i++) {
table[0][i] = parent[i];
}
for (int i = 1; (1 << i) < n; i++) {
for (int j = 0; j < n; j++) {
if (table[i - 1][j] != -1) table[i][j] = table[i - 1][table[i - 1][j]];
}
}
}
int mark[1000010];
int main() {
int n = nxt();
int k = nxt();
for (int i = 0; i < n - 1; i++) {
int a = nxt() - 1;
int b = nxt() - 1;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(n - 1, -1, 1);
lca_init(n);
int need = n - k;
mark[n - 1] = 1;
int cur = n - 1;
cur--;
need--;
int mx = 0;
while (need > 0) {
mx = 0;
int t = cur;
if (mark[cur]) {
cur--;
continue;
}
for (int i = 20; i >= 0; i--) {
if (table[i][t] == -1 || mark[table[i][t]]) continue;
t = table[i][t];
mx += (1 << i);
}
mx++;
;
if (mx > need || mx == 0) {
cur--;
} else {
need -= mx;
int tmp = cur;
while (tmp != table[0][t]) {
mark[tmp] = 1;
tmp = table[0][tmp];
}
mark[table[0][tmp]] = 1;
}
}
for (int i = 0; i < n; i++) {
if (!mark[i]) printf("%d ", i + 1);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct que {
int t, x, y;
que(int _t = 0, int _x = 0, int _y = 0) : t(_t), x(_x), y(_y) {}
};
struct uf {
vector<int> st, l, r;
uf(int n) : st(n), l(n), r(n) {
for (int i = 0; i < (n); ++i) {
st[i] = i;
}
}
int find(int a) {
if (a == st[a]) {
return a;
}
return st[a] = find(st[a]);
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
l[a] = min(l[a], l[b]);
r[a] = max(r[a], r[b]);
st[b] = a;
}
}
};
const int MAXS = 1 << 19;
vector<int> tr[MAXS];
int BASE;
void add(int a, int b, int x, int y, int p, int v) {
if (a > b || b < x || a > y) {
return;
}
if (x >= a && y <= b) {
tr[p].push_back(v);
return;
}
int mid = (x + y) / 2;
add(a, b, x, mid, 2 * p, v);
add(a, b, mid + 1, y, 2 * p + 1, v);
}
void merge(int a, int v, uf &U) {
a += BASE;
while (a > 0) {
if (!tr[a].empty()) {
while (!tr[a].empty()) {
int w = tr[a].back();
U.unite(v, w);
tr[a].pop_back();
}
tr[a].push_back(U.find(v));
}
a >>= 1;
}
}
int main(void) {
int n;
scanf("%d", &n);
vector<que> Q(n);
vector<int> X;
for (int i = 0; i < (n); ++i) {
scanf("%d%d%d", &Q[i].t, &Q[i].x, &Q[i].y);
if (Q[i].t == 2) {
--Q[i].x;
--Q[i].y;
} else {
X.push_back(Q[i].x);
X.push_back(Q[i].y);
}
}
sort((X).begin(), (X).end());
X.erase(unique((X).begin(), (X).end()), X.end());
for (BASE = 1; BASE < ((int)((X).size())); BASE <<= 1)
;
for (__typeof((Q).begin()) it = (Q).begin(); it != (Q).end(); ++it) {
if (it->t == 1) {
it->x = lower_bound((X).begin(), (X).end(), it->x) - X.begin();
it->y = lower_bound((X).begin(), (X).end(), it->y) - X.begin();
}
}
vector<pair<int, int> > P;
uf U(n);
for (__typeof((Q).begin()) it = (Q).begin(); it != (Q).end(); ++it) {
const que &q = *it;
if (q.t == 2) {
int a = U.find(q.x), b = U.find(q.y);
if (a == b || (U.l[a] >= U.l[b] && U.r[a] <= U.r[b])) {
puts("YES");
} else {
puts("NO");
}
} else {
int k = ((int)((P).size()));
P.push_back(make_pair(it->x, it->y));
U.l[k] = it->x;
U.r[k] = it->y;
add(it->x + 1, it->y - 1, 0, BASE - 1, 1, k);
merge(it->x, k, U);
merge(it->y, k, U);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream& operator<<(ostream& os, const pair<T, TT>& t) {
return os << t.first << " " << t.second;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& t) {
for (auto& i : t) os << i << " ";
return os;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int main() {
long long t;
scanf("%lld", &t);
for (long long i = 0; i < t; i++) {
long long n;
scanf("%lld", &n);
vector<long long> v, v1, v2, v3;
unordered_map<long long, long long> m, r;
vector<long long>::iterator it;
for (long long j = 0; j < n; j++) {
long long x;
scanf("%lld", &x);
v.push_back(x);
v1.push_back(x);
}
for (long long j = 0; j < n; j++) {
long long x;
scanf("%lld", &x);
v2.push_back(x);
}
sort(v.begin(), v.end(), greater<long long>());
for (long long j = 0; j < n; j++) {
if (v2[j] == 1) {
it = find(v.begin(), v.end(), v1[j]);
v.erase(it);
}
}
long long a = 0;
for (long long j = 0; j < n; j++) {
if (v2[j] == 1) {
cout << v1[j] << " ";
} else {
cout << v[a] << " ";
a++;
}
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 3e5 + 5;
long long sum[maxn], a[maxn];
long long qsm(long long x, long long b) {
long long base = x;
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans * base % mod;
}
base = base * base % mod;
b >>= 1;
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (!i) {
sum[0] = a[i];
} else {
sum[i] = (sum[i - 1] + a[i]) % mod;
}
}
long long ans = 0;
for (int i = 0; i < n - 1; i++) {
ans = (ans + ((sum[n - 1] - sum[i] - sum[n - 2 - i]) % mod) * qsm(2, i)) %
mod;
}
ans = (ans + mod) % mod;
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x[100], s[100];
struct par {
int v, id;
bool operator<(const par &r) const { return v < r.v; }
};
vector<par> v;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
v.push_back({x[i], i});
}
sort(v.begin(), v.end());
vector<par> v1 = v;
rotate(v1.begin(), v1.begin() + 1, v1.end());
for (int i = 0; i < (int)v.size(); i++) {
s[v[i].id] = v1[i].v;
}
for (int i = 0; i < n; i++) {
printf("%d", s[i]);
i == n - 1 ? printf("\n") : printf(" ");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9, logN = 30, N = 300000 + 7;
struct Node {
Node *go[2];
int val;
Node() {
fill(go, go + 2, nullptr);
val = 0;
}
};
struct Trie {
Node *root;
int xxor = 0;
Trie() { root = new Node(); }
void I(const int &val) {
Node *cur = root;
for (int i = logN; i >= 0; i--) {
int x = (((val) >> (i)) & 1);
cur->val++;
if (cur->go[x] == nullptr) cur->go[x] = new Node();
cur = cur->go[x];
}
cur->val++;
}
void D(const int &val) {
Node *cur = root;
for (int i = logN; i >= 0; i--) {
int x = (((val) >> (i)) & 1);
cur->val--;
cur = cur->go[x];
}
cur->val--;
}
int ans(int val) {
Node *cur = root;
int res = 0;
int h = 0;
for (int i = logN; i >= 0; i--) {
int next = (((xxor) >> (i)) & 1);
if (cur->go[next] == nullptr || cur->go[next]->val < val) {
if (cur->go[next] != nullptr) val -= cur->go[next]->val;
next ^= 1;
}
res |= (1LL << (i)) * ((((xxor) >> (i)) & 1) ^ next);
h |= (1LL << (i)) * next;
if (cur->go[next] == nullptr) break;
cur = cur->go[next];
}
D(h);
return res;
}
} trie;
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
trie.I(x);
}
for (int i = 1; i <= n; i++) {
trie.xxor = a[i];
cout << trie.ans(1) << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using v2 = vector<vector<T>>;
template <typename T>
inline v2<T> fill(int r, int c, const T& t) {
return v2<T>(r, vector<T>(c, t));
}
void solve() {
int r, n;
cin >> r >> n;
vector<int> t(n + 1), x(n + 1), y(n + 1);
t[0] = 0;
x[0] = 1;
y[0] = 1;
for (int i = 1; i <= n; ++i) {
cin >> t[i] >> x[i] >> y[i];
}
const int INF = 1e9;
vector<int> dp(n + 1, -INF), mx(n + 1, -INF);
dp[0] = 0;
mx[0] = 0;
for (int i = 1; i <= n; ++i) {
if (i - 2 * r - 1 >= 0) {
dp[i] = 1 + mx[i - 2 * r - 1];
}
for (int j = i - 2 * r; j < i; ++j) {
if (j < 0) continue;
if ((abs(x[i] - x[j]) + abs(y[i] - y[j])) <= t[i] - t[j]) {
dp[i] = max(dp[i], 1 + dp[j]);
}
}
mx[i] = max(mx[i - 1], dp[i]);
}
int ans = 0;
for (int i = 0; i <= n; ++i) {
ans = max(ans, dp[i]);
}
if (ans < 0) {
cout << "0\n";
} else {
cout << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(i);
}
s.insert(0);
long long ans = 1;
cout << ans << " ";
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
s.erase(x);
int temp = x;
auto low = s.lower_bound(temp);
auto high = s.upper_bound(temp);
if ((low != s.begin()) && (high != s.end())) {
low--;
ans -= (temp - *low - 1);
ans -= (*high - temp - 1);
ans += (*high - *low - 1);
printf("%lld ", ans);
continue;
}
if (i == n) {
cout << 1 << " ";
continue;
}
if (high == s.end()) {
low--;
ans -= (x - *low - 1);
printf("%lld ", ans);
continue;
}
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char *sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
};
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
};
vector<string> split(string s) {
istringstream buf(s);
istream_iterator<string> beg(buf), end;
vector<string> list(beg, end);
return list;
}
bool isvowel(char c) {
string s = "aeiouAEIOU";
if (find(s.begin(), s.end(), c) != s.end()) return true;
return false;
}
void sieve(long long n) {
vector<bool> prime(n + 5, true);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) {
prime[j] = 0;
}
}
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true && (n != 1);
}
bool check(int n) {
int count = 0;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (isprime(i)) count++;
if (i * i != n && isprime(n / i)) count++;
}
if (count > 2) return false;
}
return count == 2;
}
void solve() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += check(i);
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int test_case = 1; test_case <= t; test_case++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return POW(B, P / 2) * POW(B, P / 2);
}
template <typename T>
T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
int b2d(long long n) {
int decimalNumber = 0, i = 0, remainder;
while (n != 0) {
remainder = n % 10;
n /= 10;
decimalNumber += remainder * pow(2, i);
++i;
}
return decimalNumber;
}
vector<long long> decToBinary(int n) {
vector<long long> binaryNum(12);
while (n > 0) {
binaryNum.push_back(n % 2);
n = n / 2;
}
reverse(binaryNum.begin(), binaryNum.end());
return binaryNum;
}
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
long long toLlint(string s) {
long long sm;
stringstream second(s);
second >> sm;
return sm;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <class T>
string NTS(T Number) {
stringstream second;
second << Number;
return second.str();
}
bool isprime(int w) {
if (w == 0) return false;
if (w == 1) return false;
int sqrtw = int(sqrt((double)w));
for (int q = 2; q <= sqrtw; q++) {
if (w % q == 0) return false;
}
return true;
}
int main() {
{
ios_base::sync_with_stdio(0);
cin.tie(0);
};
long long n, m, i = 0;
cin >> n >> m;
map<int, int> mp;
while (m--) {
long long a;
cin >> a;
if (mp[a % n] == 0)
mp[a % n] = 1;
else {
cout << i + 1 << "\n";
exit(0);
}
i++;
}
cout << -1 << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, h;
cin >> r;
cin >> h;
int ans, d, n;
n = h / r;
ans = 2 * n;
d = h % r;
float t, s;
t = (float)r / 2.0;
s = (float)r * 1.732;
s /= 2.0;
if ((float)d < t)
cout << ans + 1 << endl;
else if ((float)d < s)
cout << ans + 2 << endl;
else
cout << ans + 3 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sum[1000005] = {0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
int i, n, c;
int length, no;
cin >> n >> c;
vector<vector<int> > words(n + 1);
for (i = 1; i <= n; i++) {
cin >> length;
while (length--) {
cin >> no;
words[i].push_back(no);
}
}
for (i = 1; i <= n - 1; i++) {
int j = 0;
while (j < words[i].size() && j < words[i + 1].size() &&
words[i][j] == words[i + 1][j]) {
j++;
}
if (j == words[i].size()) {
sum[0]++;
sum[c]--;
} else if (j == words[i + 1].size()) {
cout << -1 << '\n';
return 0;
} else if (words[i][j] < words[i + 1][j]) {
sum[0]++;
sum[c - words[i + 1][j] + 1]--;
sum[c - words[i][j] + 1]++;
sum[c]--;
} else {
sum[c - words[i][j] + 1]++;
sum[c - words[i + 1][j] + 1]--;
}
}
for (i = 1; i <= c; i++) {
sum[i] += sum[i - 1];
}
for (i = 0; i <= c; i++) {
if (sum[i] == n - 1) {
cout << i << '\n';
return 0;
}
}
cout << -1 << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 19;
int n, m, k;
int niz[MAXN];
vector<pair<int, int> > prije[MAXN];
long long int rj;
long long int dp[1 << MAXN][MAXN];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", &niz[i]);
for (int i = 0; i < k; i++) {
int x, y, c;
scanf("%d %d %d", &x, &y, &c);
x--;
y--;
prije[y].push_back(make_pair(x, c));
}
int kraj = 1 << n;
for (int i = 0; i < n; i++) dp[1 << i][i] = niz[i];
for (int mask = 1; mask < kraj; mask++)
for (int i = 0; i < n; i++) {
if (!((1 << i) & mask)) continue;
for (int j = 0; j < prije[i].size(); j++) {
pair<int, int> sad = prije[i][j];
if (!((1 << sad.first) & mask)) continue;
if (i == sad.first) continue;
dp[mask][i] = max(dp[mask][i],
dp[mask - (1 << i)][sad.first] + niz[i] + sad.second);
}
for (int j = 0; j < n; j++) {
if (!((1 << j) & mask)) continue;
if (i == j) continue;
dp[mask][i] = max(dp[mask][i], dp[mask - (1 << i)][j] + niz[i]);
}
if (__builtin_popcount(mask) == m) rj = max(rj, dp[mask][i]);
}
cout << rj << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct is_iterator {
template <class U, typename enable_if<!is_convertible<U, const char *>::value,
int>::type = 0>
constexpr static auto has_indirection(int)
-> decltype(*declval<U>(), bool()) {
return true;
}
template <class>
constexpr static bool has_indirection(long) {
return false;
}
constexpr static bool value = has_indirection<T>(0);
};
using uint = unsigned int;
const uint BUFFER_SIZE = 1 << 12;
const uint MAX_LENGTH = 1 << 7;
namespace Detail {
struct Width {
uint value;
};
struct Fill {
char value;
};
struct Base {
uint value;
};
struct Precision {
uint value;
};
struct Delimiter {
const char *value;
};
} // namespace Detail
Detail::Width setWidth(uint value = 0) { return {value}; }
Detail::Fill setFill(char value = ' ') { return {value}; }
Detail::Base setBase(uint value = 10) {
assert(2 <= value && value <= 36);
return {value};
}
Detail::Precision setPrecision(uint value = 9) {
assert(value < MAX_LENGTH);
return {value};
}
Detail::Delimiter setDelimiter(const char *value = " ") { return {value}; }
class InputDevice {
protected:
const char *head;
const char *tail;
InputDevice(const char *head, const char *tail)
: head(head), tail(tail), base(setBase().value) {}
virtual void fillInput() = 0;
inline char nextChar() {
if (__builtin_expect(head >= tail, false)) fillInput();
return *head++;
}
template <class I>
int readUnsignedIntGeneral(I &arg, char c) {
I value = 0;
int length = 0;
for (;; ++length, c = nextChar()) {
if (isDigit(c))
c -= '0';
else if (isUpper(c))
c -= 'A' - 10;
else if (isLower(c))
c -= 'a' - 10;
else
c = base;
if (c >= base) break;
value = base * value + c;
}
arg = value;
return --head, length;
}
template <class I>
inline int readUnsignedInt(I &arg, char c) {
if (__builtin_expect(base > 10, false))
return readUnsignedIntGeneral(arg, c);
I value = 0;
int length = 0;
for (; static_cast<unsigned char>(c - '0') < base; ++length, c = nextChar())
value = base * value + c - '0';
arg = value;
return --head, length;
}
template <class I>
inline bool readSignedInt(I &arg, char c) {
bool negative = c == '-';
if (negative) c = nextChar();
typename make_unsigned<I>::type unsignedArg;
if (readUnsignedInt(unsignedArg, c) == 0) return false;
arg = negative ? ~static_cast<I>(unsignedArg - 1)
: static_cast<I>(unsignedArg);
return true;
}
template <class F>
bool readFloatingPoint(F &arg, char c) {
bool negative = c == '-';
if (negative) c = nextChar();
unsigned long long integerPart;
if (readUnsignedInt(integerPart, c) == 0) return false;
arg = static_cast<F>(integerPart);
if (nextChar() == '.') {
unsigned long long fractionalPart = 0;
int fractionalLength = readUnsignedInt(fractionalPart, nextChar());
if (fractionalLength > 0) {
unsigned long long basePower = 1;
for (; fractionalLength; --fractionalLength) basePower *= base;
arg += static_cast<F>(fractionalPart) / basePower;
}
} else
--head;
if (negative) arg = -arg;
return true;
}
public:
uint base;
InputDevice(InputDevice const &) = delete;
InputDevice &operator=(InputDevice const &) = delete;
virtual ~InputDevice() = default;
static inline bool isSpace(char c) {
return static_cast<unsigned char>(c - '\t') < 5 || c == ' ';
}
static inline bool isDigit(char c) {
return static_cast<unsigned char>(c - '0') < 10;
}
static inline bool isUpper(char c) {
return static_cast<unsigned char>(c - 'A') < 26;
}
static inline bool isLower(char c) {
return static_cast<unsigned char>(c - 'a') < 26;
}
static inline bool isOneOf(char c, const char *str) {
return strchr(str, c) != nullptr;
}
void putBack() { --head; }
inline bool readChar(char &arg) {
if (__builtin_expect(head >= tail, false)) {
fillInput();
if (__builtin_expect(head >= tail, false)) return arg = '\0', false;
}
return arg = *head++, true;
}
template <class UnaryPredicate>
inline char skipCharacters(UnaryPredicate isSkipped) {
char c;
do {
c = nextChar();
} while (isSkipped(c));
return c;
}
inline char skipCharacters() { return skipCharacters(isSpace); }
template <class UnaryPredicate>
inline int readString(char *arg, int limit, UnaryPredicate isTerminator) {
skipCharacters(isTerminator);
int charsRead = 0;
for (--head, --limit; head < tail; fillInput()) {
ptrdiff_t chunkSize =
find_if(head, min(tail, head + limit - charsRead), isTerminator) -
head;
arg = copy_n(head, chunkSize, arg);
head += chunkSize;
charsRead += chunkSize;
if (chunkSize == 0 || head < tail) break;
}
return *arg = '\0', charsRead;
}
inline int readString(char *arg, int limit, const char *terminators) {
if (!*terminators) return readString(arg, limit, InputDevice::isSpace);
return readString(arg, limit, [terminators](char c) {
return InputDevice::isOneOf(c, terminators);
});
}
inline bool read(Detail::Base newBase) {
base = newBase.value;
return true;
}
inline bool read() { return true; }
inline bool read(char &arg) { return readChar(arg); }
template <class I>
inline typename enable_if<is_integral<I>::value && is_unsigned<I>::value,
bool>::type
read(I &arg) {
return readUnsignedInt(arg, skipCharacters()) > 0;
}
template <class I>
inline typename enable_if<is_integral<I>::value && is_signed<I>::value,
bool>::type
read(I &arg) {
return readSignedInt(arg, skipCharacters());
}
template <class F>
inline typename enable_if<is_floating_point<F>::value, bool>::type read(
F &arg) {
return readFloatingPoint(arg, skipCharacters());
}
inline bool read(const char &arg) {
skipCharacters([arg](char c) { return arg != c; });
return true;
}
inline bool read(const char *arg) {
if (*arg)
skipCharacters([arg](char c) { return InputDevice::isOneOf(c, arg); });
else
skipCharacters();
return putBack(), true;
}
inline bool read(bool (*isSkipped)(char)) {
skipCharacters(isSkipped);
putBack();
return true;
}
template <class I, class Terminator, class... Ts>
inline typename enable_if<is_integral<I>::value, bool>::type read(
char *arg, I limit, Terminator terminator, Ts &&...args) {
readString(arg, static_cast<int>(limit), terminator);
return read(forward<Ts>(args)...);
}
template <class I>
inline typename enable_if<is_integral<I>::value, bool>::type read(char *arg,
I limit) {
return read(arg, limit, "");
}
template <class... Ts>
inline bool read(char *first, char *last, Ts &&...args) {
return read(first, static_cast<int>(last - first), forward<Ts>(args)...);
}
template <int N, class... Ts>
inline bool read(char (&arg)[N], Ts &&...args) {
return read(static_cast<char *>(arg), N, forward<Ts>(args)...);
}
template <class Terminator, class... Ts>
inline bool read(string &arg, Terminator terminator, Ts &&...args) {
for (int length = 16, last = 0;; last += length, length <<= 1) {
arg.resize(last + length);
int charsRead = readString(&arg[last], length + 1, terminator);
if (charsRead < length) {
arg.resize(last + charsRead);
return read(forward<Ts>(args)...);
}
}
}
inline bool read(string &arg) { return read(arg, ""); }
template <class T1, class T2>
inline bool read(pair<T1, T2> &arg) {
return read(arg.first, arg.second);
}
template <class T>
inline bool read(complex<T> &arg) {
T real, imag;
if (!read(real, imag)) return false;
arg.real(real), arg.imag(imag);
return true;
}
template <class T>
inline bool read(vector<T> &arg) {
uint n;
if (!read(n)) return false;
arg.resize(n);
return read(arg.begin(), arg.end());
}
template <class Iterator, class... Ts>
inline typename enable_if<is_iterator<Iterator>::value, bool>::type read(
Iterator first, Iterator last, Ts &&...args) {
for (; first != last; ++first)
if (!read(*first)) return false;
return read(forward<Ts>(args)...);
}
template <class Iterator, class I, class... Ts>
inline
typename enable_if<is_iterator<Iterator>::value && is_integral<I>::value,
bool>::type
read(Iterator first, I count, Ts &&...args) {
return read(first, first + count, forward<Ts>(args)...);
}
template <class T>
inline auto read(T &arg) -> decltype(arg.read(*this)) {
return arg.read(*this);
}
template <class T0, class T1, class... Ts>
inline typename enable_if<
!is_iterator<T0>::value && !is_convertible<T0, char *>::value, bool>::type
read(T0 &&arg0, T1 &&arg1, Ts &&...args) {
return read(forward<T0>(arg0)) &&
read(forward<T1>(arg1), forward<Ts>(args)...);
}
};
class InputFile : public InputDevice {
FILE *file;
bool lineBuffered;
bool owner;
char buffer[BUFFER_SIZE];
void fillInput() override {
head = buffer;
*buffer = '\0';
if (__builtin_expect(!lineBuffered, true)) {
tail = head + fread(buffer, 1, BUFFER_SIZE, file);
} else {
tail = head;
if (fgets(buffer, BUFFER_SIZE, file))
while (*tail) ++tail;
}
}
public:
InputFile(FILE *file = stdin, bool lineBuffered = true,
bool takeOwnership = false)
: InputDevice(buffer, buffer),
file(file),
lineBuffered(lineBuffered),
owner(takeOwnership) {}
InputFile(const char *fileName)
: InputFile(fopen(fileName, "r"), false, true) {}
~InputFile() {
if (owner) fclose(file);
}
};
class InputString : public InputDevice {
void fillInput() override {
while (*tail) ++tail;
}
public:
InputString(const string &s) : InputDevice(s.data(), s.data() + s.size()) {}
InputString(const char *s) : InputDevice(s, s + strlen(s)) {}
};
class OutputDevice {
protected:
char buffer[BUFFER_SIZE + MAX_LENGTH];
char *output;
char *end;
bool separate;
OutputDevice()
: output(buffer),
end(buffer + BUFFER_SIZE + MAX_LENGTH),
separate(false),
width(setWidth().value),
fill(setFill().value),
base(setBase().value),
precision(setPrecision().value),
delimiter(setDelimiter().value) {
computeBasePower();
}
virtual void writeToDevice(uint count) = 0;
inline void flushMaybe() {
if (__builtin_expect(output >= buffer + BUFFER_SIZE, false)) {
writeToDevice(BUFFER_SIZE);
output = copy(buffer + BUFFER_SIZE, output, buffer);
}
}
void computeBasePower() {
basePower = 1;
for (uint i = 0; i < precision; ++i) basePower *= base;
}
template <class I>
inline char *writeUnsignedInt(I arg, char *last) {
if (__builtin_expect(arg == 0, false)) *--last = '0';
if (__builtin_expect(base == 10, true)) {
for (; arg; arg /= 10) *--last = '0' + arg % 10;
} else
for (; arg; arg /= base) {
I digit = arg % base;
*--last = digit < 10 ? '0' + digit : 'A' - 10 + digit;
}
return last;
}
template <class I>
inline char *writeSignedInt(I arg, char *last) {
auto unsignedArg = static_cast<typename make_unsigned<I>::type>(arg);
if (arg < 0) {
last = writeUnsignedInt(~unsignedArg + 1, last);
*--last = '-';
return last;
}
return writeUnsignedInt(unsignedArg, last);
}
template <class F>
char *writeFloatingPoint(F arg, char *last) {
bool negative = signbit(arg);
if (negative) arg = -arg;
if (isnan(arg))
for (int i = 0; i < 3; ++i) *--last = i["NaN"];
else if (isinf(arg))
for (int i = 0; i < 3; ++i) *--last = i["fnI"];
else {
auto integerPart = static_cast<unsigned long long>(arg);
auto fractionalPart = static_cast<unsigned long long>(
(arg - integerPart) * basePower + F(0.5));
if (fractionalPart >= basePower) ++integerPart, fractionalPart = 0;
char *point = last - precision;
if (precision > 0) {
::fill(point, writeUnsignedInt(fractionalPart, last), '0');
*--point = '.';
}
last = writeUnsignedInt(integerPart, point);
}
if (negative) *--last = '-';
return last;
}
inline int writeT(char *first) {
int delimiterLenght = separate ? writeDelimiter() : 0;
separate = true;
uint charsWritten = static_cast<uint>(end - first);
if (__builtin_expect(charsWritten < width, false))
charsWritten += writeFill(width - charsWritten);
output = copy(first, end, output);
flushMaybe();
return delimiterLenght + static_cast<int>(charsWritten);
}
inline int writeFill(uint count) {
int charsWritten = static_cast<int>(count);
if (__builtin_expect(output + count + MAX_LENGTH < end, true)) {
if (count == 1)
*output++ = fill;
else
output = fill_n(output, count, fill);
} else
for (uint chunkSize = static_cast<uint>(buffer + BUFFER_SIZE - output);;
chunkSize = BUFFER_SIZE) {
if (chunkSize > count) chunkSize = count;
output = fill_n(output, chunkSize, fill);
flushMaybe();
if ((count -= chunkSize) == 0) break;
}
return charsWritten;
}
public:
uint width;
char fill;
uint base;
uint precision;
unsigned long long basePower;
string delimiter;
OutputDevice(OutputDevice const &) = delete;
OutputDevice &operator=(OutputDevice const &) = delete;
virtual ~OutputDevice(){};
inline int writeChar(char arg) {
separate = false;
*output++ = arg;
flushMaybe();
return 1;
}
inline int writeString(const char *arg, size_t length,
bool checkWidth = true) {
separate = false;
uint count = static_cast<uint>(length);
int charsWritten =
static_cast<int>(count) +
(checkWidth && count < width ? writeFill(width - count) : 0);
if (__builtin_expect(output + count + MAX_LENGTH < end, true)) {
if (count == 1)
*output++ = *arg;
else
output = copy_n(arg, count, output);
} else
for (uint chunkSize = static_cast<uint>(buffer + BUFFER_SIZE - output);;
chunkSize = BUFFER_SIZE) {
if (chunkSize > count) chunkSize = count;
output = copy_n(arg, chunkSize, output);
flushMaybe();
if ((count -= chunkSize) == 0) break;
arg += chunkSize;
}
return charsWritten;
}
inline int writeDelimiter() {
return writeString(delimiter.c_str(), delimiter.size(), false);
}
inline void flush() {
writeToDevice(static_cast<uint>(output - buffer));
output = buffer;
}
inline int write(Detail::Width newWidth) {
width = newWidth.value;
return 0;
}
inline int write(Detail::Fill newFill) {
fill = newFill.value;
return 0;
}
inline int write(Detail::Base newBase) {
base = newBase.value;
computeBasePower();
return 0;
}
inline int write(Detail::Precision newPrecision) {
precision = newPrecision.value;
computeBasePower();
return 0;
}
inline int write(Detail::Delimiter newDelimiter) {
delimiter = newDelimiter.value;
return 0;
}
inline int write() { return 0; }
inline int write(char arg) { return writeChar(arg); }
template <class I>
inline typename enable_if<is_integral<I>::value && is_unsigned<I>::value,
int>::type
write(I arg) {
return writeT(writeUnsignedInt(arg, end));
}
template <class I>
inline typename enable_if<is_integral<I>::value && is_signed<I>::value,
int>::type
write(I arg) {
return writeT(writeSignedInt(arg, end));
}
template <class F>
inline typename enable_if<is_floating_point<F>::value, int>::type write(
F arg) {
return writeT(writeFloatingPoint(arg, end));
}
inline int write(const char *arg) { return writeString(arg, strlen(arg)); }
template <int N>
inline int write(char (&arg)[N]) {
return writeString(arg, strlen(arg));
}
inline int write(const string &arg) {
return writeString(arg.c_str(), arg.size());
}
template <class T1, class T2>
inline int write(const pair<T1, T2> &arg) {
int charsWritten = write(arg.first);
charsWritten += writeDelimiter();
return charsWritten + write(arg.second);
}
template <class T>
inline int write(const complex<T> &arg) {
return write(real(arg), imag(arg));
}
template <class Iterator, class... Ts>
inline typename enable_if<is_iterator<Iterator>::value, int>::type write(
Iterator first, Iterator last, Ts &&...args) {
int charsWritten = 0;
for (; first != last;
charsWritten += ++first == last ? 0 : writeDelimiter())
charsWritten += write(*first);
return charsWritten + write(forward<Ts>(args)...);
}
template <class Iterator, class I, class... Ts>
inline
typename enable_if<is_iterator<Iterator>::value && is_integral<I>::value,
int>::type
write(Iterator first, I count, Ts &&...args) {
return write(first, first + count, forward<Ts>(args)...);
}
template <class T>
inline auto write(const T &arg) -> decltype(arg.write(*this)) {
return arg.write(*this);
}
template <class T0, class T1, class... Ts>
inline typename enable_if<!is_iterator<T0>::value, int>::type write(
T0 &&arg0, T1 &&arg1, Ts &&...args) {
int charsWritten = write(forward<T0>(arg0));
return charsWritten + write(forward<T1>(arg1), forward<Ts>(args)...);
}
};
class OutputFile : public OutputDevice {
FILE *file;
bool owner;
void writeToDevice(uint count) override {
fwrite(buffer, 1, count, file);
fflush(file);
}
public:
OutputFile(FILE *file = stdout, bool takeOwnership = false)
: file(file), owner(takeOwnership) {}
OutputFile(const char *fileName) : OutputFile(fopen(fileName, "w"), true) {}
~OutputFile() override {
flush();
if (owner) fclose(file);
}
};
class OutputString : public OutputDevice {
string &str;
void writeToDevice(uint count) override { str.append(buffer, count); }
public:
OutputString(string &str) : OutputDevice(), str(str) {}
~OutputString() override { flush(); }
};
unique_ptr<InputDevice> input;
unique_ptr<OutputDevice> output;
template <class... Ts>
inline bool read(Ts &&...args) {
return input->read(forward<Ts>(args)...);
}
template <class... Ts>
inline int write(Ts &&...args) {
return output->write(forward<Ts>(args)...);
}
template <class... Ts>
inline int writeln(Ts &&...args) {
return write(forward<Ts>(args)..., '\n');
}
void flush() { output->flush(); }
template <typename T>
void dedup(vector<T> &s) {
sort((s).begin(), (s).end());
s.erase(unique((s).begin(), (s).end()), s.end());
}
template <typename T>
auto is_streamable(T *ptr) -> decltype(cout << *ptr, 0);
template <typename T>
char is_streamable(...);
struct debug {
~debug() {}
template <typename T>
typename enable_if<sizeof(is_streamable<T>(0)) != 1, debug &>::type
operator<<(const T &v) {
return cout << v, *this;
}
template <typename T>
typename enable_if<sizeof(is_streamable<T>(0)) == 1, debug &>::type
operator<<(const T &v) {
*this << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
*this << *it;
if (next(it) != v.end()) *this << ", ";
}
return *this << "]";
}
template <typename K, typename V>
debug &operator<<(const pair<K, V> &p) {
return *this << "(" << p.first << ", " << p.second << ")";
}
template <typename T, typename... Args>
void write(const T &head, const Args &...tail) {
*this << head << " ", write(tail...);
}
void write() { cout << endl; }
};
template <typename T>
auto has_size(T *ptr) -> decltype(ptr->size(), 0);
template <typename T>
char has_size(...);
template <typename T>
typename enable_if<sizeof(has_size<T>(0)) != 1, int>::type operator~(
const T &container) {
return (int)container.size();
}
int log2_floor(uint32_t n) { return 31 - __builtin_clz(n); }
int log2_ceil(uint32_t n) { return log2_floor(n) + !!(n & (n - 1)); }
class Rng {
mt19937 mtgen;
uniform_int_distribution<int> dist_;
public:
Rng(int min, int max, size_t seed = random_device()())
: mtgen(seed), dist_(min, max) {}
int operator()() { return dist_(mtgen); }
};
template <typename T>
void pmat_impl(const T &v) {
int h = v.size(), w = v[0].size(), z = 3;
for (int i = 0; i < h; ++i) {
w = max(w, (int)v[i].size());
}
cout << "\n" << setw(z) << "+";
for (int j = 0; j < w; ++j) cout << setw(z) << j << " \n"[j == (w - 1)];
for (int i = 0; i < h; ++i) {
cout << setw(z) << i;
for (int j = 0; j < v[i].size(); ++j)
cout << setw(z) << v[i][j] << " \n"[j == (v[i].size() - 1)];
}
cout << "\n";
}
template <typename... Args>
string fmt(const string &format, const Args &...args) {
size_t size = snprintf(nullptr, 0, format.c_str(), args...) + 1;
if (size <= 0) {
throw runtime_error("Error during formatting.");
}
unique_ptr<char[]> buf(new char[size]);
snprintf(buf.get(), size, format.c_str(), args...);
return string(buf.get(), buf.get() + size - 1);
}
void soln(int __ntc, int __tc) {
int n, q;
read(n, q);
int d0 = 0, d1 = 1;
for (int i = 0; i < q; ++i) {
int t;
read(t);
if (t == 1) {
int dx;
read(dx);
d0 = (d0 + dx + n) % n;
d1 = (d1 + dx + n) % n;
} else {
d0 += (d0 & 1) ? -1 : 1;
d1 += (d1 & 1) ? -1 : 1;
}
}
9;
;
vector<int> B(n);
for (int i = 0; i < n; i += 2) {
B[(i + d0) % n] = i + 1;
B[(i + d1) % n] = i + 2;
}
writeln(B.begin(), B.end());
}
int Solver() {
input.reset(new InputFile(stdin, false));
output.reset(new OutputFile());
soln(1, 1);
return 0;
}
signed main() { Solver(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
const double eps = 1e-14;
vector<pair<long long, int> > a(1005);
double ans[1005];
int x[1005], y[1005];
double p[1005];
bool valid(int i, int j) {
int x1 = x[a[i].second];
int y1 = y[a[i].second];
int x2 = x[a[j].second];
int y2 = y[a[j].second];
double dis = pow(x2 - x1, 2) + pow(y2 - y1, 2);
long long td = a[j].first - a[i].first;
if ((double)(pow(td, 2)) - dis > -1e-9) {
return true;
} else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
int q, w;
double u;
long long t;
cin >> q >> w >> t >> u;
x[i] = q;
y[i] = w;
p[i] = u;
a[i] = make_pair(t, i);
}
sort(a.begin(), a.begin() + n);
double fans = 0.000000000;
for (int i = n - 1; i >= 0; i--) {
ans[i] = p[a[i].second];
for (int j = i + 1; j < n; j++) {
if (valid(i, j)) ans[i] = max(ans[i], ans[j] + p[a[i].second]);
}
fans = max(fans, ans[i]);
}
cout << fixed << setprecision(10) << fans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
int win = 1;
for (int i = 0; i < n - 1; i++) {
if (arr[i] == 1) {
win *= (-1);
} else {
break;
}
}
if (win == 1)
cout << "First\n";
else
cout << "Second\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int& n) {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
n = x * f;
}
int outputarray[20];
inline void write(int k) {
int num = 0;
if (k < 0) putchar('-'), k = -k;
do {
outputarray[++num] = k % 10, k /= 10;
} while (k);
while (num) putchar(outputarray[num--] + '0');
puts("");
}
const int maxn = 2000005, mod = 51123987;
char s[maxn << 1];
int n, len = 0, p[maxn << 1], start[maxn], finish[maxn], a[maxn], b[maxn];
int main() {
read(n);
s[++len] = '#';
for (int i = 1; i <= n; i++) {
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
s[++len] = ch;
s[++len] = '#';
}
int mx = 0, id = 0;
for (int i = 1; s[i] != '\0'; i++) {
p[i] = mx > i ? min(p[2 * id - i], mx - i) : 1;
while (s[i + p[i]] == s[i - p[i]] && i + p[i] <= len) p[i]++;
if (i + p[i] > mx) mx = i + p[i], id = i;
}
for (int i = 1; i <= len; i++) {
int id = i / 2, q = p[i] / 2;
a[id - q + 1]++, a[id + 1]--;
}
for (int i = 1; i <= n; i++) start[i] = start[i - 1] + a[i];
for (int i = 1; i <= len; i++) {
int id = (i + 1) / 2, q = p[i] / 2;
b[id]++, b[id + q]--;
}
for (int i = 1; i <= n; i++) finish[i] = finish[i - 1] + b[i];
long long a = 0, b = 0, ans = 0, tmp = 0;
for (int i = 1; i <= n; i++) a += start[i];
b = a - 1;
if (a % 2 == 0)
a /= 2;
else
b /= 2;
ans = (a % mod) * (b % mod) % mod;
for (int i = 1; i <= n; i++) {
ans = (long long)(ans - (start[i] * tmp) % mod),
tmp = (long long)(tmp + finish[i]) % mod;
if (ans < 0) ans += mod;
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int T;
cin >> T;
while (T--) {
int n, k, ans = 0;
cin >> n;
vector<int> arr(n);
map<int, vector<int>> codes;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
codes[arr[i]].push_back(i);
}
int code = 0;
for (auto it : codes) {
for (auto ut : it.second) {
arr[ut] = code;
}
code++;
}
vector<int> last(code), first(code), dp2(code, 0), count(code, 0),
curcount(code, 0);
vector<vector<int>> indices(code, vector<int>());
for (int i = 0; i < n; ++i) {
last[arr[i]] = i;
count[arr[i]]++;
indices[arr[i]].push_back(i);
}
for (int i = n - 1; i >= 0; --i) first[arr[i]] = i;
dp2[0] = count[0];
for (int i = 1; i < code; ++i) {
if (last[i - 1] < first[i]) {
dp2[i] = count[i] + dp2[i - 1];
} else {
dp2[i] = count[i] +
lower_bound(indices[i - 1].begin(), indices[i - 1].end(),
first[i]) -
indices[i - 1].begin();
}
}
for (int i = n - 1; i >= 0; --i) {
if (i == last[arr[i]] && arr[i] < code - 1) {
dp2[arr[i]] += curcount[arr[i] + 1];
}
curcount[arr[i]]++;
}
for (int i = 0; i < code; ++i) ans = max(ans, dp2[i]);
for (int i = 0; i < n; ++i) {
ans = max(ans,
(int)((arr[i] > 0 ? (lower_bound(indices[arr[i] - 1].begin(),
indices[arr[i] - 1].end(), i) -
indices[arr[i] - 1].begin())
: 0) +
(indices[arr[i]].end() -
lower_bound(indices[arr[i]].begin(),
indices[arr[i]].end(), i))));
}
cout << n - ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool check(unordered_map<string, string>& m) {
bool flag = false;
for (auto x : m) {
if (m.find(x.second) != m.end()) {
string temp = m[x.second];
m.erase(m.find(x.second));
m[x.first] = temp;
flag = true;
}
}
return flag;
}
int main() {
int q;
cin >> q;
unordered_map<string, string> m;
for (int i = 0; i < q; i++) {
string s1, s2;
cin >> s1 >> s2;
m[s1] = s2;
}
while (1) {
if (!check(m)) break;
}
cout << m.size() << endl;
for (auto x : m) cout << x.first << " " << x.second << endl;
}
| 1 |
//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x64
#include <iostream>
using namespace std;
int main()
{
int n, k1, k2, w, b, t;
cin >> t;
for (int i = 0; i<t; ++i){
cin >> n >> k1 >> k2 >> w >>b;
if ((k1+k2)/2 >= w && (n-k1 + n-k2)/2 >=b ) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int i = 1;
int j = 1;
int k = 0;
vector<int> circle = {};
cin >> n;
if (n % 2 == 0) {
cout << "NO";
} else {
for (i == 1; i < (2 * n + 1); i++) {
if ((i % 4) == 0 or (i % 4) == 1) {
circle.push_back(i);
}
}
for (j == 1; j < (2 * n + 1); j++) {
if ((j % 4) == 2 or (j % 4) == 3) {
circle.push_back(j);
}
}
cout << "YES" << endl;
for (k == 0; k < 2 * n; k++) {
cout << circle[k] << " ";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int M = 100000000;
int main() {
int n, m;
int s, f, t;
scanf("%d %d", &n, &m);
int x = 2 * (m - 1);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &s, &f, &t);
if (s == f)
printf("%d\n", t);
else {
int ans = abs(f - s), a;
if (f > s)
a = s - 1;
else {
a = 2 * m - 1 - s;
}
if (t <= a) {
printf("%d\n", a + abs(f - s));
} else {
int tmp = (t - a) / x;
if ((t - a) % x != 0) tmp++;
ans += tmp * x + a;
printf("%d\n", ans);
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t, n, i, j, temp;
cin >> t;
while (t--) {
cin >> n;
set<long long> s;
for (i = 0; i < n; i++) {
cin >> temp;
if (temp % 2 == 0) {
s.insert(temp);
}
}
long long ans = 0;
while (s.size()) {
ans++;
long long largestElem = *(s.rbegin());
s.erase(largestElem);
if ((largestElem / 2) % 2 == 0) {
s.insert(largestElem / 2);
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define nl '\n'
#define nt ' '
typedef long long ll;
#define FIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(NULL);
int md = 1e9 ;
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(){
FIO;
int t; cin >> t;
while(t--){
int n; cin >> n ;
int f= 0 ;
int k = 2*n ;
multiset< int > s;
vector< int > df(k); for( auto &i : df ) cin >> i, s.insert( i ) ;
sort( df.begin() ,df.end() ) ;
int a = df[k-1];
vector< pair< int , int > > ans ;
for( int p = 0 ; p<k-1; ++p ){
multiset<int> ms = s ;
vector< pair< int ,int > > vans ;
int tf = 1;
int mx =a;
int x = df[p] ;
vans.push_back( {mx ,x} );
ms.erase( ms.find(mx) ); ms.erase( ms.find(x) );
// cout << x << nt << a << endl ;
for( int i =k-2; i>=0 ;--i ){
if( ms.find( df[i] )!=ms.end() and ms.find( mx - df[i] ) != ms.end() ){
int a = df[i] , b = mx - df[i] ;
ms.erase( ms.find(a) ) ;
if( ms.find( b ) == ms.end() ){ ms.insert( a ); continue; }
else{ ms.insert( a ); }
// cout << 'i'<< nt << df[i] << nt << mx - df[i] << endl ;
vans.push_back( { df[i], mx - df[i] } ) ;
ms.erase( ms.find(df[i]) ) ; ms.erase( ms.find( mx- df[i] ) );
mx = max( df[i], mx-df[i] ) ;
}
}
// cout << 'f' << vans.size() << endl ;
if( vans.size() == n ){ f=1;ans =vans; break; }
}
if(f){ cout << "YES"<<nl; cout<< ans[0].first+ans[0].second<<nl; for( auto i : ans )cout << i.first <<nt << i.second << nl ; }
else cout << "NO" << nl ;
}
// vector<int> vec = SieveOfEratosthenes( 100000 ) ;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const int N = 100000;
pair<long long, int> dp[19][10][10];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
if (n == 0) {
cout << "0" << '\n';
return 0;
}
if (n < 10) {
cout << "1\n";
return 0;
}
for (int i = 0; i < 10; i++) {
for (int a = 0; a < 10; a++) {
if (i > a) {
dp[0][i][a].first = 1;
dp[0][i][a].second = 10 + a - i;
} else {
dp[0][i][a].first = 2;
dp[0][i][a].second = 10 - i;
}
}
}
for (int d = 1; d < 19; d++) {
for (int g = 0; g < 10; g++) {
for (int i = 0; i < 10; i++) {
long long sum = 0;
int curr = i;
for (int j = 9; j >= g; j--) {
sum += dp[d - 1][j][curr].first;
curr = dp[d - 1][j][curr].second;
}
for (int j = g - 1; j >= 0; j--) {
sum += dp[d - 1][g][curr].first;
curr = dp[d - 1][g][curr].second;
}
dp[d][g][i].first = sum;
dp[d][g][i].second = curr;
}
}
}
long long powers[18];
powers[0] = 1;
for (int i = 1; i < 18; i++) {
powers[i] = powers[i - 1] * 10;
}
if (n == powers[17] * 10) {
cout << dp[17][0][9].first << "\n";
return 0;
}
int arr[19];
long long temp = n;
int cnt = 0;
while (temp > 0) {
arr[cnt] = temp % 10;
temp /= 10;
cnt++;
}
int mxs[20];
mxs[cnt - 1] = arr[cnt - 1];
for (int i = cnt - 2; i >= 0; i--) {
mxs[i] = max(mxs[i + 1], arr[i]);
}
mxs[cnt] = 0;
int curr = arr[0];
long long sum = 0;
sum += dp[0][mxs[1]][curr].first;
curr = dp[0][mxs[1]][curr].second;
for (int i = 1; i < cnt; i++) {
int j = arr[i] - 1;
while (j >= 0) {
sum += dp[i - 1][max(mxs[i + 1], j)][curr].first;
curr = dp[i - 1][max(mxs[i + 1], j)][curr].second;
j--;
}
}
cout << sum - 1 << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int a[26];
int main() {
int i, n;
a[0] = a[4] = a[8] = a[14] = a[20] = 1;
cin >> s >> t;
if (s.length() != t.length()) {
cout << "No";
return 0;
} else {
for (i = 0; i < s.length(); i++)
if ((a[s[i] - 'a']) != (a[t[i] - 'a'])) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int A[n];
map<int, int> mp;
map<int, int>::iterator itr;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) {
int y = 0;
while (A[i] % 2 == 0) {
A[i] /= 2;
y++;
}
if (mp.count(A[i]))
mp[A[i]] = max(mp[A[i]], y);
else
mp.insert(make_pair(A[i], y));
}
int u = 0;
for (itr = mp.begin(); itr != mp.end(); itr++) u += itr->second;
cout << u << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> findsum0;
int main() {
int n, val, ans = 0;
long long sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &val);
sum += val;
ans = max(ans, ++findsum0[sum]);
}
printf("%d", n - ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> fol, num;
int ans1, ans2;
int main() {
string s;
while (cin >> s) {
int sz = 0;
while (1) {
int pos;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '\\') {
pos = i;
break;
}
}
if (pos == 2) break;
s = s.substr(0, pos);
int nums = num[s];
fol[s] += sz;
num[s]++;
if (nums == 0) sz++;
ans1 = max(ans1, fol[s]);
ans2 = max(ans2, num[s]);
}
}
cout << ans1 << ' ' << ans2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
long long a[100000];
long long S;
long long n;
bool g() {
std::unordered_set<long long> set;
set.reserve(2 * n);
long long s = (S << 1);
for (int i = 0; i < n; ++i) {
set.insert(a[i]);
s -= a[i];
if (s == S || set.count(S - s)) return true;
}
return false;
}
bool f() {
std::cin >> n;
for (long long i = 0; i < n; ++i) {
std::cin >> a[i];
S += a[i];
}
if (S & 1) return false;
S >>= 1;
if (g()) return true;
std::reverse(a, a + n);
return g();
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout << (f() ? "YES" : "NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010;
const long long mod = 1e9 + 7;
const long long nax = 500006;
const long long kmax = 106;
const long long dmax = 506;
const long long inf = 2e18;
long long x, y;
long long add(long long a, long long b) {
a += b;
a %= mod;
return a;
}
long long sub(long long a, long long b) {
a -= b;
a %= mod;
a += mod;
a %= mod;
return a;
}
long long mul(long long a, long long b) {
a *= b;
a %= mod;
return a;
}
long long pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = mul(ans, a);
}
a = mul(a, a);
b /= 2;
}
return ans;
}
map<long long, long long> memo;
long long dp(long long x) {
if (memo[x] != 0) {
return memo[x];
}
long long ans = pow(2LL, x - 1);
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
ans = sub(ans, dp(x / i));
if (i * i != x) {
ans = sub(ans, dp(i));
}
}
}
ans = sub(ans, 1LL);
memo[x] = ans;
return memo[x];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
memo[1] = 1;
cin >> x >> y;
if (y % x) {
cout << "0\n";
return 0;
}
cout << dp(y / x) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> done;
map<int, pair<int, int> > pi;
int n, q;
int main() {
scanf("%d%d", &n, &q);
pi[n + 1] = pair<int, int>(0, 0);
int x, y;
char dir;
while (q--) {
scanf("%d %d %c", &x, &y, &dir);
if (done.count(x)) {
printf("0\n");
continue;
}
done.insert(x);
pair<int, int> &old = pi.upper_bound(x)->second;
if (dir == 'U') {
printf("%d\n", y - old.first);
pi[x] = pair<int, int>(old.first, old.second);
old.second = x;
} else {
printf("%d\n", x - old.second);
pi[x] = pair<int, int>(y, old.second);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[1000], c;
int b[1000], f[1000], len;
len = 0;
a[0] = ';';
b[1] = 0;
cin >> c;
while (c == '<') {
len++;
cin >> c;
if (c != '/') {
a[len] = c;
b[len + 1] = 1;
f[len] = 0;
} else {
f[len] = 1;
cin >> c;
a[len] = c;
b[len]--;
b[len + 1] = 0;
}
cin >> c;
cin >> c;
}
int i, j, h;
h = 0;
for (i = 1; i <= len; i++) {
h += b[i];
for (j = 1; j <= h; j++) cout << " ";
cout << '<';
if (f[i]) cout << "/";
cout << a[i] << ">\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, m, l = 0, s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0, j, k;
cin >> n;
long long int x1 = INT_MAX, x, y;
long long int y1 = INT_MAX;
long long int x2 = INT_MIN;
long long int y2 = INT_MIN;
for (i = 0; i < n; i++) {
cin >> x >> y;
x1 = min(x, x1);
x2 = max(x, x2);
y1 = min(y, y1);
y2 = max(y, y2);
}
x1 = x2 - x1;
y1 = y2 - y1;
cout << (unsigned long long)pow(max(x1, y1), 2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a = 1, b = 1, x, y, pcnt = 0;
long long extended_gcd(long long a, long long b) {
if (!b) {
x = 1, y = 0;
return a;
}
long long ret = extended_gcd(b, a % b), tmp = x;
x = y, y = tmp - (a / b) * y;
return ret;
}
unsigned long long k, n, v[2002], c[2002], s[2002];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) cin >> v[i];
if (k) {
k--;
c[0] = 1;
for (int i = 1; i < n; ++i) {
a *= k + i, b *= i;
while (a % 1000000007 == 0) a /= 1000000007, pcnt++;
while (b % 1000000007 == 0) b /= 1000000007, pcnt--;
b %= 1000000007, a %= 1000000007;
if (pcnt)
c[i] = 0;
else {
extended_gcd(b, 1000000007);
if (x < 0) x += 1000000007;
x *= a, x %= 1000000007;
c[i] = x;
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < i + 1; ++j)
s[i] = (s[i] + v[i - j] * c[j]) % 1000000007;
for (int i = 0; i < n; ++i) cout << s[i] << " ";
} else
for (int i = 0; i < n; ++i) cout << v[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, n;
cin >> T;
double R1, R2, R3;
while (T--) {
scanf("%lf%lf%d", &R1, &R2, &n);
R3 = R1 - R2;
double k1 = -1 / R1;
double k2 = 1 / R2;
double k3 = 1 / R3;
double k4 = k1 + k2 + k3;
double ans;
for (int i = 1; i <= n; i++) {
double R4 = 1 / k4;
ans = R4;
double k5 = 2 * (k1 + k2 + k4) - k3;
k3 = k4;
k4 = k5;
}
printf("%0.10lf\n", fabs(ans));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int Sz = 1e5 + 5;
int a[Sz];
bool check(int p, int v, int n) { return (p > 0 && p <= n && a[p] >= v); }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int Test = 1;
cin >> Test;
while (Test--) {
int n, k;
cin >> n >> k;
vector<int> p;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == k) p.push_back(i);
}
bool res = (!p.empty() && n == 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 2; j++)
for (int sig = -1; sig <= 1; sig += 2)
if (check(i, k, n) && check(i + j * sig, k, n)) res = true;
if (res && !p.empty())
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, z;
cin >> x >> y >> z;
if (x - y - z > 0)
cout << "+";
else if (y - x - z > 0)
cout << "-";
else if (x == y && z == 0)
cout << "0";
else
cout << "?";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
inline _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
inline void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
inline void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
inline void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
inline int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar++ = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*tar++ = ch, ch = getchar();
return *tar = 0, tar - s;
}
const int N = 10005;
long long dp[6][N];
long long dfs(int x, int L) {
if (~dp[x][L]) return dp[x][L];
long long ans = 0;
for (int i = 0; i <= L; ++i) {
long long tmp = ans + (i != L) + dfs(x - 1, min(10000LL, ans + L));
ans = tmp;
}
return dp[x][L] = ans;
}
int main() {
memset(dp, 255, sizeof(dp));
memset(dp[0], 0, sizeof(dp[0]));
std::iota(dp[1], dp[1] + N, 0);
dfs(5, 1);
long long L = 1;
for (int i = 5; i >= 1; --i) {
std::vector<long long> v;
long long cur = L;
int limit = min(L, 10000LL);
for (int j = 0; j <= limit; ++j) {
long long tmp = cur + dp[i - 1][min(10000LL, cur)];
cur = tmp;
if (j < limit) v.push_back(cur++);
}
printf("%d ", ((int)v.size()));
for (auto it : v) printf("%lld ", it);
printf("\n"), fflush(stdout);
int x;
read(x);
if (x == -1) return 0;
if (x) L = v[x - 1] + 1;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using std::map;
const int N = 300054;
int n;
int a[N], b[N];
int Ab[N], Bb[N], Cb[N];
map<long long, int> Am, Bm, Cm;
map<int, int> f[N];
inline void up(int &x, const int y) { x < y ? x = y : 0; }
inline int min(const int x, const int y) { return x < y ? x : y; }
int dfs(int A, int B) {
map<int, int>::iterator it;
bool _;
std::tie(it, _) = f[A].emplace(B, 0);
if (!_) return it->second;
int &ret = it->second, C = min(A, B);
ret = 0;
if (Ab[A] < Bb[B])
up(ret, dfs(A, Bb[B]) + 1);
else if (~Ab[A])
up(ret, dfs(Ab[A], B) + 1);
if (~Cb[C]) up(ret, dfs(Cb[C], Cb[C]) + 1);
return ret;
}
int main() {
int i;
long long A = 0, B = 0, C = 0;
bool ret;
map<long long, int>::iterator it;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = 1; i <= n; ++i) scanf("%d", b + i);
for (i = 0; i <= n; ++i)
std::tie(it, ret) = Am.emplace(A += a[i], i),
ret ? Ab[i] = -1 : (Ab[i] = it->second, it->second = i),
std::tie(it, ret) = Bm.emplace(B += b[i], i),
ret ? Bb[i] = -1 : (Bb[i] = it->second, it->second = i),
std::tie(it, ret) = Cm.emplace(C += a[i] + b[i], i),
ret ? Cb[i] = -1 : (Cb[i] = it->second, it->second = i);
for (i = 1; i <= n; ++i)
up(Ab[i], Ab[i - 1]), up(Bb[i], Bb[i - 1]), up(Cb[i], Cb[i - 1]);
printf("%d\n", dfs(n, n));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int x, y, z, x1, y2, z1;
int main() {
cin >> x >> y >> z;
cin >> x1 >> y2 >> z1;
for (int i = 1; i <= 6; i++) cin >> a[i];
int ans = 0;
if (y < 0) ans += a[1];
if (y > y2) ans += a[2];
if (z < 0) ans += a[3];
if (z > z1) ans += a[4];
if (x < 0) ans += a[5];
if (x > x1) ans += a[6];
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int pos[maxn * 4], frm[maxn * 4], too[maxn * 4], com[maxn * 4];
bool mark[maxn * 4], fnd[maxn * 4];
int ord[maxn], ans[maxn], siz[maxn];
int n, k, cur, cent;
int comsz;
vector<int> adj[maxn], tadj[maxn];
set<int> ver[maxn];
bool cmp(int i, int j) {
i = (frm[i] ^ too[i] ^ cur) - cur;
j = (frm[j] ^ too[j] ^ cur) - cur;
if (i < 0) i += n;
if (j < 0) j += n;
return i < j;
}
bool ordcmp(int i, int j) {
auto it1 = ver[i].end(), it2 = ver[j].end();
while (it1 != ver[i].begin() and it2 != ver[j].begin()) {
it1--, it2--;
if (*it1 < *it2)
return true;
else if (*it1 > *it2)
return false;
}
if (it2 == ver[j].begin()) return false;
return true;
}
void dfs(int e) {
if (mark[e]) return;
mark[e] = true;
int eid = e >> 1;
int v = (e & 1 ? frm[eid] : too[eid]);
int u = frm[eid] ^ too[eid] ^ v;
ver[comsz].insert(u);
ver[comsz].insert(v);
com[e] = comsz;
int ne = adj[v][pos[e] - 1] << 1;
if (v == too[ne / 2]) ne |= 1;
return dfs(ne);
}
void tdfs(int u, int p, int sz) {
siz[u] = 1;
for (auto v : tadj[u])
if ((v ^ p) and !fnd[v]) {
tdfs(v, u, sz);
siz[u] += siz[v];
}
if ((cent >> 31) and siz[u] >= (sz + 1) / 2) cent = u;
}
void go(int u, int sz = comsz, int c = 1) {
cent = -1;
tdfs(u, -1, sz);
u = cent;
fnd[u] = true;
ans[u] = c++;
for (auto v : tadj[u])
if (!fnd[v]) {
if (siz[v] > siz[u])
go(v, sz - siz[u], c);
else
go(v, siz[v], c);
}
}
int main() {
scanf("%d%d", &n, &k);
if (k == 0) {
printf("1");
return 0;
}
for (int i = 0; i < k; ++i) {
int fi, se;
cin >> fi >> se;
--fi, --se;
adj[fi].push_back(i);
adj[se].push_back(i);
frm[i] = fi, too[i] = se;
}
memset(pos, -1, sizeof pos);
for (int i = 0; i < n; i++) {
frm[i + k] = i;
too[i + k] = (i + 1) % n;
adj[i].push_back(i + k);
adj[(i + 1) % n].push_back(i + k);
}
for (int i = 0; i < n; i++) {
cur = i;
sort(adj[i].begin(), adj[i].end(), cmp);
for (int j = ((int)(adj[i]).size()) - 1; j >= 0; --j) {
if (i == frm[adj[i][j]])
pos[adj[i][j] << 1 | 1] = j;
else
pos[adj[i][j] << 1 | 0] = j;
}
}
for (int i = 0; i < k + k; i++)
if (!mark[i]) {
dfs(i);
comsz++;
}
for (int i = 0; i < k + k; i += 2) {
int u = com[i | 0];
int v = com[i | 1];
tadj[u].push_back(v);
tadj[v].push_back(u);
}
go(0);
iota(ord, ord + comsz, 0);
sort(ord, ord + comsz, ordcmp);
for (int i = 0; i < comsz; i++) cout << ans[ord[i]] << ' ';
cout << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) { return n | (1LL << i); }
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx4[] = {0, 0, +1, -1};
int dy4[] = {+1, -1, 0, 0};
int dx8[] = {+1, 0, -1, 0, +1, +1, -1, -1};
int dy8[] = {0, +1, 0, -1, +1, -1, +1, -1};
inline bool collinear(int x1, int y1, int x2, int y2, int x3, int y3) {
return (y1 - y2) * (x1 - x3) == (y1 - y3) * (x1 - x2);
}
inline double coDist(double x1, double y1, double x2, double y2) {
return sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
}
inline double TriangleAreaWithSide(double a, double b, double c) {
double s = (a + b + c) / 2;
double area = sqrt(s * (s - a) * (s - b) * (s - c));
return area;
}
inline double area3(double x1, double y1, double x2, double y2, double x3,
double y3) {
double A = abs((x1 * y2 + x2 * y3 + x3 * y1) - (y1 * x2 + y2 * x3 + y3 * x1));
A /= 2.0;
return A;
}
inline long double degreetoradian(long double x) {
long double val = PI * x;
val /= (180.0);
return val;
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
template <typename T>
inline T gcd(T a, T b) {
T c;
while (b) {
c = b;
b = a % b;
a = c;
}
return a;
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
inline bool equalTo(double a, double b) {
if (fabs(a - b) <= eps)
return true;
else
return false;
}
inline bool notEqual(double a, double b) {
if (fabs(a - b) > eps)
return true;
else
return false;
}
inline bool lessThan(double a, double b) {
if (a + eps < b)
return true;
else
return false;
}
inline bool lessThanEqual(double a, double b) {
if (a < b + eps)
return true;
else
return false;
}
inline bool greaterThan(double a, double b) {
if (a > b + eps)
return true;
else
return false;
}
inline bool greaterThanEqual(double a, double b) {
if (a + eps > b)
return true;
else
return false;
}
inline string to_s(int t) {
stringstream ss;
ss << t;
return ss.str();
}
struct edge {
int p, q, w;
};
bool cmp(edge &a, edge &b) { return a.w < b.w; }
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
clock_t tStart = clock();
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int mx = 1e6 + 5;
vector<int> a, b, c, samne, pichone;
int cnt[mx], tot[mx], p[mx], tr[mx * 3];
void update(int idx, int x, int n) {
while (idx <= n) {
tr[idx] += x;
idx += idx & (-idx);
}
}
int query(int idx) {
int sum = 0;
while (idx > 0) {
sum += tr[idx];
idx -= idx & (-idx);
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.emplace_back(x);
}
b = a;
sort((b).begin(), (b).end());
b.erase(unique(b.begin(), b.end()), b.end());
c = a;
a.clear();
for (int i = 0; i < n; i++) {
a.emplace_back(lower_bound((b).begin(), (b).end(), c[i]) - b.begin());
}
for (int i = n - 1; i >= 0; i--) {
cnt[a[i]]++;
update(cnt[a[i]], 1, n);
p[i] = cnt[a[i]];
}
long long ans = 0;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) {
update(p[i], -1, n);
cnt[a[i]]++;
ans += query(cnt[a[i]] - 1);
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << 2000 << "\n";
int x = 1000;
for (int i = 1; i <= x; i++) {
cout << i << " " << 1 << " " << i << " " << 2 << "\n";
}
for (int i = x; i >= 1; i--) {
cout << i << " " << 1 << " " << i << " " << 2 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Xor = 0;
struct fenwick {
int size;
vector<long long> p;
void build(int size_) {
size = size_;
p.resize(size);
}
fenwick() {}
fenwick(int size) { build(size); }
long long get(int l) {
long long r = 0;
for (int i = l; i >= 0; i = (i & (i + 1)) - 1) r += p[i];
return r;
}
long long get(int l, int r) { return get(r) - get(l - 1); }
void upd(int ind, long long val) {
for (int i = ind; i < size; i |= i + 1) p[i] += val;
}
void set_elem(int ind, int val) { upd(ind, val - get(ind, ind)); }
};
fenwick fen;
long long get(int l, int r, int x, int y) {
if (l >= x && r <= y) {
int L = (l ^ (Xor & (~(r - l))));
int R = (r ^ (Xor & (~(r - l))));
long long vl = fen.get(L, R);
return vl;
}
if (l > y || r < x) return 0;
int md = r + l >> 1;
return get(l, md, x, y) + get(md + 1, r, x, y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
fen.build(1 << n);
for (int i = 0; i < (1 << n); ++i) {
int a;
cin >> a;
fen.upd(i, a);
}
for (int i = 0; i < q; ++i) {
int t, x, k, l, r;
cin >> t;
if (t == 1) {
cin >> x >> k;
x = ((x - 1) ^ Xor);
fen.set_elem(x, k);
}
if (t == 2) {
cin >> x;
Xor ^= (1 << x) - 1;
}
if (t == 3) {
cin >> x;
Xor ^= (1 << x);
}
if (t == 4) {
cin >> l >> r;
l--, r--;
cout << get(0, (1 << n) - 1, l, r) << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
const int N = 503000;
int n, a[N];
long long l[N], r[N], sum[N], Even[N];
int main() {
read(n);
for (int i = 1; i <= n - 1; i++) read(a[i]);
for (int i = 2; i <= n; i++)
if (a[i - 1] > 1) l[i] = l[i - 1] + a[i - 1] - (a[i - 1] & 1);
for (int i = n - 1; i >= 1; i--)
if (a[i] > 1) r[i] = r[i + 1] + a[i] - (a[i] & 1);
for (int i = 1; i <= n - 1; i++) {
sum[i] = sum[i - 1] + a[i];
Even[i] = Even[i - 1] + (!(a[i] & 1));
}
long long mx = 0, ans = 0;
for (int i = 1; i <= n; i++) {
mx = max(mx, l[i] - sum[i - 1] + Even[i - 1]);
ans = max(ans, r[i] + sum[i - 1] - Even[i - 1] + mx);
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 5;
int n;
int a[MAX_N];
int q;
pair<int, int> op1[MAX_N];
vector<pair<int, int> > op2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int op, p, x;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &p, &x);
op1[p] = {i, x};
} else if (op == 2) {
scanf("%d", &x);
while (!op2.empty() && op2.back().second <= x) op2.pop_back();
op2.emplace_back(i, x);
}
}
for (int i = 1; i <= n; i++) {
if (op1[i].first == 0) {
if (!op2.empty()) a[i] = max(a[i], op2[0].second);
} else {
auto nxt = lower_bound(op2.begin(), op2.end(), op1[i]);
if (nxt != op2.end())
a[i] = max(op1[i].second, (*nxt).second);
else
a[i] = op1[i].second;
}
}
for (int i = 1; i <= n; i++) printf("%d%c", a[i], " \n"[i == n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
void ML(const bool v) {
if (v) return;
int *ass;
for (;;) {
ass = new int[2500000];
for (int i = 0; i < 2500000; i++) ass[i] = rand();
}
}
void TL(const bool v) {
if (v) return;
int *ass;
ass = new int[250];
for (;;) {
for (int i = 0; i < 250; i++) ass[i] = rand();
}
}
void PE(const bool v) {
if (v) return;
puts("ass 1 2 3 4 5 6 fuck");
exit(0);
}
int n;
char c[3][10400];
void LoAd() {
scanf("%d\n", &n);
for (int i = 0; i < 3; i++) gets(c[i]);
}
const int MOD = 1000000007;
int sv[10022][8][2];
bool can(const int i, const int j, const int mask) {
return '.' == c[i][j] && !(((mask) & (1 << (i))) == 0 ? false : true);
}
int cok(const int pos, const int ok, const int mask) {
if (1 == ok) return 1;
for (int i = 0; i < 3; i++) {
if (!(((mask) & (1 << (i))) == 0 ? false : true)) continue;
if ('O' == c[i][pos - 1] || 'O' == c[i][pos + 2]) return 1;
}
return 0;
}
int rec(const int pos, const int mask, const int ok) {
if (pos == n) {
if (ok && 0 == mask)
return 1;
else
return 0;
}
for (int i = 0; i < 3; i++)
if ((((mask) & (1 << (i))) == 0 ? false : true) && c[i][pos] != '.')
return 0;
int &res = sv[pos][mask][ok];
if (-1 != res) return res;
res = 0;
if (can(0, pos, mask) && can(1, pos, mask) && can(2, pos, mask)) {
res = (res + rec(pos + 1, 7, cok(pos, ok, 7))) % MOD;
res = (res + rec(pos + 1, 1, cok(pos, ok, 1))) % MOD;
res = (res + rec(pos + 1, 4, cok(pos, ok, 4))) % MOD;
}
if (can(0, pos, mask) && !can(1, pos, mask) && !can(2, pos, mask)) {
res = (res + rec(pos + 1, 1, cok(pos, ok, 1))) % MOD;
}
if (!can(0, pos, mask) && can(1, pos, mask) && !can(2, pos, mask)) {
res = (res + rec(pos + 1, 2, cok(pos, ok, 2))) % MOD;
}
if (!can(0, pos, mask) && !can(1, pos, mask) && can(2, pos, mask)) {
res = (res + rec(pos + 1, 4, cok(pos, ok, 4))) % MOD;
}
if (!can(0, pos, mask) && can(1, pos, mask) && can(2, pos, mask)) {
res = (res + rec(pos + 1, 0, max(ok, 'O' == c[0][pos] ? 1 : 0))) % MOD;
res = (res + rec(pos + 1, 6, cok(pos, ok, 6))) % MOD;
}
if (can(0, pos, mask) && !can(1, pos, mask) && can(2, pos, mask)) {
res = (res + rec(pos + 1, 5, cok(pos, ok, 5))) % MOD;
}
if (can(0, pos, mask) && can(1, pos, mask) && !can(2, pos, mask)) {
res = (res + rec(pos + 1, 0, max(ok, 'O' == c[2][pos] ? 1 : 0))) % MOD;
res = (res + rec(pos + 1, 3, cok(pos, ok, 3))) % MOD;
}
if (!can(0, pos, mask) && !can(1, pos, mask) && !can(2, pos, mask)) {
res = (res + rec(pos + 1, 0, cok(pos, ok, 0))) % MOD;
}
return res;
}
void SoLvE() {
memset(sv, -1, sizeof(sv));
int res = rec(0, 0, 0);
cout << res % MOD;
}
int main() {
srand((int)time(NULL));
LoAd();
SoLvE();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t;
vector<pair<double, int> > v;
cin >> n >> t;
int a;
double x, y;
for (int i = 0; i < n; ++i) {
cin >> x >> y >> a;
v.push_back({sqrt((x * x) + (y * y)), a});
}
int h = 0;
sort(v.begin(), v.end());
for (; h < n; ++h) {
t += v[h].second;
if (t >= 1000000) {
cout << fixed << setprecision(7) << v[h].first << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
class compare {
public:
bool operator()(pair<T, T> &x, pair<T, T> &y) {
if (x.first == y.first) {
return x.second > y.second;
}
return x.first > y.first;
}
};
template <class T>
ostream &operator<<(ostream &os, const pair<T, T> &a) {
os << a.first << " " << a.second;
}
template <class T>
void print(vector<T> &vec) {
for (int i = 1; i < (int)vec.size(); i++) cout << vec[i] << " ";
cout << endl;
}
template <class T>
void print(set<T> &s) {
for (auto it : s) cout << it << " ";
cout << endl;
}
template <class T>
void print(list<T> &lst) {
for (auto it : lst) cout << it << " ";
cout << endl;
}
template <class T>
long long power(T a, int b) {
long long po = 1;
while (b--) po *= a;
return po;
}
template <class T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first + b.first, a.second + b.second};
}
template <class T>
pair<T, T> operator-(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first - b.first, a.second - b.second};
}
template <class T>
pair<T, T> operator*(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first * b.first, a.second * b.second};
}
template <class T>
pair<T, T> operator%(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first % b.first, a.second % b.second};
}
template <class T, class U>
pair<T, T> operator+(const pair<T, T> &a, const U &b) {
return {a.first + b, a.second + b};
}
template <class T, class U>
pair<T, T> operator*(const pair<T, T> &a, const U &b) {
return {a.first * b, a.second * b};
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> divs;
divs.push_back(1);
for (int i = 2; i <= sqrt(n) + 1; i++) {
int ii = n / i;
if (i * ii == n and i <= ii) {
if (i == ii)
divs.push_back(i);
else
divs.push_back(i), divs.push_back(ii);
}
}
vector<pair<int, int> > vec;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
u %= n, v %= n;
vec.push_back(make_pair(min(u, v), max(v, u)));
}
sort(vec.begin(), vec.end());
vector<pair<int, int> > vec1(m);
for (int div : divs) {
for (int i = 0; i < m; i++) {
int u = (vec[i].first + div) % n;
int v = (vec[i].second + div) % n;
vec1[i] = make_pair(min(u, v), max(u, v));
}
sort(vec1.begin(), vec1.end());
if (vec1 == vec) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int inp[100002];
int main() {
int n, i, a = 0, b = 0, c = 0;
bool res = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", inp + i);
}
for (i = 0; i < n; i++) {
if (inp[i] == 25) {
a++;
} else if (inp[i] == 50) {
if (a == 0) {
res = 0;
break;
} else {
a--;
b++;
}
} else if (inp[i] == 100) {
if (a >= 1 && b >= 1) {
c++;
a--;
b--;
} else if (a >= 3) {
a -= 3;
} else {
res = 0;
break;
}
}
}
(res == 1) ? printf("YES") : printf("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
int n, m;
string A, B;
string a, b;
vvi dp;
vvi from;
int f(int i, int j) {
if (i >= n or j >= m) return 0;
int& ans = dp[i][j];
if (ans != -1) return ans;
ans = 0;
if (a[i] == b[j]) ans = max(ans, max(4, f(i + 1, j + 1) + 2));
ans = max(ans, f(i + 1, j) - 1);
ans = max(ans, f(i, j + 1) - 1);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
cin >> A >> B;
n = A.size();
m = B.size();
a = A;
b = B;
dp = vvi(n, vi(m, -1));
from = vvi(n, vi(m, -1));
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
ans = max(ans, f(i, j) - 2);
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename elemType>
inline void Read(elemType &T) {
elemType X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
T = (w ? -X : X);
}
long long dp[200010][3][2][2];
long long a[200010];
int N;
inline int mo(int x) { return (x % 3 + 3) % 3; }
int main() {
Read(N);
memset(dp, 0xfe, sizeof(dp));
for (int i = 1; i <= N; ++i) Read(a[i]);
if (N == 1) {
printf("%I64d\n", a[1]);
return 0;
}
dp[1][1][0][0] = -a[1];
dp[1][0][1][0] = a[1];
for (int i = 2; i <= N; ++i) {
for (int j = 0; j <= 2; ++j) {
dp[i][j][0][0] = max(dp[i][j][0][0], dp[i - 1][mo(j - 1)][1][0] - a[i]);
dp[i][j][1][0] = max(dp[i][j][1][0], dp[i - 1][j][0][0] + a[i]);
dp[i][j][0][1] = max(dp[i][j][0][1], dp[i - 1][mo(j - 1)][0][0] - a[i]);
dp[i][j][0][1] = max(dp[i][j][0][1], dp[i - 1][mo(j - 1)][0][1] - a[i]);
dp[i][j][0][1] = max(dp[i][j][0][1], dp[i - 1][mo(j - 1)][1][1] - a[i]);
dp[i][j][1][1] = max(dp[i][j][1][1], dp[i - 1][j][1][0] + a[i]);
dp[i][j][1][1] = max(dp[i][j][1][1], dp[i - 1][j][0][1] + a[i]);
dp[i][j][1][1] = max(dp[i][j][1][1], dp[i - 1][j][1][1] + a[i]);
}
}
int M = ((1 - N) % 3 + 3) % 3;
printf("%I64d\n", max(dp[N][M][0][1], dp[N][M][1][1]));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
void solve() {
int a, f = 0;
cin >> a;
while (a > 0) {
int t = 2;
if (a == 1) f += 0;
if (a == 2) f += 1;
if (a > 2) {
for (int i = 1;; i++) {
if (a - t < 3 * i + 2) {
f += 1;
break;
}
t = t + 3 * i + 2;
}
}
a = a - t;
}
cout << f << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Data {
int Value, Number;
};
bool operator<(Data A, Data B) { return A.Value < B.Value; }
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = 0;
while (c >= '0' && c <= '9') {
X = X * 10 + c - 48;
c = getchar();
}
return X;
}
void Output(int X) {
int Len = 0, Data[10];
while (X) {
Data[Len++] = X % 10;
X /= 10;
}
if (!Len) Data[Len++] = 0;
while (Len--) putchar(Data[Len] + 48);
}
int main() {
int N = Get();
static Data A[100000];
for (int i = 0; i < N; i++) {
A[i].Value = Get();
A[i].Number = i;
}
sort(A, A + N);
static int X[100000], Y[100000];
memset(X, 0, sizeof(X));
memset(Y, 0, sizeof(Y));
int K = (N - 1) / 3 + 1, T = N - K * 2;
for (int i = 0; i < K; i++) {
X[A[i].Number] = A[i].Value;
Y[A[i + K].Number] = A[i + K].Value;
}
for (int i = K * 2; i < N; i++) {
X[A[i].Number] = A[i].Value - N + i;
Y[A[i].Number] = N - i;
}
printf("YES\n");
for (int i = 0; i < N; i++) {
Output(X[i]);
putchar((i + 1 == N) ? '\n' : ' ');
}
for (int i = 0; i < N; i++) {
Output(Y[i]);
putchar((i + 1 == N) ? '\n' : ' ');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 505;
vector<int> g[mx];
int d[mx];
void bfs(int from, int to) {
queue<int> q;
q.push(from);
memset(d, -1, sizeof(d));
d[from] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (d[u] == -1) {
q.push(u);
d[u] = d[v] + 1;
}
}
}
}
int bus, train;
bool bb[mx][mx];
int main() {
int n;
int t;
scanf("%d%d", &n, &t);
for (int i = 0, a, b; i < t; i++) {
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
bb[a][b] = bb[b][a] = true;
}
bfs(1, n);
bus = d[n];
for (int i = 0; i < n; i++) g[i].clear();
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (!bb[i][j]) {
g[i].push_back(j);
g[j].push_back(i);
}
}
}
bfs(1, n);
train = d[n];
int ans = max(bus, train);
if (bus == -1 || train == -1) ans = -1;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 24;
const int mod = 1000000007;
int dis[1 << maxn], f[1 << maxn];
void solve(int x) {
for (int k = x, j; k; k ^= j) {
j = k & -k;
if ((f[x] += f[x ^ j]) >= mod) f[x] -= mod;
}
}
int main() {
int n, m;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &dis[1 << i]);
scanf("%d", &m);
int x, y;
if (m > 0) scanf("%d", &x);
if (m > 1) scanf("%d", &y);
f[0] = 1;
for (int i = 1; i <= (1 << n) - 1; i++) {
int j = i & -i;
dis[i] = dis[i ^ j] + dis[j];
if (dis[i] == x || dis[i] == y) continue;
solve(i);
}
printf("%d", f[(1 << n) - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (a != b) {
cout << "Happy Alex";
return 0;
}
}
cout << "Poor Alex";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct grad {
long long x, y;
long long k;
long long c;
int ind;
};
int n;
grad a[2005];
bool cmp(grad levo, grad desno) { return levo.c < desno.c; }
long long sol = 0;
bool bio[2005];
vector<int> lit;
vector<int> stanice;
vector<pair<int, int> > grane;
pair<long long, long long> dis[2005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].c;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].k;
}
for (int i = 1; i <= n; i++) {
a[i].ind = i;
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) bio[i] = false;
for (int i = 1; i <= n; i++) {
dis[i].second = 100000000000000000;
dis[i].first = -1;
}
while (lit.size() < n) {
long long minn = 100000000000000000;
int prvi = -1, drugi = -1;
for (int i = 1; i <= n; i++) {
if (!bio[i] && dis[i].second < minn) {
prvi = i;
drugi = dis[i].first;
minn = dis[i].second;
}
}
for (int i = 1; i <= n; i++) {
if (!bio[i]) {
if (a[i].c < minn) {
minn = a[i].c;
prvi = i;
drugi = -1;
}
}
}
bio[prvi] = true;
lit.push_back(prvi);
sol += minn;
if (drugi == -1) {
stanice.push_back(prvi);
} else {
grane.push_back({prvi, drugi});
}
for (int i = 1; i <= n; i++) {
if (!bio[i]) {
long long uk_k = a[i].k + a[prvi].k;
long long rasss = abs(a[i].x - a[prvi].x) + abs(a[i].y - a[prvi].y);
if (uk_k * rasss < dis[i].second) {
dis[i].second = uk_k * rasss;
dis[i].first = prvi;
}
}
}
}
cout << sol << "\n";
cout << stanice.size() << "\n";
for (auto tre : stanice) cout << a[tre].ind << " ";
cout << "\n";
cout << grane.size() << "\n";
for (auto tre : grane)
cout << a[tre.first].ind << " " << a[tre.second].ind << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int i, j, flag = 0;
char ch1[101], ch2[101];
scanf("%s %s", ch1, ch2);
for (i = 0, j = strlen(ch1) - 1; i < strlen(ch1); i++, j--) {
if (ch1[i] != ch2[j]) flag = 1;
}
if (flag == 0)
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2500000000;
const int inf = 123456789;
const double EPS = 1e-9;
const double PI = 2 * asin(1.0);
const long long mod = 1e9 + 7;
int double_cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int a = 0, b = 0;
while (n && m) {
if ((a + 2) % 6 == 0 && (b + 3) % 6 == 0) {
if (a + n * 2 > b + m * 3) {
a += 2;
n--;
b += 6;
m--;
} else {
b += 3;
m--;
a += 4;
n--;
}
} else if ((a + 2) % 6 == 0) {
b += 3;
m--;
} else if ((b + 3) % 6 == 0) {
a += 2;
n--;
} else {
a += 2;
n--;
b += 3;
m--;
}
}
while (n) {
if (a + 2 == b)
a += 4;
else
a += 2;
n--;
}
while (m) {
if (b + 3 == a)
b += 6;
else
b += 3;
m--;
}
printf("%d\n", max(a, b));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct cus {
int64_t a;
int64_t b;
};
bool cmp(cus A, cus B) { return A.b < B.b; }
int32_t main() {
int64_t n, r, avg;
cin >> n >> r >> avg;
cus A[n];
avg *= n;
int64_t sum = 0;
for (int64_t i = 0; i < n; i++) {
cin >> A[i].a;
sum += A[i].a;
cin >> A[i].b;
}
sort(A, A + n, cmp);
int64_t i = 0;
int64_t need = avg - sum;
int64_t cnt = 0;
while (need > 0) {
if (A[i].a == r) {
i++;
continue;
}
if (r - A[i].a <= need) {
need = need - (r - A[i].a);
cnt += (A[i].b * (r - A[i].a));
i++;
continue;
} else {
cnt += need * A[i].b;
need = 0;
}
}
cout << cnt << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MOD = 1000000007;
int t, k, dp[N];
int solve(int rem = 1e5 + 1) {
if (rem < 0) return 0;
if (rem == 0) return 1;
int &ret = dp[rem];
if (~ret) return ret;
return ret = (solve(rem - 1) + solve(rem - k)) % MOD;
}
int main() {
scanf("%d %d", &t, &k);
memset(dp, -1, sizeof dp);
solve();
for (int i = 1; i < N; i++) {
dp[i] = (dp[i] + dp[i - 1]) % MOD;
}
while (t--) {
int a, b;
scanf("%d %d", &a, &b);
int ans = (dp[b] - dp[a - 1] + MOD) % MOD;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 100;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long n, m, k, p, dis[maxn], par[maxn], dsu[maxn], ans[maxn];
bool vis[maxn];
vector<pair<long long, pair<long long, long long> > > e;
vector<pair<long long, long long> > g[maxn], vec[maxn];
vector<long long> a[maxn];
priority_queue<pair<long long, long long> > q;
void init() {
for (long long i = 1; i <= k; i++) {
dsu[i] = i;
a[i].push_back(i);
}
return;
}
void Union(long long v, long long u, long long c) {
long long x, y;
v = dsu[v];
u = dsu[u];
if (v == u) return;
if (a[v].size() < a[u].size()) swap(v, u);
for (long long i = 0; i < a[u].size(); i++) {
x = a[u][i];
a[v].push_back(x);
dsu[x] = v;
for (long long j = 0; j < vec[x].size(); j++) {
y = vec[x][j].first;
if (dsu[y] == dsu[x]) {
ans[vec[x][j].second] = min(ans[vec[x][j].second], c);
}
}
}
return;
}
int main() {
long long v, u, c;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k >> p;
for (long long i = 0; i < m; i++) {
cin >> v >> u >> c;
g[v].push_back({u, c});
g[u].push_back({v, c});
}
for (long long i = 0; i < p; i++) {
cin >> v >> u;
vec[v].push_back({u, i});
vec[u].push_back({v, i});
ans[i] = inf;
}
fill(dis, dis + maxn, inf);
for (long long i = 1; i <= k; i++) {
dis[i] = 0;
par[i] = i;
q.push({-dis[i], i});
}
while (!q.empty()) {
v = q.top().second;
q.pop();
if (vis[v]) continue;
for (long long i = 0; i < g[v].size(); i++) {
u = g[v][i].first;
c = g[v][i].second;
if (dis[u] > dis[v] + c) {
dis[u] = dis[v] + c;
par[u] = par[v];
q.push({-dis[u], u});
}
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < g[i].size(); j++) {
u = g[i][j].first;
c = g[i][j].second;
if (u > i && par[i] != par[u]) {
e.push_back({dis[i] + c + dis[u], {par[i], par[u]}});
}
}
}
init();
sort(e.begin(), e.end());
for (long long i = 0; i < e.size(); i++) {
c = e[i].first;
v = e[i].second.first;
u = e[i].second.second;
Union(v, u, c);
}
for (long long i = 0; i < p; i++) {
cout << ans[i] << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
const int MAXM = 2505;
const int MAXQ = 100005;
int n, m, q, tot;
int flw[MAXM];
double ans[MAXQ];
pair<int, int> x[MAXQ];
namespace NetworkFlow {
struct Edge {
int to;
int w;
int cap;
int nxt;
} edge[MAXM << 1];
int S, T, id = 1;
int dis[MAXN];
int first[MAXN];
bool vis[MAXN];
bool inqueue[MAXN];
queue<int> Q;
void addE(int u, int v, int w, int c) {
edge[++id] = (Edge){v, w, c, first[u]};
first[u] = id;
edge[++id] = (Edge){u, -w, 0, first[v]};
first[v] = id;
}
bool bfs() {
for (int i = 1; i <= n; i++) dis[i] = 1e9;
dis[S] = 0;
Q.push(S);
inqueue[S] = 1;
while (!Q.empty()) {
int u = Q.front();
inqueue[u] = 0;
Q.pop();
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].cap > 0 && dis[edge[i].to] > dis[u] + edge[i].w) {
dis[edge[i].to] = dis[u] + edge[i].w;
if (!inqueue[edge[i].to]) {
inqueue[edge[i].to] = 1;
Q.push(edge[i].to);
}
}
}
return dis[T] != 1e9;
}
int dfs(int u, int f) {
if (u == T) return f;
vis[u] = 1;
int res = 0;
for (int i = first[u]; i; i = edge[i].nxt)
if (!vis[edge[i].to] && edge[i].cap > 0 &&
dis[edge[i].to] == dis[u] + edge[i].w) {
int ret = dfs(edge[i].to, min(edge[i].cap, f));
edge[i].cap -= ret;
edge[i ^ 1].cap += ret;
f -= ret;
res += ret;
if (!f) break;
}
vis[u] = 0;
if (!res) dis[u] = 1e9;
return res;
}
void Dinic() {
S = 1, T = n;
while (bfs()) {
int r = dfs(S, 1e9);
while (r--) flw[++tot] = dis[T];
}
}
} // namespace NetworkFlow
int main() {
scanf("%d%d", &n, &m);
for (int u, v, w, i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
NetworkFlow::addE(u, v, w, 1);
}
NetworkFlow::Dinic();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &x[i].first);
x[i].second = i;
}
sort(x + 1, x + q + 1);
for (int i = 1; i <= tot; i++) flw[i] += flw[i - 1];
for (int i = 1, j = 1; i <= q; i++) {
while (j + 1 <= tot && (long long)(flw[j] + x[i].first) * (j + 1) >
(long long)(flw[j + 1] + x[i].first) * j)
j++;
ans[x[i].second] = (double)(flw[j] + x[i].first) / j;
}
for (int i = 1; i <= q; i++) printf("%.10lf\n", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long ans1, ans2;
int n, m, cnt, ind, sz, top, scc;
int dfn[300005], low[300005], belong[300005], q[300005];
int id[300005], last[300005], lt[300005];
int len[300005], key[300005], mn[300005], lmn[300005];
bool vis[300005], inq[300005];
char ch[300005];
map<string, int> mp;
struct edge {
int to, next;
} e[300005], ed[300005];
void insert(int u, int v) {
e[++cnt].to = v;
e[cnt].next = last[u];
last[u] = cnt;
}
void ins(int u, int v) {
ed[++cnt].to = v;
ed[cnt].next = lt[u];
lt[u] = cnt;
}
void tarjan(int x) {
dfn[x] = low[x] = ++ind;
inq[x] = 1;
q[++top] = x;
for (int i = last[x]; i; i = e[i].next)
if (!dfn[e[i].to])
tarjan(e[i].to), low[x] = min(low[x], low[e[i].to]);
else if (inq[e[i].to])
low[x] = min(low[x], dfn[e[i].to]);
int now = 0;
if (low[x] == dfn[x]) {
scc++;
while (now != x) {
now = q[top--];
inq[now] = 0;
belong[now] = scc;
if (key[now] < mn[scc] || (key[now] == mn[scc] && len[now] < lmn[scc]))
mn[scc] = key[now], lmn[scc] = len[now];
}
}
}
void rebuild(int t) {
cnt = 0;
for (int i = 1; i <= t; i++)
for (int j = last[i]; j; j = e[j].next)
if (belong[i] != belong[e[j].to]) ins(belong[i], belong[e[j].to]);
}
void dfs(int x) {
if (vis[x]) return;
for (int i = lt[x]; i; i = ed[i].next) {
int t = ed[i].to;
dfs(t);
if (mn[t] < mn[x] || (mn[t] == mn[x] && lmn[t] < lmn[x]))
lmn[x] = lmn[t], mn[x] = mn[t];
}
}
int main() {
memset(mn, 127 / 3, sizeof(mn));
memset(lmn, 127 / 3, sizeof(lmn));
n = read();
for (int i = 1; i <= n; i++) {
scanf("%s", ch);
int l = strlen(ch), k = 0;
for (int j = 0; j < l; j++) {
if (ch[j] >= 'A' && ch[j] <= 'Z') ch[j] = ch[j] - 'A' + 'a';
if (ch[j] == 'r') k++;
}
int t = mp[ch];
if (!t) t = mp[ch] = ++sz;
len[t] = l;
key[t] = k;
id[i] = t;
}
m = read();
for (int i = 1; i <= m; i++) {
scanf("%s", ch);
int l = strlen(ch), k = 0;
for (int j = 0; j < l; j++) {
if (ch[j] >= 'A' && ch[j] <= 'Z') ch[j] = ch[j] - 'A' + 'a';
if (ch[j] == 'r') k++;
}
int x = mp[ch];
if (!x) x = mp[ch] = ++sz;
len[x] = l;
key[x] = k;
scanf("%s", ch);
l = strlen(ch), k = 0;
for (int j = 0; j < l; j++) {
if (ch[j] >= 'A' && ch[j] <= 'Z') ch[j] = ch[j] - 'A' + 'a';
if (ch[j] == 'r') k++;
}
int y = mp[ch];
if (!y) y = mp[ch] = ++sz;
len[y] = l;
key[y] = k;
insert(x, y);
}
int t = mp.size();
for (int i = 1; i <= t; i++)
if (!dfn[i]) tarjan(i);
rebuild(t);
for (int i = 1; i <= t; i++) dfs(i);
for (int i = 1; i <= n; i++) {
ans1 += mn[belong[id[i]]], ans2 += lmn[belong[id[i]]];
}
printf("%I64d %I64d\n", ans1, ans2);
return 0;
}
| 8 |
#include <bits/stdc++.h>
constexpr int P = 998244353;
using i64 = long long;
int norm(int x) {
if (x < 0) {
x += P;
}
if (x >= P) {
x -= P;
}
return x;
}
template <class T>
T power(T a, int b) {
T res = 1;
for (; b; b /= 2, a *= a) {
if (b % 2) {
res *= a;
}
}
return res;
}
struct Z {
int x;
Z(int x = 0) : x(norm(x)) {}
int val() const { return x; }
Z operator-() const { return Z(norm(P - x)); }
Z inv() const {
assert(x != 0);
return power(*this, P - 2);
}
Z &operator*=(const Z &rhs) {
x = i64(x) * rhs.x % P;
return *this;
}
Z &operator+=(const Z &rhs) {
x = norm(x + rhs.x);
return *this;
}
Z &operator-=(const Z &rhs) {
x = norm(x - rhs.x);
return *this;
}
Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
friend Z operator*(const Z &lhs, const Z &rhs) {
Z res = lhs;
res *= rhs;
return res;
}
friend Z operator+(const Z &lhs, const Z &rhs) {
Z res = lhs;
res += rhs;
return res;
}
friend Z operator-(const Z &lhs, const Z &rhs) {
Z res = lhs;
res -= rhs;
return res;
}
friend Z operator/(const Z &lhs, const Z &rhs) {
Z res = lhs;
res /= rhs;
return res;
}
};
Z p[10000001], f[10000001], inv[10000001];
void solve() {
int n, k, x;
std::cin >> n >> k >> x;
if (x == 0) {
if (n > k) {
std::cout << "0\n";
} else {
Z res = 1;
Z p = power(Z(2), k), r = 1;
for (int i = 0; i < n; i++) {
res *= (p - r);
r *= 2;
}
std::cout << res.val() << "\n";
}
return;
}
p[0] = 1;
Z pn = power(Z(2), n);
Z inv2 = Z(2).inv();
Z r = 1, res = 0;
for (int i = 0; i < k; i++) {
res += r;
r *= (1 - pn) * inv[i + 1];
pn *= inv2;
r *= p[k] - p[i + 1];
}
std::cout << res.val() << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
p[0] = 1;
for (int i = 1; i <= 10000000; i++) {
p[i] = 2 * p[i - 1];
}
f[0] = 1;
for (int i = 1; i <= 10000000; i++) {
f[i] = f[i - 1] * (1 - p[i]);
}
Z x = f[10000000].inv();
for (int i = 10000000; i > 0; i--) {
inv[i] = x * f[i - 1];
x *= (1 - p[i]);
}
int t;
std::cin >> t;
while (t--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, y, x, bitsForOne, bitChoose;
int ask(vector<int>& a) {
if (a.size() == 0) return 0;
printf("? %d", (int)a.size());
for (int v : a) printf(" %d", v);
puts("");
fflush(stdout);
int ret;
scanf("%d", &ret);
return ret;
}
int binary(vector<int>& a) {
int l = 0, r = a.size() - 1;
while (l < r) {
vector<int> v;
int mid = l + r >> 1;
for (int i = 0; i <= mid; ++i) v.push_back(a[i]);
int ret = ask(v);
if (!(ret == y || ret == (y ^ x)))
l = mid + 1;
else
r = mid;
}
return a[l];
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int bits = 0; bits <= 9; ++bits) {
vector<int> a;
for (int i = 1; i <= n; ++i) {
if (i & (1 << bits)) a.push_back(i);
}
int ret = ask(a);
if (ret == y || ret == (y ^ x)) {
bitsForOne |= 1 << bits;
bitChoose = bits;
}
}
vector<int> a, b;
for (int i = 1; i <= n; ++i) {
if (i & (1 << bitChoose))
a.push_back(i);
else
b.push_back(i);
}
if (a.size() > b.size()) std::swap(a, b);
int p1 = binary(a), p2;
p2 ^= p1 ^ bitsForOne;
if (p1 > p2) std::swap(p1, p2);
printf("! %d %d\n", p1, p2);
fflush(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, logn[300005];
int a[300005][19], b[300005][19];
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
inline int cal1(int st, int ed) {
int t = logn[ed - st + 1];
return max(a[st][t], a[ed - (1 << t) + 1][t]);
}
inline int cal2(int st, int ed) {
int t = logn[ed - st + 1];
return max(b[st][t], b[ed - (1 << t) + 1][t]);
}
int main() {
int i, j;
n = read();
logn[0] = -1;
for (i = 1; i <= n; i++) a[i][0] = read(), logn[i] = logn[i >> 1] + 1;
for (i = 1; i <= n; i++)
b[i][0] = min(a[i][0], max(a[i - 1][0], a[i + 1][0]));
for (i = 1; (1 << i) <= n; i++) {
for (j = 1; j + (1 << i) - 1 <= n; j++) {
a[j][i] = max(a[j][i - 1], a[j + (1 << (i - 1))][i - 1]);
b[j][i] = max(b[j][i - 1], b[j + (1 << (i - 1))][i - 1]);
}
}
for (i = 0; i < n - 1; i++) {
if ((n - i) & 1) {
printf("%d ", cal2((n - i + 1) / 2, i + (n - i + 1) / 2));
} else {
printf("%d ", cal1((n - i) / 2, i + 1 + (n - i) / 2));
}
}
printf("%d\n", cal1(1, n));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, t[500005], s, cur;
long long ans[500005];
int main() {
cin >> n;
for (int i = 0; i < n / 2; i++) cin >> t[i];
ans[0] = 0;
ans[n - 1] = t[0];
for (int i = 1; i < n / 2; i++) {
cur = t[i] - ans[i - 1];
if (cur > ans[n - i]) cur = ans[n - i];
ans[n - i - 1] = cur;
ans[i] = t[i] - cur;
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> hm(n + m);
vector<int> tx;
vector<int> qp(m, 0);
for (int i = 0; i < n + m; i++) {
cin >> hm[i];
}
for (int i = 0; i < n + m; i++) {
bool x;
cin >> x;
if (x) tx.push_back(i);
}
int j = 0;
for (j; j < tx[0]; j++) {
qp[0]++;
}
j++;
for (int i = 1; i < m; i++) {
if (tx[i] - tx[i - 1] == 1) {
j = tx[i] + 1;
continue;
}
for (j; j < tx[i]; j++) {
if (hm[j] - hm[tx[i - 1]] <= hm[tx[i]] - hm[j]) {
qp[i - 1]++;
} else
qp[i]++;
}
j = tx[i] + 1;
}
j = tx[m - 1] + 1;
for (j; j < n + m; j++) {
qp[m - 1]++;
}
for (int e : qp) {
cout << e << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, p = 1, r = 0;
cin >> n >> x;
int b = x;
while (p < x && p <= n) {
x = b / p;
if (b % p == 0) {
if (x == p) {
r = r + 1;
} else if (x <= n) {
r = r + 2;
}
}
p++;
}
if (b == 1) {
cout << "1" << endl;
} else {
cout << r << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, s[100005], q, l, r;
map<pair<int, int>, pair<int, int> > dpMap;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int len = 1; len <= n; len *= 2) {
for (int i = 1; i + len - 1 <= n; i++) {
if (len == 1) {
dpMap[{i, i}] = {s[i], 0};
} else {
int sum = (dpMap[{i, i + len / 2 - 1}].first +
dpMap[{i + len / 2, i + len - 1}].first);
int f = dpMap[{i, i + len / 2 - 1}].second +
dpMap[{i + len / 2, i + len - 1}].second + int(sum >= 10);
dpMap[{i, i + len - 1}] = {sum % 10, f};
}
}
}
cin >> q;
while (q--) {
cin >> l >> r;
cout << dpMap[{l, r}].second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void imprimirVector(vector<int> &v) {
if (!v.empty()) {
int p = v.size();
cout << "[";
for (int i = 0; i < (int)(p - 1); i++) cout << v[i] << ",";
cout << v[p - 1] << "]" << endl;
} else
cout << "[]" << endl;
}
int main() {
int N;
cin >> N;
vector<long long> pizzas(N);
for (int i = 0; i < (int)(N); i++) cin >> pizzas[i];
long long am = 0;
bool can = true;
for (int i = 0; i < (int)(N); i++) {
if (pizzas[i] > 0)
am += pizzas[i];
else {
can &= (am % 2 == 0);
}
}
can &= (am % 2 == 0);
if (can)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long toi(string s) {
istringstream is(s);
long long x;
is >> x;
return x;
}
string tos(long long t) {
stringstream st;
st << t;
return st.str();
}
int main() {
int n, ans;
cin >> n;
ans = 0;
if (n > 10 && n <= 21) {
if (n == 20)
ans = 15;
else
ans = 4;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
int N, M;
cin >> N >> M;
vector<vector<int>> dir(N + 1);
vector<pair<int, int>> indir;
vector<int> isin(N + 1);
for (int m = 0; m < M; ++m) {
int T, X, Y;
cin >> T >> X >> Y;
if (T) {
dir[X].push_back(Y);
isin[Y]++;
} else
indir.push_back({X, Y});
}
queue<int> q, ans;
for (int n = 1; n <= N; ++n) {
if (isin[n] == 0) q.push(n);
}
while (!q.empty()) {
int tmp = q.front();
ans.push(tmp);
q.pop();
for (auto x : dir[tmp]) {
isin[x]--;
if (isin[x] == 0) q.push(x);
}
}
if (ans.size() == N) {
vector<int> lev(N + 1);
int lv = 1;
while (!ans.empty()) {
int tmp = ans.front();
ans.pop();
lev[tmp] = lv++;
}
for (auto x : indir) {
int a = x.first, b = x.second;
if (lev[a] < lev[b])
dir[a].push_back(b);
else
dir[b].push_back(a);
}
cout << "YES\n";
for (int i = 1; i <= N; ++i) {
for (auto x : dir[i]) {
cout << i << ' ' << x << '\n';
}
}
} else
cout << "NO\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], y[n];
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
int c = 0;
for (int i = 0; i < n; i++) {
int f1 = 0, f2 = 0, f3 = 0, f4 = 0;
for (int j = 0; j < n; j++) {
if (i != j) {
if (x[j] > x[i] && y[j] == y[i]) {
f1 = 1;
}
if (x[j] < x[i] && y[j] == y[i]) {
f2 = 1;
}
if (x[j] == x[i] && y[j] > y[i]) {
f3 = 1;
}
if (x[j] == x[i] && y[j] < y[i]) {
f4 = 1;
}
}
}
if (f1 == 1 && f2 == 1 && f3 == 1 && f4 == 1) {
c++;
}
}
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[2 * (int)1e5 + 5];
long long V[2 * (int)1e5 + 5], node[2 * (int)1e5 + 5][2], cnt[2 + 5];
void color(int u, int par, int c) {
++cnt[c];
for (int i = 0; i < vec[u].size(); i++) {
if (vec[u][i] != par) {
color(vec[u][i], u, c ^ 1);
}
}
}
long long ans = 0;
const long long mod = (long long)1e9 + 7;
void calc(int u, int par, int c) {
++node[u][c];
for (int i = 0; i < vec[u].size(); i++) {
if (vec[u][i] != par) {
calc(vec[u][i], u, c ^ 1);
long long sameRet = node[vec[u][i]][c];
long long oppoRet = node[vec[u][i]][c ^ 1];
ans += (((((sameRet * node[u][c]) % mod) * 2LL) % mod) * V[u]) % mod;
ans %= mod;
ans -= (((((oppoRet * node[u][c ^ 1]) % mod) * 2LL) % mod) * V[u]) % mod;
ans += mod;
ans %= mod;
node[u][c] += sameRet;
node[u][c ^ 1] += oppoRet;
}
}
long long remSame = cnt[c] - node[u][c];
ans += (((((remSame * node[u][c]) % mod) * 2LL) % mod) * V[u]) % mod;
ans %= mod;
long long remOppo = cnt[c ^ 1] - node[u][c ^ 1];
ans -= (((((remOppo * node[u][c ^ 1]) % mod) * 2LL) % mod) * V[u]) % mod;
ans += mod;
ans %= mod;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &V[i]);
ans += V[i];
ans %= mod;
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d %d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
}
color(1, -1, 0);
calc(1, -1, 0);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<char, vector<char> > e;
map<char, int> cl;
map<char, bool> was;
map<char, bool> bukv;
map<char, int> c1;
vector<char> d;
string ans = "";
map<pair<char, char>, bool> m;
bool dfs(char v) {
cl[v] = 1;
for (auto to : e[v]) {
if (cl[to] == 0) {
if (dfs(to)) return true;
} else if (cl[to] == 1) {
return true;
}
}
cl[v] = 2;
return false;
}
bool dfs2(char v) {
was[v] = 1;
ans += v;
for (auto to : e[v]) {
dfs2(to);
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
d.push_back(s[0]);
for (int i = 1; i < s.size(); i++) {
if (!m[{s[i - 1], s[i]}]) {
e[s[i - 1]].push_back(s[i]);
c1[s[i]]++;
}
bukv[s[i]] = 1;
m[{s[i - 1], s[i]}] = 1;
if (e[s[i - 1]].size() > 1) {
cout << "NO";
return 0;
}
if (c1[s[i]] > 1) {
cout << "NO";
return 0;
}
}
}
for (char c = 'a'; c <= 'z'; c++) {
if (!cl[c]) {
if (dfs(c)) {
cout << "NO";
return 0;
}
}
}
sort(d.begin(), d.end());
for (auto i : d) {
if (!was[i] && !bukv[i]) dfs2(i);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC target("sse2")
#pragma GCC optimization("O2")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int maxn = 1000500;
inline int g() {
int x;
cin >> x;
return x;
}
inline long long gl() {
long long x;
cin >> x;
return x;
}
inline char gc() {
char x;
cin >> x;
return x;
}
inline string gs() {
string s;
cin >> s;
return s;
}
template <typename T>
inline vector<T> gv(int len) {
vector<T> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<int> gv(int len) {
vector<int> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<pair<int, int>> gv_andPairCnt(int len) {
vector<pair<int, int>> a(len);
int i = 1;
for (auto &it : a) {
it.second = i;
i++;
cin >> it.first;
}
return a;
}
double power_log(double power, double val) { return log(val) / log(power); }
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it : v) os << it << ", ";
os << "\n";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &v) {
os << "deque:{";
for (auto it : v) os << it << " ";
os << "}\n";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "set:{";
for (auto it : v) os << it << " ";
os << "}";
return os;
}
template <typename T, typename T2>
ostream &operator<<(ostream &os, const map<T, T2> &v) {
os << "map:{\n";
for (auto it : v) os << " {" << it.first << " <> " << it.second << "}\n";
os << "}\n";
return os;
}
template <typename T, typename T2>
ostream &operator<<(ostream &os, const pair<T, T2> &v) {
os << "{" << v.first << ", " << v.second << "}";
return os;
}
template <typename T, typename H>
inline vector<pair<T, H>> gv_andBiPair(int len) {
vector<pair<T, H>> a(len);
for (auto &it : a) {
cin >> it.first >> it.second;
}
return a;
}
template <typename T>
inline set<T> vector_to_set(const vector<T> &vec) {
set<T> s;
for (auto &it : vec) s.insert(it);
return s;
}
const long long md = 1e9 + 7;
template <typename T>
class fenwick {
public:
vector<T> fenw;
int n;
fenwick(int _n) : n(_n) { fenw.resize(n); }
void modify(int x, T v) {
while (x < n) {
fenw[x] += v;
x |= (x + 1);
}
}
T get(int x) {
T v{};
while (x >= 0) {
v += fenw[x];
x = (x & (x + 1)) - 1;
}
return v;
}
};
const int sz = 350;
vector<int> mp[maxn];
struct pos {
int l, r, number;
bool operator<(const pos &right) const {
if ((l / sz) == (right.l / sz)) {
return r < right.r;
}
return (l / sz) < (right.l / sz);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n = g();
vector<int> a(maxn);
for (int i = 1; i <= n; i++) {
mp[i].push_back(0);
}
for (int i = 1; i <= n; i++) {
a[i] = g();
mp[a[i]].push_back(i);
}
vector<pos> vec1;
int id = 0;
set<int> st;
for (int i = 1; i <= n; i++) {
mp[i].push_back(n + 1);
for (int j = 1; j < mp[i].size(); j++) {
if (mp[i][j - 1] + 1 <= mp[i][j] - 1) {
vec1.push_back({mp[i][j - 1] + 1, mp[i][j] - 1, i});
}
}
}
vec1.push_back({1, n, n + 1});
vector<int> cnt(maxn);
fenwick<int> f = fenwick<int>(n + 4);
auto upd = [&](int val, int add) {
if (add > 0) {
cnt[val] += add;
if (cnt[val] == 1) {
f.modify(val, +1);
}
} else {
cnt[val] += add;
if (cnt[val] == 0) {
f.modify(val, -1);
}
}
};
int l = 1, r = 1;
sort(vec1.begin(), vec1.end());
assert(vec1.size() <= 2 * n + 42);
for (auto &it : vec1) {
while (r <= it.r) {
upd(a[r], +1);
r++;
}
while (r - 1 > it.r) {
upd(a[r - 1], -1);
r--;
}
while (l < it.l) {
upd(a[l], -1);
l++;
}
while (l > it.l) {
upd(a[l - 1], +1);
l--;
}
if (f.get(it.number) == it.number - 1) {
st.insert(it.number);
}
}
for (int i = 1; i <= n + 4; i++) {
if (!st.count(i)) {
return cout << i, 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int t;
cin >> t;
for (int z = 1; z <= t; z++) {
int n;
cin >> n;
string s;
cin >> s;
string res;
for (int i = 0; i < 2 * n; i++) {
res += s[i];
i++;
}
cout << res << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 1e3 + 5;
int f[N][N];
struct node {
long long x, y;
} a[N], b[N];
bool cmp(node x, node y) { return x.y < y.y; }
long long area(node a, node b, node c) {
return a.x * b.y - a.y * b.x + b.x * c.y - b.y * c.x + c.x * a.y - c.y * a.x;
}
bool toleft(node a, node b, node c) {
if (c.y <= a.y || c.y > b.y) return 0;
return area(a, b, c) > 0;
}
int n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%lld%lld", &a[i].x, &a[i].y);
for (int i = 1; i <= m; ++i) scanf("%lld%lld", &b[i].x, &b[i].y);
sort(a + 1, a + n + 1, cmp);
int ans = 0;
for (int i = 1; i < n; ++i)
for (int j = i + 1; j <= n; ++j)
for (int k = 1; k <= m; ++k)
if (toleft(a[i], a[j], b[k])) f[i][j]++;
for (int i = 1; i < n; ++i)
for (int j = i + 1; j < n; ++j)
for (int k = j + 1; k <= n; ++k)
if (f[i][j] + f[j][k] == f[i][k]) ans++;
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int cc[778][8];
int main() {
long long n;
cin >> n;
for (int i = 0; i < 778; i++) {
cc[i][0] = 1;
cc[i][1] = i;
}
for (int in = 1; in < 778; in++) {
for (int ik = 2; ik < 6; ik++) {
cc[in][ik] = cc[in - 1][ik - 1] + cc[in - 1][ik];
}
}
cout << (n + 2 * n * (n - 1) + n * (n - 1) * (n - 2) +
n * (n - 1) * (n - 2) * (n - 3) / 6 + cc[n][5]) *
(n + n * (n - 1) + cc[n][3]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 3e3;
uint16_t a[N], lst[N], nxt[N], cnxt[19], dp[N][N];
int main() {
cin.tie(0), ios::sync_with_stdio(0);
int t, n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i], --a[i];
}
memset(lst, 0, n * sizeof *lst);
for (int i = 0; i < n; ++i) {
++lst[a[i]];
}
int w = -1, r = 0, purged = 0;
while (r < n) {
if (w >= 0 && a[w] == a[r]) {
if (--lst[a[r++]] == 1) {
--w;
++purged;
}
} else if (lst[a[r]] == 1) {
++r;
++purged;
} else {
a[++w] = a[r++];
}
}
memset(lst, -1, n * sizeof *lst);
n = w + 1;
memset(nxt, 127, n * sizeof *nxt);
for (int i = 0; i < n; ++i) {
if (lst[a[i]] != (uint16_t)-1) {
nxt[lst[a[i]]] = i;
}
lst[a[i]] = i;
}
for (int i = n - 1; i > -1; --i) {
{
auto* cnxte = cnxt;
for (int z = nxt[i]; z < n; z = nxt[z]) {
*cnxte++ = z;
}
cnxte = cnxt;
}
int cs = sizeof cnxt / sizeof *cnxt;
for (int j = i + 1; j < n; ++j) {
if (a[j] == a[i]) {
--cs;
}
int t = dp[i + 1][j] - 1;
const auto* z = cnxt;
switch (cs) {
[[likely]] case 0 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 1 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 2 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 3 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 4 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 5 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 6 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 7 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 8 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 9 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 10 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 11 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 12 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 13 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 14 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 15 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 16 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 17 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[likely]] case 18 : t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[unlikely]] default:;
}
dp[i][j] = t + 1;
}
}
cout << (n ? n - dp[0][n - 1] : 0) - 1 + purged << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, t, a, b, c;
pair<int, int> dp[100][100];
int ans[100][100];
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
pair<int, int> p;
p.first = i;
p.second = j;
dp[i][j] = p;
ans[i][j] = 0;
}
}
for (int i = 0; i < q; i++) {
cin >> t;
if (t == 3) {
cin >> a >> b >> c;
pair<int, int> p = dp[a - 1][b - 1];
ans[p.first][p.second] = c;
} else if (t == 1) {
cin >> c;
pair<int, int> np = dp[c - 1][0];
for (int j = 0; j < m - 1; j++) {
dp[c - 1][j] = dp[c - 1][j + 1];
}
dp[c - 1][m - 1] = np;
} else {
cin >> c;
pair<int, int> np = dp[0][c - 1];
for (int j = 0; j < n - 1; j++) {
dp[j][c - 1] = dp[j + 1][c - 1];
}
dp[n - 1][c - 1] = np;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
struct bruh {
int t, x, y, cnt;
};
void solve() {
int r, n;
cin >> r >> n;
vector<bruh> a(n + 1);
a[0].x = 1, a[0].y = 1;
for (int i = 1; i <= n; i++) {
cin >> a[i].t >> a[i].x >> a[i].y;
a[i].cnt = -1;
}
int before_max = -1;
for (int i = 1; i <= n; i++) {
if (i - r * 2 >= 0) {
before_max = max(before_max, a[i - r * 2].cnt);
a[i].cnt = before_max + 1;
}
for (int j = max(0, i - r * 2 + 1); j < i; j++) {
if (~a[j].cnt &&
abs(a[i].x - a[j].x) + abs(a[i].y - a[j].y) <= a[i].t - a[j].t) {
a[i].cnt = max(a[i].cnt, a[j].cnt + 1);
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, a[i].cnt);
cout << ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int tcs = 1;
for (int tc = 1; tc <= tcs; tc++) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans1 = 0, ans2 = 0;
string s;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> s;
for (long long i = 0; i < n; i++) {
ans1 += ((s[i] - '0') != (i & 1));
ans2 += ((s[i] - '0') == (i & 1));
}
cout << min(ans1, ans2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5005;
const int MOD = 1000000007;
int n;
int x[MAX_N];
int y[MAX_N];
char color[MAX_N];
int dis[MAX_N][MAX_N];
int bound;
inline bool dfs(int u, int c) {
color[u] = c;
for (int v = 0; v < n; v++) {
if (dis[u][v] > bound) {
if (not color[v]) {
if (not dfs(v, c == 1 ? 2 : 1)) {
return false;
}
} else if (color[v] == c) {
return false;
}
}
}
return true;
}
inline int check(int z) {
bound = z;
fill(color, color + n, 0);
int ret = 0;
for (int i = 0; i < n; i++) {
if (not color[i]) {
if (dfs(i, 1)) {
ret++;
} else {
return 0;
}
}
}
return ret;
}
inline int find_sol(int z) {
int x = check(z);
int ret = 1;
for (; x-- > 0; ret = (ret * 2) % MOD)
;
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", x + i, y + i);
for (int j = 0; j < i; j++) {
dis[i][j] = dis[j][i] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
}
}
int lo = 0, hi = 10000, mid;
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (check(mid)) {
hi = mid - 1;
} else {
lo = mid + 1;
}
}
printf("%d\n%d\n", lo, find_sol(lo));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = (pow(10, 9) + 7);
void vec_p(vector<long long int> &a) {
for (long long int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << "\n";
}
long long int vec_sum(vector<long long int> a) {
long long int s = 0;
for (long long int i = 0; i < a.size(); i++) {
s += a[i];
}
return s;
}
void pfx(vector<long long int> &a, vector<long long int> &prefix_sum) {
prefix_sum[0] = a[0];
for (long long int i = 1; i < a.size(); i++) {
prefix_sum[i] += (prefix_sum[i - 1] + a[i]);
}
}
void sorting_p(vector<pair<long long int, long long int> > &a) {
sort(a.begin(), a.end());
}
void sorting(vector<long long int> &a) {
sort(a.begin(), a.end(), greater<long long int>());
}
void vec_in(vector<long long int> &a, long long int n) {
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
a.push_back(x);
}
}
void Graph_in(vector<vector<long long int> > &G, long long int n) {
long long int x, y;
for (long long int i = 0; i < n; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
}
void lps_table(string &s, vector<long long int> &lps) {
long long int n = s.size();
long long int len = 0;
for (long long int i = 1; i < n; i++) {
while (s[i] != s[len] && len > 0) {
len = lps[len - 1];
if (len == 0 && s[len] != s[i]) {
lps[i] = 0;
len = 0;
break;
}
}
if (s[len] == s[i]) {
lps[i] = len + 1;
len++;
}
if (len == 0 && s[len] != s[i]) {
lps[i] = 0;
len = 0;
}
}
}
void traversal(long long int &x, long long int &y,
vector<vector<long long int> > &a, long long int r,
long long int c) {
if (x + 2 < r) {
if (y + 1 < c) {
if (a[x + 2][y + 1] == -1) {
long long int i = x + 2;
long long int j = y + 1;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
if (y - 1 < c && y - 1 >= 0) {
if (a[x + 2][y - 1] == -1) {
long long int i = x + 2;
long long int j = y - 1;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
}
if (x + 1 < r) {
if (y + 2 < c) {
if (a[x + 1][y + 2] == -1) {
long long int i = x + 1;
long long int j = y + 2;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
if (y - 2 < c && y - 2 >= 0) {
if (a[x + 1][y - 2] == -1) {
long long int i = x + 1;
long long int j = y - 2;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
}
if (x - 2 < r && x - 2 >= 0) {
if (y + 1 < c) {
if (a[x - 2][y + 1] == -1) {
long long int i = x - 2;
long long int j = y + 1;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
if (y - 1 < c && y - 1 >= 0) {
if (a[x - 2][y - 1] == -1) {
long long int i = x - 2;
long long int j = y - 1;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
}
if (x - 1 < r && x - 1 >= 0) {
if (y + 2 < c) {
if (a[x - 1][y + 2] == -1) {
long long int i = x - 1;
long long int j = y + 2;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
if (y - 2 < c && y - 2 >= 0) {
if (a[x - 1][y - 2] == -1) {
long long int i = x - 1;
long long int j = y - 2;
a[i][j] = a[x][y] ^ 1;
traversal(i, j, a, r, c);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int r, c;
cin >> r >> c;
if (r < c) {
swap(r, c);
}
vector<vector<long long int> > a(r, vector<long long int>(c, -1));
for (long long int i = 0; i < r; i++) {
for (long long int j = 0; j < c; j++) {
if (a[i][j] == -1) {
a[i][j] = 1;
traversal(i, j, a, r, c);
}
}
}
long long int one = 0;
for (long long int i = 0; i < r; i++) {
for (long long int j = 0; j < c; j++) {
if (a[i][j] == 1) {
one++;
}
}
}
cout << one << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char c[1005], s[55], t[55];
int ns[55], nt[55];
int tos[55][30], tot[55][30];
int lenc, lens, lent;
int dp[1005][55][55];
void init() {
lenc = strlen(c + 1), lens = strlen(s + 1), lent = strlen(t + 1);
ns[1] = 0, nt[1] = 0;
for (int i = 2, j = 0; i <= lens; i++) {
while (j && s[j + 1] != s[i]) j = ns[j];
if (s[j + 1] == s[i]) j++;
ns[i] = j;
}
for (int i = 2, j = 0; i <= lent; i++) {
while (j && t[j + 1] != t[i]) j = nt[j];
if (t[j + 1] == t[i]) j++;
nt[i] = j;
}
for (int i = 0; i <= lens; i++) {
for (int k = 0; k < 26; k++) {
int j = i;
while (j && s[j + 1] != k + 'a') j = ns[j];
if (s[j + 1] == k + 'a') j++;
tos[i][k] = j;
}
}
for (int i = 0; i <= lent; i++) {
for (int k = 0; k < 26; k++) {
int j = i;
while (j && t[j + 1] != k + 'a') j = nt[j];
if (t[j + 1] == k + 'a') j++;
tot[i][k] = j;
}
}
}
int main() {
scanf("%s%s%s", c + 1, s + 1, t + 1);
init();
int n = strlen(c + 1);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= 50; j++)
for (int k = 0; k <= 50; k++) dp[i][j][k] = -1000000;
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++) {
if (c[i] == '*') {
for (int j = 0; j <= lens; j++) {
for (int k = 0; k <= lent; k++) {
if (dp[i - 1][j][k] <= -1000000) continue;
for (int q = 0; q < 26; q++) {
int temp1 = tos[j][q], temp2 = tot[k][q];
dp[i][temp1][temp2] =
max(dp[i][temp1][temp2],
dp[i - 1][j][k] + (temp1 == lens) - (temp2 == lent));
}
}
}
} else {
for (int j = 0; j <= lens; j++) {
for (int k = 0; k <= lent; k++) {
if (dp[i - 1][j][k] <= -1000000) continue;
int q = c[i] - 'a';
int temp1 = tos[j][q], temp2 = tot[k][q];
dp[i][temp1][temp2] =
max(dp[i][temp1][temp2],
dp[i - 1][j][k] + (temp1 == lens) - (temp2 == lent));
}
}
}
}
int res = -1000000;
for (int i = 0; i <= lens; i++)
for (int j = 0; j <= lent; j++) res = max(res, dp[n][i][j]);
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, count = 0;
char c;
cin >> n >> m;
cin.ignore();
string s;
getline(cin, s);
for (int i = 0; i < n - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.') count++;
}
for (int i = 0; i < m; i++) {
cin >> x >> c;
if (isalpha(s[x - 1]) && c == '.') {
if (x > 1) {
if (s[x] == '.') count++;
if (s[x - 2] == '.') count++;
} else {
if (s[x] == '.') count++;
}
} else if (s[x - 1] == '.' && isalpha(c)) {
if (x > 1) {
if (s[x] == '.') count--;
if (s[x - 2] == '.') count--;
} else {
if (s[x] == '.') count--;
}
}
s[x - 1] = c;
cout << count << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int a[102][102], k, n, p;
string s;
int main() {
cin >> s;
n = s.length();
p = 0;
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 20; j++) {
if (i * j >= n) {
if (i * j - n <= i) {
cout << i << " " << j << "\n";
k = i * j - n;
for (int z = 0; z < i; z++) {
for (int d = 0; d < j - 1; d++) {
cout << s[p];
p++;
}
if (k > 0) {
cout << "*";
k--;
} else {
cout << s[p];
p++;
}
cout << "\n";
}
return 0;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long large = 2000000000000000000LL;
vector<long long> a;
vector<vector<int> > adj;
vector<long long> dp;
long long val;
long long cnt;
void dfs(int u, int pa, bool f) {
dp[u] = a[u];
for (int j = 0; j < (int)adj[u].size(); j++) {
int v = adj[u][j];
if (v != pa) {
dfs(v, u, f);
dp[u] += max(dp[v], 0LL);
}
}
if (f)
val = max(val, dp[u]);
else if (dp[u] == val) {
dp[u] = 0;
cnt++;
}
}
int main() {
int n;
cin >> n;
a.assign(n, 0);
for (int i = 0; i < n; i++) cin >> a[i];
adj.assign(n, vector<int>());
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dp.assign(n, 0);
val = -large;
dfs(0, -1, 1);
cnt = 0;
dfs(0, -1, 0);
cout << cnt * val << " " << cnt << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int MAX_N = 500000;
int in[MAX_N + 7];
int buf[MAX_N + 7];
int z;
queue<int> kolej;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1, ile = 0, p = 1; i <= n; ++i) {
scanf("%d", &in[i]);
if (in[i] == 0) {
if (ile < k) {
kolej.push(i);
z = max(z, i - p + 1);
++ile;
} else {
if (!kolej.empty()) {
p = kolej.front() + 1;
kolej.pop();
kolej.push(i);
z = max(z, i - p + 1);
} else {
p = i + 1;
}
}
} else {
z = max(z, i - p + 1);
}
}
while (!kolej.empty()) kolej.pop();
for (int i = 1, ile = 0, p = 1; i <= n; ++i) {
if (in[i] == 0) {
if (ile < k) {
kolej.push(i);
in[i] = 1;
++ile;
if (z == i - p + 1) break;
} else {
if (!kolej.empty()) {
p = kolej.front() + 1;
in[p - 1] = 0;
kolej.pop();
kolej.push(i);
in[i] = 1;
if (z == i - p + 1) break;
} else {
p = i + 1;
}
}
} else {
if (z == i - p + 1) break;
}
}
printf("%d\n", z);
for (int i = 1; i <= n; ++i) {
printf("%d ", in[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string stringhe[n];
string alfabeto = "abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < n; i++) cin >> stringhe[i];
for (int j = 0; j < n; j++) {
sort(stringhe[j].begin(), stringhe[j].end());
int l = stringhe[j].length();
bool flag = false;
for (int i = 0; i < 26 - l + 1; i++) {
if (stringhe[j] == alfabeto.substr(i, l)) {
flag = true;
}
}
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.