solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 7, M = 998244353;
const double PI = acos(-1);
string l, a, r, tmp;
int ll, rr, n;
int to[N], mx[N], dp[N], arr1[N], arr2[N];
int sm[N];
void go(int *z) {
int n = tmp.size();
int L = 0, R = 0;
for (int i = 1; i < n; i++) {
if (i > R) {
L = R = i;
while (R < n && tmp[R - L] == tmp[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < n && tmp[R - L] == tmp[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
int ch(int st, int ed) {
if (ed - st + 1 < l.size()) return 0;
if (ed - st + 1 > l.size()) return 1;
int x = arr1[st + l.size() + 1];
if (x == l.size()) return 1;
if (a[st + x] < l[x]) return 0;
return 1;
}
int ch2(int st, int ed) {
if (ed - st + 1 > r.size()) return 0;
if (ed - st + 1 < r.size()) return 1;
int x = arr2[st + r.size() + 1];
if (x == r.size()) return 1;
if (a[st + x] > r[x]) return 0;
return 1;
}
int main() {
cin >> a >> l >> r;
tmp = l + '#' + a;
go(arr1);
tmp = r + '#' + a;
go(arr2);
n = a.size();
memset(to, -1, sizeof to);
memset(mx, -1, sizeof mx);
for (int i = 0; i < n; i++) {
if (a[i] == '0') {
if (l == "0") {
to[i] = i, mx[i] = i;
}
continue;
}
int l = i, r = n - 1, md;
while (l <= r) {
md = (l + r) / 2;
if (ch(i, md)) {
r = md - 1;
to[i] = md;
} else
l = md + 1;
}
l = i, r = n - 1, md;
while (l <= r) {
md = (l + r) / 2;
if (ch2(i, md)) {
l = md + 1;
mx[i] = md;
} else
r = md - 1;
}
}
dp[n] = 1;
sm[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (to[i] == -1 || mx[i] == -1 || to[i] > mx[i]) {
sm[i] = sm[i + 1];
continue;
}
dp[i] = (sm[to[i] + 1] - sm[mx[i] + 2] + M) % M;
sm[i] = (dp[i] + sm[i + 1]) % M;
}
cout << dp[0] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unsigned int seed;
unsigned int getrand() {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
return seed;
}
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 2e5 + 5;
int n;
int fa[N * 2];
struct node {
int l, r, tot;
long long sum, sumv;
unsigned int key;
int val;
} tree[N];
int lef[N], rig[N];
int rt[N * 2];
long long ans;
int tot;
int getfather(int x) { return fa[x] == x ? x : fa[x] = getfather(fa[x]); }
void update_ans(int x, long long v) {
ans = ans + v * (tree[rt[x]].sum + tree[rt[x]].sumv * (lef[x] - 1));
}
void update(int now) {
int l = tree[now].l, r = tree[now].r;
tree[now].tot = tree[l].tot + tree[r].tot + 1;
tree[now].sumv = tree[l].sumv + tree[r].sumv + tree[now].val;
tree[now].sum = tree[l].sum + 1ll * tree[now].val * (tree[l].tot + 1) +
tree[r].sum + tree[r].sumv * (tree[l].tot + 1);
}
pair<int, int> split(int now, int v) {
if (!now) return make_pair(0, 0);
if (tree[now].val > v) {
pair<int, int> u = split(tree[now].r, v);
tree[now].r = u.first;
update(now);
return make_pair(now, u.second);
}
pair<int, int> u = split(tree[now].l, v);
tree[now].l = u.second;
update(now);
return make_pair(u.first, now);
}
int merge(int x, int y) {
if (!x || !y) return x | y;
if (tree[x].key < tree[y].key) {
tree[x].r = merge(tree[x].r, y);
update(x);
return x;
}
tree[y].l = merge(x, tree[y].l);
update(y);
return y;
}
void add(int x, int v, int id = 0) {
if (!id) update_ans(x, -1);
pair<int, int> u = split(rt[x], v);
int t = id;
if (!id) t = ++tot;
tree[t].l = tree[t].r = 0;
tree[t].sum = tree[t].val = tree[t].sumv = v;
tree[t].tot = 1;
tree[t].key = getrand();
rt[x] = merge(u.first, merge(t, u.second));
if (!id) update_ans(x, 1);
}
int que[N];
int id[N];
int k;
void getque(int now) {
if (!now) return;
getque(tree[now].l);
que[++k] = tree[now].val;
id[k] = now;
getque(tree[now].r);
}
void Merge(int x, int y) {
update_ans(x, -1);
update_ans(y, -1);
if (tree[rt[x]].tot < tree[rt[y]].tot) {
k = 0;
getque(rt[x]);
for (int i = 1; i <= k; i++) add(y, que[i], id[i]);
lef[y] = lef[x];
fa[x] = y;
update_ans(y, 1);
} else {
k = 0;
getque(rt[y]);
for (int i = 1; i <= k; i++) add(x, que[i], id[i]);
rig[x] = rig[y];
fa[y] = x;
update_ans(x, 1);
}
}
int main() {
seed = 29382343;
n = get();
ans = 0;
for (int i = 1; i <= n; i++) {
int x = get(), v = get();
ans = ans - 1ll * x * v;
if (!fa[x]) {
fa[x] = x;
lef[x] = rig[x] = x;
add(x, v);
} else {
int y = getfather(x);
fa[++rig[y]] = y;
add(y, v);
}
int y = getfather(x);
if (fa[rig[y] + 1]) Merge(y, getfather(rig[y] + 1));
y = getfather(y);
if (fa[lef[y] - 1]) Merge(getfather(lef[y] - 1), y);
printf("%I64d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
using namespace std;
void redirectIO() {}
int n;
pair<int, int> inputs[100001];
pair<int, int> edges[100001];
int listStart[100001];
int pathLen[100001];
int getLen(int node) {
if (edges[listStart[node]].first != node) return 0;
if (pathLen[node]) return pathLen[node];
int best = 0;
for (int edge = listStart[node]; edges[edge].first == node; edge++) {
int r = getLen(edges[edge].second) + 1;
if (r > best) best = r;
}
return pathLen[node] = best;
}
bool check(int m) {
memcpy(edges, inputs, m * sizeof(pair<int, int>));
sort(edges, edges + m);
edges[m] = make_pair((10000000), (0));
listStart[1] = 0;
int nowAt = 0;
for (int i = 1; i <= n; i++) {
while (edges[nowAt].first < i) nowAt++;
listStart[i] = nowAt;
}
memset(pathLen, 0, (n + 1) * sizeof(int));
for (int i = 1; i <= n; i++) {
if (getLen(i) == n - 1) return true;
}
return false;
}
int main() {
redirectIO();
int m;
while (cin >> n >> m) {
for (int i = 0; i < (m); ++i) cin >> inputs[i].first >> inputs[i].second;
int mmin = 0;
int mmax = m;
while (mmin < mmax) {
int mid = (mmin + mmax) / 2;
if (check(mid))
mmax = mid;
else
mmin = mid + 1;
}
if (mmin == m && !check(m))
cout << -1 << endl;
else
cout << mmin << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> adj[100007];
int sub[100007], d[100007];
void dfs(int u, int p) {
int v;
sub[u]++;
for (int i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (v != p) {
d[v] = d[u] + 1;
dfs(v, u);
sub[u] += sub[v];
}
}
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
int u;
cin >> u;
adj[i].push_back(u);
adj[u].push_back(i);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
int ans = n - sub[i] - d[i] + 2 * (d[i] + 1);
cout << ans / 2;
if (ans % 2)
cout << ".5"
<< " ";
else
cout << ".0"
<< " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, t;
long long g(long long n, long long t);
long long f(long long type, long long depth, long long t);
long long f(long long type, long long depth, long long t) {
if (depth <= 0) return 0;
if (t == 1) return 1;
if (type == 1) return (t == 1) ? 1 : 0;
if (t % 2) return 0;
return g(min(type - 1, depth - 1), t / 2);
}
map<pair<long long, long long>, long long> memo;
long long g(long long n, long long t) {
map<pair<long long, long long>, long long>::iterator it =
memo.find(pair<long long, long long>(n, t));
if (it != memo.end()) return it->second;
long long res = 0;
for (long long type = 1; type <= n; type *= 2) {
res += f(type, min(n - type + 1, type), t);
}
return memo[pair<long long, long long>(n, t)] = res;
}
int main() {
scanf("%I64d %I64d ", &n, &t);
long long res = g(n + 1, t);
if (t == 1) res--;
printf("%I64d\n", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
set<string> se;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());
se.insert(s);
}
cout << (int)se.size();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long BMOD = 1000000000000000003;
map<string, vector<pair<string, int> > > G;
vector<bool> V;
set<pair<string, string> > res;
int main() {
int n, d;
cin >> n >> d;
V.assign(n, false);
for (int i = 0; i < n; i++) {
string a, b;
int t;
cin >> a >> b >> t;
G[a].push_back(make_pair(b, t));
}
for (map<string, vector<pair<string, int> > >::iterator it = G.begin();
it != G.end(); it++) {
for (int i = 0; i < (*it).second.size(); i++) {
for (int j = 0; j < G[(*it).second[i].first].size(); j++) {
if (((*it).first == G[(*it).second[i].first][j].first) &&
(abs((*it).second[i].second -
G[(*it).second[i].first][j].second)) <= d &&
abs((*it).second[i].second - G[(*it).second[i].first][j].second) >
0) {
string s1 = (*it).first;
string s2 = (*it).second[i].first;
if (s1 > s2) swap(s1, s2);
res.insert(make_pair(s1, s2));
}
}
}
}
cout << res.size() << "\n";
for (set<pair<string, string> >::iterator it = res.begin(); it != res.end();
it++) {
cout << (*it).first << " " << (*it).second << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
sort(s2.rbegin(), s2.rend());
int j = 0;
for (int i = 0; i < s1.size(); i++) {
if ((s1[i] - '0') < (s2[j] - '0')) {
s1[i] = s2[j];
j++;
}
}
cout << s1 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
const int N = 2e5 + 10;
int r, g, hmx = 0, dp[2][N];
int G(int x) { return x * (x + 1) / 2; }
int main() {
scanf("%d%d", &r, &g);
while (G(hmx) <= r + g) hmx++;
hmx--;
for (int i = hmx + 1; i >= 1; i--) {
for (int curr = 0; curr <= r; curr++) {
if (i == hmx + 1)
dp[i % 2][curr] = 1;
else {
int tot = G(i - 1);
int gl = g - (tot - (r - curr));
dp[i % 2][curr] = 0;
if (curr >= i) dp[i % 2][curr] += dp[!(i % 2)][curr - i];
if (gl >= i) dp[i % 2][curr] += dp[!(i % 2)][curr];
dp[i % 2][curr] %= MOD1;
}
}
}
printf("%d\n", dp[1][r]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
while (b) {
int c = b % a;
if (c == 0)
b /= a;
else if (c == 1)
b--;
else if (c == a - 1)
b++;
else
return cout << "NO", 0;
}
cout << "YES";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1024];
int ncomp;
int comp[1024];
int vis[1024], stck[1024], t, high[1024];
int num;
void dfscc(int u) {
int i, v;
high[u] = vis[u] = num--;
stck[t++] = u;
for (i = 0; i < (int)adj[u].size(); i++) {
v = adj[u][i];
if (!vis[v]) {
dfscc(v);
high[u] = max(high[u], high[v]);
} else if (vis[v] > vis[u] && !comp[v])
high[u] = max(high[u], vis[v]);
}
if (high[u] == vis[u]) {
ncomp++;
do {
v = stck[--t];
comp[v] = ncomp;
} while (v != u);
}
}
void scc(int n) {
ncomp = t = 0;
num = n;
memset(vis, 0, sizeof(vis));
memset(comp, 0, sizeof(comp));
for (int i = 0; i < n; i++)
if (!vis[i]) dfscc(i);
}
bool two_sat(int n) {
n *= 2;
bool ok = true;
scc(n);
for (int i = 0; i < n / 2 && ok; i++) ok &= (comp[2 * i] != comp[2 * i + 1]);
return ok;
}
int getsol(int x) { return comp[2 * x] < comp[2 * x + 1]; }
void clau(int x, int y) {
int negx = (x % 2 == 1 ? x - 1 : x + 1), negy = (y % 2 == 1 ? y - 1 : y + 1);
adj[negx].push_back(y);
adj[negy].push_back(x);
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
while (m--) {
int x, y, w;
cin >> x >> y >> w;
--x;
--y;
if (w) {
clau((2 * x + 1), (2 * y));
clau((2 * x), (2 * y + 1));
} else {
clau((2 * x + 1), (2 * y + 1));
clau((2 * x), (2 * y));
}
}
if (!two_sat(n))
cout << "Impossible\n";
else {
vector<int> ans;
for (int i = 0; i < (n); ++i)
if (getsol(i)) ans.push_back(i + 1);
cout << (int)((ans).size()) << endl;
for (int x : ans) cout << x << " ";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dist[1010][1010];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int bfs(int x, int y, int a, int b, int n) {
memset(dist, -1, sizeof dist);
dist[x][y] = 0;
queue<pair<int, int> > q;
q.push(make_pair(x, y));
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int curx = u.first + dx[i];
int cury = u.second + dy[i];
if (!(curx == 0 || cury == 0 || curx == n || cury == n)) continue;
if (curx < 0 || cury < 0 || curx > n || cury > n) continue;
if (dist[curx][cury] == -1) {
dist[curx][cury] = 1 + dist[u.first][u.second];
q.push(make_pair(curx, cury));
}
}
}
return dist[a][b];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
cout << bfs(x1, y1, x2, y2, n) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int inf = 1e9;
const int maxn = 1e6 + 5;
struct segtree {
pair<int, int> merge(pair<int, int> x, pair<int, int> y) { return min(x, y); }
int n;
vector<pair<int, int>> t;
void init(int n) {
n += 10;
this->n = n;
t.resize(n * 4, {inf, inf});
}
void upd(int v, int tl, int tr, int i, pair<int, int> val) {
if (tl == tr) {
t[v] = val;
} else {
int tm = (tl + tr) / 2;
if (i <= tm) {
upd(2 * v, tl, tm, i, val);
} else {
upd(2 * v + 1, tm + 1, tr, i, val);
}
t[v] = merge(t[2 * v], t[2 * v + 1]);
}
}
pair<int, int> qry(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) {
return {inf, inf};
}
if (l <= tl && tr <= r) {
return t[v];
}
int tm = (tl + tr) / 2;
return merge(qry(2 * v, tl, tm, l, r), qry(2 * v + 1, tm + 1, tr, l, r));
}
};
int n;
pair<int, int> iv[maxn];
int assigned[maxn];
vector<pair<int, int>> s[maxn];
int ans[maxn];
void print_ans() {
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> iv[i].first >> iv[i].second;
s[iv[i].first].push_back({iv[i].second, i});
}
set<pair<int, int>> act;
for (int i = 1; i <= n; i++) {
act.insert(s[i].begin(), s[i].end());
auto cur = *act.begin();
act.erase(act.begin());
assigned[i] = cur.second;
ans[cur.second] = i;
}
segtree t;
t.init(n + 10);
for (int i = 1; i <= n; i++) {
int idx = assigned[i];
t.upd(1, 1, n, i, make_pair(iv[idx].first, idx));
}
for (int i = 1; i <= n; i++) {
int idx = assigned[i];
int R = iv[idx].second;
auto cur = t.qry(1, 1, n, i + 1, R);
if (cur.first == inf) {
continue;
}
if (iv[cur.second].first <= i) {
cout << "NO\n";
print_ans();
swap(ans[idx], ans[cur.second]);
print_ans();
exit(0);
}
}
cout << "YES\n";
print_ans();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
vector<long long> v[N];
int main() {
long long n, m, mx = -1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
for (int j = 0; j < m; j++) {
int x;
cin >> x;
v[i].push_back(x);
}
sort(v[i].rbegin(), v[i].rend());
mx = max(mx, v[i][0]);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int x = v[i].size();
ans += (x * (mx - v[i][0]));
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
double a, b, s1, s2[100010];
scanf("%lf%lf", &a, &b);
scanf("%lf", &s1);
double sum = s1;
int i, j, k;
for (i = 0; i < n - 1; i++) {
scanf("%lf", &s2[i]);
sum += s2[i];
}
int cnt = 0;
sort(s2, s2 + n - 1);
for (i = n - 2; i >= 0; i--) {
double now = a * s1;
now /= sum;
if (now >= b) break;
cnt++;
sum -= s2[i];
}
deb(cnt);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5007;
long long dp[maxn][maxn];
const int mod = 998244353;
int main() {
for (int i = 0; i <= 5000; i++) dp[0][i] = 1;
for (int i = 1; i <= 5000; i++) {
dp[i][0] = 1;
for (int j = 1; j <= 5000; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1] * j) % mod;
}
}
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
long long ans = 1;
ans = ans * dp[a][b] % mod * dp[b][c] % mod * dp[c][a] % mod;
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int p = 0, pre = 0;
unordered_set<int> st;
st.insert(0);
for (char c : s) {
pre = p;
switch (c) {
case 'L':
p--;
break;
case 'R':
p++;
break;
case 'U':
p -= 1000;
break;
case 'D':
p += 1000;
}
if (st.find(p) != st.end()) {
cout << "BUG" << endl;
return 0;
}
st.insert(pre + 1);
st.insert(pre - 1);
st.insert(pre + 1000);
st.insert(pre - 1000);
}
cout << "OK" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
string s;
cin >> n >> s;
int cnt = 0;
vector<int> psum;
for (char a : s) {
psum.push_back(cnt);
if (a == '(') {
cnt++;
} else {
cnt--;
}
}
if (cnt != 0) {
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
int curmin = 0;
for (int x : psum) curmin = min(curmin, x);
for (int& x : psum) x -= curmin;
int curcnt = 0;
for (int x : psum)
if (x == 0) curcnt++;
int best = curcnt;
pair<int, int> which_swap = {0, 0};
{
int first_two = -1;
int equals_count = 0;
for (int i = 0; i < 2 * n; i++) {
int v = psum[i % n];
if (v <= 1) {
first_two = -1;
equals_count = 0;
} else if (v == 2) {
equals_count++;
if (psum[(i + n - 1) % n] == 1) {
if (first_two == -1) {
first_two = i;
}
}
if (first_two == -1) {
equals_count = 0;
}
if (psum[(i + 1) % n] == 1) {
if (first_two != -1) {
pair<int, int> swap_cand = {(first_two + n - 1) % n, (i + n) % n};
assert(s[swap_cand.first] == '(' && s[swap_cand.second] == ')');
if (equals_count + curcnt > best) {
best = equals_count + curcnt;
which_swap = swap_cand;
}
}
}
}
}
}
{
int first_two = -1;
int equals_count = 0;
for (int i = 0; i < 2 * n; i++) {
int v = psum[i % n];
if (v <= 0) {
first_two = -1;
equals_count = 0;
} else if (v == 1) {
equals_count++;
if (psum[(i + n - 1) % n] == 0) {
if (first_two == -1) {
first_two = i;
}
}
if (first_two == -1) {
equals_count = 0;
}
if (psum[(i + 1) % n] == 0) {
if (first_two != -1) {
pair<int, int> swap_cand = {(first_two + n - 1) % n, (i + n) % n};
assert(s[swap_cand.first] == '(' && s[swap_cand.second] == ')');
if (equals_count > best) {
best = equals_count;
which_swap = swap_cand;
}
}
}
}
}
}
cout << best << '\n';
cout << which_swap.first + 1 << ' ' << which_swap.second + 1 << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> go(int x, vector<int> a) {
vector<int> ret;
ret.push_back(x);
a[x]--;
while (1) {
if (x > 0 && a[x - 1] > 0)
x--;
else if (x < 3 && a[x + 1] > 0)
x++;
else
return ret;
ret.push_back(x);
a[x]--;
}
return ret;
}
int main() {
vector<int> a(4);
for (int i = 0; i < 4; i++) scanf("%d", &a[i]);
for (int i = 0; i < 4; i++) {
if (a[i] == 0) continue;
auto v = go(i, a);
if (v.size() == a[0] + a[1] + a[2] + a[3]) {
puts("YES");
for (int k = 0; k < v.size(); k++) {
if (k > 0) putchar(' ');
printf("%d", v[k]);
}
puts("");
return 0;
}
}
puts("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
char s[MAXN];
void solve() {
int n, t;
cin >> n >> t;
scanf("%s", s);
int frac = 0;
n++;
for (int i = n - 1; i > 0; i--) {
s[i] = s[i - 1];
}
s[0] = '0';
for (int i = 0; i < n; i++) {
if (s[i] == '.') {
frac = i;
break;
}
}
int big_pos = -1;
for (int i = frac + 1; i < n; i++) {
if (s[i] >= '5') {
big_pos = i;
break;
}
}
if (big_pos == -1) {
for (int i = 1; i < n; i++) {
printf("%c", s[i]);
}
return;
}
int fin = n - 1;
int carry = 0;
for (int i = big_pos; i > frac && t; i--) {
if (s[i] < '5') continue;
carry = 1;
fin = i - 1;
int j;
for (j = i - 1; j > frac; j--) {
if (s[j] == '9') {
s[j] = '0';
i--;
} else {
s[j]++;
carry = 0;
break;
}
}
t--;
}
if (carry) {
for (int i = frac - 1; i >= 0; i--) {
if (s[i] == '9') {
s[i] = '0';
} else {
s[i]++;
carry = 0;
break;
}
}
}
int beg = 1;
if (s[0] != '0') beg = 0;
for (int i = fin; i > frac; i--) {
if (s[i] == '0') {
fin--;
} else
break;
}
if (fin == frac) fin--;
for (int i = beg; i <= fin; i++) {
printf("%c", s[i]);
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int MAXN = 1024;
const int MOD = 1000000007;
struct TASK {
int t, q;
} task[MAXN];
bool cmp(TASK a, TASK b) {
if (a.t != b.t) return a.t > b.t;
return a.q > b.q;
}
vector<int> sum[128];
int main() {
int n, m, Q;
int i, j, k;
int T;
int ioflag = 1;
while ((ioflag = scanf("%d%d", &n, &T)) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d%d", &task[i].t, &task[i].q);
}
sort(task, task + n, cmp);
for (i = 0; i <= T; i++) {
sum[i].clear();
}
for (i = 0; i < n; i++) {
sum[task[i].t].push_back(task[i].q);
}
for (i = 1; i < T; i++) {
sort(sum[i].begin(), sum[i].end());
for (j = sum[i].size() - 1; j >= 0; j -= 2) {
if (j - 1 >= 0) {
sum[i + 1].push_back(sum[i][j] + sum[i][j - 1]);
} else {
sum[i + 1].push_back(sum[i][j]);
}
}
}
sort(sum[T].begin(), sum[T].end());
cout << sum[T][sum[T].size() - 1] << endl;
}
ioflag = scanf("%d", &n);
assert(ioflag != 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
int f = 0;
for (; !isdigit(c); c = getchar()) f |= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
if (f) x = -x;
}
template <typename T>
void write(T x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar(st[tp--] | '0');
putchar(ed);
}
const int N = 505000;
struct node {
long long d;
int id;
bool operator<(const node &i) const { return id < i.id; }
node(long long D = 0, int I = 0) : d(D), id(I) {}
};
vector<vector<node> > vec;
vector<node> ety;
int ne[N << 1], to[N << 1], h[N], f[N], rt, tot, n;
inline void add(int x, int y) { ne[++tot] = h[x], to[h[x] = tot] = y; }
int dep[N], L[N], R[N], cnt;
int son[N], mxd[N], rev[N];
long long ans[N];
void dfs1(int x, int fa) {
mxd[x] = dep[x] = dep[fa] + 1, L[x] = ++cnt, rev[cnt] = x;
if (dep[x] >= vec.size()) vec.push_back(ety);
vec[dep[x]].push_back(node(0, L[x]));
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
dfs1(to[i], x);
if (mxd[y] >= mxd[x]) son[x] = y, mxd[x] = mxd[y];
}
R[x] = cnt;
}
inline bool inc(int x, int l, int r) { return R[x] >= r && L[x] <= l; }
long long tab[N], t[N];
void dfs2(int x) {
int ct = 0, nw = dep[x];
long long res = 0;
t[dep[x]]++;
auto pl = lower_bound(vec[dep[x]].begin(), vec[dep[x]].end(), node(0, L[x])),
pr = pl;
++pr;
while ("jzpakioi", true) {
res += 1ll * (ct += t[nw]) * (pr - pl) + tab[nw];
tab[nw] = t[nw] = 0, pl->d += res;
if (pr != vec[nw].end()) pr->d -= res;
if (++nw > mxd[x]) break;
pl = lower_bound(vec[nw].begin(), vec[nw].end(), node(0, L[x]));
pr = upper_bound(vec[nw].begin(), vec[nw].end(), node(0, R[x]));
if (inc(son[x], pl->id, (pr - 1)->id)) {
t[nw] += ct, tab[nw] += res;
break;
}
}
if (son[x]) dfs2(son[x]);
for (int i = h[x]; i; i = ne[i])
if (to[i] != son[x]) dfs2(to[i]);
}
int main() {
read(n), vec.push_back(ety);
for (int i = 1; i <= n; i++) read(f[i]), f[i] ? add(f[i], i), 0 : rt = i;
dfs1(rt, 0), dfs2(rt);
for (int i = 1; i <= mxd[rt]; i++) {
long long res = 0;
for (auto t : vec[i]) res += t.d, ans[rev[t.id]] += res;
}
for (int i = 1; i <= n; i++) write(ans[i] - dep[i], ' ');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
};
struct triangle {
point a, b, c;
void mp(point i, point j, point k) {
a = i;
b = j;
c = k;
}
void print() {
printf("%.0f %.0f\n", a.x + b.x - c.x, a.y + b.y - c.y);
printf("%.0f %.0f\n", a.x + c.x - b.x, a.y + c.y - b.y);
printf("%.0f %.0f\n", b.x + c.x - a.x, b.y + c.y - a.y);
}
};
point a[5010], MIN, b[5010];
int top;
inline double AXB(point c, point a, point b) {
return (c.x - a.x) * (c.y - b.y) - (c.y - a.y) * (c.x - b.x);
}
inline double dis(point a, point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool cmp(point a, point b) {
double k = AXB(MIN, a, b);
if (k < 0) return 1;
if (k > 0) return 0;
return dis(MIN, a) > dis(MIN, b);
}
void scan(point *a, int n) {
for (int i = 1; i < n; i++) {
if (a[i].y < a[0].y || (a[i].y == a[0].y && a[i].x < a[0].x))
swap(a[i], a[0]);
}
MIN = a[0];
sort(a + 1, a + n, cmp);
top = 0;
b[top++] = a[0];
b[top++] = a[1];
b[top++] = a[2];
for (int i = 3; i < n; i++) {
while (AXB(b[top - 2], b[top - 1], a[i]) > 0 && top >= 2) top--;
b[top++] = a[i];
}
}
void qurry(point *a, int n) {
triangle T, temp;
double ans = 0, Max;
a[n] = a[0];
for (int i = 0; i < n; i++) {
int k = (i + 2) % n;
for (int j = i + 1; j < n; j++) {
temp.mp(b[i], b[j], b[k]);
while (AXB(b[i], b[k + 1], b[j]) > (Max = AXB(b[i], b[k], b[j]))) {
k = (k + 1) % n;
temp.mp(b[i], b[j], b[k]);
}
if (Max > ans) {
T = temp;
ans = Max;
}
}
}
T.print();
}
int main() {
int n, S;
scanf("%d %d", &n, &S);
for (int i = 0; i < n; i++) scanf("%lf %lf", &a[i].x, &a[i].y);
scan(a, n);
qurry(b, top);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i ++)
#define rep1(i, n) for(int i = 1; i <= (int)(n); i ++)
#define MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f;
int n, m, pa[100005], ord[100005], cnt;
vector<int> G[100005], T[100005];
int de[100005];
vector<PII> E;
void dfs(int v, int par)
{
ord[v] = ++ cnt;
pa[v] = par;
rep(i, G[v].size()) {
int u = G[v][i];
if(u == par || ord[u] > ord[v]) continue;
if(pa[u]) {
for(int i = v; i != u; i = pa[i]) de[i] = -1;
} else dfs(u, v);
}
}
int dp[100005][2], cho[100005];
void gen_dp(int v)
{
dp[v][0] = 0; dp[v][1] = INF;
int cnt = 0;
rep(i, T[v].size()) {
int u = T[v][i];
gen_dp(u);
dp[v][1] = min(dp[v][1] + dp[u][0], dp[v][0] + dp[u][1]);
dp[v][0] += dp[u][0];
cnt += !de[u];
}
int ndp1 = dp[v][0] - cnt / 2;
if(pa[v] == -1 || de[v]) {
dp[v][0] = min(ndp1, dp[v][1] - (cnt - 1) / 2);
cho[v] = cnt & 1 ? dp[v][0] == dp[v][1] - (cnt - 1) / 2 : dp[v][0] != ndp1; dp[v][1] = INF;
} else {
dp[v][0] = min(dp[v][0] - (cnt + 1) / 2, dp[v][1] - cnt / 2) + 1;
cho[v] = dp[v][0] == dp[v][1] - cnt / 2 + 1; dp[v][1] = ndp1;
}
}
int mu[100005];
void gen_sol(int v, int tp)
{
if(tp == 1) rep(i, T[v].size()) {
int u = T[v][i];
gen_sol(u, 0);
} else {
rep(i, T[v].size()) {
int u = T[v][i];
if(de[u] == -1) continue;
if(cho[v] && (mu[v] == -1 || dp[mu[v]][1] - dp[mu[v]][0] > dp[u][1] - dp[u][0])) mu[v] = u;
}
rep(i, T[v].size()) {
int u = T[v][i];
if(mu[v] == u) de[u] = 1;
gen_sol(u, mu[v] == u);
}
}
}
int hv[100005];
void gen_sol2(int v)
{
rep(i, T[v].size()) {
int u = T[v][i];
gen_sol2(u);
if(hv[u] == -1) continue;
if(hv[v] == -1) hv[v] = hv[u];
else {
E.push_back(MP(hv[u], hv[v])); hv[v] = -1;
}
}
if(hv[v] == -1 && !de[v]) hv[v] = v;
else if(hv[v] != -1 && de[v]) {
E.push_back(MP(pa[hv[v]] == v ? pa[v] : v, hv[v]));
hv[v] = -1;
}
}
bool solve()
{
scanf("%d%d", &n, &m);
if(n == 0) return false;
rep1(i, n) {
G[i].clear(); T[i].clear(); hv[i] = -1; mu[i] = -1;
pa[i] = 0; ord[i] = 0; de[i] = 0;
}
rep(i, m) {
int s, x, y;
scanf("%d%d", &s, &x);
rep(j, s - 1) {
scanf("%d", &y);
G[x].push_back(y); G[y].push_back(x);
x = y;
}
}
cnt = 0; dfs(1, -1);
for(int i = 2; i <= n; i ++) T[pa[i]].push_back(i);
gen_dp(1);
de[1] = -1;
gen_sol(1, 0);
E.clear();
gen_sol2(1);
printf("%d\n", dp[1][0]);
rep(i, dp[1][0]) printf("%d %d\n", E[i].first, E[i].second);
return true;
}
int main()
{
while(solve());
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], b[n], c[n], d[n], max = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
while (1) {
max++;
int ctr = 0;
for (int i = 0; i < n; i++) {
if (a[i] * max < b[i]) continue;
ctr += a[i] * max - b[i];
}
if (ctr > k) break;
}
cout << max - 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
while (n--) {
char a[102], b[102], c[102];
scanf("%s%s%s", a, b, c);
int fl = 0;
for (int i = 0; i < strlen(a); i++) {
if (a[i] != c[i] && b[i] != c[i]) fl = 1;
}
if (!(fl))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, t, suml, sumr, d[100000], dl[100000], dr[100000], a[100000], b[100000],
ans = 0;
int main() {
cin >> n >> t;
if (t < 200) {
for (int i = 0; i < n * t; i++)
if (i >= n)
a[i] = a[i - n];
else
cin >> a[i];
for (int i = 0; i < n * t; i++)
for (int j = 0; j < i; j++)
if (a[i] >= a[j]) d[i] = max(d[i], d[j] + 1);
for (int i = 0; i < n * t; i++) ans = max(ans, d[i]);
cout << ans + 1;
} else {
for (int i = 0; i < n * 100; i++)
if (i >= n)
a[i] = a[i - n];
else {
cin >> a[i];
b[a[i]]++;
}
for (int i = 0; i < n * 100; i++)
for (int j = 0; j < i; j++)
if (a[i] >= a[j]) dl[i] = max(dl[i], dl[j] + 1);
for (int i = n * 100 - 1; i >= 0; i--)
for (int j = i + 1; j < n * 100; j++)
if (a[i] <= a[j]) dr[i] = max(dr[i], dr[j] + 1);
for (int i = 0; i < n; i++) {
suml = 0;
for (int j = 0; j <= n * 100; j++)
if (a[j] <= a[i]) suml = max(suml, dl[j] + 1);
sumr = 0;
for (int j = 0; j <= n * 100; j++)
if (a[j] >= a[i]) sumr = max(sumr, dr[j] + 1);
ans = max(ans, suml + sumr + (b[a[i]] * (t - 200)));
}
cout << ans;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[10001], n;
cin >> n;
if (n < 4) {
cout << 1 << endl;
return 0;
}
a[1] = 1;
for (int i = 2; i <= n; i++) {
a[i] = i + a[i - 1];
}
int sum = 0;
for (int i = 1; i < n; i++) {
sum += a[i];
if (sum == n) {
cout << i << endl;
break;
}
if (sum > n) {
cout << i - 1 << endl;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int sum = 0;
while (b >= 1 && c >= 2) {
b -= 1;
c -= 2;
sum += 3;
}
while (a >= 1 && b >= 2) {
a -= 1;
b -= 2;
sum += 3;
}
std::cout << sum << std::endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int findCab(string str) {
char t = str[0];
for (long long int i = 0; i < str.length(); i++) {
if (str[i] == '-') continue;
if (str[i] != t) return 0;
}
return 1;
}
long long int findPizze(string str) {
long long int j = 0;
for (long long int i = 0; i < str.length(); i++) {
j = i + 1;
if (str[i] == '-') continue;
if (str[i + 1] == '-') {
j++;
}
if (j < str.length() and (str[i] - '0') <= (str[j] - '0')) return 0;
}
return 1;
}
long long int findGirl(string str) {
if (!findCab(str) and !findPizze(str))
return 1;
else
return 0;
}
void alpha() {
long long int n;
cin >> n;
pair<long long int, string> phonebook[n];
vector<vector<string>> vec;
vector<string> phoneno;
string str;
for (long long int i = 0; i < n; i++) {
cin >> phonebook[i].first;
cin >> phonebook[i].second;
for (long long int j = 0; j < phonebook[i].first; j++) {
cin >> str;
phoneno.push_back(str);
}
vec.push_back(phoneno);
phoneno.clear();
}
pair<pair<long long int, long long int>, string> taxi[n];
pair<pair<long long int, long long int>, string> pizza[n];
pair<pair<long long int, long long int>, string> girl[n];
for (long long int i = 0; i < n; i++) {
taxi[i].first.first = 0;
pizza[i].first.first = 0;
girl[i].first.first = 0;
}
for (long long int i = 0; i < n; i++) {
taxi[i].second = phonebook[i].second;
taxi[i].first.second = i;
pizza[i].second = phonebook[i].second;
pizza[i].first.second = i;
girl[i].second = phonebook[i].second;
girl[i].first.second = i;
for (long long int j = 0; j < phonebook[i].first; j++) {
taxi[i].first.first += findCab(vec[i][j]);
pizza[i].first.first += findPizze(vec[i][j]);
girl[i].first.first += findGirl(vec[i][j]);
}
}
sort(taxi, taxi + n,
greater<pair<pair<long long int, long long int>, string>>());
sort(pizza, pizza + n,
greater<pair<pair<long long int, long long int>, string>>());
sort(girl, girl + n,
greater<pair<pair<long long int, long long int>, string>>());
long long int i = 0;
cout << "If you want to call a taxi, you should call: ";
while (i < n - 1 and taxi[i].first.first == taxi[i + 1].first.first) {
i++;
}
while (i > 0) {
cout << taxi[i].second << ", ";
i--;
}
cout << taxi[i].second;
cout << "." << '\n';
i = 0;
cout << "If you want to order a pizza, you should call: ";
while (i < n - 1 and pizza[i].first.first == pizza[i + 1].first.first) {
i++;
}
while (i > 0) {
cout << pizza[i].second << ", ";
i--;
}
cout << pizza[i].second;
cout << "." << '\n';
i = 0;
cout
<< "If you want to go to a cafe with a wonderful girl, you should call: ";
while (i < n - 1 and girl[i].first.first == girl[i + 1].first.first) {
i++;
}
while (i > 0) {
cout << girl[i].second << ", ";
i--;
}
cout << girl[i].second;
cout << "." << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) alpha();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100010;
long long n, arr[N], extra[N];
long long power_mod(long long x, long long y) {
x %= 1000000007;
long long res = 1;
while (y) {
if (y & 1) {
res = (res * x) % 1000000007;
}
y /= 2;
x = (x * x) % 1000000007;
}
return res;
}
void solve() {
long long n, cnt = 1;
string s;
cin >> n >> s;
vector<long long> v, v1;
for (long long i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
cnt++;
} else {
v.push_back(cnt);
cnt = 1;
}
}
v.push_back(cnt);
long long sz = v.size(), ans = sz;
long long p = 0;
cnt = 0;
for (long long i = 0; i < sz; i++) {
if (v[i] > 1) {
p = 1;
cnt++;
if (cnt == 2) {
p = 2;
break;
}
}
if (v[i] > 2) {
p = 2;
break;
}
}
cout << ans + p << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
inline T sqr(T x) {
return x * x;
}
#pragma comment(linker, "/STACK:64000000")
using namespace std;
using namespace std;
bool comparer(pair<int, int> l, pair<int, int> r) {
if (l.first == r.first) return l.second > r.second;
return l.first < r.first;
}
int main() {
int n;
cin >> n;
pair<int, int> a[1 << 17];
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
a[i] = make_pair(x, y);
}
sort(a, a + n, comparer);
int ans = 0;
int cur = 0;
for (int i = 1; i < n; ++i) {
if (a[cur].first <= a[i].first && a[cur].second >= a[i].second)
ans++;
else
cur = i;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int sum = a[0] + 1;
for (int i = 1; i < n; i++) {
sum++;
if (a[i - 1] <= a[i]) {
sum += (a[i] - a[i - 1]) + 1;
} else {
sum += (a[i - 1] - a[i]) + 1;
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
while (cin >> a >> b) {
string s;
cin >> s;
int len = s.size();
pair<int, int> vis[105];
vis[0] = make_pair(0, 0);
int x = 0;
int y = 0;
if (a == 0 && b == 0) {
cout << "Yes" << endl;
continue;
}
for (int i = 0; i < len; i++) {
if (s[i] == 'L')
x--;
else if (s[i] == 'R')
x++;
else if (s[i] == 'D')
y--;
else
y++;
if (a == x && b == y) {
cout << "Yes" << endl;
return 0;
}
vis[i + 1] = make_pair(x, y);
}
int dx = vis[len].first;
int dy = vis[len].second;
if (dx == 0 && dy == 0) {
cout << "No" << endl;
continue;
}
for (int i = 0; i <= len; i++) {
int temp = a - vis[i].first;
int tp = b - vis[i].second;
if (dx == 0) {
if (tp % dy == 0 && tp / dy > 0 && temp == 0) {
cout << "Yes" << endl;
return 0;
}
} else if (dy == 0) {
if (temp % dx == 0 && temp / dx > 0 && tp == 0) {
cout << "Yes" << endl;
return 0;
}
} else if (temp % dx == 0 && temp / dx > 0 && tp % dy == 0 &&
tp / dy == temp / dx) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
}
| 4 |
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
const int mod=1e9+7;
//The end result of coders personal growth is,there codes becomes there documentation
void solve()
{
ll N,K;cin>>N>>K;
ll s=0;
ll A[N];for(ll i=0;i<N;++i)cin>>A[i],s+=A[i];
if(s==K)
{
cout<<"NO\n";return;
}
sort(A,A+N,greater<ll>());
vector<ll> ans;
s=0;
for(ll i=0;i<N;++i)
{
if((s+A[i])!=K)
{
s+=A[i];ans.push_back(A[i]);
}
else
{
ans.push_back(A[i+1]);
ans.push_back(A[i]);
s+=A[i];s+=A[i+1];
++i;
}
}
cout<<"YES\n";
for(auto i:ans)cout<<i<<' ';cout<<'\n';
}
int main(void)
{
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
int T=1; cin>>T;
while(T--){solve();}exit(0);
}/*Solved By:- Ritik Agarwal*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n, m;
scanf("%d %d", &n, &m);
char matrix[n + 1][m + 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> matrix[i][j];
int dist[n + 1][m + 1];
for (int j = m; j >= 1; j--)
for (int i = 1; i <= n; i++)
if (matrix[i][j] == '0' && j == m)
dist[i][j] = j;
else if (matrix[i][j] == '0')
dist[i][j] = max(j, dist[i][j + 1]);
else
dist[i][j] = j - 1;
int ans = -1;
int far;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
far = INF;
for (int k = i; k <= n && matrix[k][j] == '0'; k++) {
far = min(far, dist[k][j]);
ans = max(ans, 2 * (k - i + 1 + far - j + 1));
}
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, k, p, a[1005], b[2005], d[1005][2005];
bool used[2005];
vector<pair<int, int> > g[3005];
bool check(int x) {
for (int i = 0, j = 0; i < k; i++) {
if (abs(a[j] - b[i]) + abs(p - b[i]) <= x) j++;
if (j == n) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> p;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < k; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + k);
int lb = -1, ub = 2 * 1000000007;
while (ub - lb > 1) {
int mid = (lb + 1ll * ub) >> 1;
if (check(mid))
ub = mid;
else
lb = mid;
}
cout << ub << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << min((m + n) / 3, min(m, n));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
char c;
while ((c = getchar()) < '0' || c > '9')
;
return c - '0';
}
string s;
vector<long long> v;
long long eval(long long p1, long long p2, string s) {
int i;
stack<char> st;
stack<long long> st1;
for (i = p1; i <= p2; i++) {
long long j = 0, fl = 0;
;
while (i < s.size() && s[i] >= '0' && s[i] <= '9') {
j = j * 10 + s[i] - '0';
fl = 1;
i++;
}
if (fl) {
st1.push(j);
i--;
continue;
}
if (s[i] == '+') {
while (!st.empty()) {
long long t1 = st1.top();
st1.pop();
long long t2 = st1.top();
st1.pop();
if (st.top() == '*') {
st1.push(t1 * t2);
} else {
st1.push(t1 + t2);
}
st.pop();
}
st.push(s[i]);
} else if (s[i] == '*') {
while (!st.empty() && st.top() == '*') {
long long t1 = st1.top();
st1.pop();
long long t2 = st1.top();
st1.pop();
st1.push(t1 * t2);
st.pop();
}
st.push(s[i]);
}
}
while (!st.empty()) {
long long t1 = st1.top();
st1.pop();
long long t2 = st1.top();
st1.pop();
if (st.top() == '*') {
st1.push(t1 * t2);
} else {
st1.push(t1 + t2);
}
st.pop();
}
return st1.top();
}
long long fun(int p1, int p2) {
long long k2 = eval(p1 + 1, p2 - 1, s);
string temp = "";
for (int i = 0; i <= p1; i++) {
temp += s[i];
}
stack<int> st1;
while (k2 > 0) {
st1.push(k2 % 10);
k2 /= 10;
}
while (!st1.empty()) {
temp += (char)(st1.top() + '0');
st1.pop();
}
for (int i = p2; i < s.size(); i++) {
temp += s[i];
}
long long k1 = eval(0, temp.size(), temp);
return k1;
}
int main() {
ios_base::sync_with_stdio(false);
long long i, n, ans, j;
cin >> s;
s = "1*" + s + "*1";
for (i = 0; i < s.size(); i++) {
if (s[i] == '*') v.push_back(i);
}
ans = 0;
for (i = 0; i < v.size(); i++) {
for (j = i + 1; j < v.size(); j++) {
long long t1 = fun(v[i], v[j]);
ans = max(ans, t1);
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
int enlarge(int n) {
int res = 1;
while (res < n) {
res <<= 1;
}
return res;
}
class segment_tree {
int n;
std::vector<int> a, b;
std::vector<bool> s;
void modify_a(int u, int l, int r, int x, int v) {
if (l + 1 == r) {
a[u] = v;
s[u] = b[u] >= a[u];
return;
}
int mid = (l + r + 1) >> 1;
if (x < mid) {
modify_a(u << 1, l, mid, x, v);
} else {
modify_a(u << 1 | 1, mid, r, x, v);
}
a[u] = std::max(a[u << 1], a[u << 1 | 1]);
s[u] = s[u << 1] && s[u << 1 | 1] && b[u << 1] >= a[u << 1 | 1];
}
void modify_b(int u, int l, int r, int x, int v) {
if (l + 1 == r) {
b[u] = v;
s[u] = b[u] >= a[u];
return;
}
int mid = (l + r + 1) >> 1;
if (x < mid) {
modify_b(u << 1, l, mid, x, v);
} else {
modify_b(u << 1 | 1, mid, r, x, v);
}
b[u] = std::min(b[u << 1], b[u << 1 | 1]);
s[u] = s[u << 1] && s[u << 1 | 1] && b[u << 1] >= a[u << 1 | 1];
}
public:
segment_tree(int _n)
: n(_n),
a(enlarge(n) << 1),
b(enlarge(n) << 1),
s(enlarge(n) << 1, true) {}
void modify_a(int x, int v) { modify_a(1, 0, n, x, v); }
void modify_b(int x, int v) { modify_b(1, 0, n, x, v); }
bool get_ans() { return s[1]; }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, m, q;
std::cin >> n >> m >> q;
std::vector<std::set<int>> Sl(n), Sr(n);
segment_tree T(n);
for (int i = 0; i < n; ++i) {
Sl[i].insert(0);
Sr[i].insert(m);
T.modify_b(i, m);
}
while (q--) {
int x, y;
std::cin >> x >> y;
--x, --y;
bool op = x & 1;
x /= 2, y /= 2;
y += op;
if (op) {
if (Sl[x].count(y)) {
Sl[x].erase(y);
} else {
Sl[x].insert(y);
}
T.modify_a(x, *Sl[x].rbegin());
} else {
if (Sr[x].count(y)) {
Sr[x].erase(y);
} else {
Sr[x].insert(y);
}
T.modify_b(x, *Sr[x].begin());
}
std::cout << (T.get_ans() ? "YES\n" : "NO\n");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 201000;
int l[N], r[N], deg[N], val[N], rr[N], tot, q, ty[N], n, p[N];
vector<int> e[N];
void dfs(int u) {
l[u] = ++tot;
for (auto v : e[u]) {
dfs(v);
}
r[u] = tot;
}
struct node {
long long fg, dg, sm;
} nd[N * 4];
void setc(int p, long long c) {
nd[p].fg = nd[p].fg * c % mod;
nd[p].sm = nd[p].sm * c % mod;
nd[p].dg = nd[p].dg * c % mod;
}
void push(int p) {
if (nd[p].fg != 1) {
setc(p + p, nd[p].fg);
setc(p + p + 1, nd[p].fg);
nd[p].fg = 1;
}
}
void mul(int p, int l, int r, int tl, int tr, long long c) {
if (l == tl && r == tr) {
setc(p, c);
} else {
push(p);
int md = (l + r) >> 1;
if (tr <= md)
mul(p + p, l, md, tl, tr, c);
else if (tl > md)
mul(p + p + 1, md + 1, r, tl, tr, c);
else
mul(p + p, l, md, tl, md, c), mul(p + p + 1, md + 1, r, md + 1, tr, c);
nd[p].dg = (nd[p + p].dg + nd[p + p + 1].dg) % mod;
nd[p].sm = (nd[p + p].sm + nd[p + p + 1].sm) % mod;
}
}
void add(int p, int l, int r, int x, long long c, long long v) {
if (l == r) {
assert(nd[p].dg == 0);
nd[p].dg = (nd[p].dg + c) % mod;
nd[p].sm = (nd[p].sm + c * v) % mod;
} else {
push(p);
int md = (l + r) >> 1;
if (x <= md)
add(p + p, l, md, x, c, v);
else if (x > md)
add(p + p + 1, md + 1, r, x, c, v);
nd[p].dg = (nd[p + p].dg + nd[p + p + 1].dg) % mod;
nd[p].sm = (nd[p + p].sm + nd[p + p + 1].sm) % mod;
}
}
long long queryd(int p, int l, int r, int x) {
if (l == r) {
return nd[p].dg;
} else {
push(p);
int md = (l + r) >> 1;
if (x <= md)
return queryd(p + p, l, md, x);
else
return queryd(p + p + 1, md + 1, r, x);
}
}
long long query(int p, int l, int r, int tl, int tr) {
if (l == tl && r == tr) {
return nd[p].sm;
} else {
push(p);
int md = (l + r) >> 1;
if (tr <= md)
return query(p + p, l, md, tl, tr);
else if (tl > md)
return query(p + p + 1, md + 1, r, tl, tr);
else
return (query(p + p, l, md, tl, md) +
query(p + p + 1, md + 1, r, md + 1, tr)) %
mod;
}
}
int main() {
scanf("%d", val + 1);
scanf("%d", &q);
n = 1;
for (int i = 0; i < q; i++) {
scanf("%d", ty + i);
if (ty[i] == 1) {
n++;
rr[i] = n;
scanf("%d%d", p + n, val + n);
e[p[n]].push_back(n);
} else {
scanf("%d", rr + i);
}
}
dfs(1);
for (int i = 1; i < n + 1; i++) deg[i] = 1;
add(1, 1, n, 1, 1, val[1]);
for (int i = 0; i < q; i++) {
if (ty[i] == 1) {
int u = p[rr[i]], v = rr[i];
mul(1, 1, n, l[u], r[u], 1 + powmod(deg[u], mod - 2));
deg[u]++;
long long pd = queryd(1, 1, n, l[u]);
add(1, 1, n, l[v], pd, val[v]);
} else {
int u = p[rr[i]], v = rr[i];
long long ret = query(1, 1, n, l[v], r[v]);
if (u) ret = ret * powmod(queryd(1, 1, n, l[u]), mod - 2) % mod;
printf("%lld\n", ret);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long w1, w2, h1, h2;
std::cin >> w1 >> h1 >> w2 >> h2;
long long totalRec = 2 * (h1 + h2 + 2) + w2 + w1 + (w1 - w2);
std::cout << totalRec << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
long long x, k;
cin >> x >> k;
if (x == 0)
cout << 0;
else {
long long temp = power(2, k, 1000000007);
long long ans = (temp % 1000000007 *
(2 * (x % 1000000007) - 1 + 1000000007) % 1000000007) %
1000000007;
ans = (ans + 1) % 1000000007;
cout << ans;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 7 + 1e9;
long long Power(long long x, long long t) {
long long ans = 1;
while (t > 0) {
if (t & 1) ans = ans * x % mod;
x = x * x % mod;
t >>= 1;
}
return ans;
}
struct real_number {
long long x, y;
real_number(long long _x = 0, long long _y = 0) {
x = _x;
y = _y;
}
real_number operator+(real_number t) {
return real_number((x + t.x) % mod, (y + t.y) % mod);
}
real_number operator-(real_number t) {
return real_number((x - t.x + mod) % mod, (y - t.y + mod) % mod);
}
real_number operator*(real_number t) {
return real_number((1ll * x * t.x + 1ll * y * t.y * 5) % mod,
(1ll * x * t.y + 1ll * y * t.x) % mod);
}
real_number operator*(long long t) {
return real_number((1ll * x * t) % mod, (1ll * y * t) % mod);
}
bool operator!=(real_number t) { return x != t.x || y != t.y; }
real_number inv() {
long long t = (1ll * x * x % mod - 5ll * y * y % mod + mod) % mod;
t = Power(t, mod - 2);
return real_number(x * t % mod, (-y * t % mod + mod) % mod);
}
void operator=(long long t) {
x = t;
y = 0;
}
real_number operator^(long long t) {
real_number ret(1, 0), b = (*this);
while (t > 0) {
if (t & 1) ret = ret * b;
b = b * b;
t >>= 1;
}
return ret;
}
void out() { cout << x << "," << y << endl; }
};
long long stirling[205][205];
long long fact[205], inv[205];
real_number alpha, theta, pow_alpha[205], pow_theta[205];
long long nCr(long long n, long long r) {
if (n < r) return 0;
return (((fact[n] * inv[r]) % mod) * inv[n - r]) % mod;
}
long long sign(long long n) { return n & 1 ? mod - 1 : 1; }
real_number summation(real_number x, long long l, long long r) {
if (x.x == 1 && x.y == 0) return (r - l + 1) % mod;
real_number ans = ((x ^ l) - (x ^ (r + 1))) * (real_number(1, 0) - x).inv();
return ans;
}
long long solve(long long k, long long l, long long r) {
real_number ans;
real_number out_increase = 1, five_inDom = real_number(0, Power(5, mod - 2));
for (long long i = 1; i <= k; i++) {
out_increase = out_increase * five_inDom;
real_number inside_sum;
for (long long j = 0; j <= i; j++) {
inside_sum =
inside_sum + summation(pow_alpha[j] * pow_theta[i - j], l, r) *
nCr(i, j) * sign(i - j);
}
inside_sum = inside_sum * out_increase;
inside_sum = inside_sum * stirling[k][i];
ans = ans + inside_sum;
}
return ans.x;
}
int main() {
long long k, l, r;
scanf("%lld%lld%lld", &k, &l, &r);
fact[0] = 1;
inv[0] = 1;
stirling[0][0] = 1;
alpha = real_number(1, 1) * Power(2, mod - 2);
theta = real_number(1, 0) - alpha;
pow_alpha[0] = 1;
pow_theta[0] = 1;
for (int i = 1; i <= 200; i++) {
fact[i] = (i * fact[i - 1]) % mod;
inv[i] = Power(fact[i], mod - 2);
stirling[i][0] = 0;
stirling[0][i] = 0;
pow_alpha[i] = pow_alpha[i - 1] * alpha;
pow_theta[i] = pow_theta[i - 1] * theta;
for (int j = 1; j <= i; j++) {
stirling[i][j] =
((-(i - 1) * stirling[i - 1][j]) % mod + stirling[i - 1][j - 1]) %
mod;
}
}
l += 2;
r += 2;
printf("%lld\n", ((solve(k, l, r) % mod * inv[k]) % mod + mod) % mod);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6;
int n, m;
int L[N][2], R[N][2];
struct node {
int a, b, l, r;
friend bool operator<(node p1, node p2) { return p1.l > p2.l; }
};
priority_queue<node> q;
vector<node> a[N][2] = {};
int read(void) {
int s = 0, w = 0;
char c = getchar();
while (c < '0' || c > '9') w |= c == '-', c = getchar();
while (c >= '0' && c <= '9') s = s * 10 + c - 48, c = getchar();
return w ? -s : s;
}
int main(void) {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int a = read(), b = read();
int l = read(), r = read() - 1;
int t = (l ^ r) & 1;
q.push(node{a, b, l, r - t});
q.push(node{b, a, l, r - t});
t = t ^ 1;
q.push(node{a, b, l + 1, r - t});
q.push(node{b, a, l + 1, r - t});
}
memset(R, -1, sizeof R);
memset(L, 30, sizeof L);
L[1][0] = R[1][0] = 0;
while (q.size()) {
node now = q.top();
q.pop();
int x = now.a, y = now.b;
int l = now.l, r = now.r;
if (l > r)
continue;
else if (R[x][l % 2] < l)
a[x][l % 2].push_back(now);
else if (y == n)
return cout << l + 1, 0;
else {
l = max(L[x][l % 2], l) + 1, r++;
L[y][l % 2] = min(L[y][l % 2], l);
R[y][l % 2] = max(R[y][l % 2], r);
for (int i = 0; i < a[y][l % 2].size(); ++i)
a[y][l % 2][i].l = l, q.push(a[y][l % 2][i]);
a[y][l % 2].clear();
}
}
cout << (n == 1 ? 0 : -1) << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void calcPrefixFunction(const string& s, vector<int>& pi) {
int size = s.length();
const char* data = s.c_str();
pi.resize(size, 0);
for (int i = 1; i < size; i++) {
int j = pi[i - 1];
while (j > 0 && data[j] != data[i]) {
j = pi[j - 1];
}
if (data[j] == data[i]) {
pi[i] = j + 1;
}
if (j == 0) {
if (data[i] == data[0]) {
pi[i] = 1;
} else {
pi[i] = 0;
}
}
}
}
void findSubstrings(const string& str, const string& sub,
vector<int>& entries) {
string large = sub + string("#") + str;
int size_sub = sub.size();
int size_str = str.size();
int size = size_sub + size_str + 1;
vector<int> pi;
calcPrefixFunction(large, pi);
entries.clear();
for (int i = 0; i < size_str; i++) {
if (pi[i + size_sub + 1] == size_sub) {
entries.push_back(i - size_sub + 1);
}
}
}
void testSs() {
string a, b;
cin >> a >> b;
vector<int> subs;
findSubstrings(a, b, subs);
int size = subs.size();
for (int i = 0; i < size; i++) {
cout << subs[i] << " ";
}
}
struct segment {
int begin;
int end;
segment(int begin, int end) : begin(begin), end(end) {}
bool operator<(const segment& other) const { return end < other.end; }
};
int main() {
string large;
cin >> large;
vector<segment> entries;
int n;
cin >> n;
vector<int> temp;
for (int i = 0; i < n; i++) {
string bad;
cin >> bad;
int bad_size = bad.size();
findSubstrings(large, bad, temp);
int size = temp.size();
for (int i = 0; i < size; i++) {
entries.push_back(segment(temp[i], temp[i] + bad_size));
}
}
entries.push_back(segment(-1, large.size() + 1));
sort(entries.begin(), entries.end());
int size = entries.size();
int result_size = 0;
int result_pos = 0;
int begin = -1;
for (int i = 0; i < size; i++) {
int new_size = entries[i].end - begin - 2;
if (new_size > result_size) {
result_size = new_size;
result_pos = begin + 1;
}
if (entries[i].begin > begin) {
begin = entries[i].begin;
}
}
cout << result_size << " " << result_pos << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, x, a;
int main() {
cin >> t;
while (t--) {
cin >> n;
cout << "1 " << n - 1 << " 1 ";
for (int i = 2; i <= n; i++) cout << i << " ";
cout << endl;
cin >> x;
int l = 2, r = n, mid, maxx;
while (l <= r) {
mid = (l + r) / 2;
cout << "1 " << mid - l + 1 << " 1 ";
for (int i = l; i <= mid; i++) cout << i << " ";
cout << endl;
cin >> a;
if (a == x)
r = mid - 1;
else
l = mid + 1;
}
if (l > r) mid = r + 1;
cout << "1 " << n - 1 << " " << mid << " ";
for (int i = 1; i <= n; i++)
if (i != mid) cout << i << " ";
cout << endl;
cin >> x;
cout << "-1 " << x << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, ar[1000005], sum, t, mark[15], r, a;
long long int check(long long int x) {
long long int y = 0, z = 0;
for (long long int i = 1; i <= n; i++)
if (ar[i] < x)
y += x - ar[i];
else
z += ar[i] - x;
long long int top = 0;
if (m < a + r) {
long long int mn = min(y, z);
top += mn * m;
y -= mn;
z -= mn;
}
return top + y * a + z * r;
}
long long int bs() {
long long int l = 0, r = 1e9;
while (l < r) {
if (l == r - 1) {
if (check(l) < check(r))
return l;
else
return r;
}
long long int mid = (l + r) / 2;
if (check(mid) < check(mid + 1))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> a >> r >> m;
for (long long int i = 1; i <= n; i++) cin >> ar[i];
sort(ar + 1, ar + n + 1);
long long int x = bs();
cout << check(bs());
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
long long int results[q];
for (int j = 0; j < q; j++) {
long long int leftSway = 0, leftMax = 0, rightMax = 0, upSway = 0,
upMax = 0, downMax = 0;
string s;
cin >> s;
int a = INT_MAX, b = INT_MAX;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A') leftSway++;
if (s[i] == 'D') leftSway--;
leftMax = max(leftMax, leftSway);
rightMax = min(rightMax, leftSway);
if (s[i] == 'W') upSway++;
if (s[i] == 'S') upSway--;
upMax = max(upMax, upSway);
downMax = min(downMax, upSway);
}
results[j] = (leftMax - rightMax + 1) * (upMax - downMax + 1);
if (leftMax - rightMax + 1 >= 3) {
int firstMin = -1, lastMin = -1, firstMax = -1, lastMax = -1;
int l = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A') l++;
if (s[i] == 'D') l--;
if (firstMin == -1 && rightMax == l) {
firstMin = i;
}
if (rightMax == l) {
lastMin = i;
}
if (firstMax == -1 && leftMax == l) {
firstMax = i;
}
if (leftMax == l) {
lastMax = i;
}
}
if (firstMax > lastMin && leftMax != 0) {
results[j] = (leftMax - rightMax) * (upMax - downMax + 1);
}
if (lastMax < firstMin && rightMax != 0) {
results[j] = (leftMax - rightMax) * (upMax - downMax + 1);
}
}
if (upMax - downMax + 1 >= 3) {
int firstMin = -1, lastMin = -1, firstMax = -1, lastMax = -1;
int l = 0, u = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'W') u++;
if (s[i] == 'S') u--;
if (firstMin == -1 && downMax == u) {
firstMin = i;
}
if (downMax == u) {
lastMin = i;
}
if (firstMax == -1 && upMax == u) {
firstMax = i;
}
if (upMax == u) {
lastMax = i;
}
}
if (firstMax > lastMin && upMax != 0) {
results[j] =
min(results[j], (leftMax - rightMax + 1) * (upMax - downMax));
}
if (lastMax < firstMin && downMax != 0) {
results[j] =
min(results[j], (leftMax - rightMax + 1) * (upMax - downMax));
}
}
}
for (int i = 0; i < q; i++) cout << results[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
void run() {
long long n, b;
cin >> n >> b;
vector<pair<long long, int>> v;
for (int i = 2; 1ll * i * i <= b; i++) {
if (b % i == 0) {
int cnt = 0;
while (b % i == 0) {
++cnt;
b /= i;
}
v.push_back(make_pair(i, cnt));
}
}
if (b > 1) v.push_back(make_pair(b, 1));
long long ans = 2e18;
for (auto& it : v) {
long long x = n;
long long cnt = 0;
while (x) {
cnt += x / it.first;
x /= it.first;
}
ans = min(ans, cnt / it.second);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-8;
const long double PI = 3.1415926535897932384626433832795;
const long double E = 2.7182818284;
const int INF = 1000000000;
int t[16][16];
long long res = 0;
long long m = 1000000007;
long long fact = 1;
int n;
int f[16];
int vz[16];
void pereb(int j) {
if (j == n) {
res++;
res %= m;
return;
}
for (int i = 0; i < n; i++) {
if (f[i] || vz[t[i][j] - 1]) continue;
f[i] = 1;
vz[t[i][j] - 1] = 1;
pereb(j + 1);
f[i] = 0;
vz[t[i][j] - 1] = 0;
}
}
int main(void) {
cin >> n;
if (n == 1) {
cout << '1';
return 0;
}
if (n % 2 == 0) {
cout << "0";
return 0;
}
if (n == 13) {
cout << "695720788";
return 0;
}
if (n == 15) {
cout << "150347555";
return 0;
}
long long fact = 1;
for (int i = 2; i <= n; i++) {
fact *= 1LL * i;
fact %= m;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
t[i][j] = (i + j) % n + 1;
}
}
pereb(0);
res *= 1LL * fact;
res %= m;
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char ar[120];
int main() {
int a, b;
scanf("%d %d", &a, &b);
scanf(" %s", ar + 1);
if (a / 2 < b) {
for (int i = b; i < a; i++) printf("RIGHT\n");
for (int i = a; i > 0; i--) {
printf("PRINT %c\n", ar[i]);
if (i == 1) break;
printf("LEFT\n");
}
} else {
for (int i = b; i > 1; i--) printf("LEFT\n");
for (int i = 1; i <= a; i++) {
printf("PRINT %c\n", ar[i]);
if (i == a) break;
printf("RIGHT\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 11111;
double Area, Length;
double P_x_min, P_x_max;
double P_y_min, P_y_max;
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) : x(_x), y(_y) {}
} p[N];
Point MakeVector(Point &P, Point &Q) { return Point(Q.x - P.x, Q.y - P.y); }
double CrossProduct(Point P, Point Q) { return P.x * Q.y - P.y * Q.x; }
double MultiCross(Point P, Point Q, Point R) {
return CrossProduct(MakeVector(Q, P), MakeVector(Q, R));
}
struct halfPlane {
Point s, t;
double angle;
halfPlane() {}
halfPlane(Point _s, Point _t) : s(_s), t(_t) {}
halfPlane(double sx, double sy, double tx, double ty)
: s(sx, sy), t(tx, ty) {}
void GetAngle() { angle = atan2(t.y - s.y, t.x - s.x); }
} hp[N], q[N];
Point IntersectPoint(halfPlane P, halfPlane Q) {
double a1 = CrossProduct(MakeVector(P.s, Q.t), MakeVector(P.s, Q.s));
double a2 = CrossProduct(MakeVector(P.t, Q.s), MakeVector(P.t, Q.t));
return Point((P.s.x * a2 + P.t.x * a1) / (a2 + a1),
(P.s.y * a2 + P.t.y * a1) / (a2 + a1));
}
bool cmp(halfPlane P, halfPlane Q) {
if (fabs(P.angle - Q.angle) < 1e-8) return MultiCross(P.s, P.t, Q.s) > 0;
return P.angle < Q.angle;
}
bool IsParallel(halfPlane P, halfPlane Q) {
return fabs(CrossProduct(MakeVector(P.s, P.t), MakeVector(Q.s, Q.t))) < 1e-8;
}
void HalfPlaneIntersect(int n, int &m) {
sort(hp, hp + n, cmp);
int i, l = 0, r = 1;
for (m = i = 1; i < n; ++i)
if (hp[i].angle - hp[i - 1].angle > 1e-8) hp[m++] = hp[i];
n = m;
m = 0;
q[0] = hp[0], q[1] = hp[1];
for (i = 2; i < n; ++i) {
if (IsParallel(q[r], q[r - 1]) || IsParallel(q[l], q[l + 1])) return;
while (l < r &&
MultiCross(hp[i].s, hp[i].t, IntersectPoint(q[r], q[r - 1])) > 0)
--r;
while (l < r &&
MultiCross(hp[i].s, hp[i].t, IntersectPoint(q[l], q[l + 1])) > 0)
++l;
q[++r] = hp[i];
}
while (l < r &&
MultiCross(q[l].s, q[l].t, IntersectPoint(q[r], q[r - 1])) > 0)
--r;
while (l < r &&
MultiCross(q[r].s, q[r].t, IntersectPoint(q[l], q[l + 1])) > 0)
++l;
q[++r] = q[l];
for (i = l; i < r; ++i) p[m++] = IntersectPoint(q[i], q[i + 1]);
}
void Solve(Point *p, int n, int &m) {
int i, j;
Point a, b;
p[n] = p[0];
for (i = 0; i < n; i++) {
hp[i] = halfPlane(p[(i + 1) % n], p[i]);
hp[i].GetAngle();
}
a = p[0], b = p[1];
HalfPlaneIntersect(n, m);
Area = 0;
Length = 0;
P_x_min = P_x_max = 0;
P_y_min = P_y_max = 0;
if (m > 2) {
if (a.x > b.x) swap(a, b);
int f2 = 0, f1 = 0;
for (int i = 0; i < m; i++) {
if (p[i].y == a.y && p[(i + 1) % m].y == a.y) {
f2 = 1;
a = p[i];
b = p[(i + 1) % m];
break;
} else if (p[i].y == a.y)
f1 = 1;
}
if (f1 && !f2)
Length = 1;
else if (f2) {
if (a.x > b.x) swap(a, b);
Length = (int)(b.x - a.x) + 1;
}
}
if (m > 2) {
p[m] = p[0];
for (i = 0; i < m; ++i) Area += CrossProduct(p[i], p[i + 1]);
if (Area < 0) Area = -Area;
}
Area /= 2.0;
}
int main() {
int n, m, t = 1;
Point a, b;
while (cin >> n) {
if (n == 0) break;
for (int i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
Solve(p, n, m);
cout << Length << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 0) {
cout << "0" << endl;
} else {
if (n % 2 == 1) {
cout << (n + 1) / 2 << endl;
} else
cout << n + 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> m >> n;
int ss[35] = {};
for (int i = 0; i < n; i++) {
cout << 1 << endl;
string s;
cin >> s;
if (s == "1") {
ss[i] = 1;
} else {
ss[i] = -1;
}
}
long long r = 1;
while (r <= m) r <<= 1;
long long ans = 0;
r >>= 1;
for (int i = 0; r; r >>= 1) {
if (ans + r > m) continue;
cout << ans + r << endl;
string s;
cin >> s;
if (ss[i] == 1) {
if (s == "1") {
ans += r;
}
} else {
if (s == "-1") {
ans += r;
}
}
i++;
i %= n;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
int i = 0;
int st;
s.size() % 2 == 0 ? st = s.size() / 2 - 1 : st = s.size() / 2;
while (i < s.size()) {
cout << s[st];
if (i % 2 == 0) {
st += (i + 1);
} else {
st -= (i + 1);
}
i++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
int len = 1;
const int mod = 12345 * 12345;
struct Matrix {
long long a[128][128];
};
Matrix operator*(Matrix lhs, Matrix rhs) {
Matrix ans;
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++) {
ans.a[i][j] = 0;
for (int k = 0; k < len; k++) {
if (lhs.a[i][k] == 0 || rhs.a[k][j] == 0) continue;
(ans.a[i][j] += lhs.a[i][k] * rhs.a[k][j]);
if (ans.a[i][j] >= mod) ans.a[i][j] %= mod;
}
}
}
return ans;
}
Matrix modExp(Matrix a, long long n) {
Matrix ret;
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++) {
if (i == j)
ret.a[i][j] = 1;
else
ret.a[i][j] = 0;
}
}
for (; n; n >>= 1, a = a * a)
if (n & 1) ret = ret * a;
return ret;
}
char p[1100];
int q[1100], r[1100];
set<char> S;
int main() {
long long n;
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
char t[2];
scanf("%s", &t);
int s;
scanf("%d", &s);
p[i] = t[0];
q[i] = s;
S.insert(t[0]);
len *= s;
}
Matrix cur;
for (int i = 0; i < 128; i++)
for (int j = 0; j < 128; j++) cur.a[i][j] = 0;
for (int i = 0; i < len; i++) {
for (auto j : S) {
int t = i;
for (int j = 0; j < m; j++) r[j] = t % q[j], t /= q[j];
for (int k = 0; k < m; k++) {
if (p[k] == j) (r[k] += 1) %= q[k];
}
t = 0;
for (int k = m - 1; k >= 0; k--) t = t * q[k] + r[k];
cur.a[t][i]++;
}
}
cur = modExp(cur, n);
int ans = 0;
for (int i = 0; i < len; i++) {
int t = i;
for (int j = 0; j < m; j++) r[j] = t % q[j], t /= q[j];
bool flg = 1;
for (auto j : S) {
bool chk = 0;
for (int k = 0; k < m; k++) {
if (p[k] == j && r[k] == 0) chk = 1;
}
if (chk == 0) flg = 0;
}
if (flg) (ans += cur.a[i][0]) %= mod;
}
cout << ans % 12345 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int a[10];
const long long int MAX = 110;
const long long int MOD = 1000 * 1000 * 1000 + 7;
long long int d[MAX][10], d2[MAX][10], s[MAX];
long long int e[MAX][MAX];
int main() {
long long int n;
cin >> n;
for (int i = 0; i < 10; i++) {
cin >> a[i];
}
s[0] = a[0];
for (int i = 1; i < 10; i++) {
s[i] = s[i - 1] + a[i];
}
if (n == 1 and s[9] == 1) {
return cout << 1 << endl, 0;
}
for (int i = 0; i < MAX; i++) {
e[i][i] = 1;
e[i][1] = i;
}
for (int i = 1; i < MAX; i++) {
e[i][0] = 1;
}
for (int i = 1; i < MAX; i++) {
for (int j = 2; j < i; j++) {
e[i][j] = e[i - 1][j] + e[i - 1][j - 1];
e[i][j] %= MOD;
}
}
for (int i = a[1]; i <= n; i++) {
d[i][1] = 1;
}
for (int i = 2; i <= 9; i++) {
for (int j = 0; j <= n; j++) {
for (int k = a[i]; k <= n; k++) {
d[j][i] += (d[j - k][i - 1] * e[j][k]);
d[j][i] %= MOD;
}
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = a[0]; j <= n - i; j++) {
d[i + j][0] += (d[i][9] * e[i + j - 1][j]);
d[i + j][0] %= MOD;
}
}
for (int i = 1; i <= n; i++) {
ans += d[i][0];
ans %= MOD;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
struct sort_pred1 {
bool operator()(const int &left, const int &right) { return left < right; }
};
int b[1001];
int n, m;
vector<int> v;
void fs(int a) {
if (!b[a]) b[a] = 1, v.push_back(a);
}
int main() {
cin >> n >> m;
while (n--) {
int a;
cin >> a;
int s = ((int)v.size());
for (int i = 0; i < s; i++) fs((v[i] + a) % m);
fs(a % m);
if (b[0]) break;
}
if (n < 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
using namespace std;
const long long mod = 1e9 + 7;
long long fac[1000011];
long long inv(long long p) {
long long ret = 1, base = p, pw = mod - 2;
while (pw > 0) {
if (pw % 2 == 1) {
ret = ret * base;
ret %= mod;
pw--;
} else {
base = base * base;
base %= mod;
pw /= 2;
}
}
return ret;
}
long long C(int N, int K) {
return (((fac[N] * inv(fac[K])) % mod) * inv(fac[N - K])) % mod;
}
map<int, int> mp;
int main() {
int i, n;
long long ans = 0;
fac[0] = 1;
scanf("%d", &n);
for (i = 1; i < 1000011; ++i) fac[i] = fac[i - 1] * i, fac[i] %= mod;
for (i = 0; i < n; ++i) {
int v;
scanf("%d", &v);
mp[v]++;
}
int cnt = 0;
mp.erase(mp.rbegin()->first);
for (auto iter : mp) {
ans += (((C(n, cnt) * fac[n - cnt - 1]) % mod) * fac[cnt]) % mod *
(iter.second * iter.first) % mod;
ans %= mod;
cnt += iter.second;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[5010];
cin >> n;
int mot[5010], hai[5010], ba[5010];
int a(0), b(0), c(0);
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] == 1) {
mot[a] = i;
a++;
} else if (arr[i] == 2) {
hai[b] = i;
b++;
} else {
ba[c] = i;
c++;
}
}
int min = a;
if (b < min) {
min = b;
}
if (c < min) {
min = c;
}
cout << min << endl;
for (int i = 0; i < min; i++) {
cout << mot[i] << " " << hai[i] << " " << ba[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x[100005], z[2] = {0};
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) {
if (x[i] == 25)
z[0]++;
else if (x[i] == 50) {
if (z[0] > 0) {
z[0]--;
z[1]++;
} else {
cout << "NO";
return 0;
}
} else {
if (z[1] > 0 && z[0] > 0) {
z[0]--;
z[1]--;
} else if (z[0] >= 3) {
z[0] -= 3;
} else {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s[1005];
int row[1005], col[1005];
int main() {
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) cnt += (s[i][j] == '*');
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
row[i] += (s[i][j] == '*');
col[j] += (s[i][j] == '*');
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int tot = row[i] + col[j] - (s[i][j] == '*');
if (tot == cnt) {
cout << "YES" << endl;
cout << i + 1 << " " << j + 1 << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int r[16], b[16];
int rcnt[1 << 16], bcnt[1 << 16];
int dp[1 << 16][140];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string color;
cin >> color >> r[i] >> b[i];
int* cnt = (color[0] == 'R' ? rcnt : bcnt);
for (int mask = 0; mask < (1 << n); mask++)
if (mask & (1 << i)) cnt[mask]++;
}
int S = n * (n - 1) / 2 + 1;
for (int mask = 0; mask < (1 << n); mask++) {
for (int j = 0; j < S; j++) {
if (mask == 0 && j == 0) {
dp[mask][j] = 0;
continue;
}
dp[mask][j] = -(1 << 30);
for (int i = 0; i < n; i++) {
if ((mask & (1 << i)) == 0) continue;
int prev_mask = (mask ^ (1 << i));
int prev_j = max(0, j - min(r[i], rcnt[prev_mask]));
if (dp[prev_mask][prev_j] < 0) continue;
int bsaved = dp[prev_mask][prev_j] + min(b[i], bcnt[prev_mask]);
dp[mask][j] = max(dp[mask][j], bsaved);
}
}
}
int rtotal = 0, btotal = 0;
for (int i = 0; i < n; i++) rtotal += r[i], btotal += b[i];
int best = (1 << 30);
for (int i = 0; i < S; i++) {
int bsaved = dp[(1 << n) - 1][i];
if (bsaved == -(1 << 30)) continue;
int rt = rtotal - i;
int bt = btotal - bsaved;
int total = max(rt, bt) + n;
best = min(best, total);
}
cout << best << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m;
cin >> n >> k >> m;
vector<int> A(n);
map<int, vector<int>> B;
for (int i = 0; i < n; i++) {
cin >> A[i];
B[A[i] % m].push_back(A[i]);
if (B[A[i] % m].size() == k) {
cout << "Yes" << endl;
for (int u = 0; u < k; u++) cout << B[A[i] % m][u] << ' ';
return 0;
}
}
cout << "No";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.length();
char lastOne = s[0];
int times = 1;
bool dangerous = false;
for (int i = 1; i < n; ++i) {
if (s[i] == lastOne) {
++times;
if (times >= 7) {
dangerous = true;
break;
}
} else {
times = 1;
lastOne = s[i];
}
}
if (dangerous) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long n, m, q, i, sx, sy, ex, ey, ans1, ans2;
scanf("%lld%lld%lld", &n, &m, &q);
long long g = gcd(n, m);
long long x = n / g, y = m / g;
for (i = 1; i <= q; i++) {
scanf("%lld%lld", &sx, &sy);
scanf("%lld%lld", &ex, &ey);
if (sx == 1)
ans1 = (sy - 1) / x;
else
ans1 = (sy - 1) / y;
if (ex == 1)
ans2 = (ey - 1) / x;
else
ans2 = (ey - 1) / y;
if (ans1 == ans2)
puts("YES");
else
puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
template <typename T>
struct modular {
constexpr modular() : val(0) {}
constexpr modular(const modular<T>& _m) : val(_m.val) {}
template <typename U>
constexpr modular(const U& _r = U()) {
val = -MOD <= _r && _r < MOD ? _r : _r % MOD;
if (val < 0) {
val += MOD;
}
}
const T operator()() { return val; }
template <typename U>
explicit operator U() const {
return static_cast<U>(val);
}
modular<T>& operator+=(const modular<T>& _m) {
if ((val += _m.val) >= MOD) {
val -= MOD;
}
return *this;
}
modular<T>& operator-=(const modular<T>& _m) {
if ((val -= _m.val) < 0) {
val += MOD;
}
return *this;
}
modular<T>& operator*=(const modular<T>& _m) {
val = modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val))
.val;
return *this;
}
modular<T>& operator/=(const modular<T>& _m) {
T a = _m.val, b = MOD, u = 0, v = 1;
while (a != 0) {
T q = b / a;
b -= q * a;
swap(a, b);
u -= q * v;
swap(u, v);
}
return *this *= u;
}
modular<T>& operator=(const modular<T>& _m) {
val = _m.val;
return *this;
}
template <typename U>
modular<T>& operator+=(const U& _r) {
return *this += modular<T>(_r);
}
template <typename U>
modular<T>& operator-=(const U& _r) {
return *this -= modular<T>(_r);
}
template <typename U>
modular<T>& operator*=(const U& _r) {
return *this *= modular<T>(_r);
}
template <typename U>
modular<T>& operator/=(const U& _r) {
return *this /= modular<T>(_r);
}
template <typename U>
modular<T>& operator=(const U& _r) {
val = modular<T>(_r).val;
return *this;
}
modular<T> operator-() { return modular<T>(-val); }
template <typename U>
friend bool operator==(const modular<U>&, const modular<U>&);
friend std::istream& operator>>(std::istream& os, modular<T>& _m) {
os >> _m.val;
_m *= 1;
return os;
}
friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) {
return os << _m.val;
}
template <typename U>
modular<T> exp(U e) {
modular<T> res = 1;
modular<T> b = val;
if (e < 0) {
b = 1 / b;
e *= -1;
}
for (; e; e >>= 1) {
if (e & 1) {
res *= b;
}
b *= b;
}
return res;
}
private:
T val;
};
template <typename T>
inline modular<T> operator+(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T>
inline modular<T> operator-(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T>
inline modular<T> operator*(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T>
inline modular<T> operator/(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T>
inline bool operator==(const modular<T>& _lhs, const modular<T>& _rhs) {
return _lhs.val == _rhs.val;
}
template <typename T, typename U>
inline bool operator==(const modular<T>& _lhs, const U& _rhs) {
return _lhs == modular<T>(_rhs);
}
template <typename T, typename U>
inline bool operator==(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) == _rhs;
}
template <typename T>
inline bool operator!=(const modular<T>& _lhs, const modular<T>& _rhs) {
return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const modular<T>& _lhs, const U& _rhs) {
return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const U& _lhs, const modular<T>& _rhs) {
return !(_lhs == _rhs);
}
const int N = 64;
const int L = 31;
using M = array<array<modular<int>, N>, N>;
using V = array<modular<int>, N>;
M mul(M& a, M& b) {
M r = {};
for (int i = 0; i < 64; i++) {
for (int j = 0; j < 64; j++) {
for (int k = 0; k < 64; k++) {
r[i][j] += a[i][k] * b[k][j];
}
}
}
return r;
}
V mul(V& v, M& a) {
V r = {};
for (int i = 0; i < 64; i++) {
for (int j = 0; j < 64; j++) {
r[j] += v[i] * a[i][j];
}
}
return r;
}
M C[3] = {};
M A = {};
M ex[L];
int g[3][3];
int gate(int i, int c) {
bool mex[4] = {};
for (int _ = 0; _ < 3; _++) {
if (g[c][_]) {
mex[(i >> (4 - 2 * _)) & 0b11] = true;
}
}
int now = 0;
while (mex[now]) {
now++;
}
return (now << 4) | (i >> 2);
}
int general_gate(int i, vector<int>& can_go) {
bool mex[4] = {};
for (int _ : can_go) {
mex[(i >> (4 - 2 * _)) & 0b11] = true;
}
int now = 0;
while (mex[now]) {
now++;
}
return (now << 4) | (i >> 2);
}
void prep() {
for (int i = 0; i < 64; i++) {
for (int c = 0; c < 3; c++) {
int j = gate(i, c);
A[i][j] += 1;
C[c][i][j] += 1;
}
}
ex[0] = A;
for (int i = 1; i < L; i++) {
ex[i] = mul(ex[i - 1], ex[i - 1]);
}
}
void solve() {
int n;
cin >> n;
vector<int> len(n);
for (auto& x : len) {
cin >> x;
}
int m;
cin >> m;
vector<vector<pair<int, int>>> a(n);
for (int _ = 0; _ < m; _++) {
int i, x, c;
cin >> i >> x >> c;
i--;
x--;
c--;
a[i].emplace_back(x, c);
}
for (int i = 0; i < n; i++) {
sort(a[i].begin(), a[i].end());
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cin >> g[i][j];
}
}
prep();
auto advance = [&](V& v, int step) {
for (int i = L - 1; i >= 0; i--) {
if (step >> i & 1) v = mul(v, ex[i]);
}
};
auto step_with_color = [&](V& v, int c) { v = mul(v, C[c]); };
using R = array<modular<int>, 4>;
auto calc = [&](vector<pair<int, int>>& strip, int n) {
V v = {};
v[63] = 1;
int las = -1;
for (auto& _ : strip) {
int x, c;
tie(x, c) = _;
if (x - las > 1) {
advance(v, x - las - 1);
}
step_with_color(v, c);
las = x;
}
if (n - las > 1) advance(v, n - las - 1);
R r = {};
for (int i = 0; i < 64; i++) {
r[i >> 4] += v[i];
}
return r;
};
R dp = {};
dp[0] = 1;
for (int i = 0; i < n; i++) {
R sg = calc(a[i], len[i]);
R nxt = {};
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
nxt[i ^ j] += dp[i] * sg[j];
}
}
swap(dp, nxt);
}
cout << dp[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct Matrix {
int r, c;
T a[4][4];
Matrix() { memset(a, 0, sizeof a); }
Matrix(int si) {
memset(a, 0, sizeof a);
r = c = si;
for (int i = 0; i < si; i++) a[i][i] = 1;
}
Matrix operator*(const Matrix& rhs) {
Matrix<T> ret;
ret.r = r;
ret.c = rhs.c;
for (int k = 0; k < c; ++k)
for (int i = 0; i < ret.r; ++i)
for (int j = 0; j < ret.c; ++j)
ret.a[i][j] =
(ret.a[i][j] + (long long)a[i][k] * rhs.a[k][j]) % 1000000007;
return ret;
}
Matrix operator^(long long b) {
Matrix<T> ret, base = *this;
int setret = 0;
while (b) {
if (b & 1) ret = (setret ? ret * base : base), setret = 1;
base = base * base;
b >>= 1;
}
return ret;
}
};
int Next[100010];
char fs[30][1000010];
int fib[30];
void getNext(char* str) {
int len2 = strlen(str);
for (int i = 1, j = 0; i < len2; ++i) {
while (j && str[i] != str[j]) j = Next[j];
if (str[i] == str[j]) ++j;
Next[i + 1] = j;
}
}
int KMP(char* txt, char* str) {
int len1 = strlen(txt);
int len2 = strlen(str);
int ret = 0;
for (int i = 0, j = 0; i < len1; ++i) {
while (j && txt[i] != str[j]) j = Next[j];
if (txt[i] == str[j]) ++j;
if (j == len2) ++ret, j = Next[j];
}
return ret;
}
char instr[100010];
char A[1000010], B[1000010];
char temp[1000010];
int main() {
Matrix<int> M;
M.r = M.c = 4;
M.a[0][1] = M.a[0][2] = M.a[1][0] = M.a[1][1] = M.a[2][3] = M.a[3][2] = 1;
fib[1] = fib[2] = 1;
strcpy(fs[1], "a");
strcpy(fs[2], "b");
for (int i = 3; i < 30; ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
strcpy(fs[i], fs[i - 1]);
strcat(fs[i], fs[i - 2]);
}
for (int i = 1; i < 30; ++i) fs[i][fib[i]] = '\0';
long long k;
int m;
scanf("%I64d%d", &k, &m);
while (m--) {
scanf("%s", instr);
int len = strlen(instr);
getNext(instr);
if (k < 30) {
printf("%d\r\n", KMP(fs[k], instr));
continue;
}
int I;
for (int i = 1; i < 30; i++) {
if (fib[i] >= len) {
strcpy(B, fs[i + 1]);
strcpy(A, fs[i]);
I = i;
break;
}
}
long long CA = KMP(A, instr);
long long CB = KMP(B, instr);
strcpy(temp, B);
long long CBA = KMP(strcat(temp, A), instr) - CB - CA;
strcpy(temp, A);
long long CAB = KMP(strcat(temp, B), instr) - CA - CB;
strcpy(temp, B);
long long CBB = KMP(strcat(temp, B), instr) - CB - CB;
Matrix<int> cnt;
cnt.r = 1;
cnt.c = 4;
cnt.a[0][1] = 1;
cnt = cnt * (M ^ (k - I - 1));
long long ans = (cnt.a[0][0] * (CBA + CA) + cnt.a[0][1] * CB +
cnt.a[0][2] * CAB + cnt.a[0][3] * CBB) %
1000000007;
printf("%d\r\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<long long, bool> ma;
vector<long long> a;
int main() {
long long n, k, x;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
ma[x] = 1;
}
long long sum = 0;
for (long long i = 1; i <= 1000000000 && sum <= k; i++) {
if (ma[i] == 0 && (sum + i) <= k) {
a.push_back(i);
}
if (ma[i] == 0) {
sum += i;
}
}
cout << a.size() << endl;
for (int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long num[1000010];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
while (~scanf("%d %d", &n, &k)) {
long long flag = 1;
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) {
flag = flag * num[i] / gcd(flag, num[i]);
flag %= k;
}
if (flag == 0)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, count;
count = 0;
cin >> a;
int n[a];
int b[a];
for (int i = 0; i < a; i++) {
cin >> n[i] >> b[i];
}
for (int i = 0; i < a; i++) {
if (b[i] - n[i] >= 2) {
count++;
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int a, b, c, d;
} mp[1010];
bool cmp1(node x, node y) { return x.a < y.a; }
bool cmp2(node x, node y) { return x.b < y.b; }
void solve(int l, int r) {
if (l == r) return;
sort(mp + l, mp + r + 1, cmp1);
int mmax = mp[l].c;
int cnt = -1;
for (int i = l + 1; i <= r; i++) {
if (mp[i].a >= mmax) {
cnt = i;
break;
}
mmax = max(mmax, mp[i].c);
}
if (cnt != -1) {
solve(l, cnt - 1);
solve(cnt, r);
return;
}
sort(mp + l, mp + r + 1, cmp2);
mmax = mp[l].d;
for (int i = l + 1; i <= r; i++) {
if (mp[i].b >= mmax) {
cnt = i;
break;
}
mmax = max(mmax, mp[i].d);
}
if (cnt != -1) {
solve(l, cnt - 1);
solve(cnt, r);
return;
}
cout << "NO" << endl;
exit(0);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> mp[i].a >> mp[i].b >> mp[i].c >> mp[i].d;
solve(1, n);
cout << "YES" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
int a[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<string> s(n + 1, string(n, '0'));
int start = 0;
for (int k = n; k >= 1; k--) {
for (int i = 0; i < n; i++) {
if (a[i] == k) {
for (int j = 0; j < a[i]; j++) {
s[(start + j) % (n + 1)][i] = '1';
}
start += 1;
}
}
}
cout << n + 1 << '\n';
for (int i = 0; i < n + 1; i++) {
cout << s[i] << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
long long s[100100];
int main() {
long long n, m;
while (~scanf("%lld%lld", &n, &m)) {
long long i = 0, sum = 0;
s[i++] = m;
while (m > n) {
if (m % 2 == 0) {
m /= 2;
s[i++] = m;
} else {
m--;
if (m % 10 != 0) {
break;
} else {
m /= 10;
s[i++] = m;
}
}
}
if (m != n) {
printf("NO\n");
continue;
}
printf("YES\n");
printf("%d\n", i);
for (int j = i - 1; j >= 0; j--) {
if (j != 0)
printf("%d ", s[j]);
else
printf("%d\n", s[j]);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int next(int i) { return (i + 1) % n; }
int prev(int i) { return i ? i - 1 : n - 1; }
void move(int& i) { i = next(i); }
void back(int& i) { i = prev(i); }
bool isChess(string s) {
for (int i = 0; i < (int)n; i++) {
if (s[i] == s[prev(i)] || s[i] == s[next(i)]) return false;
}
return true;
}
char inv(char c) { return c == 'W' ? 'B' : 'W'; }
int getLength(int l, int r) {
if (l <= r)
return r - l + 1;
else
return n - (l - r) + 1;
}
string shiftRight(string& s, int k) {
string ans(n, '_');
for (int i = 0; i < (int)n; i++) {
ans[k] = s[i];
move(k);
}
return ans;
}
string solve(string& s, int l, int r, int k) {
int K = k;
int d = getLength(l, r);
string ans = string(d, '_');
int i = l;
int j = r;
int x = 0;
while (k && x < (d + 1) / 2) {
ans[x] = x ? ans[x - 1] : s[prev(i)];
ans[d - x - 1] = x ? ans[d - x] : s[next(j)];
move(i);
back(j);
x++;
k--;
}
while (x < (d + 1) / 2) {
ans[x] = (K % 2) ? inv(s[i]) : s[i];
ans[d - x - 1] = (K % 2) ? inv(s[j]) : s[j];
move(i);
back(j);
x++;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int k;
cin >> n >> k;
string s;
cin >> s;
if (isChess(s)) {
if (k % 2 == 1) {
for (int i = 0; i < (int)n; i++) {
s[i] = inv(s[i]);
}
}
cout << s << endl;
return 0;
}
bool found = false;
int start;
for (int i = 0; i < (int)n; i++) {
if (s[i] == s[next(i)]) {
found = true;
start = i;
}
}
string ans;
int i = start;
ans += s[i];
move(i);
while (i != start) {
if (s[i] == s[next(i)] || s[i] == s[prev(i)])
ans += s[i];
else {
int l = i;
int j = i;
while (s[j] != s[next(j)] && s[j] != s[prev(j)]) {
move(j);
}
int r = prev(j);
ans += solve(s, l, r, k);
i = prev(j);
}
move(i);
}
cout << shiftRight(ans, start) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
string a, b;
cin >> a >> b;
if (a == b) {
cout << -1;
return 0;
}
if (a.length() > b.length()) {
cout << a.length();
} else {
cout << b.length();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
long long int count = 0;
cin >> a >> b >> c;
for (int i = 1; i <= a; i++)
for (int j = 1; j <= b; j++)
for (int k = 1; k <= c; k++) {
long long int m = 1, n = i * j * k;
for (long long int l = 2; l <= n; l++) {
int c = 0;
while (n % l == 0) {
c++;
n /= l;
}
m *= (c + 1);
}
count += m;
}
cout << count % 1073741824;
return 0;
}
| 9 |
#include <bits/stdc++.h>
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
T chkmax(T &x, T y) {
return x = x > y ? x : y;
}
template <typename T>
T &read(T &r) {
r = 0;
bool w = 0;
char ch = getchar();
while (ch < '0' || ch > '9') w = ch == '-' ? 1 : 0, ch = getchar();
while (ch >= '0' && ch <= '9')
r = (r << 3) + (r << 1) + (ch ^ 48), ch = getchar();
return r = w ? -r : r;
}
const int N = 1000010;
int n, p[N], a[N], m, k, ans1, ans2;
bool vis[N];
int ct[N], b[N], c[N], us[N];
std::bitset<1000001> f;
void dfs(int x, int s) {
if (vis[x]) {
a[++m] = s;
return;
}
vis[x] = 1;
dfs(p[x], s + 1);
}
signed main() {
read(n);
read(k);
int _n = n;
for (int i = 1; i <= n; ++i) read(p[i]);
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i, 0);
n = m;
std::sort(a + 1, a + n + 1);
int k_ = k;
for (int i = 1; i <= n; ++i) {
if (!k_) break;
int t = Min(a[i] / 2, k_);
ans2 += t * 2;
k_ -= t;
}
for (int i = 1; i <= n; ++i)
if ((a[i] & 1) && k_) ++ans2, --k_;
for (int i = 1; i <= _n; ++i) ct[a[i]]++;
m = 0;
for (int i = 1; i <= _n; ++i)
if (ct[i]) b[++m] = i, c[m] = ct[i];
f[0] = 1;
for (int i = 1; i <= m; ++i) {
int tc = c[i];
for (int j = 1; tc; j <<= 1) {
int t = Min(j, tc);
f |= f << (b[i] * t), tc -= t;
}
}
if (f[k])
ans1 = k;
else
ans1 = k + 1;
printf("%d %d\n", ans1, ans2);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
list<int> li[500010];
int ans = -1;
vector<int> dpth;
void dfs(int start, int par, int d) {
list<int>::iterator it;
if (li[start].size() == 1 && start != 1) {
dpth.push_back(d);
return;
}
for (it = li[start].begin(); it != li[start].end(); it++) {
if (*it != par) {
dfs(*it, start, d + 1);
}
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
li[a].push_back(b);
li[b].push_back(a);
}
list<int>::iterator it;
for (it = li[1].begin(); it != li[1].end(); it++) {
dpth.clear();
dfs(*it, 1, 1);
sort(dpth.begin(), dpth.end());
int siz = dpth.size();
ans = max(ans, dpth[0]);
for (int i = 1; i < siz; i++) {
if (dpth[i] <= dpth[i - 1]) dpth[i] = dpth[i - 1] + 1;
ans = max(ans, dpth[i]);
}
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i;
cin >> n >> m;
float a, b, min = 101, x, y;
for (i = 0; i < n; i++) {
cin >> a >> b;
x = a / b;
if (x < min) {
min = x;
}
}
y = min * m;
cout << fixed << setprecision(8) << y;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
float y;
vector<int> v;
int x;
for (int i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(x);
}
vector<int> dp(n + 1);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int ans = -99;
for (int j = 0; j < i; j++) {
if (v[j] <= v[i]) {
ans = max(ans, 1 + dp[j]);
}
}
if (ans != -99)
dp[i] = ans;
else
dp[i] = 1;
}
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, dp[i]);
cout << n - ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, k, l, t;
int D[2009], san[2009], ans[2009], bir[2009], iki[2009];
struct mal {
int a, fr;
} T[109];
int so(void const *x, void const *y) {
mal m = *(mal *)x;
mal n = *(mal *)y;
return n.fr - m.fr;
}
int main() {
a = b = k = l = 0;
scanf("%d", &n);
for (int h = 0; h < 2 * n; h++) {
scanf("%d", &D[h]);
san[D[h]]++;
}
for (int j = 10; j < 100; j++) T[t].a = j, T[t++].fr = san[j];
qsort(T, t, sizeof(mal), so);
for (int j = 0; j < t; j++)
for (int i = 0; i < T[j].fr; i++)
for (int h = 0; h < 2 * n; h++)
if (D[h] == T[j].a) {
if (a < b)
a++, ans[h] = 1, bir[T[j].a] = 1;
else
b++, ans[h] = 2, iki[T[j].a] = 1;
}
for (int h = 10; h < 100; h++) {
k += bir[h];
l += iki[h];
}
printf("%d\n", k * l);
printf("%d", ans[0]);
for (int h = 1; h < 2 * n; h++) printf(" %d", ans[h]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
int x, y;
int dirx, diry;
char dir[10];
int n, m;
int cnt = 0;
long long ans;
int c;
int main() {
scanf("%d%d", &n, &m);
scanf("%d%d", &x, &y);
scanf("%s", dir);
if (dir[0] == 'U')
dirx = -1;
else
dirx = 1;
if (dir[1] == 'L')
diry = -1;
else
diry = 1;
cnt++, s.insert(make_pair(x, y));
ans = 1;
while (c <= 5 * (n + m)) {
if (x == 1 && dirx == -1) dirx = 1;
if (x == n && dirx == 1) dirx = -1;
if (y == 1 && diry == -1) diry = 1;
if (y == m && diry == 1) diry = -1;
int x0, y0;
if (dirx == -1)
x0 = x - 1;
else
x0 = n - x;
if (diry == -1)
y0 = y - 1;
else
y0 = m - y;
int q = min(x0, y0);
x += dirx * q;
y += diry * q;
ans += (long long)q;
if (!s.count(make_pair(x, y))) {
cnt++, s.insert(make_pair(x, y));
if (cnt == n + m - 2) {
printf("%I64d\n", ans);
return 0;
}
}
++c;
}
printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string c;
long long i, l, a, s1;
int main() {
while (getline(cin, c)) {
if (c[0] == 43) s1++;
if (c[0] == 45) s1--;
l = c.size();
if (c[0] != 43 && c[0] != 45) {
for (i = 1; i <= l; i++) {
if (c[i] == 58) a += (l - i - 1) * s1;
}
}
}
cout << a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long BigMod(long long Base, long long Power, long long Mod) {
long long Rem = 1;
while (Power > 0) {
if (Power % 2 == 1) Rem = (Rem * Base) % Mod;
Power = Power / 2;
Base = (Base * Base) % Mod;
}
return Rem;
}
int main() {
long long i, j, m, n, h, k, mod = 1000000007;
while (cin >> n) {
m = BigMod(2, n, 1000000007);
j = m + 1;
if (m % 2 == 0)
m = m / 2;
else
j = j / 2;
m = ((m % mod) * (j % mod)) % mod;
cout << m << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long modexp(long long x, long long y, long long m) {
long long ans = 1;
ans %= m;
while (y > 0) {
if (y % 2 == 1) ans = (ans * x) % m;
y /= 2;
x = (x * x) % m;
}
return ans;
}
long long getmid(long long l, long long r) { return l + (r - l) / 2; }
long long n, a, b;
vector<long long> fact(1000002);
bool check(long long x) {
long long sum = x * a + (n - x) * b;
while (sum != 0) {
if (sum % 10 != a and sum % 10 != b) {
return false;
}
sum /= 10;
}
return true;
}
long long ch(long long r) {
return (fact[n] * modexp(((fact[r] * fact[n - r]) % 1000000007),
1000000007 - 2, 1000000007)) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, ans = 0;
cin >> a >> b >> n;
fact[0] = 1;
for (i = 1; i < 1000001; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
for (i = 0; i < n + 1; i++) {
if (check(i)) {
ans = (ans + ch(i)) % 1000000007;
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int p[1000];
bool flag = true;
string str;
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i];
getchar();
for (int i = 0; i < n; i++) {
getline(cin, str);
int num = 0;
for (int j = 0; j < str.size(); j++)
if (str[j] == 'a' || str[j] == 'e' || str[j] == 'i' || str[j] == 'o' ||
str[j] == 'u' || str[j] == 'y')
num++;
if (num != p[i]) flag = false;
}
if (flag)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e7 + 5;
bool prim[M];
int pref[M], fmp[M];
void seive() {
memset(prim, 1, sizeof(prim));
prim[0] = prim[1] = 0;
for (int i = 2; i < M; i++) {
if (prim[i] == 1) {
for (int j = i * i; j < M && j > 0; j += i) {
prim[j] = 0;
}
}
}
}
void factor(long long x) {
int org = x;
for (long long i = 2; i * i <= x; i++) {
if (prim[x]) {
fmp[x] += pref[org];
return;
}
if (x % i == 0) {
fmp[i] += pref[org];
while (x % i == 0) x /= i;
}
}
if (x > 1) fmp[x] += pref[org];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
seive();
memset(pref, 0, sizeof(pref));
int n, x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
pref[x]++;
}
for (int i = 0; i < M; i++)
if (pref[i] > 0) factor(i);
for (int i = 1; i < M - 3; i++) fmp[i] += fmp[i - 1];
long long m, l, r;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r;
r = min((long long)M - 5, r);
l = min((long long)M - 5, l);
int ans = fmp[r] - fmp[l - 1];
cout << (ans) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80 * 80 + 200;
const int maxm = 1022702;
const int inf = 22222222;
struct Edge {
int v, next, w;
int c;
} edge[maxm];
int head[maxn], cnt;
int ans;
void insert(int u, int v, int w, int c) {
edge[cnt].v = v;
edge[cnt].w = w;
edge[cnt].c = c;
edge[cnt].next = head[u];
head[u] = cnt++;
edge[cnt].v = u;
edge[cnt].w = 0;
edge[cnt].c = -c;
edge[cnt].next = head[v];
head[v] = cnt++;
}
int dis[maxn];
int pre[maxn];
int alpha[maxn];
int que[maxn], qhead, qrear;
int spfa(int s, int e) {
for (int i = 0; i < maxn; ++i) dis[i] = inf;
memset(alpha, 0, sizeof(alpha));
dis[s] = 0;
alpha[s] = 1;
qrear = 1;
que[qhead = 0] = s;
while (qhead != qrear) {
int k = que[qhead++];
qhead %= maxn;
alpha[k] = 0;
for (int q = head[k]; ~q; q = edge[q].next)
if (edge[q].w && dis[k] + edge[q].c < dis[edge[q].v]) {
dis[edge[q].v] = dis[k] + edge[q].c;
pre[edge[q].v] = q;
if (!alpha[edge[q].v]) {
alpha[edge[q].v] = true;
if (edge[q].c < 0) {
qhead = (qhead - 1 + maxn) % maxn;
que[qhead] = edge[q].v;
} else {
que[qrear++] = edge[q].v;
qrear %= maxn;
}
}
}
}
if (dis[e] > inf - 3) return -1;
int k = 2323232;
for (int i = e; i != s; i = edge[pre[i] ^ 1].v) k = min(k, edge[pre[i]].w);
return k;
}
int mincostmaxflow(int s, int t) {
int ans = 0;
int k;
while (~(k = spfa(s, t))) {
for (int i = t; i != s; i = edge[pre[i] ^ 1].v) {
edge[pre[i]].w -= k;
edge[pre[i] ^ 1].w += k;
}
ans += ((k)*dis[t]);
}
return ans;
}
int a[100][100], sum = 0, bh[100][100];
int cal(int i, int j, int k, int q) {
if (a[i][j] == a[k][q]) return 0;
return 1;
}
int main() {
memset(head, 255, sizeof(head));
int di[10][10];
di[1][1] = 0;
di[1][2] = 1;
di[2][1] = 0;
di[2][2] = -1;
di[3][1] = 1;
di[3][2] = 0;
di[4][1] = -1;
di[4][2] = 0;
int n, m, i, j, k;
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i][j];
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
sum++;
bh[i][j] = sum;
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if ((i + j) % 2 == 0)
insert(bh[i][j], n * m + 1, 1, 0);
else
insert(0, bh[i][j], 1, 0);
if ((i + j) % 2 == 1) {
for (k = 1; k <= 4; k++) {
if (bh[i + di[k][1]][j + di[k][2]] != 0)
insert(bh[i][j], bh[i + di[k][1]][j + di[k][2]], 1,
cal(i, j, i + di[k][1], j + di[k][2]));
}
}
}
cout << mincostmaxflow(0, n * m + 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int rem = 0, remm = 0;
int aa = a, bb = b, cc = c, dd = d, ee = e;
if (c > d) {
int fi = b * (d - 1) + a * (c - 1);
while (fi < e) {
if (a == 0) break;
rem++;
fi -= (c - 1);
e -= c;
a--;
}
while (fi < e) {
if (b == 0) break;
rem++;
fi -= (d - 1);
e -= d;
b--;
}
} else {
int fi = b * (d - 1) + a * (c - 1);
while (fi < e) {
if (b == 0) break;
rem++;
fi -= (d - 1);
e -= d;
b--;
}
while (fi < e) {
if (a == 0) break;
rem++;
fi -= (c - 1);
e -= c;
a--;
}
}
a = aa, b = bb, c = cc, d = dd, e = ee;
if (c < d) {
while (c <= e) {
if (a == 0) break;
remm++;
e -= c;
a--;
}
while (d <= e) {
if (b == 0) break;
remm++;
e -= d;
b--;
}
} else {
while (d <= e) {
if (b == 0) break;
remm++;
e -= d;
b--;
}
while (c <= e) {
if (a == 0) break;
remm++;
e -= c;
a--;
}
}
cout << rem << " " << remm << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int grid[110][110];
int soln[110];
int main() {
int i, j, n;
bool found;
char row[110];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", row);
for (j = 0; j < n; j++) grid[i][j] = (row[j] == '.') ? 0 : 1;
}
int soltype = 1;
for (i = 0; i < n; i++) {
found = false;
for (j = 0; j < n; j++) {
if (grid[i][j] == 0) {
soln[i] = j;
found = true;
break;
}
}
if (!found) break;
}
if (!found) {
soltype = 2;
for (i = 0; i < n; i++) {
found = false;
for (j = 0; j < n; j++) {
if (grid[j][i] == 0) {
soln[i] = j;
found = true;
break;
}
}
if (!found) break;
}
}
if (!found)
printf("-1\n");
else {
for (i = 0; i < n; i++)
if (soltype == 1)
printf("%d %d\n", i + 1, soln[i] + 1);
else
printf("%d %d\n", soln[i] + 1, i + 1);
}
return 0;
}
| 3 |
#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)); }
vector<string> name;
vector<int> type, wid, hei, brd, spc;
int g[111][111] = {0};
long long WID[111], HEI[111];
bool used[111] = {0};
int p;
void go(int x) {
used[x] = true;
if (type[x] == 1) {
WID[x] = wid[x], HEI[x] = hei[x];
} else {
int t = 0;
for (int(i) = 0; (i) < (p); (i)++)
if (g[x][i]) t += g[x][i];
if (t == 0) {
WID[x] = HEI[x] = 0;
} else {
long long w = 2 * brd[x];
long long h = 2 * brd[x];
if (type[x] == 2)
h += (t - 1) * spc[x];
else
w += (t - 1) * spc[x];
for (int(i) = 0; (i) < (p); (i)++)
if (g[x][i] && !used[i]) go(i);
long long sw = 0, sh = 0, mw = 0, mh = 0;
for (int(i) = 0; (i) < (p); (i)++)
if (g[x][i]) {
sw += g[x][i] * WID[i];
sh += g[x][i] * HEI[i];
mw = max(mw, WID[i]);
mh = max(mh, HEI[i]);
}
if (type[x] == 2) {
w += mw;
h += sh;
} else if (type[x] == 3) {
w += sw;
h += mh;
} else {
throw "Error!";
}
WID[x] = w;
HEI[x] = h;
}
}
}
int main() {
int n;
scanf("%d", &n);
char s[100];
int len;
for (int(iter) = 0; (iter) < (n); (iter)++) {
scanf("%s", s);
len = strlen(s);
if (s[0] == 'W') {
string z;
cin >> z;
for (int(i) = 0; (i) < ((int)(z).size()); (i)++)
if (z[i] == '(') {
z = z.substr(0, i) + " " + z.substr(i);
break;
}
int w, h;
sscanf(z.c_str(), "%s (%d,%d)", s, &w, &h);
name.push_back(string(s));
type.push_back(1);
wid.push_back(w);
hei.push_back(h);
brd.push_back(-1);
spc.push_back(-1);
} else if (s[0] == 'V') {
scanf("%s", s);
name.push_back(string(s));
type.push_back(2);
wid.push_back(-1);
hei.push_back(-1);
brd.push_back(0);
spc.push_back(0);
} else if (s[0] == 'H') {
scanf("%s", s);
name.push_back(string(s));
type.push_back(3);
wid.push_back(-1);
hei.push_back(-1);
brd.push_back(0);
spc.push_back(0);
} else {
string z(s);
for (int(i) = 0; (i) < ((int)(z).size()); (i)++)
if (z[i] == '.') {
z = z.substr(0, i) + " " + z.substr(i + 1);
}
for (int(i) = 0; (i) < ((int)(z).size()); (i)++)
if (z[i] == '(') {
z = z.substr(0, i) + " " + z.substr(i + 1);
}
z = z.substr(0, (int)(z).size() - 1);
char nm[100], work[100], info[100];
sscanf(z.c_str(), "%s %s %s", nm, work, info);
int ind = -1;
string Name(nm);
for (int(i) = 0; (i) < ((int)(name).size()); (i)++)
if (Name == name[i]) {
ind = i;
break;
}
if (ind == -1) throw "Error!";
if (strcmp(work, "pack") == 0) {
Name = string(info);
int ind2 = -1;
for (int(i) = 0; (i) < ((int)(name).size()); (i)++)
if (Name == name[i]) {
ind2 = i;
break;
}
if (ind2 == -1) throw "Error!";
g[ind][ind2]++;
} else if (strcmp(work, "set_border") == 0) {
int num;
sscanf(info, "%d", &num);
brd[ind] = num;
} else if (strcmp(work, "set_spacing") == 0) {
int num;
sscanf(info, "%d", &num);
spc[ind] = num;
} else
throw "Error!";
}
}
p = (int)(name).size();
for (int(i) = 0; (i) < (p); (i)++) WID[i] = HEI[i] = -1;
for (int(i) = 0; (i) < (p); (i)++)
if (!used[i]) go(i);
vector<pair<string, pair<long long, long long> > > ans;
for (int(i) = 0; (i) < (p); (i)++)
ans.push_back(make_pair(name[i], make_pair(WID[i], HEI[i])));
sort((ans).begin(), (ans).end());
for (int(i) = 0; (i) < (p); (i)++)
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxntry = 120 * 32;
int getpo(int sum, int ac) {
if (ac * 2 > sum) return 500;
if (ac * 4 > sum) return 1000;
if (ac * 8 > sum) return 1500;
if (ac * 16 > sum) return 2000;
if (ac * 32 > sum) return 2500;
return 3000;
}
int calc(int po, int ti) {
if (ti == -1) return 0;
return po - po / 250 * ti;
}
int a[10], b[10], c[10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
for (int j = 1; j <= 5; ++j) {
cin >> a[j];
if (a[j] != -1) ++c[j];
}
for (int j = 1; j <= 5; ++j) {
cin >> b[j];
if (b[j] != -1) ++c[j];
}
for (int i = 3; i <= n; ++i) {
for (int j = 1; j <= 5; ++j) {
int x;
cin >> x;
if (x != -1) ++c[j];
}
}
for (int j = 0; j <= maxntry; ++j) {
int suma = 0, sumb = 0;
for (int k = 1; k <= 5; ++k) {
if (a[k] == -1 || (b[k] != -1 && b[k] <= a[k])) {
int po;
if (a[k] == -1)
po = getpo(n + j, c[k]);
else
po = getpo(n + j, c[k] + j);
suma += calc(po, a[k]);
sumb += calc(po, b[k]);
} else {
int po = getpo(n + j, c[k]);
suma += calc(po, a[k]);
sumb += calc(po, b[k]);
}
}
if (suma > sumb) {
cout << j << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long N;
cin >> N;
vector<pair<long long, long long>> g;
set<pair<long long, long long>> s;
for (long long j = 1; j <= N; j++) {
long long st, d;
cin >> st >> d;
long long en = st + d - 1;
bool ok = 1;
for (auto it : g) {
if ((it.first <= st && it.first >= en) or
(st >= it.first && st <= it.second) or
(en >= it.first && en <= it.second) or
(st < it.first && en > it.second)) {
ok = 0;
}
}
if (ok) {
g.push_back({st, en});
s.insert({st, en});
continue;
}
long long x = 1;
ok = 1;
for (auto it : s) {
long long st = x, en = x + d - 1;
if (en < it.first) {
g.push_back({st, en});
s.insert({st, en});
ok = 0;
break;
}
x = it.second + 1;
}
if (ok) {
g.push_back({x, x + d - 1});
s.insert({x, x + d - 1});
}
}
for (auto it : g) {
cout << it.first << " " << it.second << endl;
}
}
int32_t main() {
long long tt;
tt = 1;
long long cas = 1;
while (tt--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2222;
char ma[maxn][maxn];
int step[9][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1},
{1, -1}, {-1, -1}, {-1, 1}, {0, 0}};
int h1, h2, w1, w2, n, m;
void dfs(int i, int j) {
if (i < 0 || i >= n - 1 || j < 0 || j >= m - 1) return;
int sum = 0, xx, yy;
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (ma[i + x][j + y] == '*') {
sum++;
xx = i + x;
yy = j + y;
}
}
}
if (sum != 1) return;
ma[xx][yy] = '.';
for (int k = 0; k < 9; k++) {
int x = step[k][0] + i, y = step[k][1] + j;
if (x >= 0 && x < n - 1 && y >= 0 && y < m - 1) {
dfs(x, y);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ma[i][j];
}
}
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
dfs(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ma[i][j];
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int extendedEuclid(long long int a, long long int b, long long int* x,
long long int* y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
long long int x1, y1;
long long int gcd = extendedEuclid(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int main() {
long long int A, B, C, x, y, ebob;
cin >> A >> B >> C;
ebob = extendedEuclid(A, B, &x, &y);
if (C % ebob != 0)
cout << -1 << endl;
else {
cout << -1 * x * C / ebob;
cout << " ";
cout << -1 * y * C / ebob;
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1000100];
int d[1000100][3][3];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, x; i < n; i++) {
scanf("%d", &x);
a[x]++;
}
int ans = 0;
d[0][0][0] = 0;
for (int i = 0; i <= m; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3 && l + k + j <= a[i + 1]; l++)
d[i + 1][k][l] =
max(d[i + 1][k][l], d[i][j][k] + l + (a[i + 1] - j - k - l) / 3);
cout << d[m + 1][0][0] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string lucky1, lucky2;
vector<int> vector47, vector74;
int i;
cin >> lucky1;
cin >> lucky2;
for (i = 0; i < lucky1.size(); i++) {
if (lucky1[i] == lucky2[i])
continue;
else {
if (lucky1[i] == '4' && lucky2[i] == '7')
vector47.push_back(i);
else
vector74.push_back(i);
}
}
if (vector47.size() == vector74.size())
cout << vector47.size();
else if (!vector47.size())
cout << vector74.size();
else if (!vector74.size())
cout << vector47.size();
else {
cout << max(vector47.size(), vector74.size());
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long N = 1e6 + 1;
const long long mod = 1e8 + 0;
const long double eps = 1E-7;
int test;
string s, t;
string a[7], b[7];
int main() {
for (int i = 1; i <= 3; i++) {
s = "";
cin >> t;
for (int j = 0; j < t.size(); j++) {
if (t[j] != '-' and t[j] != ';' and t[j] != '_') {
s += tolower(t[j]);
}
}
a[i] = s;
}
b[1] = a[1] + a[2] + a[3];
b[2] = a[1] + a[3] + a[2];
b[3] = a[2] + a[1] + a[3];
b[4] = a[2] + a[3] + a[1];
b[5] = a[3] + a[1] + a[2];
b[6] = a[3] + a[2] + a[1];
cin >> test;
while (test--) {
s = "";
bool flag = false;
cin >> t;
for (int i = 0; i < t.size(); i++) {
if (t[i] != '-' and t[i] != ';' and t[i] != '_') {
s += tolower(t[i]);
}
}
for (int i = 1; i <= 6; i++) {
if (b[i] == s) flag = true;
}
if (!flag) {
cout << "WA" << endl;
} else {
cout << "ACC" << endl;
}
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.