solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 150005;
class nodo {
public:
long long sum, prefix, sufix, maxi;
nodo() {}
nodo(long long _sum, long long _prefix, long long _sufix, long long _maxi) {
sum = _sum;
prefix = _prefix;
sufix = _sufix;
maxi = _maxi;
}
} tree[1 << 19];
long long eval[N];
void build(int b, int e, int v) {
if (b == e) {
tree[v] = nodo(eval[b], eval[b], eval[b], eval[b]);
} else {
int mid = (b + e) >> 1, le = 2 * v + 1, ri = le + 1;
build(b, mid, le);
build(mid + 1, e, ri);
tree[v].sum = tree[le].sum + tree[ri].sum;
tree[v].maxi = max(tree[le].maxi, tree[ri].maxi);
tree[v].maxi = max(tree[v].maxi, tree[le].sufix + tree[ri].prefix);
tree[v].prefix = max(tree[le].prefix, tree[le].sum + tree[ri].prefix);
tree[v].sufix = max(tree[ri].sufix, tree[le].sufix + tree[ri].sum);
}
}
nodo query(int b, int e, int v, int i, int j) {
if (i <= b && e <= j) {
return tree[v];
}
int mid = (b + e) >> 1, le = 2 * v + 1, ri = le + 1;
if (mid < i)
return query(mid + 1, e, ri, i, j);
else if (mid + 1 > j)
return query(b, mid, le, i, j);
else {
nodo ret1 = query(b, mid, le, i, j);
nodo ret2 = query(mid + 1, e, ri, i, j);
nodo answer;
answer.sum = ret1.sum + ret2.sum;
answer.prefix = max(ret1.prefix, ret1.sum + ret2.prefix);
answer.sufix = max(ret2.sufix, ret1.sufix + ret2.sum);
answer.maxi = max(ret1.maxi, ret2.maxi);
answer.maxi = max(answer.maxi, ret1.sufix + ret2.prefix);
return answer;
}
}
int p[N], x[N];
int main() {
int c, m, n;
cin >> n >> m >> c;
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
for (int i = 0; i < n - 1; ++i) scanf("%d", &p[i]);
n--;
for (int i = 0; i < n; ++i) {
eval[i] = (long long)(x[i + 1] - x[i]) * 50 - (long long)c * p[i];
}
build(0, n - 1, 0);
int a, b;
long long answer = 0;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &a, &b);
a--;
b -= 2;
long long parcial = max(0LL, query(0, n - 1, 0, a, b).maxi);
answer += parcial;
}
printf("%.10f\n", answer / 100.0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct tree {
int last;
int suf[1000007];
int link[1000007];
int len[1000007];
int diff[1000007];
int to[1000007][26];
int sz;
vector<int> s;
tree() {
s.push_back(-1);
sz = 2;
last = 1;
for (int i = 0; i < 1000007; i++) suf[i] = -1, len[i] = -1, link[i] = -1;
len[1] = 0;
suf[1] = 0;
for (int i = 0; i < 1000007; i++)
for (int j = 0; j < 26; j++) to[i][j] = -1;
}
void add(int c) {
s.push_back(c);
while (last != -1) {
if (c != s[(int)s.size() - len[last] - 2])
last = suf[last];
else
break;
}
if (to[last][c] == -1) {
int v = sz++;
to[last][c] = v;
len[v] = len[last] + 2;
do {
last = suf[last];
} while (last != -1 && c != s[(int)s.size() - len[last] - 2]);
if (last == -1) {
suf[v] = 1;
} else {
suf[v] = to[last][c];
}
diff[v] = len[v] - len[suf[v]];
if (diff[v] == diff[suf[v]])
link[v] = link[suf[v]];
else
link[v] = suf[v];
last = v;
} else
last = to[last][c];
}
} cc;
int series_ans[1000007];
int p_series_ans[1000007];
string s1, s2;
int dp[1000007];
int p[1000007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s1 >> s2;
string s;
for (int i = 0; i < s1.size() * 2; i++) {
if (i % 2 == 0) {
s += s1[i / 2];
} else {
s += s2[i / 2];
}
}
dp[0] = 0;
p[0] = -1;
for (int i = 1; i <= s.size(); i++) {
cc.add(s[i - 1] - 'a');
dp[i] = 1e9 + 7;
p[i] = -1;
if (i - 2 >= 0 && s[i - 1] == s[i - 2]) {
dp[i] = dp[i - 2];
p[i] = i - 2;
}
for (int v = cc.last; v > 1; v = cc.link[v]) {
series_ans[v] = dp[i - (cc.len[cc.link[v]] + cc.diff[v])];
p_series_ans[v] = i - (cc.len[cc.link[v]] + cc.diff[v]);
if (cc.diff[v] == cc.diff[cc.suf[v]]) {
if (series_ans[cc.suf[v]] < series_ans[v]) {
series_ans[v] = series_ans[cc.suf[v]];
p_series_ans[v] = p_series_ans[cc.suf[v]];
}
}
if (series_ans[v] + 1 < dp[i]) {
dp[i] = min(dp[i], series_ans[v] + 1);
p[i] = p_series_ans[v];
}
}
if (i % 2 == 1) {
dp[i] = 1e9 + 7;
p[i] = -1;
}
}
if (dp[s.size()] == 1e9 + 7) cout << -1, exit(0);
vector<pair<int, int> > ans;
int pos = s.size();
while (pos != 0) {
int pred = p[pos];
if (pred + 2 != pos) {
ans.push_back(make_pair((pred + 2) / 2, pos / 2));
}
pos = pred;
}
cout << ans.size() << endl;
for (auto c : ans) cout << c.first << ' ' << c.second << "\n";
}
| 12 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
for (int s = 0; s < n; s++) {
for (int k = 0; k < n; k++) {
printf("%d ", n * k + (k + s) % n + 1);
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
bool safemult(long long a, long long b) {
return numeric_limits<long long>::max() / a >= b;
}
vector<long long> foo(const vector<unsigned> &p) {
vector<long long> ans;
minheap<long long> pq;
pq.emplace(1);
while (!pq.empty()) {
auto t = pq.top();
while (!pq.empty() && pq.top() == t) pq.pop();
for (auto it : p)
if (safemult(t, it))
pq.push(t * it);
else
break;
ans.push_back(t);
}
return ans;
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n;
cin >> n;
vector<unsigned> p(n);
for (auto &it : p) cin >> it;
int k;
cin >> k;
vector<unsigned> a, b;
for (size_t i = 0; i < p.size(); i++) (i & 1 ? a : b).push_back(p[i]);
auto x = foo(a);
auto y = foo(b);
auto l = 0ll, r = (long long)1e18 + 1;
while (l + 1 < r) {
auto t = (l + r) / 2;
int q = y.size() - 1;
auto s = 0ll;
for (size_t i = 0; i < x.size(); i++) {
while (q >= 0 && (!safemult(x[i], y[q]) || x[i] * y[q] > t)) q--;
s += q + 1;
}
(k <= s ? r : l) = t;
}
cout << r << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
for (i = 1; i <= n % m; i++) cout << (n / m + 1) << " ";
while (i <= m) {
cout << (n / m) << " ";
i++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, n, k, i;
int main() {
cin >> t;
for (k = 1; k <= t; k++) {
cin >> n;
cout << n << endl;
for (i = 1; i <= n; i++) cout << i << ' ';
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ar;
cin >> ar;
int l = ar.length();
int p = 0, c = 0, sum = 0;
for (int i = 0; i < l; i++) {
if (ar[i] == 'C') {
c++;
if (p > 0 && p < 5) {
sum = sum + 1;
p = 0;
}
if (c == 5) {
sum += 1;
c = 0;
}
} else if (ar[i] == 'P') {
p++;
if (c > 0 && c < 5) {
sum += 1;
c = 0;
}
if (p == 5) {
sum = sum + 1;
p = 0;
}
}
}
if (c > 0 || p > 0) {
sum += 1;
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void dfs(int v, int anc, vector<vector<int>> &edges, vector<bool> &leaf,
int &sumleaf, int &comps) {
vector<bool> bruh;
for (auto i : edges[v]) {
if (i == anc) continue;
dfs(i, v, edges, leaf, sumleaf, comps);
bruh.push_back(leaf[i]);
}
int cntleaf = 0, cnt_not_leaf = 0;
for (auto i : bruh) {
if (i)
cntleaf++;
else
cnt_not_leaf++;
}
if (!cntleaf) {
if (v == 1) comps++;
leaf[v] = 1;
sumleaf++;
return;
}
comps++;
}
void solve() {
int n, m;
cin >> n >> m;
vector<long long> points(n);
for (int i = 0; i < n; i++) cin >> points[i];
sort(points.begin(), points.end());
vector<pair<long long, long long>> s;
vector<vector<pair<long long, long long>>> lst;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
auto it = lower_bound(points.begin(), points.end(), l);
if (it != points.end() && *it <= r) continue;
s.push_back({l, r});
}
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
points.push_back(-1e18), points.push_back(1e18);
sort(points.begin(), points.end());
for (int i = 1; i < points.size(); i++) {
lst.push_back(vector<pair<long long, long long>>());
while (s.size() && s.back().first < points[i])
lst.back().push_back(s.back()), s.pop_back();
sort(lst.back().begin(), lst.back().end());
}
vector<vector<long long>> dp(n + 2, vector<long long>(2, 1e18));
dp[0][0] = dp[0][1] = 0;
for (int i = 1; i < n + 2; i++) {
vector<long long> pref(lst[i - 1].size() + 1), suf(lst[i - 1].size() + 1);
pref[0] = points[i - 1], suf[0] = points[i];
for (int j = 1; j < lst[i - 1].size() + 1; j++)
pref[j] = max(pref[j - 1], lst[i - 1][j - 1].first);
for (int j = 1; (long long)lst[i - 1].size() - j >= 0; j++)
suf[j] = min(suf[j - 1], lst[i - 1][lst[i - 1].size() - j].second);
for (int type1 = 0; type1 <= 1; type1++) {
for (int type2 = 0; type2 <= 1; type2++) {
for (int j = 0; j <= lst[i - 1].size(); j++) {
int pr1 = 1, pr2 = 1;
if (type1) pr1 = 2;
if (!type2) pr2 = 2;
dp[i][type2] = min(
dp[i][type2],
dp[i - 1][type1] + (long long)(pref[j] - points[i - 1]) * pr1 +
(long long)(points[i] - suf[lst[i - 1].size() - j]) * pr2);
}
}
}
}
long long mins = 1e18;
for (int i = 0; i < 2; i++) mins = min(mins, dp[n + 1][i]);
cout << mins << endl;
}
signed main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') t = -1;
c = getchar();
}
while (isdigit(c)) s = s * 10 + c - 48, c = getchar();
return s * t;
}
const int N = 5e5 + 5, inf = 1e9 + 7;
struct nod {
int a, b, c;
bool operator<(const nod& rhs) const { return c < rhs.c; }
} A[N];
struct node {
int x, d;
node(int a, int b) { x = a, d = b; }
bool operator<(const node& rhs) const { return d < rhs.d; }
};
set<node> S;
set<node>::iterator it, itt, ittt;
long long ans = 0, sum = 0;
inline void In(int x, int d) {
it = S.upper_bound(node(x, d));
if (it != S.end() && it->x >= x) return;
if (it != S.begin()) {
it--;
if (it->d == d && it->x >= x) return;
}
while (1) {
it = S.upper_bound(node(x, d));
if (it != S.begin()) {
it--;
if (it->x <= x) {
itt = it, itt++;
if (itt != S.end()) {
sum -= (long long)(it->x - itt->x) * it->d;
if (it != S.begin()) {
ittt = it, ittt--;
sum += (long long)(it->x - itt->x) * ittt->d;
}
} else {
sum -= (long long)it->x * it->d;
if (it != S.begin()) {
ittt = it, ittt--;
sum += (long long)it->x * ittt->d;
}
}
S.erase(it);
} else
break;
} else
break;
}
if (S.size()) {
it = S.upper_bound(node(x, d));
if (it == S.end()) {
itt = it, itt--;
sum += (long long)(d - itt->d) * x;
} else {
if (it == S.begin()) {
sum += (long long)d * (x - it->x);
} else {
itt = it, itt--;
sum += (long long)(d - itt->d) * (x - it->x);
}
}
} else
sum = (long long)x * d;
S.insert(node(x, d));
}
int main() {
int n = read();
long long p = read(), q = read(), r = read(), now = r;
for (register int i = 1; i <= n; ++i)
A[i].a = read(), A[i].b = read(), A[i].c = read();
sort(A + 1, A + n + 1);
for (register int i = 1; i <= n; ++i) In(A[i].a, A[i].b);
int L, R = n;
while (R) {
L = R;
while (L >= 1 && A[L].c == A[R].c) L--;
ans += (now - A[R].c) * sum;
for (register int i = L + 1; i <= R; ++i) In(p, A[i].b), In(A[i].a, q);
now = A[R].c, R = L;
}
ans += now * sum;
cout << p * q * r - ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
const double eps = (1e-10);
using namespace std;
int dcmp(double a, double b) {
return fabs(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
long long getBit(long long num, int idx) { return ((num >> idx) & 1ll) == 1ll; }
long long setBit1(long long num, int idx) { return num | (1ll << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(long long num, int idx) { return num ^ (1ll << idx); }
int countNumBit1(long long mask) {
int ret = 0;
while (mask) {
mask &= (mask - 1ll);
++ret;
}
return ret;
}
vector<pair<int, int>> v;
vector<int> v2, v1;
int main() {
long long n, k;
cin >> n >> k;
long long s = 0, no;
for (int i = 1; i <= n; i++) {
cin >> no;
v.push_back(make_pair(no, i));
v2.push_back(no);
s += no;
}
if (s < k) {
cout << "-1\n";
return 0;
}
sort(((v2).begin()), ((v2).end()));
long long c = 0, Ci;
int emptyy = 0;
while (1) {
if (v2.back() <= c) {
emptyy = 1;
break;
}
int id = upper_bound(((v2).begin()), ((v2).end()), c) - v2.begin();
long long turns = v2[id] - c;
int N = n - id;
long long m = min(turns, k / N);
if (k == 0)
break;
else if (k < N) {
Ci = c;
break;
} else if (k >= N) {
c += m;
k -= m * N;
}
}
if (emptyy) {
cout << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (k == 0 && v[i].first > c)
cout << v[i].second << " ";
else if (k > 0 && v[i].first > c) {
v[i].first--;
if (v[i].first - c > 0) v1.push_back(v[i].second);
k--;
}
}
for (int i = 0; i < ((int)(v1).size()); i++) cout << v1[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long k;
cin >> n >> k;
int ara[n], i;
long long fib[n + 5];
for (i = 0; i < n; i++) ara[i] = i + 1;
fib[0] = fib[1] = 1;
for (i = 2; i < n + 5; i++) fib[i] = fib[i - 1] + fib[i - 2];
for (i = 0; i < n - 1; i++) {
if (fib[n - i - 1] >= k) continue;
swap(ara[i], ara[i + 1]);
k -= fib[n - i - 1];
}
for (i = 0; i < n; i++) cout << ara[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[101], t, s, b[101][101], re;
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
s = 0;
for (int j = 0; j < a[i]; j++) {
scanf("%d", &t);
s += t;
}
s = s * 5 + 15 * a[i];
if (!re)
re = s;
else
re = min(re, s);
}
printf("%d\n", re);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[300010];
vector<pair<char, int> > v;
int main() {
scanf("%s", s);
int len = strlen(s);
int t = 0;
s[len] = '0';
for (int i = 0; i < len; ++i) {
if (s[i] == s[i + 1]) {
++t;
continue;
} else {
++t;
v.push_back(make_pair(s[i], t));
t = 0;
}
}
int Size = v.size();
if (Size % 2 == 0) {
cout << "0" << endl;
return 0;
} else {
for (int i = 0; i <= Size / 2; ++i) {
if (v[i].first != v[Size - i - 1].first) {
cout << "0" << endl;
return 0;
}
if (v[i].second + v[Size - i - 1].second < 3) {
cout << "0" << endl;
return 0;
}
if (i == Size - i + 1) {
if (v[i].second < 2) {
cout << "0" << endl;
return 0;
}
}
}
cout << v[Size / 2].second + 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int qread() {
char c;
int s = 0, t = 1;
while ((c = getchar()) < '0' || c > '9') (c == '-') && (t = -1);
do s = s * 10 + c - '0';
while ((c = getchar()) >= '0' && c <= '9');
return s * t;
}
int n, m;
int lisax[400011], lx = 0, lisay[400011], ly = 0, ll[400011], rr[400011];
struct MM {
int x, y1, y2, ty, col;
} mm[400011];
int lm = 0;
bool cmpx(const MM &a, const MM &b) { return a.x < b.x; }
bool vis[400011];
struct SMT {
struct Node {
int ls, rs, Max, Min;
set<int, greater<int> > s;
} a[400011 << 1];
int size, n;
void up(int x) {
Node &b = a[x], &p = a[a[x].ls], &q = a[a[x].rs];
int mm = b.s.empty() ? -1 : *(b.s.begin());
if (mm > max(p.Max, q.Max)) {
if (vis[mm])
b.Max = -1;
else if (mm < min(p.Min, q.Min))
b.Max = -1;
else
b.Max = mm;
} else
b.Max = max(p.Max, q.Max);
b.Min = max(mm, min(p.Min, q.Min));
}
void build(int &x, int L, int R) {
x = ++size;
a[x].Max = -1;
a[x].Min = -1;
if (L == R) return;
int mid = (L + R) >> 1;
build(a[x].ls, L, mid);
build(a[x].rs, mid + 1, R);
}
void clear(int N) {
size = 0;
n = N;
a[0].Max = a[0].Min = -1;
int x;
build(x, 1, n);
}
int ql, qr, v;
void Add(int x, int L, int R) {
if (ql <= L && R <= qr) {
if (!vis[v]) a[x].s.insert(v);
up(x);
return;
}
int mid = (L + R) >> 1;
if (ql <= mid) Add(a[x].ls, L, mid);
if (qr > mid) Add(a[x].rs, mid + 1, R);
up(x);
}
void add(int L, int R, int V) {
ql = L;
qr = R;
v = V;
Add(1, 1, n);
}
void DEL(int x, int L, int R) {
if (ql <= L && R <= qr) {
a[x].s.erase(v);
up(x);
return;
}
int mid = (L + R) >> 1;
if (ql <= mid) DEL(a[x].ls, L, mid);
if (qr > mid) DEL(a[x].rs, mid + 1, R);
up(x);
}
void Del(int L, int R, int V) {
ql = L;
qr = R;
v = V;
DEL(1, 1, n);
}
} t;
int main() {
m = qread();
for (int i = 1, x1, x2; i <= m; i++) {
x1 = qread();
lm++;
mm[lm].y1 = qread();
x2 = qread();
mm[lm].y2 = qread();
mm[lm].x = x1;
mm[lm].ty = 1;
mm[lm + 1] = mm[lm];
lm++;
mm[lm].x = x2;
mm[lm].ty = -1;
lisax[++lx] = x1;
lisax[++lx] = x2;
lisay[++ly] = mm[lm].y1;
lisay[++ly] = mm[lm].y2;
mm[lm].col = mm[lm - 1].col = i;
}
sort(lisax + 1, lisax + 1 + lx);
sort(lisay + 1, lisay + 1 + ly);
lx = unique(lisax + 1, lisax + 1 + lx) - lisax - 1;
ly = unique(lisay + 1, lisay + 1 + ly) - lisay - 1;
for (int i = 1; i <= lm; i++)
mm[i].x = lower_bound(lisax + 1, lisax + 1 + lx, mm[i].x) - lisax,
mm[i].y1 = lower_bound(lisay + 1, lisay + 1 + ly, mm[i].y1) - lisay,
mm[i].y2 = lower_bound(lisay + 1, lisay + 1 + ly, mm[i].y2) - lisay;
for (int i = 1; i <= m; i++) ll[i] = mm[i << 1].y1, rr[i] = mm[i << 1].y2;
t.clear(ly);
sort(mm + 1, mm + 1 + lm, cmpx);
int ans = 0;
for (int i = 1, j = 1; i <= lx; i++) {
for (; j <= lm && mm[j].x == i; j++) {
if (mm[j].ty == 1)
t.add(mm[j].y1, mm[j].y2 - 1, mm[j].col);
else
t.Del(mm[j].y1, mm[j].y2 - 1, mm[j].col);
}
int tmp = t.a[1].Max;
while (~tmp) {
vis[tmp] = 1;
ans++;
t.add(ll[tmp], rr[tmp] - 1, tmp);
tmp = t.a[1].Max;
}
}
printf("%d\n", ans + 1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, Min, rez = 0;
cin >> a >> b >> c;
Min = min(a % 3, min(b, c));
rez = max(rez, Min + (a - Min) / 3 + (b - Min) / 3 + (c - Min) / 3);
Min = min(b % 3, min(a, c));
rez = max(rez, Min + (a - Min) / 3 + (b - Min) / 3 + (c - Min) / 3);
Min = min(b % 3, min(a, c));
rez = max(rez, Min + (a - Min) / 3 + (b - Min) / 3 + (c - Min) / 3);
Min = min(a, min(b, c));
rez = max(rez, Min + (a - Min) / 3 + (b - Min) / 3 + (c - Min) / 3);
cout << rez;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int int_inf = 0x3f3f3f3f;
const double double_inf = 1e10 * 1e10;
int debug = 0;
const int maxn = 2e5 + 10;
int a[maxn], n;
long long sum;
long long ans[maxn];
set<pair<pair<int, int>, int> > S;
vector<int> H[maxn], v[maxn];
set<pair<pair<int, int>, int> >::iterator it, it2;
void divide(int x) {
it = S.lower_bound(make_pair(make_pair(x + 1, 0), -1));
if (it == S.begin()) return;
--it;
pair<pair<int, int>, int> t = *it;
if (t.first.second < x) return;
S.erase(it);
S.insert(make_pair(make_pair(t.first.first, x), t.second));
if (t.first.second >= x + 1)
S.insert(make_pair(make_pair(x + 1, t.first.second), t.second));
}
void remove(int x) {
divide(x - 1);
while (S.rbegin()->first.first >= x) {
pair<pair<int, int>, int> t = *S.rbegin();
sum -= (long long)t.second * (t.first.second - t.first.first + 1);
S.erase(t);
}
}
void maximize(int l, int maxi) {
it = S.lower_bound(make_pair(make_pair(l, 0), 0));
pair<pair<int, int>, int> t;
t.first.first = l, t.second = maxi;
while (it != S.end()) {
if (it->second >= maxi) break;
t.first.second = it->first.second;
sum -= (long long)it->second * (it->first.second - it->first.first + 1);
it2 = it;
it2++;
S.erase(it);
it = it2;
}
if (t.first.first <= t.first.second) {
sum += (long long)t.second * (t.first.second - t.first.first + 1);
S.insert(t);
}
}
int main() {
if (debug) freopen("in.txt", "r", stdin);
while (~scanf("%d", &n)) {
sum = 0;
S.clear();
for (int i = 0; i <= maxn - 1; i++) v[i].clear(), H[i].clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += i;
H[a[i]].push_back(i);
S.insert(make_pair(make_pair(i, i), i));
}
for (int i = 1; i <= maxn - 1; i++) {
for (int j = i; j < maxn; j += i)
for (__typeof(H[j].begin()) it = H[j].begin(); it != H[j].end(); it++)
v[i].push_back(*it);
}
ans[maxn - 1] = (long long)n * (n + 1) >> 1;
for (int i = maxn - 2; i >= 1; i--) {
int l = v[i].size() - 1;
if (l <= 0) {
ans[i] = ans[i + 1];
continue;
}
sort(v[i].begin(), v[i].end());
remove(v[i][1] + 1);
maximize(1, v[i][l - 1]);
divide(v[i][0]);
maximize(v[i][0] + 1, v[i][l]);
ans[i] = (long long)S.rbegin()->first.second * (n + 1) - sum;
}
long long tot = 0;
for (int i = 1; i <= maxn - 2; i++)
tot += (long long)i * (ans[i + 1] - ans[i]);
printf("%lld\n", tot);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, p = 1, s = 0;
cin >> a >> b >> c >> d >> e;
while (p <= a) {
p += min(b + d * s, c);
s++;
if (p > a) break;
p -= e;
}
cout << s << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long ara[100005], b[100005];
vector<long long> m, bb;
bool bad(int f1, int f2, int f3) {
return (1.0 * (bb[f3] - bb[f1]) * (m[f1] - m[f2]) <=
1.0 * (bb[f2] - bb[f1]) * (m[f1] - m[f3]));
}
void add(long long _m, long long _b) {
m.push_back(_m);
bb.push_back(_b);
int sz = m.size();
while (sz >= 3 && bad(sz - 3, sz - 2, sz - 1)) {
long long t = m.back();
m.pop_back();
m.pop_back();
m.push_back(t);
t = bb.back();
bb.pop_back();
bb.pop_back();
bb.push_back(t);
sz--;
}
return;
}
long long eval(int i, long long x) { return m[i] * x + bb[i]; }
long long query(long long x) {
int lo = 0, hi = m.size() - 1;
long long mn = LLONG_MAX;
while (lo + 5 < hi) {
int m1 = (lo + hi) / 2;
int m2 = m1 + 1;
long long y1 = eval(m1, x);
long long y2 = eval(m2, x);
if (y1 <= y2)
mn = y1, hi = m1;
else
mn = y2, lo = m2;
}
for (int i = lo; i <= hi; i++) mn = min(mn, eval(i, x));
return mn;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &ara[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
if (n == 1) {
puts("0");
return 0;
}
long long res = LLONG_MAX;
add(b[1], 0);
for (int i = 2; i <= n; i++) {
res = query(ara[i]);
add(b[i], res);
}
printf("%lld\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4005;
long long a;
char s[N];
map<long long, long long> cnt;
int main() {
scanf("%lld", &a);
scanf("%s", s);
int len = strlen(s);
cnt.clear();
long long dp[N];
dp[0] = s[0] - '0';
for (int i = 1; i < len; i++) dp[i] = dp[i - 1] + (s[i] - '0');
for (int i = 0; i < len; i++) dp[i] = s[i] - '0';
for (int i = 1; i < len; i++) dp[i] += dp[i - 1];
for (int i = 0; i < len; i++)
for (int j = i; j < len; j++) {
long long sum = dp[j];
if (i != 0) sum -= dp[i - 1];
cnt[sum]++;
}
if (a == 0) {
long long ans = 0;
for (auto data : cnt) {
ans += 2 * cnt[0] * data.second;
}
ans -= cnt[0] * cnt[0];
printf("%lld\n", ans);
return 0;
}
bool kuadrat = 0;
long long ans = 0;
for (long long i = 1; i * i <= a; i++) {
if (i * i == a && cnt[i] > 0) {
kuadrat = 1;
ans += cnt[i] * cnt[i];
} else if (a % i == 0 && cnt[i] > 0 && cnt[a / i] > 0)
ans += 2 * cnt[i] * cnt[a / i];
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int i, ans, j, t;
int num[2005];
while (scanf("%d%d", &n, &k) != EOF) {
ans = 0;
for (i = 0; i < n; i++) scanf("%d", &num[i]);
for (i = 0; i < n; i++)
for (j = 0; j < n - i - 1; j++)
if (num[j] > num[j + 1]) {
t = num[j];
num[j] = num[j + 1];
num[j + 1] = t;
}
for (i = n - 1; i >= 0; i = i - k) ans += (num[i] - 1) * 2;
printf("%d\n", ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[350][350];
int dp[305][305][305 * 2 + 5];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= 2 * n; k++) {
dp[i][j][k] = -0x3f3f3f3f;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
}
}
dp[1][1][0] = a[1][1];
for (int i = 1; i <= n; i++) {
for (int x = 1; x <= n; x++) {
for (int step = 1; step <= 2 * n - 1; step++) {
int j = 2 + step - i;
int y = 2 + step - x;
if (i == 1 && j == 1) continue;
if (x == 1 && y == 1) continue;
if (j >= 1 && j <= n && y >= 1 && y <= n) {
dp[i][x][step] = max(
dp[i][x][step], dp[i - 1][x - 1][step - 1] + a[i][j] + a[x][y]);
dp[i][x][step] =
max(dp[i][x][step], dp[i - 1][x][step - 1] + a[i][j] + a[x][y]);
dp[i][x][step] =
max(dp[i][x][step], dp[i][x - 1][step - 1] + a[i][j] + a[x][y]);
dp[i][x][step] =
max(dp[i][x][step], dp[i][x][step - 1] + a[i][j] + a[x][y]);
if (i == x && j == y) dp[i][x][step] -= a[x][y];
}
}
}
}
printf("%d\n", dp[n][n][2 * n - 2]);
}
}
| 6 |
#include <bits/stdc++.h>
int n, m, cnt = 0, fa[1000010];
long long ans = 0, du[1000010];
struct node {
int x, y;
} mp[1000010];
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[i].x = x;
mp[i].y = y;
if (x != y) {
du[x]++, du[y]++;
int fx = find(x), fy = find(y);
if (fx != fy) fa[fx] = fy;
} else
++cnt;
}
ans = (long long)cnt * (cnt - 1);
int k = find(mp[1].x);
for (int i = 1; i <= m; i++)
if (find(mp[i].x) != find(mp[i].y) || find(mp[i].x) != k) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; i++)
if (du[i]) ans += (long long)du[i] * (du[i] - 1);
ans >>= 1;
ans += (long long)cnt * (m - cnt);
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, a, odd = 0, even = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &a);
if (a % 2 == 0) {
even += 1;
} else {
odd += 1;
}
}
printf("%d\n", (odd % 2 == 1 ? odd : even));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, up(0), co(0);
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
up += arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] >= up) {
up += arr[i];
co++;
}
}
cout << ++co << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
bool dif(string s) {
vector<bool> d(10);
for (int i = 0; i < int((s).size()); i++) d[s[i] - '0'] = true;
int c = 0;
for (int i = 0; i < int((d).size()); i++)
if (d[i]) ++c;
return c == s.size();
}
int bok(string s1, string s2) {
int c = 0;
for (int i = 0; i < int((s1).size()); i++)
if (s1[i] == s2[i]) ++c;
return c;
}
int kok(string s1, string s2) {
vector<bool> d1(10);
for (int i = 0; i < int((s1).size()); i++) d1[s1[i] - '0'] = true;
vector<bool> d2(10);
for (int i = 0; i < int((s2).size()); i++) d2[s2[i] - '0'] = true;
int c = 0;
for (int i = 0; i < int((d1).size()); i++)
if (d1[i] && d2[i]) ++c;
return c - bok(s1, s2);
}
int main() {
int n;
cin >> n;
vector<string> pr(n);
vector<int> b(n), k(n);
for (int i = 0; i < int((pr).size()); i++) cin >> pr[i] >> b[i] >> k[i];
int c = 0, what;
for (int j = 123; j < 9999; ++j) {
ostringstream os;
os << j;
istringstream is(os.str());
string sj;
is >> sj;
if (sj.size() == 3) sj.insert(sj.begin(), '0');
if (!dif(sj)) continue;
int t = 0;
for (; t < n; ++t)
if (bok(sj, pr[t]) != b[t]) break;
if (t != n) continue;
t = 0;
for (; t < n; ++t)
if (kok(sj, pr[t]) != k[t]) break;
if (t != n) continue;
++c;
what = j;
}
if (c > 1)
cout << "Need more data\n";
else if (c == 1) {
if (what < 1000) cout << '0';
cout << what << endl;
} else
cout << "Incorrect data\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 20010, maxn = 10010, maxk = 1110;
const int inf = 1e7;
int to1[maxm], begin1[maxn], next1[maxm], w[maxm][maxk], cur[maxn], e = 1,
W[maxm];
int d[maxn], q[maxn], g[maxk], ans[maxk], vis[maxn], pre[maxn], lg[maxn],
t[maxk];
int tot, n;
struct node {
int x, f;
} Q[maxn];
void read(int &x) {
x = 0;
char c = getchar();
while (!('0' <= c && c <= '9')) c = getchar();
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
}
void add(int x, int y, int z) {
to1[++e] = y;
next1[e] = begin1[x];
begin1[x] = e;
w[e][0] = z;
}
int min(int x, int y) { return x < y ? x : y; }
int bfs(int x, int y) {
int r = 0, l = 1, i;
for (i = 1; i <= y; i++) d[i] = 0;
q[0] = x;
d[x] = 1;
while (r < l) {
int xx = q[r];
r++;
for (i = begin1[xx]; i; i = next1[i])
if (!d[to1[i]] && w[i][0]) {
d[to1[i]] = d[xx] + 1;
q[l] = to1[i];
l++;
}
}
return d[y];
}
int dfs(int x, int y, int sum) {
int i;
if (x == y) return sum;
int flow = 0;
for (int &i = cur[x]; i; i = next1[i]) {
if (d[to1[i]] == d[x] + 1 && w[i][0]) {
int h = dfs(to1[i], y, min(sum, w[i][0]));
w[i][0] -= h;
w[i ^ 1][0] += h;
flow += h;
sum -= h;
if (!sum) break;
}
}
if (flow == 0) d[x] = -1;
return flow;
}
int Bfs(int x, int y) {
int r = 0, l = 1, flag = 0, i;
Q[r].x = x;
Q[r].f = 25;
vis[x] = tot;
while (r < l) {
node xx = Q[r];
r++;
for (i = begin1[xx.x]; i; i = next1[i]) {
if (W[i] && vis[to1[i]] != tot) {
vis[to1[i]] = tot;
pre[to1[i]] = i;
Q[l].x = to1[i];
Q[l].f = min(xx.f, W[i]);
if (to1[i] == n) {
flag = 1;
break;
}
l++;
}
}
if (flag) break;
}
int ans = 0;
if (flag) {
ans = Q[l].f;
int now = n;
while (now != 1) {
W[pre[now]] -= ans;
W[pre[now] ^ 1] += ans;
now = to1[pre[now] ^ 1];
}
}
return ans;
}
int main() {
int i, j, m, k, q, x, y, z;
read(n);
read(m);
read(k);
read(q);
for (i = 1; i <= m; i++) {
read(x);
read(y);
read(z);
add(x, y, z);
add(y, x, 0);
}
while (bfs(1, n)) {
for (i = 1; i <= n; i++) cur[i] = begin1[i];
int h = dfs(1, n, inf);
while (h) {
ans[0] += h;
h = dfs(1, n, inf);
}
}
lg[1] = 1;
for (i = 2; i < (1 << k); i <<= 1) lg[i] = lg[i >> 1] + 1;
for (i = 1; i < (1 << k); i++) {
int p = i - (i & (-i));
for (j = 2; j <= e; j++) w[j][i] = w[j][p];
ans[i] = ans[p];
w[lg[(i & (-i))] << 1][i] = 25;
++tot;
for (j = 1; j <= e; j++) W[j] = w[j][i];
int h = Bfs(1, n);
while (h) {
ans[i] += h;
++tot;
h = Bfs(1, n);
}
for (j = 1; j <= e; j++) w[j][i] = W[j];
}
while (q--) {
int sum = ans[0];
g[0] = 0;
for (i = 1; i <= k; i++) {
read(t[i]);
sum += t[i];
g[0] += t[i];
}
for (i = 1; i < (1 << k); i++) {
int p = i - (i & (-i)), &h = g[i];
h = g[p];
h -= t[lg[i & (-i)]];
sum = min(sum, h + ans[i]);
}
printf("%d\n", sum);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, c[111], b[111], q, x, dp[111][11111], pre[111][11111], sum[111], all, ans[333], l, r, mnl, mnr, cc;
void add(int &x, int y)
{
x += y;
if (x >= mod) x -= mod;
}
int solve(int x)
{
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i <= all; i++) pre[0][i] = 1;
for (int i = 1; i <= n; i++)
{
for (int j = sum[i - 1] + i * x; j <= all; j++)
{
dp[i][j] = pre[i - 1][j];
if (c[i] < j) dp[i][j] = (dp[i][j] - pre[i - 1][j - c[i] - 1]) % mod;
}
pre[i][0] = dp[i][0];
for (int j = 1; j <= all; j++) pre[i][j] = (pre[i][j - 1] + dp[i][j]) % mod;
}
int res = 0;
for (int i = 0; i <= all; i++) res = (res + dp[n][i]) % mod;
return res;
}
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i < n; i++) scanf("%d", &b[i]);
cc = 1;
for (int i = 1; i <= n; i++)
{
cc = 1ll * cc * (c[i] + 1) % mod;
}
for (int i = 1; i < n; i++)
{
sum[i] = sum[i - 1] + b[i];
}
for (int i = 1; i <= n; i++) all += c[i];
mnl = mnr = 1e9;
for (int i = 1; i <= n; i++)
{
l -= sum[i - 1];
r += (c[i] - sum[i - 1]);
mnl = min(mnl, l / i);
mnr = min(mnr, r / i);
}
for (int i = 1; i <= n; i++) sum[i] += sum[i - 1];
for (int i = mnl; i <= mnr; i++) ans[i - mnl] = solve(i);
scanf("%d", &q);
while(q--)
{
scanf("%d", &x);
if (x > mnr) printf("0\n");
else if (x < mnl) printf("%d\n", cc);
else printf("%d\n", (ans[x - mnl] + mod) % mod);
}
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
if (p1 == p2) return EOF;
}
return *p1++;
}
inline int getint() {
int x;
char c = nc(), b = 1;
if (c == -1) return 0;
for (; !(c >= '0' && c <= '9'); c = nc())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= b;
return x;
}
int n;
vector<int> g[1000010];
int ans[1000010];
int calc(int up) {
for (int i = up; i >= 1; i--) {
int mx = 0, se = 0;
for (int v : g[i]) {
if (v > up) break;
if (se < ans[v]) se = ans[v];
if (mx < se) swap(mx, se);
}
ans[i] = max(mx, se + (i > 1));
}
return ans[1];
}
int rlt[1000010];
void solve(int l, int vl, int r, int vr) {
if (vl == vr) {
for (int i = l; i <= r; i++) rlt[i] = vl;
return;
}
if (r - l == 1) {
rlt[l] = vl, rlt[r] = vr;
return;
}
int m = l + r >> 1;
int vm = calc(m);
solve(l, vl, m, vm);
solve(m, vm, r, vr);
}
int main() {
n = getint();
n++;
for (int i = 2; i <= n; i++) {
int x;
x = getint();
g[x].push_back(i);
}
int now = calc(n);
assert(now <= 50);
solve(1, 0, n, now);
for (int i = 2; i <= n; i++) printf("%d ", rlt[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, s = 0;
cin >> a >> b >> c >> d;
while (a > 0 && c > 0 && d > 0) {
s = s + 256;
a--;
c--;
d--;
}
while (a > 0 && b > 0) {
s = s + 32;
a--;
b--;
}
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << "{" << p.first << " " << p.second << "}";
return os;
}
string str(string& str, int& pos) {
string ret = "";
while (str[pos] <= 'Z' && str[pos] >= 'A') {
ret += str[pos];
pos++;
}
return ret;
}
int cnt = 0;
map<string, int> parse(string& s, int& pos) {
string name = str(s, pos);
map<string, int> low;
if (s[pos] == ':') pos++;
while (s[pos] != '.') {
map<string, int> tmp = parse(s, pos);
for (map<string, int>::iterator it = tmp.begin(); it != tmp.end(); ++it)
low[it->first] += it->second;
if (s[pos] == ',') pos++;
}
pos++;
cnt += low[name];
low[name]++;
return low;
}
int main() {
string s;
cin >> s;
int t = 0;
parse(s, t);
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long i, j, k, n;
cin >> n;
map<long long, long long> mp;
long long x = n;
while (x % 2 == 0) {
mp[2]++;
x /= 2;
}
for (i = 3; i * i <= x; i += 2) {
while (x % i == 0) {
mp[i]++;
x /= i;
}
}
if (x > 1) mp[x]++;
long long a = 1, b = 1, c = 1;
i = 0;
auto it = mp.begin();
a = it->first;
if (it->second > 2) {
b = it->first * it->first;
c = n / (it->first * it->first * it->first);
} else if (it->second == 2) {
b = it->first;
it++;
if (it == mp.end()) {
cout << "NO\n";
continue;
} else {
b *= it->first;
c = n / (a * b);
}
} else {
it++;
if (it == mp.end()) {
cout << "NO\n";
continue;
} else {
b *= it->first;
c = n / (a * b);
}
}
if (a == b || b == c || c == a || a < 2 || b < 2 || c < 2) {
cout << "NO\n";
} else {
cout << "YES\n";
cout << a << " " << b << " " << c << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long MOD = 998244353;
long long mod(long long n) {
if (n < 0) {
return (n % MOD + MOD) % MOD;
} else {
if (n < MOD)
return n;
else if (n < 2 * MOD)
return n - MOD;
else
return n % MOD;
}
}
void add(long long &a, long long b) { a = mod(a + b); }
vector<long long> g[N];
long long ans[N], sum[N], good[N];
long long _ans[3], __ans[3];
long long _sum[3], __sum[3];
void dfs(long long u) {
if (g[u].empty()) {
ans[u] = sum[u] = good[u] = 1;
return;
}
for (long long v : g[u]) {
dfs(v);
}
for (long long i = 0; i < 3; ++i) _ans[i] = _sum[i] = 0;
_ans[0] = 1;
for (long long v : g[u]) {
for (long long i = 0; i < 3; ++i) __sum[i] = 0;
for (long long i = 0; i < 3; ++i) {
add(__sum[i], _sum[i] * ans[v] + sum[v] * _ans[i]);
if (i == 0) {
add(__sum[min(2ll, i + 1)], _sum[i] * good[v] + sum[v] * _ans[i]);
} else {
add(__sum[min(2ll, i + 1)],
_sum[i] * good[v] + sum[v] * _ans[i] - good[v] * _ans[i]);
}
}
for (long long i = 0; i < 3; ++i) _sum[i] = __sum[i];
for (long long i = 0; i < 3; ++i) __ans[i] = 0;
for (long long i = 0; i < 3; ++i) {
add(__ans[i], _ans[i] * ans[v]);
add(__ans[min(2ll, i + 1)], _ans[i] * good[v]);
}
for (long long i = 0; i < 3; ++i) _ans[i] = __ans[i];
}
ans[u] = mod(_ans[0] + _ans[2]);
sum[u] = mod(_sum[0] + _sum[2]);
good[u] = _ans[2];
long long add = 0;
long long cnt = 1;
for (long long v : g[u]) {
add = mod(add * ans[v] + good[v] * cnt);
cnt = mod(cnt * ans[v]);
}
good[u] = mod(good[u] + add);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 2; i <= n; ++i) {
long long p;
cin >> p;
g[p].push_back(i);
}
dfs(1);
cout << ans[1] << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int N = 1e5;
int a[N], curr;
int len(int i) {
if (i == 0) return 0;
return 1 + len(i / 10);
}
void solve(int x) {
int l = 1, r = N - 1, m, d;
while (l < r) {
m = (l + r) / 2;
if (x >= a[m] && x < a[m + 1]) {
d = m;
break;
}
if (x > a[m])
l = m + 1;
else
r = m - 1;
d = r;
}
x -= a[d];
if (x == 0) {
cout << d % 10 << endl;
return;
}
for (int i = 1; i <= d + 1; i++) {
if (i < 10)
x--;
else if (i >= 10 && i < 100)
x -= 2;
else if (i >= 100 && i < 1000)
x -= 3;
else if (i >= 1000 && i < 10000)
x -= 4;
else if (i >= 10000 && i < 100000)
x -= 5;
if (x == 0) {
cout << i % 10;
break;
} else if (x == -1) {
cout << (i / 10) % 10;
break;
} else if (x == -2) {
cout << (i / 100) % 10;
break;
} else if (x == -3) {
cout << (i / 1000) % 10;
break;
} else if (x == -4) {
cout << (i / 10000) % 10;
break;
} else if (x == -5) {
cout << (i / 100000) % 10;
break;
}
}
cout << endl;
return;
}
int main() {
for (int i = 1; i < N; i++) {
curr += len(i);
a[i] = a[i - 1] + curr;
}
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
solve(x);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 510;
long long a[N];
void rot1(long long& first, long long& second, long long& z) {
tie(first, second, z) = make_tuple(z, first, second);
}
void rot2(long long ind) { rot1(a[ind], a[ind + 1], a[ind + 2]); }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
map<long long, long long> pos;
long long pos1 = 0, pos2 = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (pos.count(a[i])) pos1 = pos[a[i]], pos2 = i;
pos[a[i]] = i;
a[i] *= N;
a[i] += i;
}
bool even = true;
for (long long i = 1; i <= n; i++)
for (long long j = i + 1; j <= n; j++)
if (a[i] > a[j]) even = !even;
if (!even)
if (pos1)
swap(a[pos1], a[pos2]);
else {
cout << -1 << "\n";
continue;
}
vector<long long> idx;
while (true) {
long long i = 1;
while (i <= n && min_element(a + i, a + n + 1) == a + i) i++;
if (i > n - 2) break;
long long j = min_element(a + i, a + n + 1) - a;
while (j - i >= 2) rot2(j - 2), idx.push_back(j - 2), j -= 2;
if (j - i == 1) rot2(i), idx.push_back(i), rot2(i), idx.push_back(i);
}
if (is_sorted(a + 1, a + n + 1)) {
cout << idx.size() << "\n";
for (long long i : idx) cout << i << " ";
cout << "\n";
} else
cout << -1 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
vector<pair<int, int>> ap(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[i] = x;
ap[i] = make_pair(x, i);
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
b[i] = x;
}
sort(ap.begin(), ap.end());
cout << to_string(n / 2 + 1) << endl;
cout << to_string(ap.back().second + 1) + " ";
for (int i = n - 2; i >= 0;) {
if (i == 0) {
cout << to_string(ap[i].second + 1) + " ";
break;
}
int k = ap[i].second, t = ap[i - 1].second;
if (b[k] >= b[t])
cout << to_string(k + 1) + " ";
else
cout << to_string(t + 1) + " ";
i -= 2;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void amax(T &a, const T &b) {
if (a < b) a = b;
}
const complex<long long> I(0, 1);
const long long EPS = 0;
int sign(double x) {
if (x < -EPS) return -1;
if (EPS < x) return 1;
return 0;
}
namespace std {
bool operator<(const complex<long long> &x, const complex<long long> &y) {
return real(x) != real(y) ? real(x) < real(y) : imag(x) < imag(y);
}
} // namespace std
long long cross(const complex<long long> &x, const complex<long long> &y) {
return imag(conj(x) * y);
}
struct CMP_ARG {
bool operator()(const complex<long long> &x,
const complex<long long> &y) const {
return sign(cross(x, y)) == 1;
}
} cmp_arg;
bool cmp_arg_2(const complex<long long> &x, const complex<long long> &y) {
return arg(complex<double>(x.real(), x.imag())) <
arg(complex<double>(y.real(), y.imag()));
}
int N;
long long C_sub, D_sub;
long long R[400011], W[400011];
vector<complex<long long> > U, D;
long long pos, neg;
int main() {
scanf("%d%lld%lld", &N, &C_sub, &D_sub);
for (int i = 0, i_len = (N); i < i_len; ++i) {
scanf("%lld%lld", R + i, W + i);
R[i] -= C_sub;
W[i] -= D_sub;
}
{
vector<pair<double, complex<long long> > > v;
for (int i = 0, i_len = (N); i < i_len; ++i) {
v.push_back(make_pair(arg(complex<double>(R[i], W[i])),
complex<long long>(R[i], W[i])));
}
sort(v.begin(), v.end());
cerr << v.back().first << endl;
}
for (int i = 0, i_len = (N); i < i_len; ++i) {
if (W[i] > 0)
U.push_back(complex<long long>(R[i], W[i]));
else if (W[i] < 0)
D.push_back(complex<long long>(R[i], W[i]));
else if (R[i] > 0)
pos++;
else
neg++;
}
sort(U.begin(), U.end(), cmp_arg);
sort(D.begin(), D.end(), cmp_arg);
long long ans = 0;
for (long long i = 0, lo = 0, hi = 0; i < (int)U.size(); i++) {
while (hi < (int)D.size() && cross(U[i], D[hi]) >= 0) hi++;
while (lo < (int)D.size() && cross(U[i], D[lo]) > 0) lo++;
ans += lo * ((long long)D.size() - hi);
ans += neg * ((long long)D.size() - hi);
ans += lo * pos;
}
for (long long i = 0, lo = 0, hi = 0; i < (int)D.size(); i++) {
while (hi < (int)U.size() && cross(D[i], U[hi]) >= 0) hi++;
while (lo < (int)U.size() && cross(D[i], U[lo]) > 0) lo++;
ans += lo * ((long long)U.size() - hi);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e2+10;
int n, m;
int num[maxn], ans[maxn][maxn];
int put;
bool DFS(int x, int y, int num) {
// cout << x << " " << y << " " << num << " " << put << endl;
ans[x][y] = put;
if (num == 0) return 1;
if (y-1 >= 1 && !ans[x][y-1] && DFS(x, y-1, num-1)) return 1;
if (x+1 <= n && !ans[x+1][y] && DFS(x+1, y, num-1)) return 1;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++ i) {
scanf("%d", &num[i]);
ans[i][i] = num[i];
}
int flag = 0;
for (int i = 1; i <= n && !flag; ++i) {
put = num[i];
if (DFS(i, i, num[i]-1) == 0) {
flag = 1;
}
// for (int K = 1; K <= n; ++ K) {
// for (int j = 1; j <= K; ++ j) {
// cout << ans[K][j] << " ";
// }
// cout << endl;
// }
}
if (flag == 1) {
cout << -1 << endl;
}
else {
for (int i = 1; i <= n; ++ i) {
for (int j = 1; j <= i; ++ j) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, K, tot;
struct node {
int type;
int x, y1, y2;
} b[1000005];
bool cmp(node a, node b) {
if (a.x != b.x) return a.x < b.x;
if (a.y1 != b.y1) return a.y1 > b.y1;
return a.y2 > b.y2;
}
set<pair<int, int> > s;
int a[1000005 * 4], flag[1000005 * 4];
void down(int x, int l, int r) {
if (flag[x] != -1) {
int mid = (l + r) / 2;
a[x * 2] = 1ll * (mid - l + 1) * flag[x] % 1000000007;
flag[x * 2] = flag[x];
a[x * 2 + 1] = 1ll * (r - mid) * flag[x] % 1000000007;
flag[x * 2 + 1] = flag[x];
flag[x] = -1;
}
}
void cover(int x, int l, int r, int tx, int ty, int val) {
if (tx > ty) return;
if (l >= tx && r <= ty) {
a[x] = 1ll * val * (r - l + 1) % 1000000007;
flag[x] = val;
return;
}
down(x, l, r);
int mid = (l + r) / 2;
if (mid >= tx) cover(x * 2, l, mid, tx, ty, val);
if (mid < ty) cover(x * 2 + 1, mid + 1, r, tx, ty, val);
a[x] = (a[x * 2] + a[x * 2 + 1]) % 1000000007;
}
int query(int x, int l, int r, int tx, int ty) {
if (tx > ty) return 0;
if (l >= tx && r <= ty) return a[x];
down(x, l, r);
int mid = (l + r) / 2, ret = 0;
if (mid >= tx) ret += query(x * 2, l, mid, tx, ty);
if (mid < ty) ret = (ret + query(x * 2 + 1, mid + 1, r, tx, ty)) % 1000000007;
return ret;
}
void build(int x, int l, int r) {
flag[x] = -1;
if (l == r) return;
int mid = (l + r) / 2;
build(x * 2, l, mid);
build(x * 2 + 1, mid + 1, r);
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= K; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
b[++tot].type = 1;
b[tot].x = x1;
b[tot].y1 = y1;
b[tot].y2 = y2;
b[++tot].type = 0;
b[tot].x = x2 + 1;
b[tot].y1 = y1;
b[tot].y2 = y2;
}
build(1, 1, m);
sort(b + 1, b + tot + 1, cmp);
cover(1, 1, m, 1, 1, 1);
int wh = 1;
for (; wh <= tot && b[wh].x == 1; wh++)
s.insert(make_pair(b[wh].y1, b[wh].y2));
s.insert(make_pair(0, 0));
for (int i = 2; i <= n; i++) {
for (int j = wh; j <= tot && b[j].x == i; j++) {
if (b[j].type == 1 && b[j].y2 < m) {
pair<int, int> t = *(--s.lower_bound(make_pair(b[j].y2 + 2, 0)));
int tmp = query(1, 1, m, t.second + 1, b[j].y2 + 1);
cover(1, 1, m, b[j].y2 + 1, b[j].y2 + 1, tmp);
}
}
for (int j = wh; j <= tot && b[j].x == i; j++) {
if (b[j].type == 0) {
s.erase(make_pair(b[j].y1, b[j].y2));
}
}
for (; wh <= tot && b[wh].x == i; wh++) {
if (b[wh].type == 1) {
s.insert(make_pair(b[wh].y1, b[wh].y2));
cover(1, 1, m, b[wh].y1, b[wh].y2, 0);
}
}
}
pair<int, int> t = *(--s.end());
printf("%d\n", query(1, 1, m, t.first + 1, m));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
void read(int& val) {
int x = 0;
int bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int maxn = 2e5 + 11;
const int mod = 1e9 + 7;
int a[maxn];
int n, k, t;
int main() {
read(t);
while (t--) {
read(n);
long long k;
scanf("%lld", &k);
for (int i = 1; i <= n; i++) read(a[i]);
int mx = a[1];
for (int i = 1; i <= n; i++) mx = max(mx, a[i]);
for (int i = 1; i <= n; i++) {
a[i] = mx - a[i];
}
k--;
mx = a[1];
for (int i = 1; i <= n; i++) {
mx = max(mx, a[i]);
}
if (k & 1 || n == 1) {
for (int i = 1; i <= n; i++) printf("%d ", mx - a[i]);
puts("");
} else {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[300005];
int visit[300005], par[300005], dp[300005], mark[300005];
queue<int> Q;
void dfs(int node, int par) {
dp[node] = 1;
for (int i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != par) {
dfs(adj[node][i], node);
dp[node] += dp[adj[node][i]];
}
}
}
int main() {
int N, i, j, k, x, y;
cin >> N >> x >> y;
for (i = 2; i <= N; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(x, x);
visit[x] = 1;
Q.push(x);
par[x] = 0;
while (!Q.empty()) {
int p = Q.front();
Q.pop();
for (i = 0; i < adj[p].size(); i++) {
if (!visit[adj[p][i]]) {
visit[adj[p][i]] = 1;
par[adj[p][i]] = p;
Q.push(adj[p][i]);
}
}
}
int yy = y;
while (yy != x) {
mark[yy] = 1;
yy = par[yy];
}
long long total = (long long)N * ((long long)N - 1LL);
long long papa = 0;
for (i = 0; i < adj[x].size(); i++) {
if (mark[adj[x][i]]) {
dp[x] -= (dp[adj[x][i]]);
}
}
cout << total - ((long long)dp[x] * (long long)dp[y]) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[2000][2000];
int dp[2000];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
queue<int> q;
dp[n - 1] = 0;
q.push(n - 1);
while (!q.empty()) {
int t = q.front();
q.pop();
if (t >= n) {
t -= n;
for (int i = 0; i < n; i++)
if (a[i][t] == '#' && dp[i] == -1) {
dp[i] = dp[t + n] + 1;
q.push(i);
}
} else {
for (int i = 0; i < m; i++)
if (a[t][i] == '#' && dp[n + i] == -1) {
dp[n + i] = dp[t] + 1;
q.push(n + i);
}
}
}
cout << dp[0];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int di[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dj[] = {1, -1, 0, 0, -1, 1, 1, -1};
int get(int l, int r, int v) {
if (r < l) return 0;
return (r / v) - max(0, l - 1) / v;
}
int main() {
int t, d, v, l, r;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &d, &v, &l, &r);
printf("%d\n", get(1, l - 1, v) + get(r + 1, d, v));
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1e3 + 5) * (1e3 + 5);
int now;
int vis[N];
int n, t, c[N], bo[N];
int pre[N];
int f[N][2];
vector<int> ans[5000];
int tot = 2;
;
void dfs(int x, int j, int d) {
if (j >= d && !c[x]) {
bo[x] = 1;
vis[now] = 1;
c[x] = 1;
return;
}
if (j >= d) return;
if (!bo[f[x][0]]) {
if (!f[x][0]) f[x][0] = tot++;
ans[now][j] = 0;
dfs(f[x][0], j + 1, d);
if (vis[now]) {
c[f[x][0]] = 1;
return;
}
}
if (!bo[f[x][1]]) {
if (!f[x][1]) f[x][1] = tot++;
ans[now][j] = 1;
dfs(f[x][1], j + 1, d);
if (vis[now]) {
c[f[x][1]] = 1;
return;
}
}
}
int main() {
cin >> n;
int tot = 1;
int flag = 0;
int p;
for (int i = 1; i <= n; i++) {
scanf("%d", &p);
int u = 1;
int j = 0;
ans[i].assign(p, 0);
now = i;
dfs(1, 0, p);
if (!vis[i]) {
flag = 1;
}
}
if (!flag) {
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 0; j < ans[i].size(); j++) {
printf("%d", ans[i][j]);
}
printf("\n");
}
} else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[(long long)(2e5 + 5)], b[(long long)(2e5 + 5)],
f[(long long)(2e5 + 5)], t[(long long)(2e5 + 5) << 2];
long long n;
void upt(long long i, long long x) {
while (i <= n) t[i] += x, i += (i & (-i));
}
long long qry(long long i) {
long long ans = 0;
while (i) ans += t[i], i -= (i & (-i));
return ans;
}
void solve(long long c[]) {
memset(t, 0, sizeof(t));
for (long long i = 1; i <= n; i++) upt(i, 1);
for (long long i = 1; i < n; i++) {
long long k = qry(c[i]) - 1;
f[n - i] += k;
upt(c[i], -1);
}
}
void update(long long cur, long long l, long long r, long long x, long long y) {
if (l == r) {
t[cur] += y;
return;
}
long long mid = (l + r) >> 1;
if (x <= mid)
update((cur << 1), l, mid, x, y);
else
update(((cur << 1) + 1), mid + 1, r, x, y);
t[cur] = t[(cur << 1)] + t[((cur << 1) + 1)];
}
long long query(long long cur, long long l, long long r, long long x) {
if (l == r) return l;
long long mid = (l + r) >> 1;
if (t[(cur << 1)] >= x)
return query((cur << 1), l, mid, x);
else
return query(((cur << 1) + 1), mid + 1, r, x - t[(cur << 1)]);
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]), ++a[i];
for (long long i = 1; i <= n; i++) scanf("%lld", &b[i]), ++b[i];
solve(a);
solve(b);
for (long long i = 1; i < n; i++) {
f[i + 1] += f[i] / (i + 1);
f[i] = f[i] % (i + 1);
}
memset(t, 0, sizeof(t));
for (long long i = 1; i <= n; i++) update(1, 1, n, i, 1);
f[0] = 0;
for (long long i = n - 1; i >= 0; i--) {
long long k = query(1, 1, n, f[i] + 1);
printf("%lld ", k - 1);
update(1, 1, n, k, -1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, a[100005], dfn[100005], uu, vv, loo[100005], bel[100005], scc,
hav[100005], sta[100005], din, tot;
int hea[100005], cnt, ru[100005], ans = 0x3f3f3f3f, chu[100005], minn;
bool ins[100005];
struct Edge {
int too, nxt;
} edge[200005];
void add_edge(int fro, int too) {
edge[++cnt].nxt = hea[fro];
edge[cnt].too = too;
hea[fro] = cnt;
}
void tarjan(int x) {
sta[++din] = x;
ins[x] = true;
dfn[x] = loo[x] = ++tot;
for (int i = hea[x]; i; i = edge[i].nxt) {
int t = edge[i].too;
if (!dfn[t]) {
tarjan(t);
loo[x] = min(loo[x], loo[t]);
} else if (ins[t])
loo[x] = min(loo[x], dfn[t]);
}
if (dfn[x] == loo[x]) {
int j;
scc++;
do {
j = sta[din--];
bel[j] = scc;
hav[scc]++;
ins[j] = false;
} while (dfn[j] != loo[j]);
}
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &uu, &vv);
if ((a[uu] + 1) % h == a[vv]) add_edge(uu, vv);
if ((a[vv] + 1) % h == a[uu]) add_edge(vv, uu);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++)
for (int j = hea[i]; j; j = edge[j].nxt) {
int t = edge[j].too;
if (bel[i] != bel[t]) chu[bel[i]]++;
}
for (int i = 1; i <= scc; i++)
if (!chu[i] && ans > hav[i]) {
ans = hav[i];
minn = i;
}
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (bel[i] == minn) printf("%d ", i);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)
const int N = 2e5 + 5;
int n,a[N];
void dbg(){puts("");}
template<typename T, typename... R>void dbg(const T &f, const R &... r) {
cout << f << " ";
dbg(r...);
}
template<typename Type>inline void read(Type &xx){
Type f = 1;char ch;xx = 0;
for(ch = getchar();ch < '0' || ch > '9';ch = getchar()) if(ch == '-') f = -1;
for(;ch >= '0' && ch <= '9';ch = getchar()) xx = xx * 10 + ch - '0';
xx *= f;
}
int main(int argc, char** argv) {
int T;read(T);
while(T--){
read(n);
rep(i,1,n){
read(a[i]);a[i] -= i;
}
map<int,int> b;
LL ans = 0;
rep(i,1,n){
ans += b[a[i]];
b[a[i]]++;
}
printf("%lld\n",ans);
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
int** arr = new int*[k];
int i, j;
for (i = 0; i < k; i++) {
arr[i] = new int[n];
scanf("%d", &arr[i][0]);
}
int z = 1;
int p;
for (i = 0; i < k; i++) {
for (j = 1; j < n; j++) {
line:
for (p = 0; p < k; p++) {
if (arr[p][0] == z) {
z++;
goto line;
}
}
arr[i][j] = z;
z++;
}
}
for (i = 0; i < k; i++) {
for (j = 0; j < n; j++) {
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
int n, m, k;
int dp[1005][1005];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < 1005; i++) dp[0][i] = 1;
for (int i = 1; i < 1005; i++) {
int sum = 0;
int sum2 = 0;
for (int j = 2; j < 1005; j++) {
sum = (sum + dp[i - 1][j - 2]) % p;
sum2 = (sum2 + sum) % p;
dp[i][j] = sum2;
}
}
cout << (long long)dp[k][n - 1] * dp[k][m - 1] % p;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 200003;
const int gmod = 2;
const int inf = 1039074182;
const long long llinf = 1LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
if (b > x) x = b;
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
x += b;
if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
x %= b, x += b;
if (x >= b) x -= b;
}
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, vector<T> vec) {
cout << "{";
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i != (int)vec.size() - 1) cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, set<T> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
vector<T> t;
while (q.size()) {
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, map<T1, T2> m) {
for (auto &x : m) {
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T>
T operator*(vector<T> v1, vector<T> v2) {
assert(v1.size() == v2.size());
int n = v1.size();
T res = 0;
for (int i = 0; i < n; i++) {
res += v1[i] * v2[i];
}
return res;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> x, pair<T1, T2> y) {
return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T> > operator~(vector<vector<T> > vec) {
vector<vector<T> > v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++) {
v[i].resize(n);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = vec[j][i];
}
}
return v;
}
void print0x(int x) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
std::reverse(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
reverse(vec.begin(), vec.end());
for (int i = vec.size(); i < len; i++) {
putchar('0');
}
for (int i = 0; i < vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
using namespace std;
const int basic = 500000;
int n;
int a[300005], b[300005];
char buf[500005];
vector<int> sum[basic * 2 + 5];
int m1, m2, m3, m4;
int b1, b2;
int besta, bestb;
int best;
inline void calc(int k) {
int res = 0;
chmax(res, b1);
chmax(res, b2);
int zx = max(m2, m3);
int nx = max(m1, m4);
int tx = (nx - zx) / 2;
chmax(tx, 0);
chmax(res, -tx + nx);
if (res < best) {
best = res;
besta = tx;
if (besta == 0 && k == 0) besta++;
bestb = besta + k;
}
}
inline void read(int &a, int &b) {
a = 0;
b = 0;
char c = 0;
while (c != 'N' && c != 'B') c = getchar();
while (c == 'N' || c == 'B') {
if (c == 'B')
b++;
else
a++;
c = getchar();
}
}
int main() {
cin >> n;
m1 = -inf, m2 = -inf, m3 = -inf, m4 = -inf;
b1 = -inf, b2 = -inf;
int k = basic;
for (int i = 0; i < n; i++) {
read(a[i], b[i]);
sum[b[i] - a[i] + basic].push_back(i);
chmax(b2, a[i] + k - b[i]);
chmax(m3, k - b[i]);
chmax(m4, a[i]);
}
best = inf;
calc(basic);
for (k = basic - 1; k >= -basic; k--) {
m1++;
b1++;
m3--;
b2--;
for (auto id : sum[k + basic]) {
int x0 = a[id];
int y0 = b[id];
chmax(m1, y0 - k);
chmax(m2, -x0);
chmax(b1, y0 - (x0 + k));
}
calc(k);
}
cout << best << endl;
for (int i = 0; i < bestb; i++) {
putchar('B');
}
for (int i = 0; i < besta; i++) {
putchar('N');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, f;
cin >> n >> f;
vector<long long> v(n);
long long ans = 0;
for (int i = 0; i < n; ++i) {
int k, l;
cin >> k >> l;
ans += min(k, l);
v.push_back(max(0, min(k, l - k)));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int j = 0; j < min(n, f); ++j) {
ans += v[j];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct st {
long ind;
string name, str;
bool operator<(const st &b) const {
if (str == b.str) {
return ind < b.ind;
}
if (str == "woman" && b.str == "child") {
return ind < b.ind;
}
if (str == "child" && b.str == "woman") {
return ind < b.ind;
}
if (str == "rat") return true;
if (str == "captain") return false;
if (str == "woman" || str == "child") {
if (b.str != "rat") return true;
return false;
}
if (str == "man") {
if (b.str != "rat" && b.str != "woman" && b.str != "child") return true;
return false;
}
}
} arr[105];
char s1[15], s2[15];
int main() {
long x, y, z, i, j, k, l, m, n, p, u, w, t, cas, edge, node, a, b, c, d, e, f;
while (scanf("%ld", &n) == 1) {
for (i = 0; i < n; i++) {
scanf("%s %s", s1, s2);
arr[i].ind = i + 1, arr[i].name = s1, arr[i].str = s2;
}
sort(arr, arr + n);
for (i = 0; i < n; i++) {
cout << arr[i].name << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n;
int x[N];
int y[N];
vector<int> v[2 * N + 1];
int w[N];
bool h[N];
int ind[2 * N + 1];
map<pair<int, int>, int> s;
bool comp(int i, int j) { return x[i] < x[j]; }
vector<int> ans;
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < n; i++) {
v[y[i] - x[i] + N].push_back(i);
s.insert(make_pair(make_pair(x[i], y[i]), i));
}
for (int i = 0; i <= 2 * N; i++) sort(v[i].begin(), v[i].end(), comp);
fill(h, h + n, false);
fill(ind, ind + 2 * N + 1, 0);
for (int i = 0; i < n; i++) {
int cur = w[i] + N;
if (ind[cur] >= v[cur].size()) {
cout << "NO\n";
return 0;
}
int j = v[cur][ind[cur]];
ind[cur]++;
ans.push_back(j);
h[j] = true;
bool res = true;
if (x[j] > 0 && !h[s[make_pair(x[j] - 1, y[j])]]) res = false;
if (y[j] > 0 && !h[s[make_pair(x[j], y[j] - 1)]]) res = false;
if (!res) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << x[ans[i]] << " " << y[ans[i]] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a, b;
inline void read() {
cin >> n;
a.resize(3);
b.resize(3);
for (int i = 0; i < 3; i++) cin >> a[i];
for (int i = 0; i < 3; i++) cin >> b[i];
}
inline void solve() {
int ans1 = INT_MAX;
vector<pair<int, int> > ord;
ord.push_back({0, 0});
ord.push_back({0, 2});
ord.push_back({1, 1});
ord.push_back({1, 0});
ord.push_back({2, 2});
ord.push_back({2, 1});
sort(ord.begin(), ord.end());
do {
vector<int> a1 = a, b1 = b;
for (int i = 0; i < int(ord.size()); i++) {
int cnt = min(a1[ord[i].first], b1[ord[i].second]);
a1[ord[i].first] -= cnt;
b1[ord[i].second] -= cnt;
}
int cur = min(a1[0], b1[1]) + min(a1[1], b1[2]) + min(a1[2], b1[0]);
ans1 = min(ans1, cur);
} while (next_permutation(ord.begin(), ord.end()));
int ans2 = min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0]);
cout << ans1 << ' ' << ans2 << endl;
}
int main() {
read();
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int l1, l2, l3;
cin >> l1 >> l2 >> l3;
string ans = "NO";
if (l1 + l2 == l3 || l1 + l3 == l2 || l2 + l3 == l1)
ans = "YES";
else if (l1 == l2 && l3 % 2 == 0)
ans = "YES";
else if (l1 == l3 && l2 % 2 == 0)
ans = "YES";
else if (l3 == l2 && l1 % 2 == 0)
ans = "YES";
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int s[50001];
signed main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d", &s[i]);
}
for (int i = 1; i < n - 1; i++) {
if (s[0] + s[i] <= s[n - 1]) {
printf("%d %d %d\n", 1, i + 1, n);
goto hell;
}
}
printf("-1\n");
hell : {}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INF64 = 1e18;
const int MOD = 1e9 + 7;
const long double PI = acosl(-1.0);
const long double EPS = 1e-9;
int n;
string s;
vector<int> cnt(3);
int main() {
cin >> n >> s;
for (int i = 0; i < int(n); ++i) cnt[s[i] - '0']++;
int m = n / 3;
for (int i = 0; i < int(n); ++i)
if (cnt[0] < m && s[i] - '0' > 0 && cnt[s[i] - '0'] > m) {
cnt[0]++;
cnt[s[i] - '0']--;
s[i] = '0';
}
for (int i = 0; i < int(n); ++i)
if (cnt[1] < m && s[i] - '0' > 1 && cnt[s[i] - '0'] > m) {
cnt[1]++;
cnt[s[i] - '0']--;
s[i] = '1';
}
for (int i = n - 1; i >= 0; i--)
if (cnt[2] < m && s[i] - '0' < 2 && cnt[s[i] - '0'] > m) {
cnt[2]++;
cnt[s[i] - '0']--;
s[i] = '2';
}
for (int i = n - 1; i >= 0; i--)
if (cnt[1] < m && s[i] - '0' < 1 && cnt[s[i] - '0'] > m) {
cnt[1]++;
cnt[s[i] - '0']--;
s[i] = '1';
}
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
bool forbid[200000];
vector<pair<int, int>> decomp;
map<int, vector<int>> dp;
map<int, bool> calced;
map<int, vector<int>> g;
int gcd(int p, int q) {
if (q == 0) return p;
return gcd(q, p % q);
}
vector<pair<int, int>> prime_decomposition(int nn) {
vector<pair<int, int>> ans;
for (int p = 2; p * p <= nn; p++) {
int a = 0;
while (nn % p == 0) {
nn /= p;
a++;
}
if (a) ans.push_back({p, a});
}
if (nn > 1) ans.push_back({nn, 1});
return ans;
}
int hash_decomp(vector<pair<int, int>> decomp) {
int ans = 0;
for (auto e : decomp) {
ans = ans * 17 + e.second;
}
return ans;
}
int recov(vector<pair<int, int>> dec) {
int ans = 1;
for (auto e : dec) {
for (int i = 0; i < e.second; i++) ans *= e.first;
}
return ans;
}
vector<int> work(vector<pair<int, int>> dec) {
int h = hash_decomp(dec);
if (calced[h]) return dp[h];
bool all_zero = true;
for (auto e : dec)
if (e.second) all_zero = false;
if (all_zero) {
calced[h] = true;
dp[h] = g[recov(dec)];
return dp[h];
}
vector<int> ans;
for (int i = 0; i < dec.size(); i++) {
if (dec[i].second) {
dec[i].second--;
vector<int> temp = work(dec);
if (ans.size() <= temp.size()) ans = temp;
dec[i].second++;
}
}
for (int e : g[recov(dec)]) ans.push_back(e);
calced[h] = true;
dp[h] = ans;
return ans;
}
void compute_g() {
for (int i = 1; i < m; i++) {
if (!forbid[i]) {
g[gcd(i, m)].push_back(i);
}
}
}
long long extended_euclid(long long p, long long q, long long &x,
long long &y) {
if (q == 0) {
x = 1;
y = 0;
return p;
}
long long gcd = extended_euclid(q, p % q, y, x);
y -= p / q * x;
return gcd;
}
long long line_mode_equation(long long a, long long b, long long nn) {
long long x, y;
long long d = extended_euclid(a, nn, x, y);
long long ans;
if (b % d == 0) {
x %= nn;
x += nn;
x %= nn;
ans = (x * (b / d) % (nn / d) + nn / d) % (nn / d);
for (int i = 1; i < d; i++) {
if (ans > 0 && ans < nn) return ans;
ans = (ans + nn / d);
}
}
return ans;
}
int main() {
cin >> n >> m;
while (n--) {
int s;
cin >> s;
forbid[s] = true;
}
if (m == 0) {
cout << 0 << endl << endl;
return 0;
}
decomp = prime_decomposition(m);
compute_g();
vector<int> ans = work(decomp);
int len = ans.size();
if (forbid[0] == false) len++;
cout << len << endl;
if (ans.size()) {
cout << ans[0] << ' ';
for (int i = 1; i < ans.size(); i++) {
cout << line_mode_equation(ans[i - 1], ans[i], m) << ' ';
}
}
if (forbid[0] == false) cout << 0 << ' ';
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int st[200005];
int main() {
int tam1, tam2, i;
string s, t;
cin >> s >> t;
long long r = 0;
tam1 = s.size();
tam2 = t.size();
st[0] = 0;
for (i = 0; i < tam2; i++) {
st[i + 1] = st[i] + (t[i] - '0');
}
for (i = 0; i < tam1; i++) {
if (s[i] == '0') {
r += (st[tam2 - tam1 + i + 1] - st[i]);
} else {
r += (tam2 - tam1 + 1 - (st[tam2 - tam1 + i + 1] - st[i]));
}
}
cout << r << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int vis[200];
char s[100][100];
int main() {
memset(vis, 0, sizeof(vis));
scanf("%s", s[0]);
int len = strlen(s[0]);
int sum = 0;
for (int i = 1; i < len; i++) {
for (int j = 0; j < len; j++) {
s[i][j] = s[0][(j + i) % len];
}
}
for (int i = 0; i < len; i++) {
if (vis[i] == 1)
continue;
else
sum++;
for (int j = i + 1; j < len; j++) {
if (strcmp(s[i], s[j]) == 0) {
vis[j] = 1;
}
}
}
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC_OPTIMIZE("ofast")
using namespace std;
const long long MAXN = 1000000;
vector<long long> g[MAXN];
vector<long long> dp_up(MAXN);
vector<pair<long long, long long>> dp_down1(MAXN);
vector<pair<long long, long long>> dp_down2(MAXN);
vector<pair<long long, long long>> dp_down3(MAXN);
long long n, k;
void dfs_d(long long v, long long p = -1) {
long long v1 = 0;
long long i1 = -1;
long long v2 = -1;
long long i2 = -1;
long long v3 = -1;
long long i3 = -1;
for (auto u : g[v]) {
if (u != p) {
dfs_d(u, v);
if (v1 < dp_down1[u].first + 1) {
v3 = v2;
i3 = i2;
v2 = v1;
i2 = i1;
v1 = dp_down1[u].first + 1;
i1 = u;
} else {
if (v2 < dp_down1[u].first + 1) {
v3 = v2;
i3 = i2;
v2 = dp_down1[u].first + 1;
i2 = u;
} else {
if (v3 < dp_down1[u].first + 1) {
v3 = dp_down1[u].first + 1;
i3 = u;
}
}
}
}
}
dp_down1[v] = make_pair(v1, i1);
dp_down2[v] = make_pair(v2, i2);
dp_down3[v] = make_pair(v3, i3);
}
void dfs_u(long long v, long long p = -1) {
for (auto u : g[v]) {
if (p != u) {
dp_up[u] = dp_up[v] + 1;
if (u != dp_down1[v].second && dp_down1[v].second != -1) {
dp_up[u] = max(dp_up[u], 1 + dp_down1[v].first);
} else {
if (u != dp_down2[v].second && dp_down2[v].second != -1) {
dp_up[u] = max(dp_up[u], 1 + dp_down2[v].first);
}
}
dfs_u(u, v);
}
}
}
long long ansd = -1;
long long ansi = -1;
void dfs57(long long v, long long p = -1, long long dist = 0) {
if (dist > ansd) {
ansd = dist;
ansi = v;
}
for (auto u : g[v]) {
if (u != p) {
dfs57(u, v, dist + 1);
}
}
}
vector<long long> diam;
vector<long long> now;
long long t1, t2;
void dfs58(long long v, long long p = -1) {
now.push_back(v);
if (v == t2) {
diam = now;
}
for (auto u : g[v]) {
if (u != p) {
dfs58(u, v);
}
}
now.pop_back();
}
vector<bool> used_d(MAXN);
vector<long long> ans(MAXN);
void dfs59(long long v, long long p = -1) {
for (auto u : g[v]) {
if (u != p && !used_d[u]) {
ans[u] = (ans[v] + 1) % k;
dfs59(u, v);
}
}
}
void dfs60(long long v, long long p = -1) {
for (auto u : g[v]) {
if (u != p && !used_d[u]) {
ans[u] = (ans[v] - 1 + k) % k;
dfs60(u, v);
}
}
}
signed main() {
cin >> n >> k;
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
dp_up[0] = 0;
dfs_d(0);
dfs_u(0);
for (long long i = 0; i < n; i++) {
}
for (long long i = 0; i < n; i++) {
}
for (long long i = 0; i < n; i++) {
vector<long long> arr;
if (i != 0) {
arr.push_back(dp_up[i]);
}
if (dp_down1[i].second != -1) {
arr.push_back(dp_down1[i].first);
}
if (dp_down2[i].second != -1) {
arr.push_back(dp_down2[i].first);
}
if (dp_down3[i].second != -1) {
arr.push_back(dp_down3[i].first);
}
if (arr.size() > 2) {
sort(arr.rbegin(), arr.rend());
if (k != 2 && arr[1] + arr[2] >= k - 1 && arr[2] != 0) {
cout << "No \n";
return 0;
}
}
}
dfs57(0);
t1 = ansi;
ansd = -1;
ansi = -1;
dfs57(t1);
t2 = ansi;
dfs58(t1);
for (long long i = 0; i < diam.size(); i++) {
used_d[diam[i]] = true;
}
long long now_ans = 0;
for (long long i = 0; i < diam.size(); i++) {
ans[diam[i]] = now_ans;
now_ans++;
if (now_ans == k) {
now_ans = 0;
}
}
for (long long i = 0; i < diam.size() / 2; i++) {
dfs60(diam[i]);
}
for (long long i = diam.size() / 2; i < diam.size(); i++) {
dfs59(diam[i]);
}
cout << "Yes \n";
for (long long i = 0; i < n; i++) {
cout << ans[i] + 1 << " ";
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
int cnt[N], a[N];
bool ok(int x, int y) {
memset(cnt, 0, sizeof cnt);
for (int i = x; i <= y; i++) cnt[a[i]]++;
while (x <= y && n - x - 1 > y) {
if (cnt[a[n - x - 1]] == 0) return 0;
cnt[a[n - x - 1]]--;
x++;
}
while (x <= y && x > n - y - 1) {
if (cnt[a[n - y - 1]] == 0) return 0;
cnt[a[n - y - 1]]--;
y--;
}
y++;
while (y < n - y - 1) {
if (a[y] != a[n - y - 1]) return 0;
y++;
}
x--;
while (x > n - x - 1) {
if (a[x] != a[n - x - 1]) return 0;
x--;
}
return 1;
}
int main() {
scanf("%d", &n);
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < n; i++) scanf("%d", a + i), cnt[a[i]] ^= 1;
int sum = 0;
for (int i = 0; i <= n; i++) sum += cnt[i];
if (sum > 1) {
puts("0");
return 0;
}
int le, ri;
le = 0;
ri = n - 1;
while (le < ri && a[le] == a[ri]) le++, ri--;
if (le >= ri) {
cout << (long long)n * (n + 1) / 2LL << "\n";
return 0;
}
int p, q;
{
int l = le, r = ri;
while (l < r) {
int mid = (l + r) >> 1;
if (ok(le, mid))
r = mid;
else
l = mid + 1;
}
q = r;
}
{
int l = le, r = ri;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (ok(mid, ri))
l = mid;
else
r = mid - 1;
}
p = l;
}
cout << (long long)(le + 1) * (n - q) + (long long)(p + 1) * (n - ri) -
(long long)(le + 1) * (n - ri)
<< "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long n, m, grp, ans, timer;
vector<pair<long long, long long>> g[N];
vector<long long> tree[N], comp[N];
long long isBridge[N], tin[N], low[N], vis[N], tout[N];
void dfs1(long long v, long long p) {
vis[v] = 1;
timer++;
tin[v] = timer;
low[v] = timer;
for (auto it : g[v]) {
long long u = it.first, idx = it.second;
if (!vis[u]) {
dfs1(u, v);
low[v] = min(low[v], low[u]);
if (low[u] > tin[v]) {
isBridge[idx] = 1;
}
} else if (u != p) {
low[v] = min(low[v], tin[u]);
}
}
tout[v] = timer;
}
void dfs2(long long v, long long cmp) {
queue<long long> q;
q.push(v);
vis[v] = 1;
while (q.size()) {
v = q.front();
q.pop();
comp[cmp].push_back(v);
for (auto it : g[v]) {
long long u = it.first, idx = it.second;
if (vis[u]) {
continue;
}
if (isBridge[idx]) {
grp++;
tree[grp].push_back(cmp);
tree[cmp].push_back(grp);
dfs2(u, grp);
} else {
q.push(u);
vis[u] = 1;
}
}
}
}
long long dfs3(long long v) {
long long mx1 = 0;
vis[v] = 1;
for (auto u : tree[v]) {
if (vis[u]) {
continue;
}
long long mx2 = 1 + dfs3(u);
ans = max(ans, mx1 + mx2);
mx1 = max(mx1, mx2);
}
return mx1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
memset(vis, 0, sizeof(vis));
dfs1(1, 0);
grp++;
memset(vis, 0, sizeof(vis));
dfs2(1, 1);
memset(vis, 0, sizeof(vis));
dfs3(1);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long st[100000 + 1][25 + 1];
long long lg[100000 + 1];
long long maxinrange(long long L, long long R) {
int j = lg[R - L + 1];
int minimum = max(st[L][j], st[R - (1 << j) + 1][j]);
return minimum;
}
int main() {
lg[1] = 0;
for (int i = 2; i <= 100000; i++) lg[i] = lg[i / 2] + 1;
long long n, d;
scanf("%lld %lld", &n, &d);
long long arr[n + 1];
for (long long i = 1; i <= n; i++) scanf("%lld", &arr[i]);
long long csum[n + 1];
csum[0] = 0;
for (long long i = 1; i <= n; i++) csum[i] = csum[i - 1] + arr[i];
for (int i = 1; i <= n; i++) st[i][0] = csum[i];
for (int j = 1; j <= 25; j++)
for (int i = 1; i + (1 << j) <= n + 1; i++)
st[i][j] = max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
vector<long long> idx;
for (long long i = 1; i <= n; i++)
if (csum[i] < 0 && arr[i] == 0) idx.push_back(i);
if (idx.size() == 0) {
if (maxinrange(1, n) > d)
cout << -1;
else
cout << 0;
exit(0);
}
vector<long long> maxgaps;
if (idx[0] == 0)
maxgaps.push_back(-1000000000000000);
else
maxgaps.push_back(maxinrange(0, idx[0] - 1));
int curr = 1;
while (curr != (long long)(idx).size()) {
if (idx[curr] - idx[curr - 1] == 1)
maxgaps.push_back(-1000000000000000);
else {
long long val = maxinrange(idx[curr - 1] + 1, idx[curr - 1] - 1);
maxgaps.push_back(val);
}
curr++;
}
if (n == idx[curr - 1])
maxgaps.push_back(-1000000000000000);
else
maxgaps.push_back(maxinrange(idx[curr - 1] + 1, n));
if (maxgaps[0] > d) {
cout << -1;
exit(0);
}
long long upd = 0;
long long minc[(long long)(idx).size()];
minc[(long long)(idx).size() - 1] = csum[idx[(long long)(idx).size() - 1]];
for (int i = (long long)(idx).size() - 2; i >= 0; --i)
minc[i] = min(minc[i + 1], csum[idx[i]]);
long long minupd[(long long)(maxgaps).size()];
minupd[(long long)(maxgaps).size() - 1] =
d - maxgaps[(long long)(maxgaps).size() - 1];
for (int i = (long long)(maxgaps).size() - 2; i >= 0; i--)
minupd[i] = min(minupd[i + 1], d - maxgaps[i]);
curr = 0;
int ans = 0;
while (curr != (long long)(idx).size()) {
if (csum[idx[curr]] + upd >= 0) {
curr++;
continue;
}
long long maxupdate = 0;
maxupdate = minc[curr] + upd;
maxupdate = -maxupdate;
long long lowestgap = 1000000000000000;
lowestgap = minupd[curr + 1] - upd;
maxupdate = min(maxupdate, lowestgap);
if (csum[idx[curr]] + upd + maxupdate < 0) {
cout << -1;
exit(0);
}
upd += maxupdate;
curr++;
ans++;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(6);
char trump;
cin >> trump;
map<char, int> m;
m['6'] = 1;
m['7'] = 2;
m['8'] = 3;
m['9'] = 4;
m['T'] = 5;
m['J'] = 6;
m['Q'] = 7;
m['K'] = 8;
m['A'] = 9;
string first;
cin >> first;
string second;
cin >> second;
if (first[1] == trump and second[1] != trump) {
cout << "YES" << '\n';
} else if (first[1] == second[1]) {
if (m[first[0]] > m[second[0]])
cout << "YES" << '\n';
else
cout << "NO" << '\n';
} else
cout << "NO" << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<int> adj[500500];
int can0[500500], can1[500500], dp0[500500], dp1[500500];
int dp[4];
int n, sz[500500];
void dfs(int u, int f = 0) {
sz[u] = 1;
for (int v : adj[u])
if (v != f) dfs(v, u), sz[u] += sz[v];
can0[u] = 1;
dp[0] = 1, dp[1] = 0;
for (int v : adj[u]) {
if (v == f) continue;
can0[u] &= can1[v];
int t[2] = {dp[0], dp[1]};
dp[0] = t[0] * can1[v];
dp[1] = t[0] * can0[v] + t[1] * can1[v];
}
can1[u] = dp[1];
dp[0] = 1, dp[1] = 0;
for (int v : adj[u]) {
if (v == f) continue;
int t[2] = {dp[0], dp[1]};
dp[0] = t[0] * can1[v];
dp[1] = t[1] * can1[v] + t[0] * dp1[v];
}
dp0[u] = dp[1];
dp1[u] = can0[u];
dp[0] = 1, dp[1] = 0;
for (int v : adj[u]) {
if (v == f) continue;
int t[2] = {dp[0], dp[1]};
dp[0] = t[0] * can1[v];
dp[1] = t[1] * can1[v] + t[0] * dp0[v];
}
dp1[u] += dp[1];
dp[0] = 1, dp[1] = dp[2] = dp[3] = 0;
for (int v : adj[u]) {
if (v == f) continue;
int t[4] = {dp[0], dp[1], dp[2], dp[3]};
dp[0] = t[0] * can1[v];
dp[1] = t[0] * can0[v] + t[1] * can1[v];
dp[2] = t[0] * dp1[v] + t[2] * can1[v];
dp[3] = t[1] * dp1[v] + t[2] * can0[v] + t[3] * can1[v];
}
dp1[u] += dp[3];
}
long long ans;
int c0[500500], c1[500500], d0[500500], d1[500500];
int R[500500], Rdp[500500][4];
void redfs(int u, int f = 0) {
if (f) {
if (can1[u] && c1[u])
ans += (long long)sz[u] * (n - sz[u]);
else
ans += (long long)dp1[u] * d1[u];
}
R[adj[u].size()] = 1;
Rdp[adj[u].size()][0] = 1;
Rdp[adj[u].size()][1] = 0;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
R[i] = R[i + 1] & (v == f ? c1[u] : can1[v]);
Rdp[i][0] = Rdp[i + 1][0] * (v == f ? c1[u] : can1[v]);
Rdp[i][1] = Rdp[i + 1][0] * (v == f ? c0[u] : can0[v]) +
Rdp[i + 1][1] * (v == f ? c1[u] : can1[v]);
}
int cur = 1;
dp[0] = 1, dp[1] = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != f) {
c0[v] = cur & R[i + 1];
c1[v] = dp[0] & Rdp[i + 1][1] | dp[1] & Rdp[i + 1][0];
}
int t[2] = {dp[0], dp[1]};
cur &= (v == f ? c1[u] : can1[v]);
dp[0] = t[0] * (v == f ? c1[u] : can1[v]);
dp[1] =
t[0] * (v == f ? c0[u] : can0[v]) + t[1] * (v == f ? c1[u] : can1[v]);
}
Rdp[adj[u].size()][0] = 1;
Rdp[adj[u].size()][1] = 0;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
Rdp[i][0] = Rdp[i + 1][0] * (v == f ? c1[u] : can1[v]);
Rdp[i][1] = Rdp[i + 1][0] * (v == f ? d1[u] : dp1[v]) +
Rdp[i + 1][1] * (v == f ? c1[u] : can1[v]);
}
dp[0] = 1, dp[1] = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != f) d0[v] = dp[0] * Rdp[i + 1][1] + dp[1] * Rdp[i + 1][0];
int t[2] = {dp[0], dp[1]};
dp[0] = t[0] * (v == f ? c1[u] : can1[v]);
dp[1] =
t[1] * (v == f ? c1[u] : can1[v]) + t[0] * (v == f ? d1[u] : dp1[v]);
}
for (int v : adj[u])
if (v != f) d1[v] = c0[v];
Rdp[adj[u].size()][0] = 1;
Rdp[adj[u].size()][1] = 0;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
Rdp[i][0] = Rdp[i + 1][0] * (v == f ? c1[u] : can1[v]);
Rdp[i][1] = Rdp[i + 1][0] * (v == f ? d0[u] : dp0[v]) +
Rdp[i + 1][1] * (v == f ? c1[u] : can1[v]);
}
dp[0] = 1, dp[1] = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != f) d1[v] += dp[0] * Rdp[i + 1][1] + dp[1] * Rdp[i + 1][0];
int t[2] = {dp[0], dp[1]};
dp[0] = t[0] * (v == f ? c1[u] : can1[v]);
dp[1] =
t[1] * (v == f ? c1[u] : can1[v]) + t[0] * (v == f ? d0[u] : dp0[v]);
}
Rdp[adj[u].size()][0] = 1;
Rdp[adj[u].size()][1] = 0;
Rdp[adj[u].size()][2] = 0;
Rdp[adj[u].size()][3] = 0;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
Rdp[i][0] = Rdp[i + 1][0] * (v == f ? c1[u] : can1[v]);
Rdp[i][1] = Rdp[i + 1][0] * (v == f ? c0[u] : can0[v]) +
Rdp[i + 1][1] * (v == f ? c1[u] : can1[v]);
Rdp[i][2] = Rdp[i + 1][0] * (v == f ? d1[u] : dp1[v]) +
Rdp[i + 1][2] * (v == f ? c1[u] : can1[v]);
Rdp[i][3] = Rdp[i + 1][1] * (v == f ? d1[u] : dp1[v]) +
Rdp[i + 1][2] * (v == f ? c0[u] : can0[v]) +
Rdp[i + 1][3] * (v == f ? c1[u] : can1[v]);
}
dp[0] = 1, dp[1] = dp[2] = dp[3] = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != f)
d1[v] += dp[0] * Rdp[i + 1][3] + dp[1] * Rdp[i + 1][2] +
dp[2] * Rdp[i + 1][1] + dp[3] * Rdp[i + 1][0];
int t[4] = {dp[0], dp[1], dp[2], dp[3]};
dp[0] = t[0] * (v == f ? c1[u] : can1[v]);
dp[1] =
t[0] * (v == f ? c0[u] : can0[v]) + t[1] * (v == f ? c1[u] : can1[v]);
dp[2] =
t[0] * (v == f ? d1[u] : dp1[v]) + t[2] * (v == f ? c1[u] : can1[v]);
dp[3] = t[1] * (v == f ? d1[u] : dp1[v]) +
t[2] * (v == f ? c0[u] : can0[v]) +
t[3] * (v == f ? c1[u] : can1[v]);
}
for (int v : adj[u])
if (v != f) redfs(v, u);
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
redfs(1);
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const long long mod = 1e9 + 7;
const int mxN = 1e6 + 9;
int Log[mxN];
int sp[mxN][21];
int ar[mxN];
int leftquery[mxN];
int rightquery[mxN];
map<int, int> idx;
void PreLog(int n) {
Log[1] = 0;
for (int i = 2; i <= n; i++) Log[i] = Log[i / 2] + 1;
}
void SparseTable(int n) {
for (int i = 0; i < n; i++) sp[i][0] = ar[i];
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 0; i + (1 << j) - 1 < n; i++) {
sp[i][j] = min(sp[i][j - 1], sp[i + (1 << (j - 1))][j - 1]);
}
}
}
int RMQ(int leftmost, int rightmost) {
int k = Log[rightmost - leftmost + 1];
return min(sp[leftmost][k], sp[rightmost - (1 << k) + 1][k]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
set<int> s1;
for (int i = 0; i < n; i++) {
cin >> leftquery[i] >> rightquery[i];
s1.insert(leftquery[i]);
s1.insert(rightquery[i]);
s1.insert(rightquery[i] + 1);
}
int dummy = 0;
for (auto &c : s1) {
idx[c] = dummy;
++dummy;
}
for (int i = 0; i < n; i++) {
int left = idx[leftquery[i]];
int right = idx[rightquery[i]];
ar[left] += 1;
ar[right + 1] -= 1;
}
for (int i = 1; i < dummy; i++) ar[i] += ar[i - 1];
PreLog(dummy);
SparseTable(dummy);
for (int i = 0; i < n; i++) {
int left = idx[leftquery[i]];
int right = idx[rightquery[i]];
int mn = RMQ(left, right);
if (mn > 1) {
cout << i + 1 << "\n";
return 0;
}
}
cout << -1 << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inff = 0x3f3f3f3f3f3f3f3f;
pair<int, int> a[18], c[18];
int main() {
cin.tie(0);
int r, b;
scanf("%d", &r), scanf("%d", &b);
for (int i(1); i <= (r); ++i)
scanf("%d", &a[i].first), scanf("%d", &a[i].second);
for (int i(1); i <= (b); ++i)
scanf("%d", &c[i].first), scanf("%d", &c[i].second);
if (r != b)
puts("NO");
else {
puts("YES");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10;
struct ope {
int x, y, z;
ope() {}
ope(int a, int b, int c) : x(a), y(b), z(c) {}
void out() { printf("%d %d %d\n", x, y, z); }
} ans[M], op[101];
int top, bit[M];
int n, A[M], ls[M];
void add(int a, int b, int c) { ans[++top] = ope(a, b, c); }
void add(ope a) { ans[++top] = a; }
bool check(int p, int p1, int p2, int p3, int d = 1) {
if (A[p] == p1 && A[p + d] == p2 && A[p + (d * 2)] == p3) return 1;
return 0;
}
void flip(int *ar, int a, int b, int c, int type = 0) {
ar[a] ^= 1;
ar[b] ^= 1;
ar[c] ^= 1;
if (type) add(a, b, c);
}
bool hadans;
void find(int l, int r) {
int sz = 0;
for (int i = l; i <= r; i++) {
for (int j = i + 2; j <= r; j += 2) {
op[sz++] = ope(i, (i + j) >> 1, j);
}
}
int minans = M, pos;
for (int i = 0, up = (1 << sz), wc; i < up; i++) {
for (int j = l; j <= r; j++) ls[j] = A[j];
wc = 0;
for (int j = i, p; j; j -= ((j) & (-(j)))) {
p = bit[((j) & (-(j)))];
++wc;
flip(ls, op[p].x, op[p].y, op[p].z);
}
bool flag = 0;
for (int j = l; j <= r; j++)
if (ls[j]) {
flag = 1;
break;
}
if (!flag) {
hadans = 1;
if (wc < minans) minans = wc, pos = i;
}
}
if (hadans) {
for (int j = pos, p; j; j -= ((j) & (-(j)))) {
p = bit[((j) & (-(j)))];
add(op[p]);
}
}
}
void solve(int l, int r) {
if (r - l + 1 <= 8) {
while (r - l + 1 < 8 && l > 1) --l;
while (r - l + 1 < 8 && r < n) ++r;
find(l, r);
return;
}
if (!A[l]) {
solve(l + 1, r);
return;
}
if (!A[r]) {
solve(l, r - 1);
return;
}
if (check(l, 1, 1, 1)) {
flip(A, l, l + 1, l + 2, 1);
solve(l + 3, r);
return;
}
if (check(l, 1, 0, 1)) {
flip(A, l, l + 2, l + 4, 1);
solve(l + 3, r);
return;
}
if (check(l, 1, 0, 0)) {
flip(A, l, l + 3, l + 6, 1);
solve(l + 3, r);
return;
}
if (check(r, 1, 1, 1, -1)) {
flip(A, r, r - 1, r - 2, 1);
solve(l, r - 3);
return;
}
if (check(r, 1, 0, 1, -1)) {
flip(A, r, r - 2, r - 4, 1);
solve(l, r - 3);
return;
}
if (check(r, 1, 0, 0, -1)) {
flip(A, r, r - 3, r - 6, 1);
solve(l, r - 3);
return;
}
if ((r - l + 1) & 1) {
flip(A, l, (l + r) >> 1, r, 1);
flip(A, l + 1, (l + r) >> 1, r - 1, 1);
solve(l + 3, r - 3);
} else {
flip(A, l, (l + r - 1) >> 1, r - 1, 1);
flip(A, l + 1, (l + r + 1) >> 1, r, 1);
solve(l + 3, r - 3);
}
}
void init() {
for (int i = 0; i <= 17; i++) bit[1 << i] = i;
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
solve(1, n);
if (hadans) {
puts("YES");
printf("%d\n", top);
for (int i = 1; i <= top; i++) ans[i].out();
} else
puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n;
long long a[n + 1], b[n + 1], c[n + 1];
a[0] = 0;
b[0] = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum = sum + a[i];
b[i] = sum;
}
sort(a, a + n + 1);
sum = 0;
c[0] = 0;
for (int i = 1; i <= n + 1; i++) {
sum = sum + a[i];
c[i] = sum;
}
cin >> m;
while (m--) {
int type;
long l, r;
cin >> type >> l >> r;
if (type == 1) {
sum = b[r] - b[l - 1];
} else {
sum = c[r] - c[l - 1];
}
cout << sum << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, st, ed;
string s;
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'G') st = i;
if (s[i] == 'T') ed = i;
}
if ((abs(st - ed)) % k != 0)
printf("NO\n");
else {
int i;
for (i = min(st, ed); i != max(st, ed); i += k) {
if (s[i] == '#') break;
}
if (i == max(st, ed))
printf("YES\n");
else
printf("NO\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 3e3 + 5;
int dp[maxn][maxn], pre[maxn], a[maxn], b[maxn], tot, n, last[maxn];
void solve() {
cin >> n;
tot = 0;
for (int i = 1; i <= n; i++) cin >> a[i], last[i] = 0;
for (int i = 1; i <= n; i++)
if (a[i] != a[i - 1]) b[++tot] = a[i];
for (int i = 1; i <= tot; i++) a[i] = b[i];
n = tot;
for (int i = 1; i <= n; i++) pre[i] = last[a[i]], last[a[i]] = i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i <= j)
dp[i][j] = inf;
else
dp[i][j] = 0;
for (int i = 1; i <= n; i++) dp[i][i] = 0;
for (int i = 1; i <= n - 1; i++)
if (a[i] != a[i + 1])
dp[i][i + 1] = 1;
else
dp[i][i + 1] = 0;
for (int len = 3; len <= n; len++) {
for (int i = 1, L, R; i + len - 1 <= n; i++) {
L = i, R = i + len - 1;
dp[L][R] = min(dp[L][R - 1] + 1, dp[L + 1][R] + 1);
if (a[L] == a[R]) dp[L][R] = min(dp[L][R], dp[L + 1][R - 1] + 1);
int cur = pre[R];
while (cur > L) {
dp[L][R] = min(dp[L][R], dp[L][cur - 1] + dp[cur][R] + 1);
if (a[L] == a[R])
dp[L][R] = min(dp[L][cur - 1] + dp[cur + 1][R], dp[L][R]);
cur = pre[cur];
}
}
}
cout << dp[1][n] << "\n";
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, maxd;
vector<vector<int> > g;
vector<int> dist;
vector<int> p;
vector<int> v;
void dfs(int u, int pre, int d) {
p[u] = pre;
dist[u] = d;
maxd = max(maxd, d);
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i] != pre) {
dfs(g[u][i], u, d + 1);
}
}
if (g[u].size() == 1 && d > 2) v[u] = 2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
g = vector<vector<int> >(n);
dist = vector<int>(n);
p = vector<int>(n);
v = vector<int>(n, 3);
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
maxd = 0;
dfs(0, 0, 0);
priority_queue<pair<int, int> > q;
for (int i = 0; i < n; ++i) {
if (v[i] == 2) {
q.push(pair<int, int>(maxd, i));
}
}
while (!q.empty() && q.top().first > 2) {
int u = q.top().second;
q.pop();
if (v[p[u]] == 3) q.push(pair<int, int>(dist[p[u]], p[u]));
v[p[u]] = min((v[u] + 1) % 3, v[p[u]]);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans += (v[i] == 0);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long p1, p2, p3, p4, a, b, i, sum = 0;
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
for (i = a; i <= b; i++) {
if (i == ((((i % p1) % p2) % p3) % p4)) sum++;
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int n2 = n, i = 1, a;
long long ac = 0;
for (int x = 1; x <= n; x++) {
scanf("%d", &a);
if (ac - (long long)(i - 1) * (n2 - i) * a < k) {
printf("%d\n", x);
n2--;
} else {
ac += (long long)a * (i - 1);
i++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
for (int i = (1); i <= (n); ++i) scanf("%lld", &a[i]);
long long total = 0;
a[0] = 0;
for (int i = (1); i <= (k - 1); ++i) total += a[i];
double ans = 0;
for (int i = (k); i <= (n); ++i) {
total = total + a[i] - a[i - k];
ans += 1.0 * total / (n - k + 1);
}
printf("%.10lf\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long fastpow(long long a, long long p) {
if (p == 0) return 1;
long long z = fastpow(a, p / 2);
z = (z * z);
if (p % 2) z = (z * a);
return z;
}
const int ma = 2e5 + 5;
int x[ma], y[ma];
long long n;
long long xp1, yp1;
bool check(int sz) {
for (int i = 1; i <= n - sz + 1; i++) {
int j = i + sz - 1;
long long tpx = x[i - 1] + x[n] - x[j];
long long tpy = y[i - 1] + y[n] - y[j];
long long tp = abs((long long)(xp1 - tpx)) + abs((long long)(yp1 - tpy));
if (tp <= sz && (tp % 2 == sz % 2)) return true;
}
return false;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == 'R') {
x[i] = x[i - 1] + 1;
y[i] = y[i - 1];
} else if (c == 'L') {
x[i] = x[i - 1] - 1;
y[i] = y[i - 1];
} else if (c == 'U') {
y[i] = y[i - 1] + 1;
x[i] = x[i - 1];
} else {
y[i] = y[i - 1] - 1;
x[i] = x[i - 1];
}
}
cin >> xp1 >> yp1;
long long k = abs(xp1) + abs(yp1);
if (k > n || (k % 2 != n % 2)) {
cout << -1 << endl;
return 0;
}
int l = 0, r = n;
int ans;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3;
int v[MAXN + 2], nxt[MAXN + 2];
int main() {
int n, elim = 0, unuap = 0, num;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
v[i] += v[i - 1];
}
elim = v[n];
for (int i = 1; i <= n; ++i)
elim = min(elim, v[i - 1] + (n - i) - (v[n] - v[i]));
cout << n - elim;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1.0);
const int maxn = 2e5 + 10;
const long long inf = 0x3f3f3f3f;
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
long long n, k;
bool check(long long x) {
long long l = x, r = x + 1;
if (x & 1) r--;
long long res = 0;
while (l <= n) {
res += min(n, r) - l + 1;
l <<= 1;
r = (r << 1) + 1;
}
return res >= k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long l = 1, r = n / 2, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid << 1))
ans = max(ans, mid << 1), l = mid + 1;
else
r = mid - 1;
}
l = 0, r = n / 2;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid << 1 | 1))
ans = max(ans, mid << 1 | 1), l = mid + 1;
else
r = mid - 1;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
int face[102][102];
char color[] = "wb";
int main(int argc, char const *argv[]) {
int k;
scanf("%d", &k);
if (k % 2 == 1)
printf("-1\n");
else {
int dx = 0, dy = 0;
int n = k;
int c = 0;
while (n > 0) {
for (int i = 1; i < n; i++) face[dx++][dy] = c;
for (int i = 1; i < n; i++) face[dx][dy++] = c;
for (int i = 1; i < n; i++) face[dx--][dy] = c;
for (int i = 1; i < n; i++) face[dx][dy--] = c;
dx++;
dy++;
n -= 2;
c = 1 - c;
}
for (int a = 0; a < k; a++) {
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
printf("%c", color[face[i][j] ^ (a & 1)]);
}
printf("\n");
}
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long x1, x2;
pair<long long, long long> segs[100010];
int main() {
cin >> n >> x1 >> x2;
long long k, b;
for (int i = 0; i < n; ++i) {
cin >> k >> b;
segs[i] = make_pair(k * x1 + b, k * x2 + b);
}
sort(segs, segs + n);
for (int i = 0; i < n - 1; ++i) {
if (segs[i + 1].second < segs[i].second &&
segs[i + 1].first != segs[i].first) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int rax(long long int a) {
while (a > 1) {
if (a % 2 == 0) {
a /= 2;
} else if (a % 3 == 0) {
a /= 3;
} else
break;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<long long int> vec;
int k;
cin >> k;
vec.push_back(k);
for (int i = 1; i < n; i++) {
int p;
cin >> p;
k = gcd(k, p);
vec.push_back(p);
}
for (int i = 0; i < n; i++) {
vec[i] /= k;
vec[i] = rax(vec[i]);
if (i > 0 && vec[i] != vec[i - 1]) {
cout << "NO";
return 0;
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 100005;
vector<int> v[maxn * 2];
set<int> s2, s1;
int main() {
string s;
cin >> s;
int pos = 0, flag = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '0') {
if (s2.size() == 0) {
v[++pos].push_back(i + 1);
s1.insert(pos);
} else {
int now = *s2.begin();
v[now].push_back(i + 1);
s2.erase(now);
s1.insert(now);
}
} else {
if (s1.size() == 0) {
flag = 1;
break;
} else {
int now = *s1.begin();
v[now].push_back(i + 1);
s1.erase(now);
s2.insert(now);
}
}
}
if (s2.size() != 0 || flag) {
cout << "-1\n";
} else {
cout << pos << endl;
for (int i = 1; i <= pos; ++i) {
printf("%d", v[i].size());
for (int j = 0; j < v[i].size(); ++j) {
printf(" %d", v[i][j]);
}
printf("\n");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205, M = 2e4 + 5, inf = 0x3f3f3f3f, mod = 1e9 + 7;
char mp[N][N];
int n, m, a, b, c;
void Herio() {
puts("IMPOSSIBLE");
exit(0);
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
if (n * m % 2) Herio();
if (n & 1) a -= m / 2;
if (m & 1) b -= n / 2;
if (a < 0 || b < 0) Herio();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) mp[i][j] = (i / 2 % 2 == j / 2 % 2 ? 'a' : 'b');
c -= (n / 2) * (m / 2);
for (int i = 0; i < n - n % 2; i += 2)
for (int j = 0; j < m - m % 2; j += 2) {
if (c < 0) {
if (a > 1)
a -= 2, mp[i][j] += 2, mp[i][j + 1] += 2, c++;
else if (b > 1)
b -= 2, mp[i][j] += 2, mp[i + 1][j] += 2, c++;
else
Herio();
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(mp[i][j]);
putchar('\n');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ara[10000];
set<int> grp[10000];
int change(int N) {
map<int, int> mp;
map<int, int>::iterator it;
for (int i = 0; i < N; i++) mp[ara[i]] = -1;
int i;
for (it = mp.begin(), i = 1; it != mp.end(); it++, i++) it->second = i;
for (int j = 0; j < N; j++) ara[j] = mp[ara[j]];
return i - 1;
}
int go(set<int>& a, set<int>& b) {
int cnt = 0, traverse = 1;
set<int>::iterator it1, it2;
it1 = a.begin(), it2 = b.begin();
cnt = 1;
traverse = 2;
int lst;
lst = *it1;
while (it1 != a.end() && it2 != b.end()) {
if (traverse == 1) {
it1 = a.upper_bound(lst);
if (it1 == a.end()) break;
++cnt;
lst = *it1;
traverse = 2;
} else {
it2 = b.upper_bound(lst);
if (it2 == b.end()) break;
++cnt;
lst = *it2;
traverse = 1;
}
}
return cnt;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i <= n - 1; i++) scanf("%d", &ara[i]);
if (n <= 2) return cout << n << endl, 0;
int r = change(n);
for (int i = 0; i < n; i++) grp[ara[i]].insert(i + 1);
int ans = 1;
for (int i = 1; i <= r; i++) {
int tmp = grp[i].size();
if (tmp > ans) ans = tmp;
for (int j = i + 1; j <= r; j++) {
int ff = go(grp[i], grp[j]);
if (ff > tmp) tmp = ff;
ff = go(grp[j], grp[i]);
if (ff > tmp) tmp = ff;
if (tmp > ans) ans = tmp;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, a[N], ans[N], bo[N];
inline void calc(int x) {
ans[x] = 0;
for (int i = 1, la = 1, num = 0; i <= n; ++i) {
num += bo[a[i]] == 0;
bo[a[i]] = 1;
if (num > x) {
num = 1;
++ans[x];
for (int j = la; j < i; ++j) bo[a[j]] = 0;
la = i;
}
if (i == n) {
++ans[x];
for (int j = la; j <= i; ++j) bo[a[j]] = 0;
la = i;
}
}
}
inline void solve(int l, int r) {
if (r - l <= 1) return;
int mid = (l + r) >> 1;
calc(mid);
if (ans[l] == ans[mid])
for (int i = l + 1; i < mid; ++i) ans[i] = ans[l];
else
solve(l, mid);
if (ans[mid] == ans[r])
for (int i = mid + 1; i < r; ++i) ans[i] = ans[r];
else
solve(mid, r);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
calc(1);
calc(n);
solve(1, n);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main(void) {
int i, n, k, j;
scanf("%d", &n);
int a[n], b[n], c[n + 1], d[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (j = 0; j < n; j++) scanf("%d", &b[j]);
for (i = 0; i < n; i++)
if (b[0] == a[i]) {
k = i;
break;
}
for (i = 0; i < n; i++) {
c[i] = a[k];
k++;
if (k >= n) k = k - n;
}
if (c[0] == 0) {
for (i = 0; i < n; i++)
if (c[1] == b[i]) {
k = i;
break;
}
d[0] = 0;
for (i = 1; i < n; i++) {
d[i] = c[k];
k++;
if (k >= n) k = k - n + 1;
}
for (i = 0; i < n; i++)
if (b[i] != d[i]) break;
if (i == n)
printf("YES\n");
else
printf("NO\n");
} else {
c[n] = -1;
c[0] = -1;
for (i = 1; i < n; i++)
if (b[i] == 0) {
k = i;
break;
}
for (i = 1; i < n; i++)
if (i != k) {
if (i < k && (c[i] != b[i] && c[i + 1] != b[i]))
break;
else if (i > k && (c[i] != b[i] && c[i - 1] != b[i]))
break;
}
if (i == n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
struct Node {
long long x;
long long y;
};
int main() {
long long n, m;
long long ans[N];
long long re[N];
long long x, y, z;
long long i, j, k;
Node node[110];
while (scanf("%lld%lld", &n, &m) == 2) {
memset(ans, 0, sizeof(ans));
memset(re, 0, sizeof(re));
for (int i = 0; i < m; i++) {
scanf("%lld%lld%lld", &x, &y, &z);
long long t = x + z - 1;
for (j = 1, k = 0; j <= n && y > 0; j++) {
if (re[j] < x) {
node[k].x = j;
node[k].y = re[j];
k++;
y--;
ans[i] += j;
re[j] = t;
}
}
if (y) {
for (j = 0; j < k; j++) {
re[node[j].x] = node[j].y;
}
ans[i] = -1;
}
}
for (i = 0; i < m; i++) {
printf("%lld\n", ans[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int MX = 1000;
int cnt(int x) {
int ans = 0;
for (int i = 0; i < 15; ++i)
if (x >> i & 1) ++ans;
return ans;
}
int main() {
string s;
cin >> s;
int k;
cin >> k;
if (k == 0) {
cout << 1 << endl;
return 0;
}
--k;
vector<int> dp1(MX);
dp1[1] = 0;
for (int i = 2; i < MX; ++i) dp1[i] = dp1[cnt(i)] + 1;
int n = s.size();
vector<vector<long long>> dp(n + 1, vector<long long>(n + 1)), dp2 = dp;
vector<int> good;
for (int i = 1; i < MX; ++i)
if (dp1[i] == k) good.push_back(i);
dp[0][0] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= n; ++j) {
dp[i][j] %= mod;
dp2[i][j] %= mod;
if (dp[i][j] == 0 && dp2[i][j] == 0) continue;
if (s[i] == '1') {
dp2[i + 1][j] += dp[i][j];
dp[i + 1][j + 1] += dp[i][j];
dp2[i + 1][j] += dp2[i][j];
dp2[i + 1][j + 1] += dp2[i][j];
} else {
dp[i + 1][j] += dp[i][j];
dp2[i + 1][j] += dp2[i][j];
dp2[i + 1][j + 1] += dp2[i][j];
}
}
long long ans = 0;
for (int x : good)
if (x <= n) ans += dp2[n][x];
if (dp1[count(s.begin(), s.end(), '1')] == k) ++ans;
if (k == 0) ans += mod - 1;
cout << ans % mod << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 100, OO = 1e12, M = 1e9 + 7, M2 = 998244353,
sq = 31622, lg = 23;
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
multiset<long long> s;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
s.insert(x);
}
long long ans = 0;
if (n % 2 == 0) s.insert(0);
while (s.size() != 1) {
long long x = *s.begin();
s.erase(s.find(*s.begin()));
long long y = *s.begin();
s.erase(s.find(*s.begin()));
long long z = *s.begin();
s.erase(s.find(*s.begin()));
x += y + z;
ans += x;
s.insert(x);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int dp[N][N][N];
char st[N];
int nex[N];
int f[N];
const int mod = 1e9 + 7;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void cg(char &c) {
if (c == '(')
c = ')';
else
c = '(';
}
void init(int n) {
nex[0] = 0, nex[1] = 0;
for (int i = 1; i < n; i++) {
int j = nex[i];
while (j && st[i] != st[j]) j = nex[j];
nex[i + 1] = st[i] == st[j] ? j + 1 : 0;
}
f[0] = 0;
for (int i = 1; i < n; i++) {
int j = nex[i];
while (j && st[i] == st[j]) j = nex[j];
f[i] = st[i] != st[j] ? j + 1 : 0;
}
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", st);
int len = strlen(st);
init(len);
dp[0][0][0] = 1;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < len; j++) {
for (int k = 0; k <= n; k++) {
if (st[j] == '(') {
add(dp[i + 1][j + 1][k + 1], dp[i][j][k]);
} else
add(dp[i + 1][f[j]][k + 1], dp[i][j][k]);
if (k) {
if (st[j] == ')') {
add(dp[i + 1][j + 1][k - 1], dp[i][j][k]);
} else
add(dp[i + 1][f[j]][k - 1], dp[i][j][k]);
}
}
}
for (int k = 0; k <= n; k++) {
add(dp[i + 1][len][k + 1], dp[i][len][k]);
if (k) add(dp[i + 1][len][k - 1], dp[i][len][k]);
}
}
printf("%d\n", dp[2 * n][len][0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll maxn = 1e6 + 6, mod = 1e9 + 7;
ll n, m, ps[maxn], ans, n0, n1, p0 = -1, p1 = -1, pw[maxn];
string s, t;
bool check(ll p, ll p2, ll val0, ll val1, ll k0, ll k1) {
if (p == n - 1) return 1;
if (p >= n) return 0;
if (s[p + 1] == '0') {
ll val = (ps[p2 + k0 + 1] - ps[p2 + 1] + mod * 10) % mod;
ll y = p2 + 1;
y = pw[y];
if (val != val0 * y % mod) {
return 0;
}
return check(p + 1, p2 + k0, val0, val1, k0, k1);
}
ll y = p2 - p1 * k0 + 1;
y = pw[y];
ll val = (ps[p2 + k1 + 1] - ps[p2 + 1] + mod * 10) % mod;
if (val != val1 * y % mod) return 0;
return check(p + 1, p2 + k1, val0, val1, k0, k1);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
pw[0] = 1;
for (ll i = 1; i < maxn; i++) pw[i] = (pw[i - 1] * 26) % mod;
cin >> s >> t;
n = s.size();
m = t.size();
for (ll i = 0; i < m; i++) {
if (t[i] == 'b')
t[i] = 'x';
else if (t[i] == 'x')
t[i] = 'b';
}
if (s[0] == '1') {
for (ll i = 0; i < n; i++) s[i] = char('0' + 1 - (s[i] - '0'));
}
for (ll i = 0; i < n; i++) {
if (s[i] == '0') {
n0++;
if (p0 == -1) p0 = i;
} else {
n1++;
if (p1 == -1) p1 = i;
}
}
for (ll i = 0; i < m; i++) {
ll x = t[i] - 'a';
ps[i + 1] = (ps[i] + pw[i] * x) % mod;
}
for (ll i = 0; i < m; i++) {
ll x = i + 1;
if (x * n0 + n1 > m) break;
ll y = m - x * n0;
if ((y <= 0) || (y % n1 > 0)) continue;
y /= n1;
ll val0, val1;
ll z = pw[p1 * x];
val0 = ps[x];
val1 = (ps[p1 * x + y] - ps[p1 * x] + mod * 10) % mod;
bool b = check(0, i, val0, val1, x, y);
if (!b) continue;
if (val1 == val0 * z % mod && x == y) continue;
ans++;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, n;
map<int, int> mask, G;
inline void add(int n) {
int cnt;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) {
cnt = 0;
while (n % i == 0) n /= i, ++cnt;
mask[i] |= 1 << cnt;
}
if (n > 1) mask[n] |= 1 << 1;
}
inline string bin(int m) {
string res("00000000");
for (int i = 0; i < m; ++i)
if ((m >> i) & 1) res[i] = '1';
reverse(res.begin(), res.end());
return res;
}
inline int prin(int v, int m) { return v; }
int grundy(int Mask) {
if (G.count(Mask)) return G[Mask];
vector<int> v;
for (int i = 1; i <= 30; ++i) {
int x = (Mask >> i) | (Mask & ((1 << i) - 1));
if (x == Mask) break;
v.push_back(grundy(x));
}
sort(v.begin(), v.end());
unique(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i)
if (v[i] != i) return prin(G[Mask] = i, Mask);
return prin(G[Mask] = v.size(), Mask);
}
void init() {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> n;
add(n);
}
}
void sol() {
int ans = 0;
G[0] = G[1] = 0;
for (auto x : mask) ans ^= grundy(x.second);
if (ans)
puts("Mojtaba");
else
puts("Arpa");
}
int main() {
init();
sol();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dp[828][828][3][3];
int n, match[828];
string s;
long long DFS(int l, int r, int c1, int c2) {
if (dp[l][r][c1][c2] != -1) return dp[l][r][c1][c2];
if (l >= r) return dp[l][r][c1][c2] = 0;
long long ans = 0;
int m = match[l];
if (m == r) {
if ((c1 == 0 && c2) || (c1 && c2 == 0)) {
if (l + 1 == r) return dp[l][r][c1][c2] = 1LL;
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if ((c1 == 0 || x != c1) && (c2 == 0 || y != c2)) {
ans = (ans + DFS(l + 1, r - 1, x, y)) % mod;
}
}
}
}
} else if (m < r) {
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (x == 0 || y == 0 || (x != y)) {
ans = (ans + (DFS(l, m, c1, x) * DFS(m + 1, r, y, c2) % mod)) % mod;
}
}
}
}
return dp[l][r][c1][c2] = ans;
}
int main() {
cin >> s;
n = s.size();
stack<int> tt;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
tt.push(i);
else {
int tp = tt.top();
match[tp] = i;
match[i] = i;
tt.pop();
}
}
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) ans = (ans + DFS(0, n - 1, i, j)) % mod;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, T = 3010, size = 1 << 20, mod = 998244353, inf = 2e9;
const long long INF = 1e15;
template <class o>
void qr(o &x) {
char c = getchar();
x = 0;
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x *= f;
}
template <class o>
void qw(o x) {
if (x / 10) qw(x / 10);
putchar(x % 10 + '0');
}
template <class o>
void pr1(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar(' ');
}
template <class o>
void pr2(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar('\n');
}
int n, k, m, Q, a[N], b[N], c[N], R[N], lim[N], val[N], id[N], tot, ans, cnt;
int bl[T], br[T], pos[N], w[T][1 << 14], tag[N];
void ask() {
if (cnt)
puts("-1");
else
pr2(ans);
}
void add(int x, int y, int z) {
if (x > y) return;
int p = pos[x], q = pos[y];
if (p == q) {
for (auto i = x; i <= y; i++) w[p][val[i]]--, w[p][val[i] ^= z]++;
return;
}
for (auto i = p + 1; i <= q - 1; i++) tag[i] ^= z;
for (auto i = x; i <= br[p]; i++) w[p][val[i]]--, w[p][val[i] ^= z]++;
for (auto i = bl[q]; i <= y; i++) w[q][val[i]]--, w[q][val[i] ^= z]++;
}
int count(int x, int y) {
if (x > y) return 0;
int p = pos[x], q = pos[y], s = 0;
if (p == q) {
for (auto i = x; i <= y; i++) s += (val[i] != tag[p]);
return s;
}
for (auto i = p + 1; i <= q - 1; i++) s += w[i][tag[i]];
for (auto i = x; i <= br[p]; i++) s += (val[i] == tag[p]);
for (auto i = bl[q]; i <= y; i++) s += (val[i] == tag[q]);
return y - x + 1 - s;
}
void modify(int x, int y) {
if (x > n) return;
int z = x % k;
cnt -= count(lim[z], R[z]);
ans -= count(id[x], R[z]);
add(id[x], R[z], y);
cnt += count(lim[z], R[z]);
ans += count(id[x], R[z]);
}
int main() {
qr(n);
qr(k);
m = n - k + 1;
qr(Q);
for (auto i = 1; i <= n; i++) qr(a[i]);
for (auto i = 1; i <= n; i++) qr(b[i]), c[i] = a[i] ^ b[i];
if (k == 1) {
cnt = 0;
for (auto i = 1; i <= n; i++) cnt += !!c[i];
pr2(cnt);
while (Q--) {
char s[5];
int x, y;
scanf("%s", s);
qr(x);
qr(y);
cnt -= !!c[x];
if (s[0] == 'a')
c[x] ^= a[x] ^ y, a[x] = y;
else
c[x] ^= b[x] ^ y, b[x] = y;
cnt += !!c[x];
pr2(cnt);
}
return 0;
}
for (auto i = n; i >= 1; i--) c[i] ^= c[i - 1];
for (auto i = 0; i <= k - 1; i++) {
int s = (n - i) / k + (i > 0), j, d = 0;
for (j = !i ? k : i; s--; j += k) val[++tot] = d = c[j] ^ d, id[j] = tot;
j -= k;
R[i] = tot;
if (j > m)
lim[i] = tot, cnt += !!val[tot];
else
lim[i] = tot + 1;
}
for (auto i = 1; i <= tot; i++) ans += !!val[i];
int len = max(sqrt(1.0 * n / k + 0.5), ceil(1.0 * n / 3000)), t = n / len;
for (auto i = 1; i <= t; i++) bl[i] = br[i - 1] + 1, br[i] = i * len;
if (R[t] < n) t++, bl[t] = br[t - 1] + 1, br[t] = n;
for (auto i = 1; i <= t; i++)
for (auto j = bl[i]; j <= br[i]; j++) pos[j] = i, w[i][val[j]]++;
ask();
while (Q--) {
char s[5];
int x, y;
scanf("%s", s);
qr(x);
qr(y);
if (s[0] == 'a')
modify(x, a[x] ^ y), modify(x + 1, a[x] ^ y), a[x] = y;
else
modify(x, b[x] ^ y), modify(x + 1, b[x] ^ y), b[x] = y;
ask();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[100001];
int v[100001];
for (int i = 0; i < n; i++) cin >> arr[i];
int mx = arr[n - 1];
v[0] = 0;
int c = 1;
for (int i = n - 2; i >= 0; i--) {
if (mx >= arr[i]) {
v[c] = mx - arr[i] + 1;
c++;
} else {
mx = arr[i];
v[c] = 0;
c++;
}
}
for (int i = c - 1; i >= 0; i--) {
cout << v[i];
if (i > 0) cout << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int q = 0; q < t; q++) {
vector<pair<int, int>> ans1, ans2;
int n, k;
string s;
cin >> n >> k >> s;
char skob = '(';
for (int l = 0; l < n; l++) {
if (s[l] == skob) {
if (skob == '(')
skob = ')';
else
skob = '(';
continue;
}
for (int r = l; r < n; r++) {
if (s[r] == skob) {
reverse(s.begin() + l, s.begin() + r + 1);
ans1.push_back({l + 1, r + 1});
if (skob == '(')
skob = ')';
else
skob = '(';
break;
}
}
}
for (int i = 1; i < 2 * (n / 2 - k); i++) {
if (i % 2 == 0) {
reverse(s.begin(), s.begin() + i + 2 + 1);
} else {
reverse(s.begin() + 1, s.begin() + 2 + i);
}
}
skob = '(';
for (int l = 0; l < n; l++) {
if (s[l] == skob) {
if (skob == '(')
skob = ')';
else
skob = '(';
continue;
}
for (int r = l; r < n; r++) {
if (s[r] == skob) {
reverse(s.begin() + l, s.begin() + r + 1);
ans2.push_back({l + 1, r + 1});
if (skob == '(')
skob = ')';
else
skob = '(';
break;
}
}
}
reverse(ans2.begin(), ans2.end());
cout << ans1.size() + ans2.size() << endl;
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i].first << ' ' << ans1[i].second << endl;
}
for (int i = 0; i < ans2.size(); i++) {
cout << ans2[i].first << ' ' << ans2[i].second << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long MOD = 1e9;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
string s;
cin >> s;
sort(s.begin(), s.end());
char last = s[s.length() - 1];
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == last) {
cout << s[i];
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
int m;
cin >> m;
int w, h;
long long L = 0, w1 = 0, h1 = 0;
for (int i = 0; i < m; i++) {
cin >> w >> h;
L = max(L + h1, a[w]);
cout << L << endl;
w1 = w;
h1 = h;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string l;
int b = s.length();
int p = 0;
l = s;
reverse(s.begin(), s.end());
int i = 0;
while (s[i] == '0') {
p++;
i++;
}
while (p > 0) {
s = s + "0";
l = s;
p--;
}
int c = s.length();
if (c > b) {
reverse(s.begin(), s.end());
}
if (l == s) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
const int N = 1e5 + 100;
int n;
vector<int> g[N];
struct seg {
int l, r, id;
seg() {}
seg(int L, int R, int I) : l(L), r(R), id(I) {}
bool operator<(const seg &a) const {
return l == a.l ? (r == a.r ? id < a.id : r < a.r) : l < a.l;
}
};
set<seg> all;
int col[N];
void TZL() {
scf(n);
for (int i = (1); i <= (n); ++i) {
int l, r;
scf(l, r);
all.insert(seg(l, r, i));
col[i] = -1;
}
return;
}
void dfs(int u, int c = 0) {
col[u] = c;
for (int v : g[u])
if (!~col[v]) dfs(v, c ^ 1);
return;
}
void RANK1() {
while ((int)all.size() > 1) {
seg a = *all.begin();
all.erase(all.begin());
seg b = *all.begin();
all.erase(all.begin());
if (a.r < b.l) {
all.insert(b);
continue;
}
g[a.id].push_back(b.id);
g[b.id].push_back(a.id);
if (a.r > b.r) all.insert(seg(b.r + 1, a.r, a.id));
if (a.r < b.r) all.insert(seg(a.r + 1, b.r, b.id));
}
for (int i = (1); i <= (n); ++i) {
if (!~col[i]) dfs(i);
printf("%d ", col[i]);
}
return;
}
int main() {
TZL();
RANK1();
return 0;
}
| 11 |
Subsets and Splits