solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int f[300], p[100100], ps[100100];
pair<int, int> sk[100100];
int sz;
char s[2 * 100100], ss[100100];
int main() {
sz = 0;
memset(p, -1, sizeof(p));
f['('] = 1;
f['['] = 2;
f[')'] = -1;
f[']'] = -2;
scanf("%s", s);
n = strlen(s);
ps[0] = 0;
for (int i = (1); i <= (n); i++) {
ps[i] = ps[i - 1];
if (s[i - 1] == '[') ps[i]++;
}
for (int i = (0); i < (n); i++) {
if (f[s[i]] > 0)
sk[sz++] = pair<int, int>(f[s[i]], i);
else {
int x = sk[sz - 1].first, y = sk[sz - 1].second;
if (x + f[s[i]]) sz = 0;
if (!sz) continue;
p[i] = y;
sz--;
}
}
int mx = -1;
for (int i = (0); i < (n); i++) {
if (p[i] <= 0) continue;
if (p[p[i] - 1] != -1) p[i] = p[p[i] - 1];
}
for (int i = (0); i < (n); i++) {
if (p[i] == -1) continue;
if (mx != -1 && ps[i + 1] - ps[p[i]] <= ps[mx + 1] - ps[p[mx]]) continue;
mx = i;
}
if (mx == -1)
puts("0");
else {
printf("%d\n", ps[mx + 1] - ps[p[mx]]);
for (int i = (p[mx]); i <= (mx); i++) printf("%c", s[i]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
mt19937 rnd(51);
const long long N = 510;
vector<long long> par(N);
set<long long> g[N];
vector<long long> used(N);
long long c_e = 0, c_b = 0;
bool dfs(long long v) {
used[v] = 1;
for (auto to : g[v]) {
if (!used[to]) {
par[to] = v;
if (dfs(to)) return 1;
}
if (used[to] == 1) {
c_e = v, c_b = to;
return 1;
}
}
used[v] = 2;
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[a].insert(b);
}
for (long long i = 1; i <= n; i++) {
if (used[i] == 0) {
if (dfs(i)) {
vector<long long> v;
v.push_back(c_b);
for (long long u = c_e; u != c_b; u = par[u]) {
v.push_back(u);
}
v.push_back(c_b);
reverse(v.begin(), v.end());
for (long long j = 0; j < v.size() - 1; j++) {
g[v[j]].erase(v[j + 1]);
fill(used.begin(), used.end(), 0);
bool x = 0;
for (long long k = 1; k <= n; k++) {
if (!used[k]) {
if (dfs(k)) {
x = 1;
}
}
}
if (!x) {
cout << "YES";
return 0;
}
g[v[j]].insert(v[j + 1]);
}
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int res[500010];
bool f = false;
int cnt = 0;
int main() {
scanf("%s", s);
int l = strlen(s);
reverse(s, s + l);
s[l] = '0';
s[l + 1] = '0';
s[l + 2] = 0;
vector<pair<int, int> > tmp;
l += 2;
for (int i = 0, state = 1, r; i < l; i++) switch (state) {
case 1:
if (s[i] == '0') {
state = 1;
break;
}
if (s[i] == '1') {
r = i;
state = 4;
break;
}
case 2:
if (s[i] == '0') {
state = 3;
break;
}
if (s[i] == '1') {
state = 2;
break;
}
case 3:
if (s[i] == '0') {
res[cnt++] = i - 1;
res[cnt++] = -r;
state = 1;
break;
}
if (s[i] == '1') {
res[cnt++] = -(i - 1);
state = 2;
break;
}
case 4:
if (s[i] == '0') {
res[cnt++] = r;
f = f || (r == 0);
state = 1;
break;
}
if (s[i] == '1') {
state = 2;
break;
}
}
cout << cnt << endl;
for (int i = 0; i < cnt; i++)
printf("%c2^%d\n", (res[i] > 0 || res[i] == 0 && f ? '+' : '-'),
abs(res[i]));
exit:
return (0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int N = 1 << 17;
struct point {
int a, b, x, y;
void read() { cin >> x >> y >> a >> b; }
void rot() {
int vx = x - a;
int vy = y - b;
int rx = -vy;
int ry = vx;
x = a + rx;
y = b + ry;
}
bool operator==(point o) {
if (a != o.a) return 0;
if (b != o.b) return 0;
if (x != o.x) return 0;
if (y != o.y) return 0;
return 1;
}
} a[4], b[4];
long long getdist(point a, point b) {
long long x = a.x - b.x;
long long y = a.y - b.y;
return x * x + y * y;
}
long long dist[7];
bool ok(int ca, int cb, int cc, int cd) {
b[0] = a[0];
for (int i = 0; i < ca; i++) b[0].rot();
b[1] = a[1];
for (int i = 0; i < cb; i++) b[1].rot();
b[2] = a[2];
for (int i = 0; i < cc; i++) b[2].rot();
b[3] = a[3];
for (int i = 0; i < cd; i++) b[3].rot();
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++)
if (b[i] == b[j]) return 0;
int k = 0;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++) dist[k++] = getdist(b[i], b[j]);
sort(dist, dist + k);
return (dist[0] == dist[1] && dist[2] == dist[3] && dist[0] == dist[3] &&
dist[4] == dist[5] && dist[0] + dist[1] == dist[4]);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) a[j].read();
int ans = inf;
int c = 0;
for (int ca = 0; ca < 4; ca++)
for (int cb = 0; cb < 4; cb++)
for (int cc = 0; cc < 4; cc++)
for (int cd = 0; cd < 4; cd++)
if (ok(ca, cb, cc, cd)) ans = min(ans, ca + cb + cc + cd);
if (ans == inf) ans = -1;
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
int n, s;
int k[1 << 7];
pair<int, int> a[100][100];
int o[1 << 7];
int v[1 << 7];
int p[1 << 7];
int m;
pair<int, int> ev[1 << 14];
int near[100][100];
int tn[100][100];
int nx[1 << 7];
inline void init() {
m = 0;
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++i) {
scanf("%d", &k[i]);
int curt = 0;
for (int j = 0; j < k[i]; ++j) {
scanf("%d%d", &a[i][j].first, &a[i][j].second);
ev[m++] = pair<int, int>(curt, i);
curt += a[i][j].second;
}
ev[m++] = pair<int, int>(curt, i);
}
sort(ev, ev + m);
memset(near, 0, sizeof near);
}
inline int isOver(int x) { return (o[x] == k[x]); }
int main() {
init();
memset(o, -1, sizeof o);
memset(v, 0, sizeof v);
memset(p, 0, sizeof p);
long long res = 0;
for (int t = 0; t < m;) {
int curt = ev[t].first;
while (t < m && ev[t].first == curt) {
int x = ev[t].second;
++o[x];
if (!isOver(x)) v[x] = a[x][o[x]].first;
++t;
}
if (t == m) break;
int nextt = ev[t].first;
int dif = nextt - curt;
for (int i = 0; i < n; ++i) {
if (isOver(i)) continue;
nx[i] = p[i] + dif * v[i];
}
memset(tn, 0, sizeof tn);
for (int x = 0; x < n; ++x) {
if (isOver(x)) continue;
for (int y = x + 1; y < n; ++y) {
if (isOver(y)) continue;
int i = x;
int j = y;
if (v[i] < v[j]) swap(i, j);
if (p[i] > p[j]) continue;
if (p[i] == p[j]) {
if (!near[i][j]) continue;
++res;
continue;
}
if (nx[i] == nx[j]) {
tn[i][j] = 1;
continue;
}
if (nx[i] > nx[j]) ++res;
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
if (tn[j][i]) tn[i][j] = 1;
near[i][j] = tn[i][j];
}
for (int i = 0; i < n; ++i) {
if (isOver(i)) continue;
p[i] = nx[i];
}
}
printf("%lld\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int ans[maxn];
vector<int> xs[maxn], ys[maxn];
struct query {
int l, r, d, u, id;
query(int aa, int bb, int cc, int dd, int ee) {
l = aa;
r = bb;
d = cc;
u = dd;
id = ee;
}
query() {}
};
query qry[maxn];
vector<int> xq[maxn], yq[maxn];
struct SegmentTree {
SegmentTree *lc, *rc;
static SegmentTree mem[2000000];
static SegmentTree *ptr;
int pos;
SegmentTree() {}
~SegmentTree() {}
SegmentTree(int L, int R) {
lc = rc = nullptr;
pos = 0;
if (L == R) return;
lc = new (ptr++) SegmentTree(L, ((L + R) >> 1));
rc = new SegmentTree(((L + R) >> 1) + 1, R);
}
void pull() { pos = min(lc->pos, rc->pos); }
void modify(int L, int R, int x, int v) {
if (L == R) {
pos = v;
return;
}
if (x <= ((L + R) >> 1))
lc->modify(L, ((L + R) >> 1), x, v);
else
rc->modify(((L + R) >> 1) + 1, R, x, v);
pull();
}
int ask(int L, int R, int l, int r) {
if (L > r || l > R) return maxn;
if (L >= l && R <= r) return pos;
return min(lc->ask(L, ((L + R) >> 1), l, r),
rc->ask(((L + R) >> 1) + 1, R, l, r));
}
} * stx, *sty;
SegmentTree SegmentTree::mem[2000000];
SegmentTree *SegmentTree::ptr = mem;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k, q;
cin >> n >> m >> k >> q;
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
xs[x].push_back(y);
ys[y].push_back(x);
}
for (int i = 0; i < q; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
qry[i] = query(x1, x2, y1, y2, i);
xq[x2].push_back(i);
yq[y2].push_back(i);
}
stx = new (SegmentTree::ptr++) SegmentTree(0, maxn - 1);
sty = new (SegmentTree::ptr++) SegmentTree(0, maxn - 1);
for (int i = 0; i < maxn; ++i)
if (xs[i].size() || xq[i].size()) {
for (int j : xs[i]) stx->modify(0, maxn - 1, j, i);
for (int j : xq[i]) {
if (stx->ask(0, maxn - 1, qry[j].d, qry[j].u) < qry[j].l) ++ans[j];
}
}
for (int i = 0; i < maxn; ++i)
if (ys[i].size() || yq[i].size()) {
for (int j : ys[i]) sty->modify(0, maxn - 1, j, i);
for (int j : yq[i]) {
if (sty->ask(0, maxn - 1, qry[j].l, qry[j].r) < qry[j].d) ++ans[j];
}
}
for (int i = 0; i < q; ++i) {
if (ans[i] == 2)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, d, i, c = 0, m = 0, j, k = 0;
char s[1000][1000];
scanf("%d %d", &n, &d);
for (i = 0; i < d; i++) {
scanf("%s", s[i]);
}
for (i = 0; i < d; i++) {
m = 0;
for (j = 0; j < n; j++) {
if (s[i][j] == '0') {
m = 1;
break;
}
}
if (m == 1) {
c++;
} else if (m == 0) {
if (c > k) {
k = c;
c = 0;
}
c = 0;
}
}
if (c > k) {
k = c;
c = 0;
}
printf("%d\n", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
const int mx[8] = {-1, -2, -2, -1, 1, 2, 2, 1};
const int my[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
const double eps = 1e-6;
const double PI = acos(-1.0);
const long long maxn = 1e7 + 5;
const long long inf = 1LL << 62;
int n, num, p1, p2, per1, per2, siz;
long long ans, now0, now1, now2, a[1000005];
bool vis[maxn];
vector<int> vec[maxn];
int main() {
while (~scanf("%d", &n)) {
ans = inf;
per1 = per2 = 0;
for (long long i = 0LL; i < maxn; ++i) vec[i].clear();
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
vec[a[i]].push_back(i);
vis[a[i]] = true;
}
for (long long i = 1LL; i < maxn; ++i) {
num = 0;
for (long long j = i; j < maxn && num < 2; j += i) {
if (!vis[j]) continue;
if (num == 0) {
siz = vec[j].size();
if (siz == 1) {
++num;
p1 = vec[j][0];
now1 = j;
} else {
num += 2;
p1 = vec[j][0], p2 = vec[j][1];
now1 = j, now2 = j;
}
} else {
++num;
now2 = j;
p2 = vec[j][0];
}
}
if (num == 2) {
now0 = now1 / i * now2;
if (ans > now0) {
ans = now0;
per1 = p1, per2 = p2;
}
}
}
if (per1 > per2) swap(per1, per2);
printf("%d %d\n", per1, per2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool mark;
string s;
int main() {
cin >> s;
int i = 0;
while (i < s.size() && s[i] != '@') {
if (!((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
(s[i] >= '0' && s[i] <= '9') || s[i] == '_')) {
mark = true;
}
i++;
}
if (i == s.size() || i > 16 || i == 0) mark = true;
i++;
if (mark)
cout << "NO" << endl;
else {
int dot = 0, ss = 0, sw = 0;
while (i < s.size() && s[i] != '/') {
if (s[i] == '.') {
dot++;
if (dot > 15 || sw > 16 || sw < 1) {
mark = true;
}
sw = -1;
} else {
if (!((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
(s[i] >= '0' && s[i] <= '9') || s[i] == '_')) {
mark = true;
}
}
sw++;
ss++;
i++;
}
if (ss > 32 || ss < 1 || sw == 0) mark = true;
if (i < s.size()) {
ss = 0;
i++;
while (i < s.size()) {
if (!((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
(s[i] >= '0' && s[i] <= '9') || s[i] == '_'))
mark = true;
i++;
ss++;
}
if (ss > 16 || ss < 1) mark = true;
}
if (mark)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace Solve {
const int MAXN = 2e6 + 10;
const long long MOD = 998244353;
int height[MAXN], treesize[MAXN];
int n;
long long dp[MAXN][2];
int used[MAXN][2];
long long DP(int n, int s) {
if (n == 1) return s == 1;
if (n == 2) return s == 0;
if (used[n][s]) return dp[n][s];
used[n][s] = 1;
long long& ans = dp[n][s];
ans = 0;
int h = height[n];
int remains = n - treesize[h];
int minsize = 0, maxsize = remains;
if (remains > (1 << h)) {
minsize = remains - (1 << h);
maxsize = (1 << h);
}
for (int i = minsize; i <= maxsize; i++) {
int leftsize = treesize[h] / 2 + i,
rightsize = treesize[h] / 2 + remains - i;
assert(leftsize + 1 + rightsize == n);
if ((leftsize + s) % 2 == 0) continue;
if (s == 0) {
ans += DP(leftsize, s ^ 1) * DP(rightsize, s);
} else {
ans += DP(leftsize, s ^ 1) * DP(rightsize, s ^ 1);
}
ans %= MOD;
}
return ans;
}
void table() {
cin >> n;
set<int> ones;
for (int s = 1, d = 3, flag = -1; s <= n;) {
ones.insert(s);
ones.insert(s + 1);
s = s + d;
d = d * 2 + flag;
flag *= -1;
}
cout << (ones.find(n) == ones.end() ? 0 : 1) << endl;
}
void solve() {
table();
return;
for (int s = 1, d = 2, h = 0; s <= MAXN;) {
treesize[h] = s;
for (int i = s; i < s + d && i <= MAXN; i++) {
height[i] = h;
}
s += d;
d *= 2;
h++;
}
for (int i = 1; i <= int(1e6 + 10); i++) {
int value = (DP(i, 0) + DP(i, 1)) % MOD;
if (value == 1) {
cout << i << " " << value << endl;
}
}
}
} // namespace Solve
int main() {
Solve::solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Read(T &t) {
int c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar()) f = (c == '-');
for (t = 0; c >= '0' && c <= '9'; c = getchar())
t = (t << 3) + (t << 1) + (c ^ 48);
if (f) t = -t;
}
const int N = 5e5 + 5;
int test;
long long n, c, cap[N];
struct Friend {
long long t, a, p;
bool operator<(const Friend &rhs) const { return t < rhs.t; }
} f[N];
struct Node {
long long p, id;
Node() { p = 0, id = 0; }
Node(long long __p, long long __id) { p = __p, id = __id; }
bool operator<(const Node &rhs) const { return p < rhs.p; }
bool operator>(const Node &rhs) const { return p > rhs.p; }
bool operator<=(const Node &rhs) const { return p <= rhs.p; }
bool operator>=(const Node &rhs) const { return p >= rhs.p; }
};
struct my_priority_queue {
private:
int size, num1[N], num2[N];
Node heap1[N], heap2[N];
public:
my_priority_queue() { size = 0; }
bool empty() { return !size; }
void clear(int limit) {
size = 0;
for (int i = 1; i <= limit; i++) num1[i] = num2[i] = 0;
for (int i = 1; i <= limit; i++)
heap1[i] = Node(0, 0), heap2[i] = Node(0, 0);
}
Node top1() { return heap1[1]; }
Node top2() { return heap2[1]; }
void push(Node x) {
heap1[++size] = x, heap2[size] = x;
num1[x.id] = num2[x.id] = size;
int now = size, next;
while (now > 1) {
next = now >> 1;
if (heap1[now] <= heap1[next]) break;
num1[heap1[now].id] = next, num1[heap1[next].id] = now;
swap(heap1[now], heap1[next]);
now = next;
}
now = size;
while (now > 1) {
next = now >> 1;
if (heap2[now] >= heap2[next]) break;
num2[heap2[now].id] = next, num2[heap2[next].id] = now;
swap(heap2[now], heap2[next]);
now = next;
}
}
void pop1() {
int temp = num2[heap1[1].id];
heap1[1] = heap1[size], heap2[temp] = heap2[size];
num1[heap1[1].id] = 1, num2[heap2[temp].id] = temp;
size--;
int now = 1, next;
while ((now << 1) <= size) {
next = now << 1;
if (next < size && heap1[next | 1] > heap1[next]) next |= 1;
if (heap1[now] >= heap1[next]) break;
num1[heap1[now].id] = next, num1[heap1[next].id] = now;
swap(heap1[now], heap1[next]);
now = next;
}
now = temp;
if (now > 1 && heap2[now] < heap2[now >> 1])
while (now > 1) {
next = now >> 1;
if (heap2[now] >= heap2[next]) break;
num2[heap2[now].id] = next, num2[heap2[next].id] = now;
swap(heap2[now], heap2[next]);
now = next;
}
else
while ((now << 1) <= size) {
next = now << 1;
if (next < size && heap2[next | 1] < heap2[next]) next |= 1;
if (heap2[now] <= heap2[next]) break;
num2[heap2[now].id] = next, num2[heap2[next].id] = now;
swap(heap2[now], heap2[next]);
now = next;
}
}
void pop2() {
int temp = num1[heap2[1].id];
heap2[1] = heap2[size], heap1[temp] = heap1[size];
num2[heap2[1].id] = 1, num1[heap1[temp].id] = temp;
size--;
int now = 1, next;
while ((now << 1) <= size) {
next = now << 1;
if (next < size && heap2[next | 1] < heap2[next]) next |= 1;
if (heap2[now] <= heap2[next]) break;
num2[heap2[now].id] = next, num2[heap2[next].id] = now;
swap(heap2[now], heap2[next]);
now = next;
}
now = temp;
if (now > 1 && heap1[now] > heap1[now >> 1])
while (now > 1) {
next = now >> 1;
if (heap1[now] <= heap1[next]) break;
num1[heap1[now].id] = next, num1[heap1[next].id] = now;
swap(heap1[now], heap1[next]);
now = next;
}
else
while ((now << 1) <= size) {
next = now << 1;
if (next < size && heap1[next | 1] > heap1[next]) next |= 1;
if (heap1[now] >= heap1[next]) break;
num1[heap1[now].id] = next, num1[heap1[next].id] = now;
swap(heap1[now], heap1[next]);
now = next;
}
}
} q;
void work() {
long long now, ans = 0, last = 0;
Read(n), Read(f[n + 1].t), Read(c), Read(now);
for (int i = 1; i <= n; i++) Read(f[i].t), Read(f[i].a), Read(f[i].p);
for (int i = 1; i <= n; i++) cap[i] = 0;
sort(f + 1, f + n + 1);
q.push(Node(0, 0)), cap[0] = now;
for (int i = 1; i <= n + 1; i++) {
long long temp = f[i].t - last, a = f[i].a, p = f[i].p;
last = f[i].t;
if (temp > now) {
q.clear(n), puts("-1");
return;
}
now -= temp;
while (temp > 0) {
long long id = q.top2().id, __p = q.top2().p;
if (temp >= cap[id])
ans += cap[id] * __p, temp -= cap[id], q.pop2();
else
ans += temp * __p, cap[id] -= temp, temp = 0;
}
if (i == n + 1) break;
if (a + now <= c) {
now += a, cap[i] = a, q.push(Node(p, i));
continue;
}
a -= c - now, cap[i] = c - now, now = c;
while (a > 0 && !q.empty()) {
long long id = q.top1().id, __p = q.top1().p;
if (p >= __p) break;
if (a >= cap[id])
a -= cap[id], cap[i] += cap[id], q.pop1();
else
cap[id] -= a, cap[i] += a, a = 0;
}
q.push(Node(p, i));
}
q.clear(n);
printf("%I64d\n", ans);
}
int main() {
Read(test);
while (test--) work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v[4];
cin >> v[0] >> v[1] >> v[2] >> v[3];
sort(v, v + 4);
if (v[0] + v[3] == v[1] + v[2])
cout << "YES\n";
else if (v[0] + v[1] + v[2] == v[3])
cout << "YES\n";
else
cout << "NO\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 1;
const int mod = 1e9 + 7;
int dp[maxn], g[maxn], ans = 1;
struct node {
int u, v, w, id;
} s[maxn];
bool cmp(const node &a, const node &b) { return a.w < b.w; }
int main() {
int n, m, u, v, w, j, t = 1;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d %d", &u, &v, &w);
s[i].u = u, s[i].v = v, s[i].w = w, s[i].id = i;
}
sort(s + 1, s + 1 + m, cmp);
for (int i = 1; i <= m; ++i) {
dp[i] = g[s[i].u] + 1;
if (s[i].w != s[i + 1].w) {
for (j = t; j <= i; ++j) g[s[j].v] = max(g[s[j].v], dp[j]);
t = i + 1;
}
}
for (int i = 1; i <= m; ++i) ans = max(ans, dp[i]);
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int na, ma, nb, mb;
string A[51], B[51];
cin >> ma >> na;
for (int i = 1; i <= ma; ++i) {
cin >> A[i];
A[i] = " " + A[i];
}
cin >> mb >> nb;
for (int i = 1; i <= mb; ++i) {
cin >> B[i];
B[i] = " " + B[i];
}
int r1, r2, m = 0;
for (int x = -50; x <= 50; ++x) {
for (int y = -50; y <= 50; ++y) {
int S = 0;
for (int i = 1; i <= ma; ++i)
if (i + y > 0 && i + y <= mb) {
for (int j = 1; j <= na; ++j)
if (j + x > 0 && j + x <= nb) {
S += (A[i][j] - 48) * (B[i + y][j + x] - 48);
}
}
if (S > m) {
m = S;
r1 = x;
r2 = y;
}
}
}
cout << r2 << " " << r1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 100;
long long F(long long N, long long P) {
if (P == 0) return 1;
if (P % 2 == 0) {
long long ret = F(N, P / 2);
return ((ret % M) * (ret % M)) % M;
} else
return ((N % M) * (F(N, P - 1) % M)) % M;
}
int main() {
long long n;
long long f = 5;
cin >> n;
cout << F(f, n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct debug {
template <typename T>
debug& operator<<(const T&) {
return *this;
}
};
const int mod = 1e9 + 7;
const int mxn = 1e6 + 5;
int n, m;
vector<string> color, mat;
vector<vector<vector<array<int, 2>>>> inv;
vector<vector<bool>> vis, vis2;
vector<array<int, 2>> cycle;
vector<int> cnt;
int curr_size;
array<int, 2> node(int i, int j, char dir) {
if (dir == 'U') {
--i;
} else if (dir == 'L') {
--j;
} else if (dir == 'R') {
++j;
} else if (dir == 'D') {
++i;
}
return {i, j};
}
void dfs(array<int, 2> i) {
if (vis[i[0]][i[1]]) {
cycle.push_back(i);
return;
}
vis[i[0]][i[1]] = 1;
array<int, 2> p = node(i[0], i[1], mat[i[0]][i[1]]);
dfs(p);
if (cycle.back() == p && cycle[0] != i) {
cycle.push_back(i);
}
}
void dfs2(array<int, 2> i, int d = 0) {
vis[i[0]][i[1]] = vis2[i[0]][i[1]] = 1;
if (color[i[0]][i[1]] == '0') {
++cnt[d % curr_size];
}
for (auto a : inv[i[0]][i[1]]) {
if (!vis2[a[0]][a[1]]) {
dfs2(a, d + 1);
}
}
}
void solve() {
cin >> n >> m;
color = vector<string>(n);
mat = vector<string>(n);
for (int i = 0; i < n; ++i) {
cin >> color[i];
}
for (int i = 0; i < n; ++i) {
cin >> mat[i];
}
inv = vector<vector<vector<array<int, 2>>>>(n,
vector<vector<array<int, 2>>>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
array<int, 2> v = node(i, j, mat[i][j]);
array<int, 2> u = {i, j};
inv[v[0]][v[1]].push_back(u);
}
}
vis = vis2 = vector<vector<bool>>(n, vector<bool>(m));
int total = 0, black = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!vis[i][j]) {
cycle.clear();
dfs({i, j});
curr_size = cycle.size();
total += curr_size;
if (curr_size != 0) {
cnt = vector<int>(curr_size);
dfs2(cycle[0]);
for (int k = 0; k < curr_size; ++k) {
if (cnt[k] > 0) ++black;
}
}
}
}
}
cout << total << " " << black << "\n";
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) {
return v;
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = (int)1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
const int nax = 1e5 + 10;
vector<pair<int, int>> node[nax];
int depth[nax], xat[nax], rem[nax], mate[nax], out[nax], mout[nax];
vector<int> has[nax];
void dfs(vector<int>& v, int p, int par = -1, int d = 1, int x = 0) {
if (rem[p]) return;
if (depth[p]) {
if (d > depth[p]) v.push_back(x ^ xat[p]);
return;
}
xat[p] = x;
depth[p] = d;
for (auto [i, w] : node[p]) {
if (i == par || rem[i]) continue;
dfs(v, i, p, d + 1, x ^ w);
}
}
struct Reduced {
vector<int> row;
Reduced operator+(int m) const {
if (row == vector<int>({0})) return {{0}};
Reduced r = {row};
for (int v : row) {
int first = 31 - __builtin_clz(v);
if (m >> first & 1) m ^= v;
}
if (!m) return {{0}};
{
int first = 31 - __builtin_clz(m);
for (int& v : r.row) {
if (v >> first & 1) v ^= m;
}
r.row.push_back(m);
}
sort(r.row.rbegin(), r.row.rend());
return r;
}
bool operator<(const Reduced& other) const { return row < other.row; }
};
ostream& operator<<(ostream& cout, const Reduced& r) {
for (int v : r.row) cout << bitset<5>(v) << endl;
return cout;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
node[a].emplace_back(b, c);
node[b].emplace_back(a, c);
}
vector<int> adj0(n);
for (auto [i, w] : node[0]) {
adj0[i] = 1;
out[i] = w;
}
rem[0] = 1;
for (auto [i, w] : node[0]) {
assert(out[i] == w);
mate[i] = -1;
for (auto [j, c] : node[i])
if (adj0[j]) {
assert(mate[i] == -1);
mate[i] = j;
mout[i] = c;
}
if (mate[i] != -1) rem[mate[i]] = 1;
dfs(has[i], i);
if (mate[i] != -1) rem[mate[i]] = 0;
}
map<Reduced, int> comp;
vector<Reduced> y;
comp[{}];
queue<Reduced> q;
q.push({});
while (q.size()) {
Reduced r = q.front();
q.pop();
for (int v = 0; v < 32; v++) {
Reduced i = r + v;
if (!comp.count(i)) {
comp[i];
q.push(i);
}
}
}
int equivs = 0;
for (auto& [p, i] : comp) {
y.push_back(p);
i = equivs++;
}
vector<vector<int>> mem(equivs, vector<int>(32, -1));
auto merge = [&](int i, int j) {
if (mem[i][j] == -1) {
mem[i][j] = comp[y[i] + j];
}
return mem[i][j];
};
auto add = [&](int i, vector<int>& v) {
for (int j : v) {
i = merge(i, j);
}
return i;
};
vector<Mint> dp(equivs);
dp[comp[{}]] = 1;
for (int i = 0; i < n; i++) {
vector<Mint> ndp = dp;
if (adj0[i]) {
if (mate[i] == -1) {
for (int k = 0; k < equivs; k++) {
ndp[add(k, has[i])] += dp[k];
}
} else if (i < mate[i]) {
assert(mate[mate[i]] == i);
vector<int>& a = has[i];
vector<int>& b = has[mate[i]];
int t = out[i] ^ out[mate[i]] ^ mout[i];
for (int k = 0; k < equivs; k++) {
int sum = add(add(k, a), b);
ndp[sum] += dp[k] * 2;
ndp[merge(sum, t)] += dp[k];
}
}
}
swap(dp, ndp);
}
Mint ans = 0;
for (int i = 0; i < equivs; i++) {
if (merge(i, 0) != i) ans += dp[i];
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ch, cs, ret;
int S[500005], H[500005];
char s[500005];
int doit(int x) {
if (x + cs < ch) return 0;
if (m >= 2 * n) return 1;
if (x >= ch) return H[ch - 1] + 1 <= m;
int t = 0, mn = (1 << 30), cnt = 0, b, j;
int lh = H[ch - 1], ls = S[ch - x - 1];
for (int i = 0; i < n && cnt < ch; i++) {
++t;
if (s[i] == 'S') ++x;
if (s[i] == 'H') {
++cnt;
if (!x) {
mn = min(mn, t + 2 * (max(lh, ls) - i));
b = 1, j = i;
while (b) {
++j;
if (s[j] == 'S') --b;
if (s[j] == 'H') ++b, ++cnt;
}
t += 3 * (j - i);
i = j;
} else
--x;
}
}
mn = min(mn, t);
return mn <= m;
}
int main() {
scanf("%d%d%s", &n, &m, s);
for (int i = (0); i < (n); i++) {
if (s[i] == 'H') H[ch++] = i;
if (s[i] == 'S') S[cs++] = i;
}
ret = -1;
for (int i = 0, j = n, k; j >= i;) {
k = (i + j) >> 1;
if (doit(k))
ret = k, j = k - 1;
else
i = k + 1;
}
printf("%d\n", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace Flandre_Scarlet {
long long mod;
class Matrix {
private:
long long a[5][5];
public:
long long n;
Matrix() {
memset(a, 0, sizeof(a));
n = 0;
}
Matrix(long long _n) {
memset(a, 0, sizeof(a));
n = _n;
}
Matrix(long long _n, long long _x) {
_x %= mod;
n = _n;
for (long long i = 0; i < 5; ++i) {
for (long long j = 0; j < 5; ++j) {
a[i][j] = _x;
}
}
}
long long* operator[](long long i) { return *(a + i); }
void Set(long long x) {
x %= mod;
for (long long i = 0; i < 5; ++i) {
for (long long j = 0; j < 5; ++j) {
a[i][j] = x;
}
}
}
void Identity() {
memset(a, 0, sizeof(a));
for (long long i = 0; i < 5; ++i) {
a[i][i] = 1;
}
}
};
Matrix operator*(Matrix x, Matrix y) {
Matrix ans(x.n, 0);
long long n = ans.n;
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
for (long long k = 1; k <= n; ++k) {
ans[i][j] += x[i][k] * y[k][j];
ans[i][j] %= mod;
}
}
}
return ans;
}
Matrix operator^(Matrix x, long long p) {
Matrix ans(x.n, 1);
ans.Identity();
while (p) {
if (p & 1) ans = ans * x;
x = x * x, p >>= 1;
}
return ans;
}
long long Fib(long long x) {
Matrix Init(2, 0);
Init[1][1] = 0, Init[1][2] = 1;
Matrix Trans(2, 1);
Trans[1][1] = 0;
Matrix Ans = Init * (Trans ^ x);
return Ans[1][1];
}
long long l, r, k;
void R1(long long& x) {
x = 0;
char c = getchar();
long long f = 1;
while (c < '0' or c > '9') f = (c == '-') ? -1 : 1, c = getchar();
while (c >= '0' and c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = (f == 1) ? x : -x;
}
void Input() {
R1(mod);
R1(l), R1(r), R1(k);
}
bool cxk(long long x) { return (r / x - (l - 1) / x) >= k; }
void Soviet() {
long long ans = -0x3f3f3f3f;
for (long long i = 1; i * i <= r; ++i) {
if (cxk(i)) ans = max(ans, i);
if (cxk(r / i)) ans = max(ans, r / i);
}
printf("%lld\n", Fib(ans));
}
void IsMyWife() {
Input();
Soviet();
}
} // namespace Flandre_Scarlet
int main() {
Flandre_Scarlet::IsMyWife();
getchar();
getchar();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000007;
const double pi = acos(-1.0);
int main() {
long long a, b;
cin >> a >> b;
long long ans = 0;
for (int m = (1); m <= (b - 1); ++m) {
long long s1 = (a * (a + 1)) / 2 % MOD;
s1 = (s1 * b) % MOD;
s1 = (s1 * m) % MOD;
long long s2 = m * a % MOD;
ans = (ans + s1 + s2) % MOD;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, list<int> > f;
vector<int> dis_f;
map<int, bool> use;
void dfs(int u) {
int v;
list<int>& l = f[u];
while (!l.empty()) {
v = *(l.begin());
l.pop_front();
if (!use[v]) dfs(v);
}
dis_f.push_back(u);
}
map<int, int> g;
int n;
int main() {
int n;
while (~scanf("%d", &n)) {
int start = 0;
for (int i = 0; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
f[u].push_back(v);
f[v].push_back(u);
g[u]++, g[v]++;
}
map<int, int>::iterator it;
for (it = g.begin(); it != g.end(); ++it) {
if ((it->second % 2)) {
start = it->first;
break;
}
}
dfs(start);
for (int i = 0; i < n; ++i) printf("%d ", dis_f[i]);
printf("%d\n", dis_f[n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int min3(int a, int b, int c) { return min(a, min(b, c)); }
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v;
int x;
int i = 0;
while (i < n) {
cin >> x;
v.push_back(x);
i++;
}
sort(v.begin(), v.end());
i = 0;
long long z;
long long ans = -1;
x = n / 2;
while (i < x) {
z = v[i];
z *= (long long)v[n - 1 - i];
if (ans == -1) ans = z;
if (ans != z) break;
i++;
}
if (i == x) {
if (n & 1) {
z = v[i];
z *= (long long)v[n - 1 - i];
if (ans == -1) ans = z;
if (z != ans) {
cout << -1 << endl;
continue;
}
}
i = 0;
long long p = 2;
long long c = floor(sqrt(ans));
while (p <= c) {
if (ans % p == 0) {
if (p != (long long)v[i]) break;
i++;
}
p++;
}
if (p > c)
cout << ans << endl;
else
cout << -1 << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<vector<long long> > dp(n + 1, vector<long long>(31, 1e9));
dp[0][0] = 0;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
for (long long j = 0; j <= 30; j++) {
dp[i + 1][min(30, j + a / 1000)] =
min(dp[i + 1][min(30, j + a / 1000)], dp[i][j] + a);
}
for (long long j = 0; j <= 30; j++) {
dp[i + 1][max(0, j - a / 100)] = min(
dp[i + 1][max(0, j - a / 100)], dp[i][j] + a - min(j, a / 100) * 100);
}
}
long long ans = 1e9;
for (long long i = 0; i <= 30; i++) {
ans = min(ans, dp[n][i]);
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, q, i, j, current, ma;
cin >> n >> q;
long long A[n];
for (i = 0; i < n; i++) cin >> A[i];
j = distance(A, max_element(A, A + n));
ma = A[j];
list<long long> solve;
list<long long>::iterator itr;
for (i = 0; i < n; i++) solve.push_back(A[i]);
long long ans[j + 1][2], a, b;
for (i = 0; i < j; i++) {
itr = solve.begin();
a = *itr;
solve.pop_front();
itr = solve.begin();
b = *itr;
solve.pop_front();
solve.push_back(min(a, b));
solve.push_front(max(a, b));
ans[i][0] = b;
ans[i][1] = a;
}
i = 0;
itr = solve.begin();
itr++;
for (itr = itr; itr != solve.end(); itr++) {
A[i] = *itr;
i++;
}
for (i = 0; i < q; i++) {
cin >> current;
if (current <= j)
cout << ans[current - 1][1] << " " << ans[current - 1][0] << endl;
else {
current = current - (j + 1);
current = current % (n - 1);
cout << ma << " " << A[current] << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
unsigned long long int ans = 0;
cin >> n >> m;
vector<vector<int>> mat(n, vector<int>(m, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
int x = (m % 2 == 0) ? (m / 2) - 1 : (m / 2);
for (int k = 0; k <= x; k++) {
for (int i = 0, j = n - 1; i <= j; i++, j--) {
if (i != j) {
int p = mat[i][k];
int q = mat[i][m - 1 - k];
int r = mat[j][k];
int s = mat[j][m - 1 - k];
vector<int> nums = {p, q, r, s};
sort(nums.begin(), nums.end());
int mid = nums[1];
unsigned long long int a =
(abs(mid - nums[0]) + abs(mid - nums[2]) + abs(mid - nums[3]));
if (k == m - 1 - k) a = a / 2;
ans += a;
} else {
int p = mat[i][k];
int q = mat[i][m - 1 - k];
vector<int> nums = {p, q};
sort(nums.begin(), nums.end());
int mid = nums[0];
ans += (abs(mid - nums[1]));
}
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string st;
int a[10], b[10], res;
vector<int> ra, rb;
int calc(int u) {
if (a[u] == 0 || b[10 - u] == 0) return 0;
a[u]--;
b[10 - u]--;
int s = 0;
for (int i = 0; i < 10; i++) s += min(a[i], b[9 - i]);
int temp1 = min(a[0], b[9]);
int temp2 = min(b[0], a[9]);
s += min(a[0] - temp1, b[0] - temp2);
a[u]++;
b[10 - u]++;
return s + 1;
}
int main() {
cin >> st;
for (int i = 0; i < st.length(); i++) a[st[i] - '0']++;
for (int i = 0; i < 10; i++) b[i] = a[i];
res = min(a[0], b[0]);
int s, id = -1;
for (int i = 1; i < 10; i++) {
s = calc(i);
if (s > res) {
res = s;
id = i;
}
}
if (id != -1) {
a[id]--;
b[10 - id]--;
ra.push_back(id);
rb.push_back(10 - id);
for (int u = 0; u < 10; u++) {
for (int i = 0; i < min(a[u], b[9 - u]); i++) {
ra.push_back(u);
rb.push_back(9 - u);
}
int temp = min(a[u], b[9 - u]);
a[u] -= temp;
b[9 - u] -= temp;
}
}
int temp = min(a[0], b[0]);
a[0] -= temp;
b[0] -= temp;
for (int u = 0; u < 10; u++)
for (int i = 0; i < a[u]; i++) ra.push_back(u);
for (int u = 0; u < 10; u++)
for (int i = 0; i < b[u]; i++) rb.push_back(u);
for (int i = ra.size(); i > 0; i--) printf("%d", ra[i - 1]);
for (int i = 0; i < temp; i++) printf("0");
printf("\n");
for (int i = rb.size(); i > 0; i--) printf("%d", rb[i - 1]);
for (int i = 0; i < temp; i++) printf("0");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[1000010], b[1000010];
int c[1000010];
int main() {
cin >> a;
cin >> b;
int n = strlen(a);
int m = strlen(b);
int ch = 0;
for (int i = 0; i < m; i++) {
if (a[i] != b[i]) ch++;
}
for (int i = 1; i < n; i++)
if (a[i] != a[i - 1]) c[i] = 1;
int ans = 0;
if (a[0] != b[0]) c[0] = 1;
if (ch % 2 == 0) ans += 1;
int kh = 0;
for (int i = 0; i < m; i++) kh += c[i];
for (int i = 1; i <= n - m; i++) {
kh -= c[i - 1];
kh += c[i + m - 1];
ch += kh;
if (ch % 2 == 0) ans++;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long N = 206;
unsigned long long n, m, k, c[N], s, INF = 1e18 + 1;
unsigned long long dp[N][N];
int p[N];
pair<unsigned long long, unsigned long long> q[N];
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
for (int i = 0; i < N; i++) c[i] = 1e18;
cin >> n >> m >> k;
s = m + n - 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
unsigned long long x;
cin >> x;
c[i + j] = min(c[i + j], x);
}
for (int i = 0; i < s; i++) q[i].first = c[i], q[i].second = i;
sort(q, q + s);
for (int i = 0; i < s; i++) {
p[q[i].second] = 1;
if (p[0] != 2)
dp[0][1] = 1;
else
dp[0][1] = 0;
for (int j = 1; j < s; j++) {
for (int u = 0; u <= j + 1 and u <= s - 1 - j; u++) {
dp[j][u] = 0;
if (p[j] == 1) {
if (u) dp[j][u] = dp[j - 1][u - 1];
} else if (p[j] == 2) {
if (u + 1 <= j and u + 1 <= s - j) dp[j][u] = dp[j - 1][u + 1];
} else {
if (u) dp[j][u] = dp[j - 1][u - 1];
if (u + 1 <= j and u + 1 <= s - j) dp[j][u] += dp[j - 1][u + 1];
}
dp[j][u] = min(dp[j][u], INF);
}
}
if (dp[s - 1][0] < k or dp[s - 1][0] == 0) {
p[q[i].second] = 2;
k -= dp[s - 1][0];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (p[i + j] == 1)
cout << "(";
else
cout << ")";
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int arr[MAXN];
double ans;
int main() {
int n, k, m;
scanf("%d%d%d", &n, &k, &m);
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
sum += arr[i];
}
sort(arr + 1, arr + 1 + n);
for (int i = 0; i < n && i <= m; i++) {
sum -= arr[i];
ans = max(ans, (sum + min(1LL * m - i, 1LL * k * (n - i))) * 1.0 / (n - i));
}
printf("%.20lf", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
char str[105];
int bin[405];
scanf("%s", str);
int n = 0;
int i;
for (i = 0; i < strlen(str); i++) {
switch (str[i]) {
case '>':
bin[n++] = 1;
bin[n++] = 0;
bin[n++] = 0;
bin[n++] = 0;
break;
case '<':
bin[n++] = 1;
bin[n++] = 0;
bin[n++] = 0;
bin[n++] = 1;
break;
case '+':
bin[n++] = 1;
bin[n++] = 0;
bin[n++] = 1;
bin[n++] = 0;
break;
case '-':
bin[n++] = 1;
bin[n++] = 0;
bin[n++] = 1;
bin[n++] = 1;
break;
case '.':
bin[n++] = 1;
bin[n++] = 1;
bin[n++] = 0;
bin[n++] = 0;
break;
case ',':
bin[n++] = 1;
bin[n++] = 1;
bin[n++] = 0;
bin[n++] = 1;
break;
case '[':
bin[n++] = 1;
bin[n++] = 1;
bin[n++] = 1;
bin[n++] = 0;
break;
case ']':
bin[n++] = 1;
bin[n++] = 1;
bin[n++] = 1;
bin[n++] = 1;
break;
}
}
long long two = 1;
int sum = 0;
for (i = n - 1; i >= 0; i--) {
two %= 1000003;
sum += bin[i] * two;
two *= 2;
sum %= 1000003;
}
printf("%d", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
struct node {
node *next[4], *suf;
int dist[4];
int vis;
int len;
node(int _len = 0, node *_suf = NULL, node **_next = NULL)
: suf(_suf), len(_len) {
vis = 0;
if (!_next)
for (int i = 0; i < (4); ++i) next[i] = NULL;
else
for (int i = 0; i < (4); ++i) next[i] = _next[i];
}
};
node *root, *last;
long long n;
void add(int c) {
node *p = last, *np = new node(last->len + 1);
for (; p && !p->next[c]; p = p->suf) p->next[c] = np;
if (!p)
np->suf = root;
else {
node *q = p->next[c];
if (p->len + 1 == q->len)
np->suf = q;
else {
node *nq = new node(p->len + 1, q->suf, q->next);
q->suf = np->suf = nq;
for (; p && p->next[c] == q; p = p->suf) p->next[c] = nq;
}
}
last = np;
}
void calc(node *u) {
if (u->vis) return;
u->vis = 1;
for (int i = (0); i < (4); ++i)
if (u->next[i]) calc(u->next[i]);
for (int i = (0); i < (4); ++i) u->dist[i] = u->next[i] ? 1000000 : 1;
for (int i = (0); i < (4); ++i)
if (u->next[i])
for (int j = (0); j < (4); ++j)
u->dist[j] = min(u->dist[j], u->next[i]->dist[j] + 1);
}
long long M[83][4][4];
void mult(int a, int b, int c) {
for (int i = (0); i < (4); ++i)
for (int j = (0); j < (4); ++j) M[c][i][j] = n + 3;
for (int i = (0); i < (4); ++i)
for (int j = (0); j < (4); ++j)
for (int k = (0); k < (4); ++k)
M[c][i][k] = min(M[c][i][k], M[a][i][j] + M[b][j][k]);
}
void mov(int a, int b) {
for (int i = (0); i < (4); ++i)
for (int j = (0); j < (4); ++j) M[b][i][j] = M[a][i][j];
}
bool sm(int a) {
for (int i = (0); i < (4); ++i)
for (int j = (0); j < (4); ++j)
if (M[a][i][j] < n) return 1;
return 0;
}
int main() {
root = last = new node();
cin >> n;
string T;
cin >> T;
for (int i = (0); i < ((int)T.size()); ++i) add(T[i] - 'A');
calc(root);
for (int i = (0); i < (4); ++i) {
for (int j = (0); j < (4); ++j) {
M[0][i][j] = root->next[i]->dist[j];
}
}
for (int p = (1); p < (62); ++p) mult(p - 1, p - 1, p);
for (int i = (0); i < (4); ++i)
for (int j = (0); j < (4); ++j) M[80][i][j] = 0;
long long r = 1;
for (int i = (61); i > (-1); --i) {
mult(80, i, 81);
if (sm(81)) {
r += (1LL << i);
mov(81, 80);
}
}
cout << r << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int x, n, flag = 1;
cin >> n;
vector<int> a;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
for (int i = 1; i < n; i++) {
if ((a[i] - a[i - 1]) % 2 != 0) {
flag = 0;
break;
}
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
a.clear();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct seg {
seg(int a, int x, int y) : A(a), X(x), Y(y) {}
int A;
int X;
int Y;
};
bool operator<(const seg &M, const seg &N) { return M.A < N.A; }
set<seg> segs;
int main() {
int N, Q;
scanf("%d %d\n", &N, &Q);
segs.insert(seg(0, 0, 0));
for (int i = 0; i < Q; ++i) {
int x, y;
char c;
scanf("%d %d %c\n", &x, &y, &c);
set<seg>::iterator it = segs.upper_bound(seg(x, 0, 0));
--it;
if (x == it->A) {
printf("0\n");
continue;
}
int fa = it->A;
int fy = it->Y;
int fx = it->X;
if (c == 'U') {
printf("%d\n", y - it->Y);
segs.insert(seg(x, x, fy));
} else {
printf("%d\n", x - it->X);
segs.erase(it);
segs.insert(seg(fa, fx, y));
segs.insert(seg(x, fx, fy));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, lc, rc;
int dep_a, dep_a_2b, dep_2b_c, dep_2b, dep_a_2b_c, cover;
};
const int N = 200000;
const int root = 0;
struct Segment_Tree {
int num;
node tr[2 * N];
void setRange(int l, int r, int now = root) {
num = 0;
build(l, r, now);
}
void build(int l, int r, int now) {
tr[now].l = l;
tr[now].r = r;
tr[now].dep_2b_c = tr[now].dep_a = tr[now].dep_2b = tr[now].dep_a_2b =
tr[now].dep_a_2b_c = 0;
tr[now].cover = 0;
if (l < r) {
int mid = (l + r) >> 1;
++num;
tr[now].lc = num;
++num;
tr[now].rc = num;
build(l, mid, tr[now].lc);
build(mid + 1, r, tr[now].rc);
}
}
void pushup(node &f, node &lc, node &rc) {
f.dep_a = max(lc.dep_a, rc.dep_a);
f.dep_2b = max(lc.dep_2b, rc.dep_2b);
f.dep_a_2b = max(max(lc.dep_a_2b, rc.dep_a_2b), lc.dep_a + rc.dep_2b);
f.dep_2b_c = max(max(lc.dep_2b_c, rc.dep_2b_c), lc.dep_2b + rc.dep_a);
f.dep_a_2b_c = max(max(lc.dep_a_2b_c, rc.dep_a_2b_c),
max(lc.dep_a + rc.dep_2b_c, lc.dep_a_2b + rc.dep_a));
}
void lazyupdate(int now, int val) {
tr[now].cover += val;
tr[now].dep_a += val;
tr[now].dep_a_2b -= val;
tr[now].dep_2b_c -= val;
tr[now].dep_2b -= 2 * val;
}
void pushdown(int now) {
lazyupdate(tr[now].lc, tr[now].cover);
lazyupdate(tr[now].rc, tr[now].cover);
tr[now].cover = 0;
}
void update(int l, int r, int val, int now = root) {
if (tr[now].l == l && tr[now].r == r) {
lazyupdate(now, val);
return;
} else {
if (tr[now].cover != 0) pushdown(now);
int mid = (tr[now].l + tr[now].r) >> 1;
if (r <= mid)
update(l, r, val, tr[now].lc);
else if (l > mid)
update(l, r, val, tr[now].rc);
else {
update(l, mid, val, tr[now].lc);
update(mid + 1, r, val, tr[now].rc);
}
pushup(tr[now], tr[tr[now].lc], tr[tr[now].rc]);
}
}
node query(int l, int r, int now = root) {
if (tr[now].l == l && tr[now].r == r)
return tr[now];
else {
if (tr[now].cover != 0) pushdown(now);
int mid = (tr[now].l + tr[now].r) >> 1;
if (r <= mid)
return query(l, r, tr[now].lc);
else if (l > mid)
return query(l, r, tr[now].rc);
else {
node f, lc, rc;
lc = query(l, mid, tr[now].lc);
rc = query(mid + 1, r, tr[now].rc);
pushup(f, lc, rc);
return f;
}
}
}
};
Segment_Tree tr;
bool p[200000];
int main() {
int n, q;
char ch[200000];
scanf("%d%d%s", &n, &q, ch);
n = (n - 1) * 2;
tr.setRange(1, n);
for (int i = 0; i < n; ++i) {
if (ch[i] == '(') {
p[i + 1] = true;
tr.update(i + 1, n, 1);
} else {
p[i + 1] = false;
tr.update(i + 1, n, -1);
}
}
printf("%d\n", tr.query(1, n).dep_a_2b_c);
while (q--) {
int s, t;
scanf("%d%d", &s, &t);
if (s > t) swap(s, t);
if (p[s] != p[t]) {
p[s] = !p[s];
p[t] = !p[t];
if (p[s]) {
tr.update(s, t - 1, 2);
} else {
tr.update(s, t - 1, -2);
}
}
printf("%d\n", tr.query(1, n).dep_a_2b_c);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int k;
string s, sbad;
map<char, int> bad;
struct trie {
int terminal = 0;
map<char, int> mp;
int baddies = 0;
};
vector<trie> v(1);
void addTrie(int a, int b) {
int it = 0;
for (int i = a; i <= b; i++) {
if (v[it].mp.count(s[i]) == 0) {
v[it].mp[s[i]] = v.size();
v.emplace_back();
if (bad[s[i]])
v.back().baddies = v[it].baddies + 1;
else
v.back().baddies = v[it].baddies;
}
it = v[it].mp[s[i]];
}
}
int main() {
cin >> s >> sbad >> k;
for (int i = 0; i < 26; i++)
if (sbad[i] == '0')
bad['a' + i] = 1;
else
bad['a' + i] = 0;
for (int i = 0; i < s.size(); i++) {
addTrie(i, s.size() - 1);
}
int sum = 0;
for (auto x : v)
if (x.baddies <= k) sum++;
cout << sum - 1 << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, n;
int main() {
cin >> t;
while (t--) {
cin >> a >> b >> n;
switch (n % 3) {
case 0:
cout << a;
break;
case 1:
cout << b;
break;
default:
cout << (a ^ b);
break;
}
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct BIT {
vector<long long> bit;
BIT() {
bit.resize(1024);
fill(bit.begin(), bit.end(), 0LL);
}
void add(int pos, long long val) {
if (pos == 0) return;
for (; pos < 1024; pos += (pos & (-pos))) bit[pos] ^= val;
}
long long _get(int to) {
long long ret = 0;
for (; to > 0; to -= (to & (-to))) ret ^= bit[to];
return ret;
}
long long get(int lo, int hi) {
if (lo > hi) return 0;
return _get(hi) ^ _get(lo - 1);
}
};
struct data1 {
BIT end_pos;
BIT sum_nech;
void _add(int hi, long long how) {
end_pos.add(hi, how);
if (hi & 1) sum_nech.add(hi, how);
}
void add(int lo, int hi, long long how) {
_add(hi, how);
_add(lo - 1, how);
}
long long _get(int hi) {
if (hi == 0) return 0;
long long ret = 0;
if (hi & 1) ret ^= end_pos.get(hi + 1, 1024 - 1);
ret ^= sum_nech.get(1, hi);
return ret;
}
long long get(int lo, int hi) { return _get(hi) ^ _get(lo - 1); }
};
int GLO, GHI;
long long HOW;
struct BIT2 {
vector<data1> bit;
BIT2() { bit.resize(1024); }
void add(int pos) {
if (pos == 0) return;
for (; pos < 1024; pos += (pos & (-pos))) bit[pos].add(GLO, GHI, HOW);
}
long long _get(int to) {
long long ret = 0;
for (; to > 0; to -= (to & (-to))) ret ^= bit[to].get(GLO, GHI);
return ret;
}
long long get(int lo, int hi) {
if (lo > hi) return 0;
return _get(hi) ^ _get(lo - 1);
}
};
struct data2 {
BIT2 end_pos;
BIT2 sum_nech;
void _add(int hi) {
end_pos.add(hi);
if (hi & 1) sum_nech.add(hi);
}
void add(int lo, int hi, int glo, int ghi, long long ghow) {
GLO = glo, GHI = ghi, HOW = ghow;
_add(hi);
_add(lo - 1);
}
long long _get(int hi) {
if (hi == 0) return 0;
long long ret = 0;
if (hi & 1) ret ^= end_pos.get(hi + 1, 1024 - 1);
ret ^= sum_nech.get(1, hi);
return ret;
}
long long get(int lo, int hi, int glo, int ghi) {
GLO = glo, GHI = ghi;
return _get(hi) ^ _get(lo - 1);
}
};
data2 U;
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) {
int op;
scanf("%d", &op);
int x1, y1, x2, y2;
long long val;
if (op == 2) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
scanf("%Ld", &val);
U.add(x1, x2, y1, y2, val);
} else {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf(
"%Ld"
"\n",
U.get(x1, x2, y1, y2));
}
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define debug(x) cerr<<#x<<" = "<<x
#define sp <<" "
#define el <<endl
#define fgx cerr<<" ------------------------------------------------------------------------- "<<endl
#define uint unsigned int
#define ULL unsigned long long
#define LDB long double
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
inline LL read(){
LL nm=0; bool fh=true; char cw=getchar();
for(;!isdigit(cw);cw=getchar()) fh^=(cw=='-');
for(;isdigit(cw);cw=getchar()) nm=nm*10+(cw-'0');
return fh?nm:-nm;
}
#define mod 1000000007
namespace CALC{
inline int add(int x,int y){return (x+y>=mod)?(x+y-mod):(x+y);}
inline int mns(int x,int y){return (x-y<0)?(x-y+mod):(x-y);}
inline int mul(LL x,LL y){return x*y%mod;}
inline void upd(int &x,int y){x=(x+y>=mod)?(x+y-mod):(x+y);}
inline void dec(int &x,int y){x=(x-y<0)?(x-y+mod):(x-y);}
inline int qpow(int x,int sq){LL res=1;for(;sq;sq>>=1,x=mul(x,x))if(sq&1)res=mul(res,x);return res;}
}using namespace CALC;
#define M 402000
int n,m,c[M],num[M],d[M];
int tg[M],tim,otd[M];
vector<int>hv[M],to[M],ot[M];
inline bool cmp(int x,int y){return d[x]==d[y]?(x<y):(d[x]<d[y]);}
inline void yes(int a,int b){
if(a<=n){printf("%d %d\n",a,b);return;}
a=num[a-n],b=num[b-n];
int las=0;
for(int i=1;i<=n;i++){
bool hva=false,hvb=false;
for(int j=0;j<c[i]&&!(hva&&hvb);j++)
hva|=(hv[i][j]==a),hvb|=(hv[i][j]==b);
if(!hva) continue;
if(!hvb) continue;
if(!las){las=i;continue;}
printf("%d %d\n",las,i);
return ;
}
}
inline void solve(){
n=read(),m=0;
for(int i=1;i<=n;i++){
c[i]=read(),hv[i].clear();
for(int j=1,x;j<=c[i];j++) x=read(),hv[i].pb(x),num[++m]=x;
} sort(num+1,num+m+1),m=unique(num+1,num+m+1)-num-1;
for(int i=1;i<=n+m;i++) d[i]=0,to[i].clear(),ot[i].clear();
for(int i=1;i<=n;i++) for(int j=0;j<c[i];j++){
int x=i,y=lower_bound(num+1,num+m+1,hv[i][j])-num+n;
d[x]++,d[y]++;
}
for(int i=1;i<=n;i++) for(int j=0;j<c[i];j++){
int x=i,y=lower_bound(num+1,num+m+1,hv[i][j])-num+n;
cmp(x,y)?to[x].pb(y):to[y].pb(x);
}
for(int i=1;i<=n+m;i++) otd[i]=to[i].size();
for(int x=1;x<=n+m;x++){
for(int i=0;i<otd[x];i++) for(int j=0;j<otd[x];j++){
int y=to[x][i],z=to[x][j];
if(cmp(y,z)) ot[y].pb(z);
}
}
for(int x=1;x<=n+m;x++){
++tim;
for(int i=0;i<otd[x];i++) for(int y=to[x][i],j=0;j<otd[y];j++){
int z=to[y][j];
if(tg[z]==tim) return yes(x,z);
tg[z]=tim;
}
sort(ot[x].begin(),ot[x].end());
for(int i=0,TP=ot[x].size();i+1<TP;i++) if(ot[x][i]==ot[x][i+1])
return yes(x,ot[x][i]);
for(int i=0,TP=ot[x].size();i<TP;i++)
if(tg[ot[x][i]]==tim) return yes(x,ot[x][i]);
}
puts("-1");
return ;
}
int main(){
for(int Cas=read();Cas;--Cas) solve();
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e4;
const long long INF = 1e18;
const int mod = 1e9 + 7;
const double eps = 1e-6;
int num[MAX + 5], a[MAX + 5];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", num + i);
bool succ = true;
a[1] = num[1];
for (int i = 2; i <= n; i++) {
a[i] = min(a[i - 1], num[i] - (num[i - 1] - a[i - 1]));
if (a[i] < 0) succ = false;
}
if (succ)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define ll int64_t
#define VL vector<int64_t>
#define VI vector<int>
#define PII pair<int, int>
#define PLL pair<int64_t, int64_t>
ll nxt();
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v);
struct Node {
Node (int i_, ll a_, ll c_, int pi_) : i(i_), a(a_), c(c_), pi(pi_) {}
const int i;
ll a;
const ll c;
const int pi;
vector<Node*> bin_lift;
};
PLL getHere(Node* node, ll w) {
if (node->a > w) {
node->a -= w;
return {w, w*node->c};
} else {
PLL res = {node->a, node->a * node->c};
node->a = 0;
return res;
}
}
PLL getGold(Node* node, ll w) {
if (w == 0) return {0, 0};
if (node->a == 0) return {0, 0};
ll total_got = 0, total_paid = 0;
ll rest = w;
while (!node->bin_lift.empty()) {
auto [got, paid] = getGold(node->bin_lift.back(), rest);
total_got += got;
total_paid += paid;
rest = w - total_got;
assert(total_got <= w);
if (total_got == w) {
return { total_got, total_paid };
} else {
node->bin_lift.pop_back();
}
}
auto [got, paid] = getHere(node, rest);
total_got += got;
total_paid += paid;
return {total_got, total_paid};
}
void updateBinLifting(Node* node, Node* cur_up, size_t k) {
if (k == 0) {
node->bin_lift.push_back(cur_up);
updateBinLifting(node, cur_up, k + 1);
} else if (cur_up->bin_lift.size() > k - 1) {
Node* new_up = cur_up->bin_lift[k - 1];
node->bin_lift.push_back(new_up);
updateBinLifting(node, new_up, k + 1);
}
return;
}
void solve() {
int qq = nxt();
ll a = nxt(), c = nxt();
unordered_map<int, Node*> nodes;
Node* root = new Node(0, a, c, -1);
nodes[0] = root;
for (int q = 1; q < qq + 1; ++q) {
int type = nxt();
if (type == 1) {
ll p = nxt(), a = nxt(), c = nxt();
Node* curr = new Node(q, a, c, p);
Node* parent = nodes[p];
updateBinLifting(curr, parent, 0);
nodes[q] = curr;
} else if (type == 2) {
ll v = nxt(), w = nxt();
auto [got, paid] = getGold(nodes[v], w);
cout << got << ' ' << paid << endl;
}
}
for (auto& [k, v] : nodes) {
delete v;
}
}
int main() {
std::ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
solve();
return 0;
}
//auto p_start = std::chrono::steady_clock::now();
//auto p_finish = std::chrono::steady_clock::now();
//cout << "process() took "
//<< std::chrono::duration<double>(p_finish - p_start).count()
//<< " seconds\n";
ll nxt() {
ll n;
cin >> n;
return n;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (const auto& i : v) {
os << i << ' ';
}
os << '\n';
return os;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n >= 4) {
cout << "YES" << endl;
if (n == 4) {
cout << "1 * 2 = 2" << endl;
cout << "2 * 3 = 6" << endl;
cout << "6 * 4 = 24" << endl;
} else if (n == 5) {
cout << "5 * 4 = 20" << endl;
cout << "3 + 20 = 23" << endl;
cout << "2 - 1 = 1" << endl;
cout << "23 + 1 = 24" << endl;
} else if (n % 2 == 0) {
for (int i = 6; i <= n; i += 2) {
cout << i << " - " << i - 1 << " = 1" << endl;
cout << "1 * 1 = 1" << endl;
}
cout << "1 * 2 = 2" << endl;
cout << "2 * 3 = 6" << endl;
cout << "6 * 4 = 24" << endl;
} else {
for (int i = 7; i <= n; i += 2) {
cout << i << " - " << i - 1 << " = 1" << endl;
cout << "1 * 1 = 1" << endl;
}
cout << "5 * 4 = 20" << endl;
cout << "3 + 20 = 23" << endl;
cout << "2 - 1 = 1" << endl;
cout << "23 + 1 = 24" << endl;
}
} else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int64_t t[2002], c[2002], dp[2002][2 * 2002];
void knapsack(int64_t n) {
int64_t i, j;
for (i = 0; i <= n; i++)
for (j = 0; j <= 2 * n; j++) {
if (j == 0)
dp[i][j] = 0;
else if (i == 0)
dp[i][j] = 100000000000000;
else if (j >= t[i] + 1)
dp[i][j] = min(dp[i - 1][j - t[i] - 1] + c[i], dp[i - 1][j]);
else
dp[i][j] = dp[i - 1][j];
}
}
signed main() {
int64_t n, i;
cin >> n;
for (i = 1; i <= n; i++) cin >> t[i] >> c[i];
knapsack(n);
int64_t ma = 1000000000000000;
for (i = n; i <= 2 * n; i++)
if (dp[n][i] <= ma) ma = dp[n][i];
cout << ma << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[100005];
long long int par[100005], level[100005];
void dfs(long long int num, long long int p, long long int l) {
par[num] = p;
level[num] = l;
for (auto x : adj[num]) {
if (x == par[num]) continue;
dfs(x, num, l + 1);
}
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, a, b, da, db, i, j;
cin >> n >> a >> b >> da >> db;
for (i = 0; i <= n; i++) {
adj[i].clear();
par[i] = 0;
level[i] = -1;
}
for (i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0, 0);
long long int maxi = -1, ind = a;
for (i = 1; i <= n; i++) {
if (level[i] > maxi) {
maxi = level[i];
ind = i;
}
}
for (i = 1; i <= n; i++) level[i] = -1;
dfs(ind, 0, 0);
maxi = -1;
for (i = 1; i <= n; i++) maxi = max(maxi, level[i]);
if (2 * da >= min(db, maxi)) {
cout << "Alice\n";
continue;
}
for (i = 1; i <= n; i++) level[i] = -1;
dfs(a, 0, 0);
if (level[b] <= da)
cout << "Alice\n";
else
cout << "Bob\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long res = 1;
vector<int> a;
a.resize(10);
for (int k = 0; k < s.size(); ++k) {
if (s[k] == '?') {
res *= 10;
}
if (s[k] == 'A') {
a[0] = 1;
}
if (s[k] == 'B') {
a[1] = 1;
}
if (s[k] == 'C') {
a[2] = 1;
}
if (s[k] == 'D') {
a[3] = 1;
}
if (s[k] == 'E') {
a[4] = 1;
}
if (s[k] == 'F') {
a[5] = 1;
}
if (s[k] == 'G') {
a[6] = 1;
}
if (s[k] == 'I') {
a[7] = 1;
}
if (s[k] == 'J') {
a[8] = 1;
}
if (s[k] == 'H') {
a[9] = 1;
}
}
if (s[0] == '?') {
res /= 10;
res *= 9;
}
int sum = 0;
for (int i = 0; i < a.size(); ++i) {
if (a[i]) sum++;
}
if (s[0] >= 'A' && s[0] <= 'J') {
res *= 9;
sum--;
while (sum > 0) {
res *= (10 - sum);
sum--;
}
} else {
while (sum > 0) {
res *= (10 - sum + 1);
sum--;
}
}
cout << res;
cin >> s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
long long K, B, N, MOD;
long long A[MAX], psum[MAX];
map<int, int> ma;
long long C2(long long a) { return a * (a - 1) / 2; }
long long zero() {
A[N] = 10000000;
int last = -1;
long long res = 0;
for (int i = 0; i <= N; i++) {
if (A[i] != 0) {
res += C2(i - last);
last = i;
}
}
return res;
}
int main() {
cin >> K >> B >> N;
MOD = K - 1;
psum[0] = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
psum[i + 1] = A[i] + psum[i];
}
long long z = zero();
if (B == 0) {
cout << z << endl;
return 0;
}
long long res = 0;
ma.clear();
ma[0] = 1;
for (int i = 1; i <= N; i++) {
int c = psum[i] % MOD;
int n = (c - B + MOD) % MOD;
res += ma[n];
ma[c]++;
}
if (B == MOD) {
res -= z;
}
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
int presum[n + 1];
cin >> a[0];
presum[0] = a[0];
for (int i = 1; i < n; i++) {
cin >> a[i];
presum[i] = presum[i - 1] + a[i];
}
cout << 0 << " ";
for (int i = 1; i < n; i++) {
priority_queue<int> pq;
for (int j = 0; j < i; j++) {
pq.push(a[j]);
}
int sum = presum[i - 1];
if (m - presum[i - 1] >= a[i]) {
cout << 0 << " ";
} else {
int cnt = 0;
while (m - sum < a[i]) {
sum = sum - pq.top();
pq.pop();
cnt++;
}
cout << cnt << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 10;
int lpos[N], rpos[N], ar[N], cnt[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
while (cin >> n >> k) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i += 1) {
cin >> ar[i];
lpos[ar[i]] = min(lpos[ar[i]], i);
rpos[ar[i]] = i;
}
int st = 0, res = 0;
while (st < n) {
int ed = rpos[ar[st]], mx = 0;
for (int i = st; i <= ed; i += 1) {
cnt[ar[i]] += 1;
ed = max(ed, rpos[ar[i]]);
if (cnt[ar[i]] > mx) mx = cnt[ar[i]];
}
res += (ed - st + 1 - mx);
st = ed + 1;
}
cout << res << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vector_in(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
return v;
}
void vector_out(vector<int> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
int vector_sum(vector<int> v) {
int sum;
for (int i = 0; i < v.size(); i++) sum += v[i];
return sum;
}
int main() {
int n;
vector<int> T(1001, 1);
vector<char> rla;
cin >> n;
for (int i = 0; i < n - 1; i++) {
char c;
cin >> c;
rla.push_back(c);
}
for (int i = 0; i < n - 1; i++) {
if (rla[i] == 'R') {
T[i + 1] = max(T[i + 1], T[i] + 1);
} else if (rla[i] == '=') {
T[i + 1] = T[i];
}
}
for (int i = n - 2; i >= 0; i--) {
if (rla[i] == 'L') {
T[i] = max(T[i], T[i + 1] + 1);
} else if (rla[i] == '=') {
T[i] = T[i + 1];
}
}
for (int i = 0; i < n; i++) {
cout << T[i] << " \n"[i == n - 1];
}
cout << flush;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const long long int MAXINT = 4611686018427387903;
vector<long long int> edges[MAXN];
vector<pair<long long int, long long int>> links[MAXN];
set<pair<long long int, long long int>> s;
long long int dist[MAXN][MAXN];
long long int answer[MAXN];
long long int result[MAXN];
pair<long long int, long long int> taxi[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, m, start, end, a, b, c, u;
cin >> n >> m;
cin >> start >> end;
start--;
end--;
for (int i = 0; i < MAXN; i++) fill(dist[i], dist[i] + MAXN, MAXINT);
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
dist[a][b] = min(dist[a][b], c);
dist[b][a] = min(dist[b][a], c);
}
for (int i = 0; i < n; i++) {
cin >> a >> b;
taxi[i].first = a;
taxi[i].second = b;
}
for (int k = 0; k < n; k++) {
s.clear();
for (int i = 0; i < n; i++) {
answer[i] = MAXINT;
if (i == k) answer[k] = 0;
s.insert(make_pair(answer[i], i));
}
while (!s.empty()) {
u = s.begin()->second;
s.erase(s.begin());
for (long long int i : edges[u]) {
if (answer[u] + dist[u][i] < answer[i]) {
s.erase(make_pair(answer[i], i));
answer[i] = answer[u] + dist[u][i];
s.insert(make_pair(answer[i], i));
}
}
}
for (int i = 0; i < n; i++) {
if (answer[i] <= taxi[k].first)
links[k].push_back(make_pair(i, taxi[k].second));
}
}
s.clear();
for (int i = 0; i < n; i++) {
result[i] = MAXINT;
if (i == start) result[start] = 0;
s.insert(make_pair(result[i], i));
}
while (!s.empty()) {
u = s.begin()->second;
s.erase(s.begin());
for (pair<long long int, long long int> i : links[u]) {
a = i.first;
b = i.second;
if (result[u] + b < result[a]) {
s.erase(make_pair(result[a], a));
result[a] = result[u] + b;
s.insert(make_pair(result[a], a));
}
}
}
cout << (result[end] == MAXINT ? -1 : result[end]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[400000], i, j = -1, k, m = 0, y = 0, l = -1, r = -1;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
i = 0;
while (j != n - 1) {
m += (1 - a[j + 1]);
j++;
while (m > k) {
m -= (1 - a[i]);
i++;
}
if (m <= k && y < j - i + 1) {
l = i;
r = j;
y = r - l + 1;
}
}
for (i = l; i <= r; i++) a[i] = 1;
cout << y << "\n";
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long int n, k, i;
scanf("%lld %lld", &n, &k);
long long int arr[n], s = 0, d, j, t, s1 = 0;
for (i = 0; i < k; i++) {
scanf("%lld", &arr[0]);
for (j = 1; j <= arr[0]; j++) {
scanf("%lld", &arr[j]);
}
if (arr[1] != 1) {
s += 2 * arr[0] - 1;
} else {
for (j = 1; j <= arr[0]; j++) {
if (arr[j] != j) {
s += 2 * (arr[0] - j + 1);
break;
}
}
}
}
printf("%lld\n", s);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m;
long long n, a, d, one, A, last, ans;
int main() {
scanf("%lld%d%lld%lld", &n, &m, &a, &d);
one = d / a + 1;
A = n * a;
for (int i = 1; i <= m; i++) {
long long T;
scanf("%lld", &T);
if (T <= last) continue;
long long A1 = last / a * a + a;
if (T <= A1 || A < A1)
last = T + d, ans++;
else {
long long jump = (min(A, T) - A1) / (a * one);
ans += jump;
A1 += jump * one * a;
if (A1 + d < T)
last = T + d, ans += 2;
else
last = A1 + d, ans++;
}
}
long long A1 = last / a * a + a;
if (A1 <= A) ans += ((A - A1) / a + one) / one;
printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[8][50];
int ed[8];
int h[66];
char ans[100][100];
char te[100][100];
int sx, sy, tx, ty;
bool cmp() {
for (int i = 0; i < max(sx, tx); i++)
for (int j = 0; j < max(sy, ty); j++)
if (ans[i][j] != te[i][j]) return ans[i][j] > te[i][j];
return 0;
}
void ok() {
if (sx == -1 || cmp()) {
sx = tx;
sy = ty;
for (int i = 0; i < sx; i++)
for (int j = 0; j < sy; j++) ans[i][j] = te[i][j];
}
}
void pri() {
for (int i = 0; i < tx; i++, putchar(10))
for (int j = 0; j < ty; j++) putchar(te[i][j]);
}
int main() {
for (int i = 0; i < 6; i++) gets(s[i]), ed[i] = strlen(s[i]);
for (int i = 0; i < 6; i++) h[i] = i;
sx = -1;
do {
int a = ed[h[0]], b = ed[h[1]], c = ed[h[5]], d = ed[h[4]];
if (ed[h[3]] == a + c - 1 && ed[h[2]] == b + d - 1) {
bool f = 1;
ty = a + c - 1;
tx = b + d - 1;
for (int i = 0; i < tx; i++)
for (int j = 0; j < ty; j++) te[i][j] = '.';
for (int i = 0; i < tx; i++) te[i][ty] = 0;
for (int i = 0; i <= ty; i++) te[tx][i] = 0;
for (int i = 0; i < ed[h[0]]; i++)
if (te[0][i] == '.' || te[0][i] == s[h[0]][i])
te[0][i] = s[h[0]][i];
else
f = 0;
for (int i = 0; i < ed[h[1]]; i++)
if (te[i][0] == '.' || te[i][0] == s[h[1]][i])
te[i][0] = s[h[1]][i];
else
f = 0;
for (int i = 0; i < ed[h[2]]; i++)
if (te[i][a - 1] == '.' || te[i][a - 1] == s[h[2]][i])
te[i][a - 1] = s[h[2]][i];
else
f = 0;
for (int i = 0; i < ed[h[3]]; i++)
if (te[b - 1][i] == '.' || te[b - 1][i] == s[h[3]][i])
te[b - 1][i] = s[h[3]][i];
else
f = 0;
for (int i = 0; i < ed[h[4]]; i++)
if (te[i + b - 1][a + c - 2] == '.' ||
te[i + b - 1][a + c - 2] == s[h[4]][i])
te[i + b - 1][a + c - 2] = s[h[4]][i];
else
f = 0;
for (int i = 0; i < ed[h[5]]; i++)
if (te[b + d - 2][i + a - 1] == '.' ||
te[b + d - 2][i + a - 1] == s[h[5]][i])
te[b + d - 2][i + a - 1] = s[h[5]][i];
else
f = 0;
if (f) ok();
}
} while (next_permutation(h, h + 6));
if (sx == -1)
puts("Impossible");
else {
for (int i = 0; i < sx; i++, putchar(10))
for (int j = 0; j < sy; j++) putchar(ans[i][j]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int dp[100005][12];
long long ans;
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = len - 1; i >= 0; i--) {
int t = s[i] - '0';
for (int k = 0; k < 11; k++) {
dp[i][k] = 1;
if (i < len - 1) {
if (k > s[i + 1] - '0')
dp[i][k] += dp[i + 1][(k * (k - 1) / 2 + s[i + 1] - '0' + 10) % 11];
}
}
if (t) ans = ans + dp[i][t];
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
long long arr[100009];
long long brr[100009];
int arr2[100][100];
int M(int n) {
if (n > 100)
return (n - 10);
else
return (M(M(n + 11)));
}
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
std::ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
long long r, g, b, maxi = 0;
cin >> r >> g >> b;
long long red = (r + 1) / 2, green = (g + 1) / 2, blue = (b + 1) / 2;
if (blue >= red && blue >= green) {
cout << (blue * 3) + 29 << endl;
return 0;
} else if (green >= red && green >= blue) {
cout << (green * 3) - 1 + 29 << endl;
return 0;
} else if (red >= green && red >= blue) {
cout << (red * 3) - 2 + 29 << endl;
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, k, j, a[100001];
int main() {
cin >> n >> k;
if (k == 1)
for (i = 1; i <= n; i++) cout << i << " ";
else {
if (k % 2 == 0) {
j = n;
for (i = 0; i < k; i += 2) {
a[i] = j;
j--;
}
j = 1;
for (i = 1; i < k; i += 2) {
a[i] = j;
j++;
}
for (i = i - 1; i < n; i++) {
a[i] = j;
j++;
}
} else {
j = n;
for (i = 1; i < k; i += 2) {
a[i] = j;
j--;
}
j = 1;
for (i = 0; i < k; i += 2) {
a[i] = j;
j++;
}
for (i--; i < n; i++) {
a[i] = j;
j++;
}
}
for (i = 0; i < n; i++) cout << a[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long T, a, b, c, d, n;
cin >> T;
while (T--) {
cin >> n >> a >> b >> c >> d;
if ((((n * (a + b)) <= (c + d)) && ((n * (a - b)) >= (c - d))) ||
(((n * (a + b)) >= (c - d)) && ((n * (a - b)) <= (c + d)))) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length(), n = 0;
for (int i = 1; i < len; i++) {
if (!(s[i] == s[i - 1] && s[i] == '/')) {
++n;
cout << s[i - 1];
}
}
if (s[len - 1] != '/' || n == 0) cout << s[len - 1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(200005);
int n;
int f[2][MAXN], sumA[MAXN], sumB[MAXN];
void update(int c, int i, int v) {
for (i; i <= n; i += i & (-i)) f[c][i] += v;
}
int query(int c, int i) {
int ret = 0;
for (i; i; i -= i & (-i)) ret += f[c][i];
return ret;
}
int main() {
int k, A, B, q;
scanf("%d%d%d%d%d", &n, &k, &A, &B, &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, v;
scanf("%d%d", &d, &v);
update(0, d, min(v, A - sumA[d]));
update(1, d, min(v, B - sumB[d]));
sumA[d] = min(A, sumA[d] + v);
sumB[d] = min(B, sumB[d] + v);
} else {
int d;
scanf("%d", &d);
printf("%d\n", query(1, d - 1) + query(0, n) - query(0, d + k - 1));
}
}
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:136777216")
using namespace std;
int bits(int x) { return x == 0 ? 0 : 1 + bits(x & (x - 1)); }
map<string, int> h;
int main() {
const string VOID = "void";
const string ERROR = "errtype";
h[VOID] = 0;
h[ERROR] = -1;
int n;
cin >> n;
string s;
for (int(iter) = 0; (iter) < (n); (iter)++) {
cin >> s;
if (s == "typedef") {
string ntype;
cin >> s >> ntype;
int a = 0, b = 0;
for (int(i) = 0; (i) < ((int)(s).size()); (i)++) {
if (s[i] == '&')
a++;
else
break;
}
for (int i = (int)(s).size() - 1; i >= 0; i--) {
if (s[i] == '*')
b++;
else
break;
}
string name = s.substr(a, (int)(s).size() - a - b);
if (h.find(name) == h.end() || h[name] == -1) {
h[ntype] = -1;
} else {
int k = h[name];
k = k + b - a;
if (k < 0) {
h[ntype] = -1;
} else {
h[ntype] = k;
}
}
} else {
cin >> s;
int a = 0, b = 0;
for (int(i) = 0; (i) < ((int)(s).size()); (i)++) {
if (s[i] == '&')
a++;
else
break;
}
for (int i = (int)(s).size() - 1; i >= 0; i--) {
if (s[i] == '*')
b++;
else
break;
}
string name = s.substr(a, (int)(s).size() - a - b);
if (h.find(name) == h.end() || h[name] == -1) {
cout << ERROR << "\n";
} else {
int k = h[name];
k = k + b - a;
if (k < 0) {
cout << ERROR << "\n";
} else {
cout << VOID;
for (int(it) = 0; (it) < (k); (it)++) cout << "*";
cout << "\n";
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (k == 2) {
string a = s, b = s;
int ca = 0, cb = 0;
for (int i = 0; i < a.size(); i++) {
a[i] = (i % 2) ? 'B' : 'A';
ca += a[i] != s[i];
}
for (int i = 0; i < b.size(); i++) {
b[i] = (i % 2) ? 'A' : 'B';
cb += b[i] != s[i];
}
if (ca < cb) {
cout << ca << endl;
cout << a << endl;
} else {
cout << cb << endl;
cout << b << endl;
}
} else {
vector<char> c(1, s[0]);
vector<int> f(1, 0);
for (char a : s) {
if (a == c.back()) {
f.back()++;
} else {
c.push_back(a);
f.push_back(1);
}
}
char pre, sub;
int cost = 0, ind = 0;
string fs = s;
for (int i = 0; i < c.size(); i++) {
cost += f[i] / 2;
pre = (i ? c[i - 1] : 0);
if (f[i] == 1) {
ind++;
continue;
}
if (f[i] % 2) {
sub = 'B';
if (c[i] == 'B') sub = 'A';
for (int j = 0; j < f[i]; j++) {
if (j % 2) {
fs[ind] = sub;
}
ind++;
}
} else {
sub = 'B';
if (c[i] == 'B') sub = 'A';
set<char> s;
s.insert('A');
s.insert('B');
s.insert('C');
s.erase(pre);
s.erase(c[i]);
sub = *s.begin();
for (int j = 0; j < f[i]; j++) {
if (j % 2 == 0) {
fs[ind] = sub;
}
ind++;
}
}
}
cout << cost << endl;
cout << fs << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
int main()
{
ll k;
scanf("%lld",&k);
while(k--)
{
ll n;
scanf("%lld",&n);
ll a[101]={0};
for(int i=0;i<n;i++)
{
ll x;
cin>>x;
a[x]++;
}
sort(a,a+101);
cout<<a[100]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine",
"ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", " eighteen", "nineteen"};
string t[] = {"", "", "twenty", "thirty", "forty",
"fifty", "sixty", "seventy", "eighty", "ninety"};
int n;
cin >> n;
if (n / 10 < 2) {
cout << s[n];
} else {
cout << t[n / 10];
if (n % 10 != 0) cout << "-" << s[n % 10];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 123;
int mapa3[MAX];
int mapa[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, M;
map<int, vector<int> > mapa2;
cin >> N >> M;
vector<int> tab(N, 1e7);
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
if (a > M) continue;
tab[i] = a;
mapa[a]++;
}
pair<int, int> res = {0, 1};
for (int i = 1; i <= M; ++i) {
int k = 0;
while (i * ++k <= M) {
mapa3[i * k] += mapa[i];
}
}
for (int i = 0; i < MAX; ++i) {
if (mapa3[i] > res.first) {
res = {mapa3[i], i};
}
}
cout << res.second << " " << res.first << "\n";
vector<int> temp;
for (int i = 0; i < N; ++i) {
if (tab[i] <= M && !(res.second % tab[i])) cout << i + 1 << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int root, n, val[2010], res[2010];
int f;
vector<int> edge[2010];
queue<int> dfs(int now) {
queue<int> temp;
for (auto to : edge[now]) {
queue<int> buf = dfs(to);
while (!buf.empty()) {
temp.push(buf.front());
buf.pop();
}
}
int sz = temp.size();
if (val[now] > sz) f = 1;
if (val[now] == 0) temp.push(now);
for (int i = 1; i <= sz; i++) {
temp.push(temp.front());
temp.pop();
if (val[now] == i) temp.push(now);
}
return temp;
}
int main() {
cin >> n;
for (int i = 1, fa; i <= n; i++) {
cin >> fa >> val[i];
if (fa != 0)
edge[fa].push_back(i);
else
root = i;
}
queue<int> que = dfs(root);
int cnt = 0;
while (!que.empty()) {
res[que.front()] = ++cnt;
que.pop();
}
if (f) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << res[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long int> ggc;
vector<vector<long long int>> v;
for (int i = 0; i < n; i++) {
vector<long long int> vv(n);
for (int j = 0; j < n; j++) cin >> vv[j];
v.push_back(vv);
}
long long int save;
save = (v[0][1] * v[0][2]) / v[1][2];
save = sqrt(save);
cout << save << " ";
for (int i = 1; i < v[0].size(); i++) {
cout << v[0][i] / save << " ";
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll,ll> pll;
typedef long double ld;
#define go_corona ios_base::sync_with_stdio(false)
#define corona_go cin.tie(NULL)
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define rall(x) x.end(),x.begin()
#define INF 1e18+5
#define mod 1000000007
#define f(i,x,y) for(ll i=x;i<y;i++)
#define sz(x) ll((x).size())
#define ff first
#define ss second
#define pq priority_queue
int main()
{
go_corona;
corona_go;
int t;
cin>>t;
while(t--){
int n;
cin>>n;
vll a(n+1),m(n+1);
ll maxi = -1;
for(int i=0;i<n;i++) cin>>a[i+1];
for(int i=n;i>=1;i--)
{
m[i] = a[i];
if(i+a[i]<=n)
m[i] = m[i] + m[i+a[i]];
if(m[i]>maxi)
maxi = m[i];
}
cout<<maxi<<'\n';
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, l;
cin >> h >> l;
printf("%.9f", (pow(l, 2) - pow(h, 2)) / (2 * h));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c;
scanf("%lf%lf%lf", &a, &b, &c);
double ans1 = max((-b + sqrt(b * b - 4 * a * c)) / 2 / a,
(-b - sqrt(b * b - 4 * a * c)) / 2 / a);
double ans2 = min((-b + sqrt(b * b - 4 * a * c)) / 2 / a,
(-b - sqrt(b * b - 4 * a * c)) / 2 / a);
printf("%f\n%f", ans1, ans2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7;
const long long INF = 1e18;
const int N = 1e5 + 5;
mt19937 rng(time(0));
int n, d, m, x, n1, n2;
long long a[N], b[N];
int main() {
scanf("%d%d%d", &n, &d, &m);
for (int i = (1); i <= (n); ++i) {
scanf("%d", &x);
if (x > m)
b[++n2] = x;
else
a[++n1] = x;
}
sort(a + 1, a + n1 + 1), reverse(a + 1, a + n1 + 1);
sort(b + 1, b + n2 + 1), reverse(b + 1, b + n2 + 1);
for (int i = (1); i <= (n1); ++i) a[i] += a[i - 1];
for (int i = (1); i <= (n2); ++i) b[i] += b[i - 1];
long long ans = 0;
for (int i = (0); i <= (n2); ++i) {
int na = n - (i + (i - 1) * d);
if (na < 0) break;
ans = max(ans, b[i] + a[min(na, n1)]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10240000")
using namespace std;
const int MAXN = 550;
char str[MAXN];
int main() {
scanf("%s", &str);
int len = strlen(str);
int now = 'a' - 1;
bool flag = true;
for (int i = 0; i < len; i++) {
if (str[i] > now + 1) {
flag = false;
break;
} else if (str[i] == now + 1) {
now++;
}
}
if (flag) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1510;
struct P {
int x, y, id;
inline P(int x = 0, int y = 0) : x(x), y(y) {}
} v[N];
inline P operator-(P u, P v) { return P(u.x - v.x, u.y - v.y); }
inline bool sgncross(P u, P v) { return 1ll * u.x * v.y > 1ll * u.y * v.x; }
int n, m, x, y, tot, fi[N], ne[N << 1], a[N << 1], ans[N], si[N];
inline void add(int x, int y) {
a[++tot] = y;
ne[tot] = fi[x];
fi[x] = tot;
}
inline void get_size(int x, int fa) {
si[x] = 1;
for (int i = fi[x]; i; i = ne[i])
if (a[i] != fa) get_size(a[i], x), si[x] += si[a[i]];
}
int jz;
inline bool cmp(P x, P y) { return sgncross(x - v[jz], y - v[jz]) > 0; }
inline void solve(int x, int fa, int l, int r) {
for (int i = l + 1; i <= r; ++i)
if (v[i].y < v[l].y) swap(v[l], v[i]);
jz = l;
ans[v[l].id] = x;
sort(v + l + 1, v + r + 1, cmp);
for (int pos = l + 1, i = fi[x]; i; i = ne[i])
if (a[i] != fa) {
solve(a[i], x, pos, pos + si[a[i]] - 1);
pos += si[a[i]];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) scanf("%d%d", &x, &y), add(x, y), add(y, x);
for (int i = 1; i <= n; ++i) scanf("%d%d", &v[i].x, &v[i].y), v[i].id = i;
get_size(1, 0);
solve(1, 0, 1, n);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long n, k, d;
cin >> n >> k >> d;
unordered_map<long long, long long, custom_hash> m;
long long a[n];
for (long long i = 0, max_i = n; i < max_i; ++i) cin >> a[i];
long long ans = 0, temp = 0;
for (long long i = 0, max_i = d; i < max_i; ++i) {
auto it = m.find(a[i]);
if (it == m.end() || !it->second) {
++temp;
m[a[i]] = 1;
} else
++it->second;
}
ans = temp;
for (long long i = d, max_i = n; i < max_i; ++i) {
auto it = m.find(a[i]);
if (it == m.end() || !it->second) {
++temp;
m[a[i]] = 1;
} else
++it->second;
if (!(--m[a[i - d]])) --temp;
ans = min(temp, ans);
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
int n, q, t, a[512], p[512], d[512], v[100100] = {1};
int main(void) {
cin >> n >> q >> t;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 0, x, y; i < q && cin >> x >> y; ++i) p[x] = y, ++d[y];
int c = 0;
for (int i = 1; t >= 0 && i <= n; ++i)
if (!d[i]) {
int s = 0;
for (int j = i; t >= 0 && j > 0; j = p[j]) {
++c;
s = (a[j] += s);
if (p[j] > 0) t -= a[j];
}
}
if (t < 0 || c < n)
cout << 0 << endl;
else {
for (int i = 1; i <= n; ++i)
for (int j = a[i]; j <= t; ++j)
if ((v[j] += v[j - a[i]]) >= M) v[j] -= M;
cout << v[t] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 100005;
const long long K = 205;
long long n, k;
struct qq {
long long x, y, last;
} e[N * 2];
long long num, last[N];
void init(long long x, long long y) {
num++;
e[num].x = x;
e[num].y = y;
e[num].last = last[x];
last[x] = num;
}
long long S[K][K];
long long JC[K];
long long h[K];
long long siz[N];
long long f[N][K];
long long g[N];
void dfs(long long x, long long fa) {
siz[x] = 1;
f[x][0] = 2;
for (long long xx = last[x]; xx != -1; xx = e[xx].last) {
long long y = e[xx].y;
if (y == fa) continue;
dfs(y, x);
for (long long u = 0; u <= min(siz[x] + siz[y] - 1, k); u++) g[u] = 0;
for (long long u = 0; u < siz[x] && u <= k; u++)
for (long long i = 0; i <= siz[y] && (u + i) <= k; i++)
g[u + i] = (g[u + i] + f[x][u] * f[y][i] % MOD) % MOD;
siz[x] = siz[x] + siz[y];
for (long long u = 0; u <= min(siz[x] - 1, k); u++) f[x][u] = g[u];
}
if (x == 1) {
for (long long u = 0; u <= k; u++) h[u] = h[u] + f[x][u];
} else {
for (long long u = 1; u <= k; u++) h[u] = (h[u] - f[x][u - 1]) % MOD;
h[1] = (h[1] + 1) % MOD;
}
for (long long u = k; u >= 1; u--) f[x][u] = (f[x][u] + f[x][u - 1]) % MOD;
f[x][1] = (f[x][1] - 1 + MOD) % MOD;
}
int main() {
num = 0;
memset(last, -1, sizeof(last));
scanf("%lld%lld", &n, &k);
JC[0] = 1;
for (long long u = 1; u <= k; u++) JC[u] = JC[u - 1] * u % MOD;
S[0][0] = 1;
for (long long u = 1; u <= k; u++)
for (long long i = 1; i <= u; i++)
S[u][i] = (S[u - 1][i - 1] + S[u - 1][i] * i % MOD) % MOD;
for (long long u = 1; u < n; u++) {
long long x, y;
scanf("%lld%lld", &x, &y);
init(x, y);
init(y, x);
}
dfs(1, 0);
long long ans = 0;
for (long long u = 0; u <= k; u++)
ans = (ans + S[k][u] * JC[u] % MOD * h[u] % MOD) % MOD;
ans = (ans + MOD) % MOD;
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int prime[10000010 / 10], pn, mp[10000010];
void choto_divisibleprime(int x) {
int i, j;
for (i = 2; i <= x; i++) {
if (!mp[i]) prime[++pn] = i, mp[i] = i;
for (j = 1; prime[j] * i <= x; j++) {
mp[prime[j] * i] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
choto_divisibleprime(10000010);
int n;
cin >> n;
int arr[n + 4];
for (int i = 0; i < n; i++) cin >> arr[i];
int d1[n + 3], d2[n + 3];
for (int i = 0; i < n; i++) {
d1[i] = d2[i] = -1;
int x = arr[i];
while (x % mp[arr[i]] == 0) x /= mp[arr[i]];
if (x > 1) d1[i] = x, d2[i] = mp[arr[i]];
}
for (int i = 0; i < n; i++) cout << d1[i] << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << d2[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 100000;
int n, k;
int num[MAXN + 10];
char s[MAXN + 10];
int c[MAXN + 10], ck[MAXN + 10], suf[MAXN + 10];
int quickpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = (long long)res * x % MOD;
x = (long long)x * x % MOD;
y >>= 1;
}
return res;
}
int ny(int x) { return quickpow(x, MOD - 2); }
void doit() {
int res = 0;
for (int i = 1; i <= n; ++i) res = ((long long)res * 10 % MOD + num[i]) % MOD;
printf("%d", res);
}
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= n; ++i) num[i] = s[i] - '0';
if (!k) return doit(), 0;
c[k - 1] = 1;
for (int i = k; i <= n - 2; ++i)
c[i] = (long long)c[i - 1] * i % MOD * ny(i - k + 1) % MOD;
for (int i = n - 2; i >= 0; --i)
suf[i] =
(suf[i + 1] + (long long)quickpow(10, n - 2 - i) * c[i] % MOD) % MOD;
ck[k] = 1;
for (int i = k + 1; i <= n - 1; ++i)
ck[i] = (long long)ck[i - 1] * i % MOD * ny(i - k) % MOD;
int ans = 0;
for (int i = 1; i <= n; ++i)
ans = ((ans + (long long)num[i] * suf[i - 1] % MOD) % MOD +
(long long)num[i] * quickpow(10, n - i) % MOD * ck[i - 1]) %
MOD;
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<long long, long long>;
using pll = pair<ll, ll>;
using vi = vector<long long>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
const ld pi = 3.141592653589793238;
const long long MOD = 1e9 + 7;
vi fact((long long)1e5 + 5, 0);
template <typename T>
inline T add(T a, T b) {
a %= MOD;
b %= MOD;
return ((a + b) % MOD);
}
template <typename T>
inline T sub(T a, T b) {
return add(a, -b);
}
template <typename T>
inline T mul(T a, T b) {
a %= MOD;
b %= MOD;
return (1ll * a * b) % MOD;
}
template <typename T>
inline T binpow(T a, T b) {
T res = 1;
while (b > 0) {
if (b % 2) res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
template <typename T>
inline T inv(T a) {
return binpow(a, MOD - 2);
}
template <typename T>
inline T inv2(T a, T b) {
return mul(a, inv(b));
}
template <typename T>
inline T normalize(T a) {
return ((a % MOD) + MOD) % MOD;
}
template <typename T>
inline T comb(T n, T k) {
return mul(fact[n], mul(inv(fact[k]), inv(fact[n - k])));
}
template <typename T>
inline bool powerof2(T a) {
return (a && (!(a & (a - 1))));
}
template <typename T>
inline T log_2(T a) {
T res = -1;
while (a) {
a /= 2;
res++;
}
return res;
}
void solve() {
long long c;
cin >> c;
vi arr(c);
set<long long> s;
for (long long i = 0; i < (long long)c; i++) cin >> arr[i];
for (long long i = 0; i < (long long)c; i++) {
if (arr[i] != -1) {
s.insert(i + 1);
}
}
long long n = c - s.size();
for (long long i = 0; i < (long long)c; i++) {
if (arr[i] != -1) {
s.erase(arr[i]);
}
}
long long r = n - s.size();
long long ans = fact[n];
long long sign = -1;
for (long long i = (long long)1; i <= (long long)r; i++) {
ans += (sign * (mul(comb(r, i), fact[n - i])));
sign *= -1;
}
ans = normalize(ans);
cout << ans << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
fact[0] = 1;
for (long long i = (long long)1; i <= (long long)1e5 + 4; i++)
fact[i] = mul(fact[i - 1], i);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A;
cin >> A;
int N;
if (A == 1)
N = 1;
else
N = 2 * (A - 1);
cout << N << " " << 2 << endl << 1 << " " << 2 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<list<long long int> > m(1000005);
long long int prime[1000005];
void sieve() {
prime[1] = 1;
for (long int i = 2; i <= 1000003; i++) {
if (prime[i] == 0) {
for (long int j = 2; i * j <= 1000003; j++) {
prime[i * j] = 1;
long int temp = j;
long int counter = 1;
while (temp % i == 0) {
counter++;
temp = temp / i;
}
m[i * j].push_back(counter + 1);
}
}
}
}
int main() {
ios::sync_with_stdio(false);
long int a, b, c;
cin >> a >> b >> c;
sieve();
long long int mod = (long long int)(1073741824 * (pow(2, 30)));
for (long int i = 1; i <= 1000003; i++) {
long int ans = 1;
list<long long int>::iterator iter;
if (prime[i] == 0) {
prime[i] = 2;
continue;
}
for (iter = m[i].begin(); iter != m[i].end(); iter++) {
ans = (ans * (*iter)) % mod;
}
prime[i] = ans;
}
long long int sum = 0;
for (long int i = 1; i <= a; i++) {
for (long int j = 1; j <= b; j++) {
for (long int k = 1; k <= c; k++) {
sum += (prime[i * j * k]) % mod;
}
}
}
cout << sum << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<array<int, 2> > adj[200105];
int xMove[] = {0, 1, 0, -1, 1, 1, -1, -1, 2, 2, -2, -2, 1, 1, -1, -1};
int yMove[] = {1, 0, -1, 0, 1, -1, 1, -1, 1, -1, 1, -1, 2, -2, 2, -2};
int main() {
cin.tie(0), cout.tie(0);
ios_base::sync_with_stdio(0);
cout.setf(ios::fixed);
cout.precision(10);
int TC = 1;
int n, m, k, q, t;
cin >> TC;
for (int t1 = 1; t1 <= TC; t1++) {
cin >> n;
vector<int> vec;
int one = 0, zero = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vec.push_back(s.size());
for (char c : s)
if (c == '1')
one++;
else
zero++;
}
int ans = 0;
for (int len : vec) {
while (len > 1) {
if (one > 1)
len -= 2, one -= 2;
else if (zero > 1)
len -= 2, zero -= 2;
else
break;
}
if (len <= 1) ans++;
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
multiset<long long int> s;
long long int sm;
long long int n;
int main() {
long long int i, j;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> j;
sm = sm + j;
s.insert(j);
}
long long int mnr = 4 * n;
if (n % 2 == 0) {
mnr = mnr + n / 2;
} else {
mnr = mnr + n / 2 + 1;
}
long long int cnt = 0;
multiset<long long int>::iterator it;
for (it = s.begin(); it != s.end() && sm < mnr; ++it) {
sm = sm - (*it) + 5;
cnt++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, w, x, c;
long long ans = 0;
int v[1010];
long long qta[1010], qtc[1010], qt[1010], qA[1010], qC[1010];
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &a, &b, &w, &x, &c);
long long t = 0, ta = 0, tc = 0, eq = 0;
while (1) {
if (b >= x) {
if (c - b / x <= a) {
printf("%I64d", ans + c - a);
return 0;
}
t += b / x;
c = c - b / x;
tc += b / x;
ans += b / x;
b = b % x;
eq = 0;
} else {
if (c <= a) {
printf("%I64d", ans - eq);
return 0;
}
if (!v[b])
v[b] = 1;
else {
long long ex = (qC[b] - qA[b]) - (c - a);
long long nt = ((c - a) / ex);
ans += nt * (t - qt[b]);
a -= nt * (ta - qta[b]);
c -= nt * (tc - qtc[b]);
memset(v, 0, sizeof(v));
continue;
}
qta[b] = ta;
qtc[b] = tc;
qt[b] = t;
qC[b] = c;
qA[b] = a;
b = w - x + b;
a--;
c--;
ta++;
tc++;
ans++;
t++;
eq++;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double g = 9.8;
double v, al[100005], ss[100005], cc[100005];
int d[100005];
pair<double, double> w[100005];
double first[100005];
double run(double first, double alpha) {
return (v * sin(alpha) + v * sin(alpha) - g * first / (v * cos(alpha))) *
first / (v * cos(alpha)) / 2;
}
bool cmp(const int &a, const int &b) { return al[a] < al[b]; }
int main() {
int n, m;
scanf("%d%lf", &n, &v);
for (int i = 1; i <= n; i++)
scanf("%lf", &al[d[i] = i]), cc[i] = cos(al[i]), ss[i] = sin(al[i]);
sort(d + 1, d + 1 + n, cmp);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%lf%lf", &w[i].first, &w[i].second);
sort(w + 1, w + 1 + m);
int j = 1;
for (int i = 1; i <= n; i++) {
while (j <= m && run(w[j].first, al[d[i]]) > w[j].second) j++;
if (j > m || run(w[j].first, al[d[i]]) < 0) {
first[d[i]] = v * ss[d[i]] / g * 2 * v * cc[d[i]];
continue;
}
first[d[i]] = w[j].first;
}
for (int i = 1; i <= n; i++)
printf("%.9lf %.9lf\n", first[i], run(first[i], al[i]));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2047;
int n, m, p[N], a[N], q[N], vis[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= 2 * n; ++i) scanf("%d", &p[q[i] = i]);
for (int i = 0, x, y; i < m; ++i) scanf("%d%d", &x, &y), a[a[x] = y] = x;
sort(q + 1, q + 2 * n + 1, [](int x, int y) -> bool {
return a[x] && !a[y] ? 1 : !a[x] && a[y] ? 0 : p[x] > p[y];
});
scanf("%d", &m);
if (m == 1) printf("%d\n", vis[q[1]] = q[1]), fflush(stdout);
for (int t = 1;;) {
scanf("%d", &m);
for (vis[m] = m; vis[q[t]]; t++)
;
if (t > 2 * n) break;
m = a[m] && !vis[a[m]] ? a[m] : q[t];
printf("%d\n", vis[m] = m), fflush(stdout);
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 2e5 + 10;
int m, n, k, tt, a[N], vis[N], L, R, cnt[N];
struct node {
int l, r, d;
} t[N];
int cmp(int a, int b) { return a > b; }
inline int check(int mid) {
int low = a[mid], tot = 0;
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= k; i++)
if (t[i].d > low) {
cnt[t[i].l]++, cnt[t[i].r + 1]--;
}
for (int i = 1; i <= n + 1; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i <= n + 1; i++) tot += (cnt[i] >= 1);
return tot * 2 <= tt - 1 - n;
}
signed main() {
cin >> m >> n >> k >> tt;
L = 0, R = m;
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = 1; i <= k; i++) scanf("%d %d %d", &t[i].l, &t[i].r, &t[i].d);
sort(a + 1, a + 1 + m, cmp);
while (L < R) {
int mid = L + R + 1 >> 1;
if (check(mid))
L = mid;
else
R = mid - 1;
}
cout << L << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, l, c = 0, s;
cin >> n >> s;
long long a[n], b[n];
vector<long long> v;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
bool bb = true;
if (s == b[n / 2])
return cout << "0", 0;
else if (s < b[n / 2]) {
for (i = n / 2; i >= 0; i--) {
if (b[i] > s) {
c += abs(s - b[i]);
}
}
cout << c << endl;
} else if (s > b[n / 2]) {
for (i = n / 2; i < n; i++) {
if (s > b[i]) {
c += abs(s - b[i]);
}
}
cout << c << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 1e5 + 5;
long long fr[N];
long long fc[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m;
cin >> m;
vector<vector<int> > a(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
if (n > m) {
vector<vector<int> > b(m, vector<int>(n, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) b[j][i] = a[i][j];
swap(a, b);
swap(n, m);
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) fr[i] += a[i][j], fc[j] += a[i][j];
long long ans = 0;
for (int i = 0; i < n; ++i) {
vector<long long> vec;
for (int j = 0; j < m; ++j) vec.emplace_back(fc[j] - a[i][j]);
sort(vec.begin(), vec.end(), greater<long long>());
if (vec.size() > 3) vec.resize(3);
ans = max(ans, fr[i] + accumulate(vec.begin(), vec.end(), 0ll));
}
for (int j = 0; j < m; ++j) {
vector<long long> vec;
for (int i = 0; i < n; ++i) vec.emplace_back(fr[i] - a[i][j]);
sort(vec.begin(), vec.end(), greater<long long>());
if (vec.size() > 3) vec.resize(3);
ans = max(ans, fc[j] + accumulate(vec.begin(), vec.end(), 0ll));
}
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
long long mx1 = 0;
long long mx2 = 0;
for (int k = 0; k < m; ++k) {
long long nxt = fc[k] - a[i][k] - a[j][k];
if (mx2 < nxt) mx2 = nxt;
if (mx1 < mx2) swap(mx1, mx2);
}
ans = max(ans, fr[i] + fr[j] + mx1 + mx2);
}
sort(fr, fr + n, greater<long long>());
ans = max(ans, accumulate(fr, fr + 4, 0ll));
sort(fc, fc + m, greater<long long>());
ans = max(ans, accumulate(fc, fc + 4, 0ll));
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, m;
char a[N], b[N];
inline int digit(int x) {
int res = 0;
while (x) {
res++;
x /= 10;
}
return res;
}
int cnt[10];
vector<int> res, res2;
bool cmp(vector<int> &ans, vector<int> &res) {
return ans.empty() or res.size() < ans.size() or
(res.size() == ans.size() and res < ans);
}
bool solve(int x) {
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) cnt[a[i] - '0']++;
while (x) {
if (cnt[x % 10] == 0) return 0;
cnt[x % 10]--;
x /= 10;
}
for (int i = 1; i <= m; i++) {
if (cnt[b[i] - '0'] == 0) return 0;
cnt[b[i] - '0']--;
}
int dif = 1, start = b[1] - '0';
while (dif <= m and b[dif] == b[1]) dif++;
if (dif <= m and b[dif] < b[1]) start--;
res.clear();
if (b[1] != '0') {
for (int i = 1; i <= m; i++) res.push_back(b[i] - '0');
for (int i = 0; i < 10; i++)
for (int it = 0; it < cnt[i]; it++) res.push_back(i);
}
int nonZero = 1;
while (nonZero < 10 and cnt[nonZero] == 0) nonZero++;
if (nonZero == 10) return 1;
res2.clear();
res2.push_back(nonZero);
cnt[nonZero]--;
for (int i = 0; i < 10; i++) {
for (int it = 0; it < cnt[i]; it++) res2.push_back(i);
if (i == start)
for (int i = 1; i <= m; i++) res2.push_back(b[i] - '0');
}
if (cmp(res, res2)) res = res2;
return 1;
}
int main() {
scanf(" %s %s", a + 1, b + 1);
n = strlen(a + 1);
m = strlen(b + 1);
if (n == 2 and m == 1 and b[1] == '0') {
puts("0");
return 0;
}
vector<int> pos;
for (int i = 1; i <= n; i++) {
if (n - digit(i) == i) pos.push_back(i);
}
assert(pos.size() == 1);
assert(solve(pos.back()));
for (auto i : res) printf("%d", i);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> spuu;
unordered_map<long long, unordered_map<long long, long long>> asd;
unordered_set<long long> vl[400000];
long long C[400000];
void update(long long r) {
long long l = 0;
l += 1048576 / 2;
r += 1048576 / 2;
while (l < r) {
if (l % 2 == 1) {
spuu[l]++;
l++;
}
if (r % 2 == 0) {
spuu[r]++;
r--;
}
l /= 2;
r /= 2;
}
if (l == r) spuu[l]++;
}
long long get(long long a) {
a += 1048576 / 2;
long long s = 0;
while (a > 0) {
s += spuu[a];
a /= 2;
}
return s;
}
int main() {
cout.sync_with_stdio(false);
cin.sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
asd[a][b]++;
asd[b][a]++;
vl[a].insert(b);
vl[b].insert(a);
C[a]++;
C[b]++;
}
for (long long i = 1; i <= n; i++) update(C[i]);
long long v = 0;
for (long long i = 1; i <= n; i++) {
long long oma = C[i];
if (oma >= m) {
v += n - 1;
continue;
}
long long po = m - oma;
long long a = get(po);
if (oma >= po) a--;
v += a;
for (long long e : vl[i]) {
if (C[e] >= po) {
long long oikea = C[e];
oikea -= asd[i][e];
if (oikea < po) v--;
}
}
}
cout << v / 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
inline long long inverse(long long x) {
int y = 0;
while (x) y = y * 10 + (x % 10), x /= 10;
return y;
}
int main() {
cin >> a >> b;
cout << a + inverse(b);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[102];
scanf("%s", s);
int n = strlen(s);
sscanf(s, "%s", &s[n]);
s[n << 1] = '\0';
string ss;
map<string, bool> m;
int distinct = 0;
for (int i = 0; i < n; ++i) {
char t = s[n + i];
s[n + i] = '\0';
ss = string(&s[i]);
if (!m[ss]) {
m[ss] = true;
++distinct;
}
s[n + i] = t;
}
printf("%d\n", distinct);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1024], tmp[1024];
int main() {
int n, k, maxm = 0, minm = INT_MAX, p, x;
cin >> n >> k >> x;
for (int i = 0; i < n; i++) cin >> p, cnt[p]++;
for (int i = 0; i < k; i++) {
for (int j = 0; j < 1024; j++) tmp[j] = cnt[j];
int par = 0;
for (int j = 0; j < 1024; j++) {
if (cnt[j] > 0) {
int curr = j ^ x;
int change = cnt[j] / 2;
if (par == 0) change += (cnt[j] & 1);
tmp[j] -= change;
tmp[curr] += change;
par ^= (cnt[j] & 1);
}
}
memcpy(cnt, tmp, sizeof(tmp));
}
for (int i = 0; i < 1024; i++)
if (cnt[i] > 0) minm = min(minm, i), maxm = max(maxm, i);
cout << maxm << " " << minm;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int nxt[100010][30];
string words[4];
long long int dp[255][255][255];
void process(long long int i, long long int j, long long int k) {
long long int val = LONG_MAX;
if (i >= 1 && dp[i - 1][j][k] != LONG_MAX)
val = min(val, nxt[dp[i - 1][j][k]][words[1][i - 1] - 'a']);
if (j >= 1 && dp[i][j - 1][k] != LONG_MAX)
val = min(val, nxt[dp[i][j - 1][k]][words[2][j - 1] - 'a']);
if (k >= 1 && dp[i][j][k - 1] != LONG_MAX)
val = min(val, nxt[dp[i][j][k - 1]][words[3][k - 1] - 'a']);
dp[i][j][k] = val;
}
int main() {
ios_base::sync_with_stdio(false);
long long int n, q;
char op;
char ch;
long long int arrNum;
cin >> n >> q;
string second;
cin >> second;
dp[0][0][0] = 0;
for (long long int i = 0; i <= n; i++)
for (long long int j = 0; j < 30; j++) nxt[i][j] = LONG_MAX;
for (long long int i = n - 1; i >= 0; i--) {
for (long long int j = 0; j < 30; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][second[i] - 'a'] = i + 1;
}
long long int min1, max1, min2, max2, min3, max3;
while (q--) {
cin >> op;
cin >> arrNum;
if (op == '+') {
cin >> ch;
words[arrNum] += ch;
max1 = words[1].size();
max2 = words[2].size();
max3 = words[3].size();
min1 = arrNum == 1 ? max1 : 0;
min2 = arrNum == 2 ? max2 : 0;
min3 = arrNum == 3 ? max3 : 0;
for (long long int i = min1; i <= max1; i++) {
for (long long int j = min2; j <= max2; j++) {
for (long long int k = min3; k <= max3; k++) {
process(i, j, k);
}
}
}
} else {
words[arrNum].pop_back();
}
cout << ((dp[words[1].size()][words[2].size()][words[3].size()] == LONG_MAX)
? "NO"
: "YES")
<< '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 1;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
void print(vector<int> &a) {
for (int i : a) cout << i << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
int n;
cin >> n;
int a[n][4];
for (int i = 0; i < n; i++)
for (int j = 0; j < 4; j++) cin >> a[i][j];
int ans = n;
for (int i = 0; i < n; i++) {
bool ok = true;
for (int j = 1; j < i + 1; j++) {
double c = 0, m = 0;
double p;
for (int k = j; k < i + 1; k++) {
int d = abs(a[k][0] - a[k][2]);
p = (double)(a[k][0] + a[k][2]) / 2;
c += p * d * d * d;
m += d * d * d;
}
p = (double)c / m;
if (p < a[j - 1][0] && p < a[j - 1][2] ||
p > a[j - 1][0] && p > a[j - 1][2]) {
ok = false;
break;
}
}
if (!ok) {
ans = min(ans, i);
break;
}
}
for (int i = 0; i < n; i++) {
bool ok = true;
for (int j = 1; j < i + 1; j++) {
double c = 0, m = 0;
double p;
for (int k = j; k < i + 1; k++) {
int d = abs(a[k][1] - a[k][3]);
p = (double)(a[k][1] + a[k][3]) / 2;
c += p * d * d * d;
m += d * d * d;
}
p = (double)c / m;
if (p < a[j - 1][1] && p < a[j - 1][3] ||
p > a[j - 1][1] && p > a[j - 1][3]) {
ok = false;
break;
}
}
if (!ok) {
ans = min(ans, i);
break;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void data() {}
const int N = 1e6 + 100;
const long long mod = 998244353;
const long long mod2 = 1e9 + 7;
int main() {
data();
long long n;
cin >> n;
map<long long, long long> was;
for (long long i = 1; i <= 1e5; i++) {
was[i * i + i] = 1;
}
n *= 2;
for (long long i = 1; i <= 1e5; i++) {
long long kek = n - (i * i);
kek -= i;
if (was[kek] && kek > 0) {
cout << "YES";
return 0;
}
}
cout << "NO\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void cmin(T &x, T y) {
x = (x < y ? x : y);
}
template <typename T>
inline void cmax(T &x, T y) {
x = (x > y ? x : y);
}
char buf[100000], *p1(buf), *p2(buf);
inline long long read() {
long long x = 0, f = 1;
char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
}
return f ? x : -x;
}
const long long N = 2e5 + 1;
const long long INF = 1e9 + 7;
long long n, a[N];
inline void input() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
return;
}
bool dfs(const long long op, long long lef, long long rig, long long x,
long long y) {
if (lef == rig) return op;
if (a[lef] >= a[rig] && (x & 1)) return op;
if (a[rig] >= a[lef] && (y & 1)) return op;
if (a[lef] < a[rig]) return dfs(op ^ 1, lef + 1, rig, x - 1, y);
if (a[rig] < a[lef]) return dfs(op ^ 1, lef, rig - 1, x, y - 1);
if (a[lef] == a[rig]) return op ^ 1;
}
inline void work() {
long long lef = 1, rig = n, lt = 1, rt = 1;
while (a[lef] < a[lef + 1] && lef < n) lt++, lef++;
while (a[rig] < a[rig - 1] && rig > 1) rt++, rig--;
puts(dfs(0, 1, n, lt, rt) ? "Bob" : "Alice");
return;
}
inline void solve() {
input();
work();
return;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int ans = -1;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
if (y != 0 && x > s || y == 0 && x > s || x == s && y > 0) continue;
ans = std::max(ans, y == 0 ? 0 : 100 - y);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
string s;
long long dp[N][3];
long long solve(int ind, int rem) {
if (ind == s.size()) return rem == 0;
if (~dp[ind][rem]) return dp[ind][rem];
if (!rem) return dp[ind][rem] = solve(ind + 1, (s[ind] - '0') % 3) + 1;
return dp[ind][rem] = max(solve(ind + 1, (rem * 10 + (s[ind] - '0')) % 3),
solve(ind + 1, (s[ind] - '0') % 3));
}
int main() {
cin >> s;
memset(dp, -1, sizeof(dp));
cout << solve(1, (s[0] - '0') % 3);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long T = 1;
while (T--) {
long long n, m, k, x = 0, y = 0, c = 0;
cin >> n >> m;
long long a[n + m][2];
long long b[m], arr[m];
memset(b, 0, sizeof(b));
memset(arr, 0, sizeof(arr));
for (long long i = 0; i < n + m; ++i) {
cin >> a[i][0];
}
long long j = 0;
for (long long i = 0; i < n + m; ++i) {
cin >> a[i][1];
if (a[i][1] == 1) arr[j++] = i;
}
if (m == 1) cout << n << "\n";
if (m > 1) {
for (long long i = 0; i < n + m; ++i) {
if (a[i][1] == 1) {
b[0] = i;
break;
}
}
long long p = 0;
while (p < m - 1) {
for (long long i = arr[p] + 1; i < arr[p + 1]; ++i) {
if (abs(a[arr[p]][0] - a[i][0]) > abs(a[i][0] - a[arr[p + 1]][0]))
b[p + 1]++;
else
b[p]++;
}
p++;
}
for (long long i = m + n - 1; i >= 0; --i) {
if (a[i][1] == 1) {
b[p] += n + m - i - 1;
break;
}
}
for (long long i = 0; i < m; ++i) {
cout << b[i] << " ";
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.