solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
void read() { scanf("%lld%lld", &x, &y); }
} w1, w2, f[2000];
int n;
inline long long dis(const point& i, const point& j) {
return ((i.x - j.x) * (i.x - j.x) + (i.y - j.y) * (i.y - j.y));
}
long long ans = LLONG_MAX, hh________________, kk__________________;
vector<long long> v1, v2;
int main() {
scanf("%d", &n);
w1.read();
w2.read();
for (int i = 0; i < n; ++i) f[i].read();
for (int i = 0; i < n; ++i) {
v1.push_back(dis(f[i], w1));
v2.push_back(dis(f[i], w2));
}
v1.push_back(0);
for (int i = 0; i <= n; ++i) {
hh________________ = v1[i];
kk__________________ = 0;
for (int j = 0; j < n; ++j) {
if (v1[j] > hh________________)
kk__________________ = max(kk__________________, v2[j]);
}
ans = min(ans, hh________________ + kk__________________);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, n, i, j;
scanf("%lld", &a);
scanf("%lld", &b);
c = a - b;
long long lm = (long long)(sqrt(c)), x, y, cnt = 0;
if (a == b) {
cout << "infinity" << endl;
return 0;
}
for (i = 1; i <= lm; i++) {
if (c % i == 0) {
x = i;
y = c / i;
if (x > b) cnt++;
if (y > b && x != y) cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxh = 200 * 1000 + 5;
struct item {
int pos, hash;
item(int pos, int hash) : pos(pos), hash(hash) {}
};
bool operator<(item a, item b) { return a.pos < b.pos; }
int n, m, h;
set<item> S[maxh];
map<int, int> M;
int pos[maxh];
int Len[maxh];
int Base[maxh];
bool used[maxh];
long long add(int x, int hash) {
int base = Base[hash];
set<item>::iterator it = S[base].lower_bound(item(pos[hash], hash));
if (it == S[base].end()) {
it = S[base].begin();
}
int nhash = it->hash;
M[x] = nhash;
S[base].erase(it);
long long res = pos[nhash] - pos[hash];
if (res < 0) {
res += Len[base];
}
return res;
}
void del(int x) {
int base = Base[M[x]];
S[base].insert(item(pos[M[x]], M[x]));
}
int main() {
cin >> h >> m >> n;
for (int i = 0; i < h; ++i) {
if (used[i]) {
continue;
}
for (int j = i, p = 0; !used[j]; j += m, j %= h, ++p) {
S[i].insert(item(p, j));
pos[j] = p;
Base[j] = i;
used[j] = 1;
}
Len[i] = (int)S[i].size();
}
long long res = 0;
for (int i = 0; i < n; ++i) {
char op;
int id;
cin >> op >> id;
if (op == '+') {
int hash;
cin >> hash;
res += add(id, hash);
} else {
del(id);
}
}
cout << res << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 15;
const int SQRT = 185;
int M;
int gmod(int x) { return x % M; }
int add(int x, int y) { return (gmod(x) + gmod(y)) % M; }
int mult(int x, int y) { return gmod(x) * gmod(y) % M; }
int N, A[MAXN];
vector<int> vals;
int ind[MAXN];
int Q;
vector<pair<pair<int, int>, int>> qu[SQRT];
int ans[MAXN];
int F[2 * MAXN];
int gfib(int a, int b, int k) {
return add(mult(a, F[abs(k - 1)]), mult(b, F[k]));
}
struct node {
int size;
int sum0, sum1;
node() { size = sum0 = sum1 = 0; }
node(int su0, int su1, int sz) {
size = sz;
sum0 = su0;
sum1 = su1;
}
};
node operator+(node n1, node n2) {
return node(add(n1.sum0, gfib(n2.sum0, n2.sum1, n1.size)),
add(n1.sum1, gfib(n2.sum0, n2.sum1, n1.size + 1)),
n1.size + n2.size);
}
struct segtree {
node tree[2 * MAXN];
void update(int x) {
int v = gmod(vals[x]);
x += MAXN;
tree[x].sum1 = (tree[x].size ^= 1) * v;
while (x /= 2) {
tree[x] = tree[2 * x] + tree[2 * x + 1];
}
}
} seg;
int nocc[MAXN];
void add(int x) {
if ((nocc[ind[x]]++) == 0) {
seg.update(ind[x]);
}
}
void rem(int x) {
if ((--nocc[ind[x]]) == 0) {
seg.update(ind[x]);
}
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
vals.push_back(A[i]);
}
sort((vals).begin(), (vals).end());
vals.resize(unique((vals).begin(), (vals).end()) - vals.begin());
for (int i = 0; i < N; i++) {
ind[i] = lower_bound((vals).begin(), (vals).end(), A[i]) - vals.begin();
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int lt, rt;
scanf("%d %d", <, &rt);
lt--;
qu[lt / SQRT].push_back(make_pair(pair<int, int>(rt, lt), i));
}
F[1] = 1;
for (int i = 2; i < 2 * MAXN; i++) {
F[i] = add(F[i - 1], F[i - 2]);
}
for (int i = 0; i < SQRT; i++) {
auto &vq = qu[i];
if (vq.empty()) {
continue;
}
fill_n(nocc, vals.size(), 0);
memset((seg.tree), (0), sizeof(seg.tree));
int lt = i * SQRT, rt = lt;
sort((vq).begin(), (vq).end());
for (auto p : vq) {
while (rt < p.first.first) {
add(rt++);
}
while (lt > p.first.second) {
add(--lt);
}
while (lt < p.first.second) {
rem(lt++);
}
ans[p.second] = seg.tree[1].sum1;
}
}
for (int i = 0; i < Q; i++) {
printf("%d\n", ans[i]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int power[10];
int count_power(int d, int f) {
int n = 0;
while (d) {
d /= f;
n += d;
}
return n;
}
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
int d = s[i] - '0';
power[2] += count_power(d, 2);
power[3] += count_power(d, 3);
power[5] += count_power(d, 5);
power[7] += count_power(d, 7);
}
string r;
while (power[7]) {
r.push_back('7');
power[7]--;
power[5]--;
power[3] -= 2;
power[2] -= 4;
}
while (power[5]) {
r.push_back('5');
power[5]--;
power[3]--;
power[2] -= 3;
}
while (power[3]) {
r.push_back('3');
power[3]--;
power[2]--;
}
while (power[2]) {
r.push_back('2');
power[2]--;
}
cout << r << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct point {
long long x, y;
friend point operator-(const point &i, const point &j) {
return (point){i.x - j.x, i.y - j.y};
}
} p[205];
long long f[205][205], s[205][205];
long long cj(point i, point j) { return i.x * j.y - i.y * j.x; }
inline int cg(int x) {
x %= n;
if (x == 0) return n;
return x;
}
inline long long jdz(long long x) {
if (x < 0) return 0 - x;
return x;
}
inline bool ok(int i, int k, int j) {
long long now = cj(p[j] - p[k], p[i] - p[k]);
if (now == 0) return 0;
if ((jdz(now) + jdz(s[i][k]) + jdz(s[k][j]) + jdz(s[j][i])) == jdz(s[1][n]))
return 1;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) cin >> p[i].x >> p[i].y;
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j)
for (int k = i + 1; k < j; ++k) {
s[i][j] += cj(p[k + 1] - p[k], p[i] - p[k]);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j)
for (int k = cg(i + 1); k != j; k = cg(k + 1)) {
s[i][j] += cj(p[cg(k + 1)] - p[k], p[i] - p[k]);
}
for (int d = 1; d <= n; ++d)
for (int i = 1; i <= n; ++i) {
int j = i + d;
if (j > n) break;
if (d == 1) {
f[i][j] = 1;
continue;
}
for (int k = i + 1; k < j; ++k)
if (ok(i, k, j)) {
(f[i][j] += f[i][k] * f[k][j] % 1000000007ll) %= 1000000007ll;
}
}
cout << f[1][n] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1000000;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
int kol[300000];
int x1[300000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
int n, mn = 1e9;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x1[i];
mn = min(x1[i], mn);
}
for (int i = 1; i <= n; i++) {
x1[i] -= mn;
kol[x1[i]]++;
}
if (kol[2] == 0) {
cout << n << endl;
for (int i = 1; i <= n; i++) cout << x1[i] + mn << " ";
cout << endl;
return 0;
}
int kol1 = kol[0];
int kol2 = kol[1];
int kol3 = kol[2];
int ans = n;
if (kol2 / 2 * 2 >= min(kol1, kol3) * 2) {
ans -= kol2 / 2 * 2;
kol1 += kol2 / 2;
kol3 += kol2 / 2;
kol2 -= kol2 / 2 * 2;
} else {
int kek = min(kol1, kol3);
ans -= kek * 2;
kol2 += kek * 2;
kol1 -= kek;
kol3 -= kek;
}
cout << ans << endl;
for (int i = 1; i <= kol1; i++) cout << mn << " ";
for (int i = 1; i <= kol2; i++) cout << mn + 1 << " ";
for (int i = 1; i <= kol3; i++) cout << mn + 2 << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, k, now, p;
cin >> q >> k;
string vowels[4], line;
int scheme = 0;
bool possible = true;
for (int i = 0; i < q; i++) {
now = 0;
for (int j = 0; j < 4; j++) {
cin >> line;
vowels[j] = "";
for (p = line.length() - 1; p >= 0 && vowels[j].length() < k; p--) {
char v = line[p];
if (v == 'a' || v == 'e' || v == 'i' || v == 'o' || v == 'u')
vowels[j] += v;
}
if (vowels[j].length() < k) {
possible = false;
break;
}
vowels[j] = line.substr(p + 1);
}
if (vowels[0] == vowels[1] && vowels[2] == vowels[3]) {
if (vowels[0] == vowels[2])
now = 0;
else
now = 1;
} else if (vowels[0] == vowels[2] && vowels[1] == vowels[3]) {
now = 2;
} else if (vowels[0] == vowels[3] && vowels[1] == vowels[2]) {
now = 3;
} else
possible = false;
if (scheme == 0 || scheme == now)
scheme = now;
else if (now)
possible = false;
}
string op;
if (!possible)
op = "NO";
else
switch (scheme) {
case 0:
op = "aaaa";
break;
case 1:
op = "aabb";
break;
case 2:
op = "abab";
break;
case 3:
op = "abba";
break;
}
cout << op << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 3e4 + 7, LG = 32, inf = 1e9 + 7;
vector<int> graph[N], tmp;
int c[N], cnt;
vector<pair<int, pair<int, int> > > th;
vector<pair<int, int> > tw;
vector<int> on;
void dfs(int u) {
c[u] = 1;
cnt++;
tmp.push_back(u);
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (c[v] == 0) dfs(v);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (c[i] == 0) {
tmp.clear();
cnt = 0;
dfs(i);
if (cnt > 3) cout << -1 << endl, exit(0);
if (cnt == 3)
th.push_back(
pair<int, pair<int, int> >(tmp[0], pair<int, int>(tmp[1], tmp[2])));
if (cnt == 2) tw.push_back(pair<int, int>(tmp[1], tmp[0]));
if (cnt == 1) on.push_back(tmp[0]);
}
if ((on.size() - tw.size()) % 3 == 0) {
for (int i = tw.size(); i < on.size(); i += 3) {
cout << on[i] << ' ' << on[i + 1] << ' ' << on[i + 2] << endl;
}
for (int i = 0; i < tw.size(); i++) {
cout << tw[i].first << ' ' << tw[i].second << ' ' << on[i] << endl;
}
for (int i = 0; i < th.size(); i++) {
cout << th[i].first << ' ' << th[i].second.first << ' '
<< th[i].second.second << endl;
}
exit(0);
}
cout << -1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vis[10005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(vis, 0, sizeof(vis));
int n;
scanf("%d", &n);
vector<int> d;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (i != 1) d.emplace_back(i);
if (i != n / i) d.emplace_back(n / i);
}
}
sort(d.begin(), d.end());
vector<int> p, co;
for (int i = 0; i < d.size(); i++) {
bool prime = 1;
for (int j = 0; j < i; j++) {
if (d[i] % d[j] == 0) {
prime = 0;
break;
}
}
if (prime)
p.emplace_back(d[i]);
else
co.emplace_back(d[i]);
}
if (p.size() == 1) {
for (int i = 0; i < d.size(); i++) printf("%d ", d[i]);
printf("\n");
printf("0\n");
} else if (p.size() == 2) {
int cnt = 0;
for (int i = 0; i < co.size(); i++) {
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) {
cnt++;
}
}
if (cnt == 1) {
printf("%d ", p[0]);
for (int i = 0; i < co.size(); i++) {
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) continue;
if (co[i] % p[0] == 0) printf("%d ", co[i]);
}
for (int i = 0; i < co.size(); i++) {
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) printf("%d ", co[i]);
}
printf("%d ", p[1]);
for (int i = 0; i < co.size(); i++) {
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) continue;
if (co[i] % p[1] == 0) printf("%d ", co[i]);
}
printf("\n");
printf("1\n");
} else {
printf("%d ", p[0]);
for (int i = 0; i < co.size(); i++) {
if (vis[i]) continue;
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) continue;
if (co[i] % p[0] == 0) printf("%d ", co[i]), vis[i] = 1;
}
for (int i = 0; i < co.size(); i++) {
if (vis[i]) continue;
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) {
printf("%d ", co[i]);
vis[i] = 1;
break;
}
}
printf("%d ", p[1]);
for (int i = 0; i < co.size(); i++) {
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) continue;
if (co[i] % p[1] == 0) printf("%d ", co[i]), vis[i] = 1;
}
for (int i = 0; i < co.size(); i++) {
if (vis[i]) continue;
if (co[i] % p[0] == 0 && co[i] % p[1] == 0) {
printf("%d ", co[i]);
vis[i] = 1;
}
}
printf("\n");
printf("0\n");
}
} else {
for (int i = 0; i < p.size(); i++) {
int pv = p[(i - 1 + p.size()) % p.size()];
int cur = p[i];
int nt = p[(i + 1) % p.size()];
printf("%d ", cur);
for (int j = 0; j < co.size(); j++) {
if (vis[j]) continue;
if (co[j] % cur == 0 && co[j] % nt == 0) continue;
if (co[j] % cur == 0 && co[j] % pv == 0) continue;
if (co[j] % cur == 0) printf("%d ", co[j]), vis[j] = 1;
}
for (int j = 0; j < co.size(); j++) {
if (vis[j]) continue;
if (co[j] % cur == 0 && co[j] % nt == 0)
printf("%d ", co[j]), vis[j] = 1;
}
}
printf("\n");
printf("0\n");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[105];
int main() {
int n, i, x, y, sum = 0, sumone = 0, sumtwo = 0, flag = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
sum += arr[i];
}
scanf("%d %d", &x, &y);
for (i = 1; i <= n; i++) {
sumone += arr[i];
if (sumone >= x && sumone <= y) {
sumtwo = sum - sumone;
if (sumtwo > y) {
flag = 1;
continue;
} else
break;
} else if (sumone >= x && sumone > y) {
if (flag == 1) {
printf("0");
return 0;
}
sumone -= arr[i];
sumtwo = sum - sumone;
break;
}
}
if (sumone < x || sumone > y || sumtwo < x || sumtwo > y)
printf("0");
else {
sum = 0;
for (i = 1; i <= n; i++) {
sum += arr[i];
if (sum == sumone) {
printf("%d", i + 1);
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const int maxP = 1024 * 1024;
bool npr[maxP];
vector<int> pr;
int K;
int main() {
npr[0] = npr[1] = true;
for (int i = (2); i < (maxP); i++) {
if (npr[i]) continue;
pr.push_back(i);
for (int j = i + i; j < maxP; j += i) npr[j] = true;
}
cin >> K;
int need = (K + 1) / 2;
for (int j = (1); j < (K); j++) {
vector<int> cnt(j, 0);
set<pair<int, int> > todo;
set<int> num;
num.insert(1);
for (int i = (0); i < (j); i++) todo.insert(pair<int, int>(cnt[i], i));
for (int i = (0); i < (j); i++) {
vector<int> ins;
for (int x : num) {
for (int y = x * pr[i]; y <= 2 * K * K; y *= pr[i]) {
ins.push_back(y);
}
}
for (int y : ins) num.insert(y);
}
bool fail = false;
set<int> res;
while (!todo.empty()) {
int want = todo.begin()->second;
int select = -1;
int nu = 0;
for (int x : num) {
if (x % pr[want]) continue;
int nnu = 1;
for (int i = (0); i < (j); i++)
if (i != want && (x % pr[i] == 0)) nnu++;
if (nnu > nu) {
nu = nnu;
select = x;
}
}
if (select == -1) {
fail = true;
break;
}
num.erase(select);
res.insert(select);
for (int i = (0); i < (j); i++)
if (select % pr[i] == 0) {
todo.erase(pair<int, int>(cnt[i], i));
cnt[i]++;
if (cnt[i] < need) todo.insert(pair<int, int>(cnt[i], i));
}
}
if (fail) continue;
num.erase(num.begin());
if (int((num).size()) + int((res).size()) < K) continue;
if (int((res).size()) > K) continue;
while (int((res).size()) < K) {
res.insert(*num.begin());
num.erase(num.begin());
}
bool first = true;
for (int r : res) {
if (first)
first = false;
else
cout << " ";
cout << r;
}
cout << endl;
break;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int Next[1000005];
bool vis[1000005];
int len;
void getnext() {
Next[0] = -1;
int j = -1, i = 0;
while (i < len) {
if (j == -1 || s[i] == s[j]) {
i++;
j++;
Next[i] = j;
} else {
j = Next[j];
}
}
}
int main() {
scanf("%s", s);
len = strlen(s);
getnext();
for (int i = 1; i < len; i++) vis[Next[i]] = 1;
int i = Next[len];
while (i) {
if (vis[i]) {
for (int j = 0; j < i; j++) cout << s[j];
cout << endl;
break;
} else
i = Next[i];
}
if (i == 0) cout << "Just a legend" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 1;
const long long MOD = 1e9 + 7;
const long long MAXN = 1e5 + 1;
const long double EPS = 1e-12;
const long double PI = acos(-1);
const long long XX[] = {0, -1, 0, 1, 0, -1};
const long long YY[] = {-1, 0, 1, 0, -1, 0};
const long long ALPH = 31;
void bye() {
cout << "\n";
exit(0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
if (n == 2) {
cout << 2 << "\n";
} else {
cout << (n & 1) << "\n";
}
}
bye();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, y;
cin >> n >> x >> y;
cout << max(1, min(n, x + y - n + 1)) << " " << min(n, x + y - 1) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int nax = 1e5 + 5;
vector<vector<long long> > bit(nax, vector<long long>(12));
int g(int i) { return i & (i + 1); }
int h(int i) { return i | (i + 1); }
long long getsum(int l, int len) {
long long ret = 0;
while (l >= 0) {
ret += bit[l][len];
l = g(l) - 1;
}
return ret;
}
void update(int l, int len, long long x) {
for (; l < nax; l = l | (l + 1)) {
bit[l][len] += x;
}
}
int main() {
int n, k;
cin >> n >> k;
int a[n];
long long ans = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = k + 1; j >= 2; j--) {
long long k1 = getsum(a[i] - 1, j - 1);
if (k1 > 0) {
if (j == k + 1) ans += k1;
update(a[i], j, k1);
}
}
update(a[i], 1, 1);
}
if (k == 0)
cout << n << endl;
else if (k >= n)
cout << "0" << endl;
else
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[] = {15, 14, 12, 13, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7};
int main() {
cin >> n;
cout << a[n];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxx = 2e5 + 10;
const long long mod = 1e9 + 7;
const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int s[maxx];
int l[maxx];
int r[maxx];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) l[i] = l[i - 1] + s[i];
for (int i = n; i >= 1; i--) r[i] = r[i + 1] + s[i];
int ans = 0;
for (int i = 1; i < n; i++) {
if (l[i] == r[i + 1]) ans++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef priority_queue<ll> prq; // Max priority Queue.
#define fi first
#define se second
#define pb push_back
#define pob pop_back
#define sz(x) (ll)(x).size()
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(),(x).rend()
#define decimal(x) cout << fixed << setprecision(x)
#define fr(i,a,b) for(ll (i)=(a) ; (i) <= (b) ; ++(i))
#define frr(i,a,b) for(ll (i)=(a) ; (i) >= (b) ; --(i))
#define trav(ele,container) for(auto (ele): (container)) // Just gives a copy of the elements.
#define tra(ele,container) for(auto& (ele): (container)) // Gives the reference to the elements.
#define deb(x) cout << #x << " = " << x << endl
#define deb2(x, y) cout << #x << " = " << x << " , " << #y << "=" << y << endl
#define deb3(x, y, z) cout << #x << " = " << x << " , " << #y << "=" << y << " , " << #z << "=" << z << endl
#define fastIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
template <typename T> using min_prq = priority_queue<T, vector<T>, greater<T>>; // Min priority queue
inline ll pmod(ll i, ll n) { return (i % n + n) % n; }
const int mod = 1e9 + 7;
const long long INF = 1e18;
void solve() {
ll n;
cin >> n;
vl v(n);
vector<int> prefix_xor(n);
// Note that in each step we take only the adjacent elements.
fr(i,0,n-1) {
cin >> v[i];
if (i==0)
prefix_xor[0] = v[0];
else { prefix_xor[i] = v[i] ^ prefix_xor[i-1] ; }
}
// If entire xor == 0, We found sol.
bool done = not(prefix_xor[n-1]);
// Dividing into 3 partitions at i, j.
fr(i,0,n-1){
fr(j,i+1,n-2){
// Let array is split into three parts whose xors are x,a,b at i, j, n-1 positions resp.
// Then x == a== b yields the below conditions.
// We are doing OR to check if atleast 1 partition exists.
// Similar to x += y, x |= y can be used if x, y are castable to `bools`.
done |= ( prefix_xor[j] == 0 and prefix_xor[i] == prefix_xor[n-1] );
}
}
if (done){
cout << "YES";
}
else{
cout << "NO";
}
}
signed main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
fastIO;
int t = 1;
cin >> t; // Comment this line if only 1 testcase exists.
fr(T,1,t){
//cout << "Case #" << T << ": ";
solve();
cout << "\n";
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
deque<int> dq;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
dq.push_back(x);
}
while (!dq.empty() && dq.front() <= k) dq.pop_front();
while (!dq.empty() && dq.back() <= k) dq.pop_back();
printf("%d\n", max(0, n - (int)dq.size()));
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 105;
int n, m, a[N][N];
int read() {
int x = 0, f = 1;
char s;
while ((s = getchar()) > '9' || s < '0')
if (s == '-') f = -1;
while (s >= '0' && s <= '9')
x = (x << 1) + (x << 3) + (s ^ 48), s = getchar();
return x * f;
}
int choose(const int x, const int y) {
if (a[x][y]) return a[x][y];
for (int i = 1; i <= 26; ++i)
if (a[x - 1][y] != i && a[x + 1][y] != i && a[x][y - 1] != i &&
a[x][y + 1] != i)
return i;
}
int main() {
int delta;
n = read(), m = read();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j]) continue;
int tmp = choose(i, j);
delta = 1;
while (i + delta <= n && j + delta <= m && choose(i, j + delta) == tmp)
++delta;
--delta;
for (int k = i; k <= i + delta; ++k)
for (int u = j; u <= j + delta; ++u) a[k][u] = tmp;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) putchar(a[i][j] + 'A' - 1);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i, x, y;
vector<pair<int, int> > posi;
vector<pair<int, int> > neg;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
if (x > 0) {
posi.push_back(make_pair(x, y));
} else {
neg.push_back(make_pair(abs(x), y));
}
}
sort(posi.begin(), posi.end());
sort(neg.begin(), neg.end());
int sum = 0;
int nsize = neg.size();
int psize = posi.size();
if (psize > nsize) {
for (i = 0; i < nsize; i++) {
sum += neg[i].second + posi[i].second;
}
sum += posi[nsize].second;
} else if (nsize > psize) {
for (i = 0; i < psize; i++) {
sum += neg[i].second + posi[i].second;
}
sum += neg[psize].second;
} else {
for (i = 0; i < psize; i++) {
sum += neg[i].second + posi[i].second;
}
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, tot = 0;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
if (a[0] < a[i] && a[n - 1] > a[i]) {
tot++;
}
}
cout << tot << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
long long int x, y;
cin >> x >> y;
long long int sum = 0;
while (x > 0 && y > 0) {
if (x > y) {
sum += x / y;
x = x % y;
} else {
sum += y / x;
y = y % x;
}
}
cout << sum << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int main() {
int n, m, l, r, t, c;
cin >> n >> m;
pair<int, int> s[n + 1];
for (int i = (1), _b = (n + 1); i < (_b); ++i) s[i] = make_pair(0, 0);
for (int i = (0), _b = (m); i < (_b); ++i) {
cin >> l >> r >> t >> c;
for (int j = (l), _b = (r + 1); j < (_b); ++j) {
if (!s[j].second)
s[j] = make_pair(t, c);
else {
if (t < s[j].first) {
s[j] = make_pair(t, c);
}
}
}
}
int ret = 0;
for (int i = (1), _b = (n + 1); i < (_b); ++i) {
ret += s[i].second;
}
cout << ret << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] + a[i + 1] < k) {
ans += k - a[i + 1] - a[i];
a[i + 1] = k - a[i];
}
}
cout << ans << "\n";
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long x, sum[2000020];
int n, Q, p, nxt[2000020], f[2000020], pre[2000020];
int qiu(long long x) {
p = 1;
int ret = (1 << 30);
for (int i = 1; i <= n; ++i) {
while (p < (n << 1) && sum[p + 1] - sum[i - 1] <= x) ++p;
nxt[i] = p + 1;
}
for (int i = n; i; --i) f[i] = f[nxt[i]] + 1, pre[i] = pre[nxt[i]];
for (int i = 1; i <= n; ++i)
if (pre[i] - i >= n) ret = min(ret, f[i]);
return ret;
}
int main() {
scanf("%d%d", &n, &Q);
for (int i = n + 1; i <= (n << 1) + 1; ++i) pre[i] = i;
for (int i = 1; i <= n; ++i) scanf("%I64d", &sum[i]);
for (int i = 1; i <= n; ++i) sum[i + n] = sum[i];
for (int i = 1; i <= (n << 1); ++i) sum[i] += sum[i - 1];
for (int i = 1; i <= Q; ++i) {
scanf("%I64d", &x);
printf("%d\n", qiu(x));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using dbl = long double;
using pii = pair<int, int>;
int MOD;
void sadd(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int add(int a, int b) {
sadd(a, b);
return a;
}
void ssub(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
int sub(int a, int b) {
ssub(a, b);
return a;
}
int mul(int a, int b) { return (a * 1LL * b) % MOD; }
const int N = 405;
int dp[N][N];
int fact[N];
int ans[N];
int splitPref[N];
void calcDp() {
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = mul(fact[i - 1], i);
for (int n = 1; n < N; n++) {
for (int k = 1; k < n; k++) {
int cur = sub(fact[k], splitPref[k]);
cur = mul(cur, fact[n - k]);
sadd(splitPref[n], cur);
}
}
dp[0][0] = 1;
for (int pos = 0; pos < N; pos++)
for (int cnt = 0; cnt <= pos; cnt++) {
int cur = dp[pos][cnt];
for (int k = 1; k + pos < N; k++)
sadd(dp[pos + k][cnt + 1], mul(cur, fact[k]));
}
for (int k = 1; k < N; k++) {
ans[k] = fact[k];
for (int t = 3; t < k; t++) ssub(ans[k], mul(dp[k][t], ans[t]));
ssub(ans[k], mul(2, splitPref[k]));
if (k < 12) (void)0;
}
}
void solve() {
int t;
scanf("%d%d", &t, &MOD);
calcDp();
ans[2] = 2;
for (int i = 0; i < t; i++) {
int n;
scanf("%d", &n);
printf("%d\n", ans[n]);
}
}
int main() {
solve();
(void)0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string st;
int ans = 0;
int main() {
cin >> st;
int n = st.size();
for (int i = 0; i < n; i++) {
string sub = "";
int usedpar = 0;
int q = 0;
int sum = 0;
for (int j = i; j < n; j++) {
sub += st[j];
if (st[j] == '(') {
sum++;
}
if (st[j] == ')') {
if (sum > 0)
sum--;
else {
if (usedpar > 0) {
usedpar--;
} else {
sum--;
}
}
if (sum < 0) {
if (q - usedpar > 0) {
q--;
sum++;
}
}
}
if (sum < 0) break;
if (st[j] == '?') {
q++;
if (sum > 0) {
usedpar++;
sum--;
}
}
if (sum == 0 && abs(q - usedpar) % 2 == 0) {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x60000000;
const int MINF = -1000000000;
const int mod = 99999997;
const long long cons = 100000;
const double pi = 3.141592653589793;
int lim;
int p[100005][20];
int depth[100005];
pair<int, int> dmax[100005][3];
int up[100005][20];
int down[100005][20];
vector<vector<int> > adj;
int n;
void dfs(int u, int prev) {
if (prev != -1) {
for (int i = 2; i >= 0; i--) {
if (dmax[prev][i].second == u) continue;
up[u][0] = dmax[prev][i].first + 1;
down[u][0] = dmax[prev][i].first;
break;
}
}
p[u][0] = prev;
for (int j = 0; j <= lim; j++) {
if (p[u][j] == -1) continue;
p[u][j + 1] = p[p[u][j]][j];
up[u][j + 1] = max(up[p[u][j]][j] + (1 << j), up[u][j]);
down[u][j + 1] = max(down[u][j] + (1 << j), down[p[u][j]][j]);
}
for (auto v : adj[u]) {
if (v == prev) continue;
depth[v] = depth[u] + 1;
dfs(v, u);
}
}
int getPar(int u, int dist) {
if (dist < 0) return -1;
for (int i = 0; i < lim; i++)
if (dist & (1 << i)) u = p[u][i];
return u;
}
int getLca(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
v = getPar(v, depth[v] - depth[u]);
if (u == v) return u;
for (int i = lim; i >= 0; i--) {
if (p[u][i] == p[v][i]) continue;
u = p[u][i];
v = p[v][i];
}
return p[u][0];
}
int getDist(int u, int v) {
int lca = getLca(u, v);
return depth[u] + depth[v] - 2 * depth[lca];
}
void buildDmax(int u, int prev) {
for (auto v : adj[u]) {
if (v == prev) continue;
buildDmax(v, u);
if (dmax[u][0].first < dmax[v][2].first + 1) {
dmax[u][0].first = dmax[v][2].first + 1;
dmax[u][0].second = v;
}
sort(dmax[u], dmax[u] + 3);
}
}
void build() {
for (lim = 0; (1 << lim) < n; lim++)
;
buildDmax(1, -1);
dfs(1, -1);
}
int getUMax(int u, int d) {
if (d < 0) return -1e7;
int ret = 0;
int added = 0;
for (int i = 0; i < lim; i++) {
if (d & (1 << i)) {
ret = max(ret, up[u][i] + added);
added |= (1 << i);
u = p[u][i];
}
}
return ret;
}
int getDMax(int u, int d) {
if (d < 0) return -1e7;
int ret = 0;
int added = d;
for (int i = 0; i < lim; i++) {
if (d & (1 << i)) {
added ^= (1 << i);
ret = max(ret, down[u][i] + added + 1);
u = p[u][i];
}
}
return ret;
}
int query(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
int lca = getLca(u, v);
int d = getDist(u, v);
int center = getPar(u, (d - 1) / 2);
int vld = getDist(v, lca);
int ans = dmax[u][2].first;
if (lca != v) ans = max(ans, dmax[v][2].first);
ans = max(ans, getUMax(v, vld - 1));
ans = max(ans, getUMax(lca, depth[lca]) + vld);
ans = max(ans, getUMax(u, depth[u] - depth[center]));
ans = max(ans, getDMax(center, depth[center] - depth[lca] - 1) + vld);
for (int i = 2; i >= 0; i--) {
if (dmax[lca][i].second == getPar(v, depth[v] - depth[lca] - 1) ||
dmax[lca][i].second == getPar(u, depth[u] - depth[lca] - 1))
continue;
ans = max(ans, dmax[lca][i].first + vld);
break;
}
return ans;
}
int main() {
scanf("%d", &n);
adj.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
build();
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d\n", query(u, v));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long inf;
int n;
long long f[65][65], sum[65];
struct tt {
long long a, b;
bool operator<(const tt &x) const { return a == x.a ? b > x.b : a > x.a; }
} p[65];
bool judge(long long mid) {
memset(f, 127, sizeof(f));
inf = f[0][0];
f[0][0] = 0;
for (int i = 1, loc; i <= n; i = loc + 1) {
for (loc = i; p[loc + 1].a == p[i].a; loc++)
;
sum[i - 1] = 0;
for (int j = i; j <= loc; j++) sum[j] = sum[j - 1] + p[j].b;
for (int j = 0; j <= n; j++)
if (f[i - 1][j] != inf) {
for (int k = max(0, (loc - i + 1) - (2 * j - (i - 1)));
k <= min(n - j, loc - i + 1); k++) {
f[loc][j + k] =
min(f[loc][j + k], f[i - 1][j] + p[i].a * k -
mid * (sum[i + k - 1] - sum[i - 1]));
}
}
}
for (int i = 0; i <= n; i++)
if (f[n][i] <= 0) return true;
return false;
}
void work() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &p[i].a), p[i].a *= 1000;
for (int i = 1; i <= n; i++) scanf("%I64d", &p[i].b);
sort(p + 1, p + n + 1);
long long l = 1, r = 1ll * 100000000 * 1000, ans;
while (l <= r) {
long long mid = (l + r) >> 1;
if (judge(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%I64d\n", ans);
}
int main() {
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int sum = 0;
int num[n];
int cou = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
int koal = a[0];
if (a[0] >= (sum / 2) + 1)
cout << cou << '\n' << cou;
else {
for (int i = 1; i < n; i++) {
if (a[0] >= (a[i] * 2)) {
koal += a[i];
num[cou++] = i + 1;
}
}
if (koal >= (sum / 2) + 1) {
cout << cou << '\n' << '1' << ' ';
for (int i = 1; i < cou; i++) cout << num[i] << ' ';
} else
cout << '0';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e9 + 7;
ll bpow(ll a, ll b, ll m) {
a %= m;
ll res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll modinv(ll n, ll p) { return bpow(n, p - 2, p); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
ll a[n], b[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
ll check = 1 << 9;
check--;
ll ans;
for (; check >= 0; check--) {
bool cc = false;
for (int i = 0; i < n; i++) {
cc = false;
for (int j = 0; j < m; j++) {
if (((a[i] & b[j]) | check) == check) {
cc = true;
break;
}
}
if (!cc) break;
}
if (cc) {
ans = check;
}
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
pair<int, int> ans;
int a[100001];
bool fx = false, fy = false;
int main() {
int n, l, x, y;
cin >> n >> l >> x >> y;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
mp[a[i]] = 1;
}
for (int i = 0; i < n; ++i) {
if (mp.find(a[i] - x) != mp.end() || mp.find(a[i] + x) != mp.end())
fx = true;
if (mp.find(a[i] - y) != mp.end() || mp.find(a[i] + y) != mp.end())
fy = true;
if (fx && fy) {
cout << "0" << endl;
return 0;
}
}
if (fx && !fy) {
cout << "1" << endl << y << endl;
return 0;
}
if (!fx && fy) {
cout << "1" << endl << x << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
if (a[i] + x <= l && mp.find(a[i] + x + y) != mp.end()) {
cout << "1" << endl << a[i] + x << endl;
return 0;
}
if (a[i] - x >= 0 && mp.find(a[i] - x + y) != mp.end()) {
cout << "1" << endl << a[i] - x << endl;
return 0;
}
if (a[i] + x <= l && mp.find(a[i] + x - y) != mp.end()) {
cout << "1" << endl << a[i] + x << endl;
return 0;
}
}
printf("2\n%d %d\n", x, y);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
if (n == 1)
cout << "9 8" << endl;
else {
cout << n * 3 << " " << n * 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[5005];
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
for (int i = 0; i < m; ++i) {
for (int j = n - 1; j > -1; --j) {
if (s[j] == t[i]) {
dp[j + 1] = (dp[j + 1] + dp[j] + 1) % 1000000007;
}
}
}
int ret = 0;
for (int j = 0; j <= n; ++j) {
ret = (ret + dp[j]) % 1000000007;
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[101];
gets(str);
int i = 2, l;
while (str[strlen(str) - i] == ' ') {
i++;
}
l = strlen(str) - i;
if (str[l] == 'a' || str[l] == 'e' || str[l] == 'i' || str[l] == 'o' ||
str[l] == 'u' || str[l] == 'y' || str[l] == 'A' || str[l] == 'E' ||
str[l] == 'I' || str[l] == 'O' || str[l] == 'U' || str[l] == 'Y') {
printf("YES");
} else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int arr[n];
long long int queries[m];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) cin >> queries[i];
long long int A[n + 1];
long long int soma = 0;
A[0] = 0;
for (int i = 0; i < n; i++) {
soma += arr[i];
A[0] = min(A[0], soma);
}
for (int i = 0; i < n; i++) {
int h = -1;
long long int answer = A[i];
long long int sum = 0;
long long int accmin[n];
accmin[0] = 0;
for (int j = 0; j < n - 1; j++) {
sum += arr[j];
accmin[j + 1] = min(sum, accmin[j]);
}
sum += arr[n - 1];
long long int peak = sum;
for (int j = n - 1; j > 0; j--) {
peak = min(peak, sum);
long long int candidate = min(accmin[j - 1], peak - arr[j - 1]);
if (answer < candidate) {
answer = candidate;
h = j - 1;
}
sum -= arr[j];
}
if (accmin[n - 1] > answer) {
answer = accmin[n - 1];
h = n - 1;
}
if (h != -1) {
arr[h] = 0;
}
A[i + 1] = answer;
}
for (int q = 0; q < m; q++) {
int lo, hi;
hi = n;
lo = -1;
while (hi - lo > 1) {
int mid = (hi + lo) / 2;
if (A[mid] + queries[q] < 0)
lo = mid;
else
hi = mid;
}
cout << hi << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, m, k, a[1005][1005];
int main() {
while (scanf("%d%d%d", &m, &n, &k) != EOF) {
int i, j;
for (i = 1; i <= m; ++i)
for (j = 1; j <= n; ++j) scanf("%d", &a[i][j]);
int r[1005], c[1005];
for (i = 1; i <= m; ++i) r[i] = i;
for (i = 1; i <= n; ++i) c[i] = i;
int x, y;
char op;
for (i = 0; i < k; ++i) {
getchar();
scanf("%c%d%d", &op, &x, &y);
if (op == 'r') {
int tt = r[x];
r[x] = r[y], r[y] = tt;
} else if (op == 'c') {
int tt = c[x];
c[x] = c[y], c[y] = tt;
} else
printf("%d\n", a[r[x]][c[y]]);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
int N;
cin >> N;
vector<char> command(N);
for (int i = 0; i < N; ++i) {
cin >> command[i];
}
long long int dp[N][N];
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
dp[i][j] = 0;
}
}
dp[0][0] = 1;
for (int i = 1; i < N; ++i) {
if (command[i - 1] == 'f') {
dp[i][0] = 0;
for (int j = 1; j < N; ++j) {
dp[i][j] = dp[i - 1][j - 1];
}
} else {
for (int k = 0; k < N; ++k) {
dp[i][0] = (dp[i][0] % M + dp[i - 1][k] % M) % M;
}
for (int j = 1; j < N; ++j) {
dp[i][j] = (dp[i][j - 1] % M - dp[i - 1][j - 1] % M + M) % M;
}
}
}
long long int ans = 0;
for (int i = 0; i < N; ++i) {
ans = (ans % M + dp[N - 1][i] % M) % M;
}
cout << ans % M;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
if (n == 1)
cout << 1;
else {
long long arr[n];
for (long long i = 1; i <= n; ++i) arr[i] = i;
for (long long i = 1; i <= n; ++i) swap(arr[i], arr[n]);
for (long long i = 1; i <= n; ++i) cout << arr[i] << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500;
int p[N];
int main() {
int n, m;
cin >> n >> m;
int ans = 0, bt = 0, pos = 1, mn = 0;
int mas[N][N] = {0};
for (int i = 1; i <= n; i++) p[i] = i;
do {
for (int i = 1; i <= n; i++) {
mn = p[i];
for (int j = i; j <= n; j++) {
mn = min(mn, p[j]);
ans += mn;
}
}
if (ans > bt) {
for (int i = 1; i <= pos; i++)
for (int j = 1; j <= n; j++) mas[i][j] = 0;
pos = 1;
for (int i = 1; i <= n; i++) {
mas[pos][i] = p[i];
}
pos++;
bt = ans;
} else if (ans == bt) {
for (int i = 1; i <= n; i++) {
mas[pos][i] = p[i];
}
pos++;
}
ans = 0;
} while (std::next_permutation(p + 1, p + n + 1));
for (int i = 1; i <= n; i++) cout << mas[m][i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, 1, -1}, dy[] = {-1, 1, 0, 0};
const int dxx[] = {0, 0, 1, -1, -1, -1, 1, 1},
dyy[] = {-1, 1, 0, 0, 1, -1, 1, -1};
ifstream f("");
ofstream g("");
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n, m, prv = 0, prvmax = -1;
cin >> n >> m;
vector<int> v(0);
for (int a; n; n--) cin >> a, v.push_back(a);
vector<pair<long long, long long> > w(0);
for (int a, b; m; m--) cin >> a >> b, w.push_back({a, b});
sort(w.begin(), w.end());
for (int i = 0; i <= w.size() - 1; i++) {
w[i].first = max(w[i].first, prvmax);
prvmax = w[i].first;
w[i].second += prv;
prv = w[i].second;
}
for (auto i : v)
if (i < w.front().first)
cout << "0 ";
else if (i >= w.back().first)
cout << w.back().second << " ";
else {
int st = 0, dr = w.size() - 1, rz;
while (st <= dr) {
int m = (st + dr) / 2;
if (w[m].first <= i)
st = m + 1, rz = m;
else
dr = m - 1;
}
cout << w[rz].second << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const string nw[] = {
"", "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na",
"Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V",
"Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br",
"Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag",
"Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr",
"Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu",
"Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi",
"Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am",
"Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr"};
map<string, int> t;
int read() {
string s;
cin >> s;
return t[s];
}
int n, m;
int a[17], b[17];
int sum[1 << 17];
int len[1 << 17];
int pup[1 << 17];
vector<vector<int>> sol;
void print(bool ok) {
if (!ok) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (auto &rw : sol) {
int sz = (int)rw.size();
for (int j = 0; j + 1 < sz; j++) {
cout << nw[rw[j]];
if (j == sz - 2)
cout << "->";
else
cout << "+";
}
cout << nw[rw[sz - 1]] << "\n";
}
}
int main() {
for (int i = 1; i <= 100; i++) t[nw[i]] = i;
cin >> n >> m;
for (int i = 0; i < n; i++) a[i] = read();
for (int i = 0; i < m; i++) b[i] = read();
for (int mk = 0; mk < (1 << n); mk++)
for (int j = 0; (1 << j) <= mk; j++)
if (mk & (1 << j)) sum[mk] += a[j];
len[0] = 0;
for (int mk = 1; mk < (1 << n); mk++) {
len[mk] = -1;
for (int sub = mk; 1; sub = (sub - 1) & mk) {
int dif = mk - sub;
if (len[mk] == len[sub]) pup[mk] = sub;
if (len[sub] < 0) continue;
int need = b[len[sub]];
if (sum[dif] == need) {
len[mk] = max(len[mk], len[sub] + 1);
if (len[sub] + 1 == len[mk]) pup[mk] = sub;
}
if (sub == 0) break;
}
}
if (len[(1 << n) - 1] >= m) {
int cur = (1 << n) - 1;
int jj = m - 1;
while (cur) {
int ant = pup[cur];
vector<int> addup;
int sub = cur - ant;
for (int j = 0; (1 << j) <= sub; j++)
if (sub & (1 << j)) addup.push_back(a[j]);
addup.push_back(b[jj]);
sol.push_back(addup);
jj--;
cur = ant;
}
print(1);
} else
print(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T, typename... U>
inline void read(T& x, U&... y) {
read(x), read(y...);
}
int Q;
struct Point {
int x, y;
Point() {}
Point(int x, int y) : x(x), y(y) {}
bool operator<(const Point& rhs) const {
return x == rhs.x ? y < rhs.y : x < rhs.x;
}
} O;
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
Point operator+(Point A, Point B) {
Point C(A.x + B.x, A.y + B.y);
int t = GCD(C.x, C.y);
C.x /= t;
C.y /= t;
return C;
}
map<long long, set<Point>> RD;
map<Point, int> L;
int main() {
read(Q);
O = Point(0, 0);
int now = 0;
while (Q--) {
int opt, x, y;
read(opt, x, y);
long long d = 1ll * x * x + 1ll * y * y;
Point P(x, y);
if (opt == 1) {
for (auto t : RD[d]) L[P + t] += 2;
++L[P + O];
++now;
RD[d].insert(P);
}
if (opt == 2) {
RD[d].erase(RD[d].find(P));
for (auto t : RD[d]) L[P + t] -= 2;
--L[P + O];
--now;
}
if (opt == 3) printf("%d\n", now - L[P + O]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int str2int(string s) {
istringstream ss(s);
int t;
ss >> t;
return t;
}
int main() {
string s;
cin >> s;
int ans = -1;
for (int i = 1; i < s.length(); i++) {
string s1 = s.substr(0, i);
if (s1.length() > 1 && s1[0] == '0') continue;
int t1 = str2int(s1);
if (t1 > 1000000) continue;
for (int j = 1; j < s.length(); j++) {
if (i + j >= s.length()) continue;
string s2 = s.substr(i, j);
string s3 = s.substr(i + j);
if (s2.length() > 1 && s2[0] == '0') continue;
if (s3.length() > 1 && s3[0] == '0') continue;
int t2 = str2int(s2);
int t3 = str2int(s3);
if (t2 > 1000000) continue;
if (t3 > 1000000) continue;
int temp = t1 + t2 + t3;
if (temp > ans) ans = temp;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
int lst[305], to[100005], pre[100005], tot;
int from[305];
bool vis[305];
inline void add_edge(int u, int v) {
to[tot] = v;
pre[tot] = lst[u];
lst[u] = tot++;
}
bool work(int u) {
for (int i = lst[u]; ~i; i = pre[i]) {
if (vis[to[i]]) continue;
vis[to[i]] = true;
if (from[to[i]] == -1 || work(from[to[i]])) {
from[to[i]] = u;
return true;
}
}
return false;
}
inline void hungary(int n) {
memset(from, -1, sizeof(from));
for (int i = 0; i < n; i++) {
memset(vis, false, sizeof(vis));
work(i);
}
}
namespace maxflower {
int lst[305], to[100005], pre[100005], cap[100005], tot;
int que[305], fst[305], dep[305];
inline void init() { memset(lst, -1, sizeof(lst)); }
inline void add_edge(int u, int v, int _cap) {
to[tot] = v;
pre[tot] = lst[u];
cap[tot] = _cap;
lst[u] = tot++;
to[tot] = u;
pre[tot] = lst[v];
cap[tot] = 0;
lst[v] = tot++;
}
inline bool bfs(int s, int t) {
int he = 0, ta = 0;
memset(dep, -1, sizeof(dep));
que[ta++] = s;
dep[s] = 0;
while (he < ta) {
int u = que[he++];
for (int i = lst[u]; ~i; i = pre[i]) {
if (cap[i] && dep[to[i]] == -1) {
dep[to[i]] = dep[u] + 1;
que[ta++] = to[i];
}
}
}
return ~dep[t];
}
int dfs(int u, int t, int mx) {
if (u == t) return mx;
int ans = 0;
for (int i = fst[u]; ~i; i = pre[i]) {
if (cap[i] && dep[to[i]] == dep[u] + 1) {
int res = dfs(to[i], t, std::min(mx - ans, cap[i]));
cap[i] -= res;
cap[i ^ 1] += res;
if (cap[i]) fst[u] = i;
ans += res;
if (ans == mx) return ans;
}
}
if (!ans) dep[u] = -1;
return ans;
}
inline int dinic(int s, int t) {
int ans = 0;
while (bfs(s, t)) {
memcpy(fst, lst, sizeof(lst));
ans += dfs(s, t, 1e9);
}
return ans;
}
} // namespace maxflower
int main() {
memset(lst, -1, sizeof(lst));
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int len;
scanf("%d", &len);
for (int j = 0; j < len; j++) {
int x;
scanf("%d", &x);
add_edge(i, --x);
}
}
hungary(n);
maxflower::init();
for (int i = 0; i < n; i++) {
for (int j = lst[i]; ~j; j = pre[j])
maxflower::add_edge(i + 1, from[to[j]] + 1, 1e9);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x < 0) {
maxflower::add_edge(0, i + 1, -x);
ans += x;
} else
maxflower::add_edge(i + 1, n + 1, x);
}
printf("%d\n", ans + maxflower::dinic(0, n + 1));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 1) + (v << 3) + c - '0';
return;
}
int get() {
int v;
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 1) + (v << 3) + c - '0';
return v;
}
int a[1000 + 80];
int close(double x, double y) { return x < y + 1e-2 && y < x + 1e-2; }
int main() {
int n, i, j;
double kk, b1, b2;
bool flag;
get(n);
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 2; i <= n; i++) {
kk = (a[i] - a[1]) / (i - 1.0);
flag = 0;
b1 = a[1] - 1 * kk;
for (j = 1; j <= n; j++) {
if (close(a[j], kk * j + b1)) continue;
if (flag && close(a[j], kk * j + b2)) continue;
if (flag)
break;
else {
flag = 1;
b2 = a[j] - kk * j;
}
}
if (j > n && flag) goto YES;
}
for (i = 3; i <= n; i++) {
kk = (a[i] - a[2]) / (i - 2.0);
flag = 0;
b1 = a[2] - 2 * kk;
for (j = 1; j <= n; j++) {
if (close(a[j], kk * j + b1)) continue;
if (flag && close(a[j], kk * j + b2)) continue;
if (flag)
break;
else {
flag = 1;
b2 = a[j] - kk * j;
}
}
if (j > n && flag) goto YES;
}
if (0)
YES:
puts("Yes");
else
puts("NO");
return 0;
}
| 4 |
//By: Luogu@rui_er(122461)
#include <bits/stdc++.h>
#define loop while(true)
#define rep(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define per(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define fil(x,y) memset((x), (y), sizeof(x))
using namespace std;
typedef long long ll;
const int N = 105;
int T, n, m, s[N<<1];
int main() {
scanf("%d", &T);
while(T--) {
int _ = 0; fil(s, 0);
scanf("%d%d", &n, &m);
rep(i, 1, n) rep(j, 1, m) {int x; scanf("%d", &x); s[i+j] ^= x;}
rep(i, 2, n+m) if(s[i]) {puts("Ashish"); _ = 1; break;}
if(!_) puts("Jeel");
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
const int MAXV = 1e9;
struct Seg {
int desde, hasta;
long long suma;
int cantidad;
Seg *izq, *der;
Seg(int i, int d)
: desde(i), hasta(d), suma(0), cantidad(0), izq(NULL), der(NULL) {}
void actualiza() {
suma = 0;
cantidad = 0;
if (izq != NULL) {
suma += izq->suma;
cantidad += izq->cantidad;
}
if (der != NULL) {
suma += der->suma;
cantidad += der->cantidad;
}
}
void add(int p) {
if (desde >= hasta) {
cantidad++;
suma += p;
} else {
int mitad = (desde + hasta) / 2;
if (mitad < 0 && (desde + hasta) % 2 != 0) mitad--;
if (p <= mitad) {
if (izq == NULL) izq = new Seg(desde, mitad);
izq->add(p);
} else {
if (der == NULL) der = new Seg(mitad + 1, hasta);
der->add(p);
}
actualiza();
}
}
void remove(int p) {
if (desde >= hasta) {
cantidad--;
suma -= p;
} else {
if (izq != NULL && p <= izq->hasta)
izq->remove(p);
else
der->remove(p);
actualiza();
}
}
long long min_query(int k) {
if (cantidad <= k) return suma;
if (desde >= hasta) {
long long ret = k;
ret *= (long long)desde;
return ret;
}
if (izq != NULL) {
if (izq->cantidad >= k) return izq->min_query(k);
long long ret = izq->suma;
if (der != NULL) ret += der->min_query(k - izq->cantidad);
return ret;
}
return der->min_query(k);
}
long long max_query(int k) {
if (cantidad <= k) return suma;
if (desde >= hasta) {
long long ret = k;
ret *= (long long)desde;
return ret;
}
if (der != NULL) {
if (der->cantidad >= k) return der->max_query(k);
long long ret = der->suma;
if (izq != NULL) ret += izq->max_query(k - der->cantidad);
return ret;
}
return izq->max_query(k);
}
};
long long arr[MAXN + 2];
Seg *tree_neg, *tree_pst;
long long resuelve(long long sum, int k) {
long long ret = abs(sum - 2LL * tree_neg->min_query(k));
ret = max(ret, abs(sum - 2LL * tree_pst->max_query(k)));
ret = max(ret, abs(sum));
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, len;
cin >> n >> len;
for (int i = 0; i < n; ++i) cin >> arr[i];
int k;
cin >> k;
tree_neg = new Seg(-MAXV, -1);
tree_pst = new Seg(1, MAXV);
long long sum = 0, mejor;
int c = 0, f = len;
for (int i = 0; i < len; ++i) {
sum += arr[i];
if (arr[i] < 0)
tree_neg->add(arr[i]);
else if (arr[i] > 0)
tree_pst->add(arr[i]);
}
mejor = resuelve(sum, k);
while (f < n) {
if (arr[c] < 0)
tree_neg->remove(arr[c]);
else if (arr[c] > 0)
tree_pst->remove(arr[c]);
sum -= arr[c];
c++;
if (arr[f] < 0)
tree_neg->add(arr[f]);
else if (arr[f] > 0)
tree_pst->add(arr[f]);
sum += arr[f];
f++;
mejor = max(mejor, resuelve(sum, k));
}
cout << mejor << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433;
const long long M = 998244353;
long long n, a, b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
if ((n + 4) % 2 == 0 || (n + 4) % 3 == 0)
cout << n + 4 << " " << 4;
else if ((n + 6) % 2 == 0 || (n + 6) % 3 == 0)
cout << n + 6 << " " << 6;
else
cout << n + 8 << " " << 8;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int hell = 1000000007;
const long long int maxn = 1e5 + 5;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
map<long long int, long long int> d;
long long int sum = 0, ans = 2e18;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
sum += x;
d[sum]++;
ans = min(ans, n - d[sum]);
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 5005;
int n, q, a[M];
int f[M][M];
int dp[M][M];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i][i] = dp[i][i] = a[i];
}
for (int d = 2; d <= n; d++) {
for (int l = 1; l <= n - d + 1; l++) {
int r = l + d - 1;
f[l][r] = f[l + 1][r] ^ f[l][r - 1];
}
}
for (int d = 2; d <= n; d++) {
for (int l = 1; l <= n - d + 1; l++) {
int r = l + d - 1;
dp[l][r] = max(f[l][r], max(dp[l + 1][r], dp[l][r - 1]));
}
}
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d\n", dp[u][v]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string itosm(long long x) {
if (x == 0) return "0";
string res = "";
while (x > 0) {
res += ((x % 10) + '0');
x /= 10;
}
reverse(res.begin(), res.end());
return res;
}
long long stoim(string str) {
long long res = 0;
int p = 0;
if (str[0] == '-') p++;
for (int i = p; i < str.length(); i++) {
res *= 10;
res += (str[i] - '0');
}
return res;
}
const long long infll = 1e18 + 3;
const int inf = 1009000999;
const long double eps = 1e-7;
const int maxn = 1e6 + 1146;
const int baseint = 1000200013;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
const long long mod = 1e9 + 9;
void solve() {
long long n, l, w;
cin >> n >> l >> w;
vector<long long> a;
vector<long long> b;
for (int i = 0; i < n; i++) {
int x, u;
cin >> x >> u;
if (u == 1)
a.push_back(x);
else
b.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long ans = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] < 0) {
if (a[i] + l > 0)
ans += (b.end() - upper_bound(b.begin(), b.end(), 0));
else {
double th = (-2 * a[i]);
th = th / (w + 1);
th = th + a[i] - l;
int t = ceil(th);
if (t != th) t--;
ans += (b.end() - upper_bound(b.begin(), b.end(), t));
}
} else {
if (w != 1) {
double th = (2 * a[i]);
th = th / (w - 1);
th = th + a[i] - l;
int t = ceil(th);
if (t != th) t--;
ans += (b.end() - upper_bound(b.begin(), b.end(), t));
}
}
}
cout << ans;
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
;
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Node {
int x, y;
} node[50];
int tot;
map<int, bool> f;
double s;
int p1, p2, p3, p4;
bool check(int i, int j) {
if (i < 0 || i > n) return false;
if (j < 0 || j > m) return false;
if (f[i * 10000 + j]) return false;
f[i * 10000 + j] = true;
return true;
}
double dis(int a, int b) {
double tmp = (node[a].x - node[b].x) * (node[a].x - node[b].x) +
(node[a].y - node[b].y) * (node[a].y - node[b].y);
tmp = sqrt(tmp);
return tmp;
}
void work(int a, int b, int c, int d) {
if ((a == b) || (a == c) || (a == d) || (b == c) || (b == d) || (c == d))
return;
double tmp = 0;
tmp = dis(a, b) + dis(b, c) + dis(c, d);
if (tmp > s) {
s = tmp;
p1 = a;
p2 = b;
p3 = c;
p4 = d;
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
f.clear();
tot = 0;
s = 0;
for (int i = -4; i < 5; i++)
for (int j = -4; j < 5; j++) {
if (check(i, j)) {
tot++;
node[tot].x = i;
node[tot].y = j;
}
if (check(n + i, m + j)) {
tot++;
node[tot].x = n + i;
node[tot].y = m + j;
}
}
for (int a = 1; a <= tot; a++)
for (int b = 1; b <= tot; b++)
for (int c = 1; c <= tot; c++)
for (int d = 1; d <= tot; d++) {
work(a, b, c, d);
}
printf("%d %d\n", node[p1].x, node[p1].y);
printf("%d %d\n", node[p2].x, node[p2].y);
printf("%d %d\n", node[p3].x, node[p3].y);
printf("%d %d\n", node[p4].x, node[p4].y);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char LR;
char str[101];
char key[40] = "qwertyuiopasdfghjkl;zxcvbnm,./";
scanf("%c", &LR);
scanf("%s", &str);
if (LR == 'L') {
int len = strlen(str);
for (int i = 0; i < len; i++) {
for (int j = 0; j < 30; j++) {
if (str[i] == key[j]) {
printf("%c", key[j + 1]);
break;
}
}
}
} else {
int len = strlen(str);
for (int i = 0; i < len; i++) {
for (int j = 0; j < 30; j++) {
if (str[i] == key[j]) {
printf("%c", key[j - 1]);
break;
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
const int inf = 1e9 + 7;
;
const unsigned long long int INF = 1e12 + 7;
const double pi = 2 * acos(0);
int64_t gcd(int64_t a, int64_t b) { return b == 0 ? a : gcd(b, a % b); }
int64_t lcm(int64_t a, int64_t b) { return a / gcd(a, b) * b; }
int64_t mod_pow(int64_t a, int64_t b, int64_t m) {
if (b == 0) return 1;
if (b & 1) return a * mod_pow(a, b - 1, m) % m;
return mod_pow(a * a % m, b >> 1, m);
}
bool is_prime(int64_t x) {
if (x <= 3) return x >= 2;
if (x % 2 == 0) return false;
for (int64_t d = 3; d * d <= x; d += 2) {
if (x % d == 0) return false;
}
return true;
}
int arr[500010];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= n; ++i) std::cin >> arr[i];
for (int i = 2; i <= n; ++i) {
arr[i] += arr[i - 1];
}
int ind = 1, m = arr[k];
for (int i = k + 1; i <= n; ++i) {
if (arr[i] - arr[i - k] < m) {
m = arr[i] - arr[i - k];
ind = i - k + 1;
}
}
std::cout << ind << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int S[n], C[n];
for (int i = 0; i < n; i++) cin >> S[i];
for (int i = 0; i < n; i++) cin >> C[i];
long long int mina, minb, min = INT_MAX, sum, a, b, c;
bool founda = false, foundb = false;
for (int i = 1; i < (n - 1); i++) {
mina = INT_MAX;
for (int j = i - 1; j >= 0; j--) {
if (S[i] > S[j]) {
founda = true;
if (C[j] < mina) {
a = j;
mina = C[j];
}
}
}
minb = INT_MAX;
for (int j = i + 1; j < n; j++) {
if (S[i] < S[j]) {
foundb = true;
if (C[j] < minb) {
c = j;
minb = C[j];
}
}
}
sum = C[i] + mina + minb;
if (sum < min) {
b = i;
min = sum;
}
}
if (!(founda && foundb))
cout << -1;
else {
cout << min;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[500009];
int n, k;
char f(int x, int y) {
char cc = 'A' + (k - 1);
for (char c = 'A'; c <= cc; c++) {
if (c != s[x] && c != s[y]) return c;
}
return '0';
}
int main() {
int i, j, m, d, test, t = 0;
while (scanf("%d%d", &n, &k) == 2) {
scanf("%s", s + 1);
s[0] = '0';
int cnt = 0;
if (k == 2) {
int cnt1 = 0, cnt2 = 0;
for (i = 1; i <= n; i++) {
if (i % 2 == 1 && s[i] == 'B') cnt1++;
if (i % 2 == 0 && s[i] == 'A') cnt1++;
}
for (i = 1; i <= n; i++) {
if (i % 2 == 0 && s[i] == 'B') cnt2++;
if (i % 2 == 1 && s[i] == 'A') cnt2++;
}
if (cnt1 <= cnt2) {
for (i = 1; i <= n; i++) {
if (i % 2 == 1)
s[i] = 'A';
else
s[i] = 'B';
}
} else {
for (i = 1; i <= n; i++) {
if (i % 2 == 1)
s[i] = 'B';
else
s[i] = 'A';
}
}
printf("%d\n%s\n", min(cnt1, cnt2), s + 1);
continue;
}
for (i = 1; i < n; i++) {
if (s[i] == s[i + 1]) {
cnt++;
if (i != n - 1 && s[i] == s[i + 2]) {
s[i + 1] = f(i, i + 2);
i++;
} else
s[i] = f(i - 1, i + 1);
}
}
printf("%d\n%s\n", cnt, s + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100069], ps[100069], sq[100069];
int main() {
long long t, rr, i, j, k, sm;
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
sort(a + 1, a + n + 1, greater<long long>());
for (i = 1; i <= n; i++) {
ps[i] = ps[i - 1] + a[i];
}
for (i = 1; i <= 100000; i++) {
sm = 0;
k = 1;
for (j = 0; sm < n; j++) {
sq[i] += (ps[min(sm + k, n)] - ps[sm]) * j;
sm += k;
k *= i;
}
}
scanf("%lld", &t);
for (rr = 0; rr < t; rr++) {
scanf("%lld", &k);
printf("%lld%c", sq[k], " \n"[rr == t - 1]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
int m = 0, n = 0;
for (int i = 0; i < x; i++) {
int a, b;
cin >> a >> b;
if (b > a) {
cout << "Happy Alex";
return 0;
}
}
cout << "Poor Alex";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int arr[n + 1];
int sum[n + 1];
int i;
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
sum[0] = 0;
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + arr[i];
}
int count = 0;
for (i = 2; i <= n; i++) {
int sum1 = sum[i - 1];
int sum2 = sum[n] - sum[i - 1];
if (sum1 == sum2) {
count += 1;
}
}
cout << count << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > ans;
void tree_size(const vector<vector<int> > &g, vector<int> &sz, int u,
int parent = -1) {
sz[u] = 1;
for (int i = 0; i < g[u].size(); i++)
if (g[u][i] != parent) {
tree_size(g, sz, g[u][i], u);
sz[u] += sz[g[u][i]];
}
}
int tree_centroid(const vector<vector<int> > &g, int u = 0) {
vector<int> sz(g.size());
tree_size(g, sz, u);
for (int i = 0; i < g[u].size(); i++)
if (sz[g[u][i]] > g.size() / 2) return tree_centroid(g, g[u][i]);
return u;
}
void dfs(const vector<vector<int> > &g, const vector<int> &sz, int u,
int parent, const vector<int> &a) {
for (int i = 0, s = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == parent) continue;
ans.push_back(make_pair(make_pair(u, v), a[s]));
vector<int> t;
for (int j = 1; j < sz[v]; j++) t.push_back(a[s + j] - a[s]);
dfs(g, sz, v, u, t);
s += sz[v];
}
}
int main(int argc, char *argv[]) {
int n;
cin >> n;
vector<vector<int> > g(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
if (u > v) swap(u, v);
g[u].push_back(v);
g[v].push_back(u);
}
int c = tree_centroid(g);
vector<int> sz(n);
tree_size(g, sz, c);
vector<pair<int, int> > g1, g2;
for (int i = 0; i < g[c].size(); i++)
g2.push_back(make_pair(sz[g[c][i]], g[c][i]));
sort(g2.begin(), g2.end());
int sum = 0;
while (sum * 3 < (n - 1)) {
sum += g2.back().first;
g1.push_back(g2.back());
g2.pop_back();
}
vector<int> a(sum), b(n - sum - 1);
for (int i = 0; i < a.size(); i++) a[i] = i + 1;
for (int i = 0; i < b.size(); i++) b[i] = (i + 1) * (sum + 1);
g[c].clear();
for (int i = 0; i < g1.size(); i++) g[c].push_back(g1[i].second);
dfs(g, sz, c, -1, a);
g[c].clear();
for (int i = 0; i < g2.size(); i++) g[c].push_back(g2[i].second);
dfs(g, sz, c, -1, b);
for (int i = 0; i < ans.size(); i++)
cout << (ans[i].first.first + 1) << ' ' << (ans[i].first.second + 1) << ' '
<< ans[i].second << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long MOD = 998244353;
long long fact[N], invfact[N];
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
long long modinv(long long k) { return pow(k, MOD - 2, MOD); }
void precompute() {
fact[0] = fact[1] = 1;
for (long long i = 2; i < N; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
invfact[N - 1] = modinv(fact[N - 1]);
for (long long i = N - 2; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1);
invfact[i] %= MOD;
}
}
long long n;
long long a[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
precompute();
long long t;
cin >> t;
while (t--) {
cin >> n;
map<long long, long long> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a + 1, a + n + 1);
long long mx = a[n];
long long mx2 = a[n - 1];
if (mx == mx2) {
long long ans = fact[n];
cout << ans << "\n";
} else if (mx > mx2 + 1)
cout << 0 << "\n";
else {
long long totalWays = fact[n];
long long invalidWays = (fact[n] * modinv(m[mx2] + 1)) % MOD;
long long ans = (totalWays - invalidWays + MOD) % MOD;
cout << ans << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int tab[5005];
int d[5005][5005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%*f", &tab[i]);
}
int bst;
for (int j = 1; j <= m; j++) d[0][j] = 0;
d[0][tab[0]] = 1;
bst = 1;
for (int i = 1; i < n; i++) {
int mv = 0;
for (int j = 0; j <= tab[i]; j++) {
mv = max(mv, d[i - 1][j]);
d[i][j] = d[i - 1][j];
}
d[i][tab[i]] = max(mv, 0) + 1;
bst = max(bst, d[i][tab[i]]);
for (int j = tab[i] + 1; j <= m; j++) d[i][j] = d[i - 1][j];
}
printf("%d\n", n - bst);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const long long inf = 1e13;
namespace bf {
long long dis[N], iq[N], pre[N];
vector<pair<int, long long>> edge[N];
int vis[N];
void add_edge(int u, int v, int w) { edge[u].push_back(make_pair(v, w)); }
void init() {
for (int i = 0; i < N; ++i) {
dis[i] = inf;
vis[i] = 0;
edge[i].clear();
}
}
bool relax(int u, int v, long long w) {
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
pre[v] = u;
return true;
}
return false;
}
bool bellman_ford(int beginning, int n) {
dis[beginning] = 0;
priority_queue<pair<int, long long>> que;
que.push({beginning, 0});
bool flag = true;
int cur;
while (!que.empty()) {
cur = que.top().first;
que.pop();
vis[cur]++;
for (auto &s : edge[cur])
if (relax(cur, s.first, s.second)) que.push({s.first, dis[s.first]});
if (vis[cur] > n + 1) {
flag = false;
break;
}
}
return flag;
}
} // namespace bf
using namespace bf;
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *oh = obuf;
std::streambuf *fb;
inline void print(char c) {
oh == obuf + OUT_LEN ? (fb->sputn(obuf, OUT_LEN), oh = obuf) : 0;
*oh++ = c;
}
template <class T>
inline void print(T x) {
static int buf[30], cnt;
if (x == 0) {
print('0');
return;
}
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 | 48;
while (cnt) print((char)buf[cnt--]);
}
inline void flush() { fb->sputn(obuf, oh - obuf); }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
fb = cout.rdbuf();
int n, m, k, u, v, w;
cin >> n >> m;
memset(pre, -1, sizeof(pre));
init();
for (int i = 0; i < m; ++i) {
cin >> u >> v >> w;
add_edge(u, v, w);
add_edge(v, u, w);
}
bellman_ford(1, n);
stack<int> ans;
if (pre[n] == -1)
print('-'), print(1);
else {
int k = pre[n];
ans.push(n);
while (k != -1) {
ans.push(k);
k = pre[k];
}
while (!ans.empty()) {
print(ans.top()), print(' ');
ans.pop();
}
}
flush();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 45;
int a[maxn];
int d[100000 + 10];
int main() {
int n, i;
a[1] = a[2] = 1;
for (i = 3; i < maxn; ++i) a[i] = a[i - 1] + a[i - 2];
while (cin >> n) {
for (i = 1; i <= n; ++i) cin >> d[i];
if (n == 1) {
cout << "1" << endl;
continue;
}
int Max = 2;
int cnt = 2;
for (i = 3; i <= n; ++i) {
if (d[i] == d[i - 1] + d[i - 2])
cnt++;
else {
if (cnt > Max) Max = cnt;
cnt = 2;
}
}
if (Max < cnt) Max = cnt;
cout << Max << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to;
int next;
} e[2000005];
int t, n, edgenum, head[1000005], d[1000005], num[1000005];
void add(int u, int v) {
e[++edgenum].to = v;
e[edgenum].next = head[u];
head[u] = edgenum;
}
inline bool read() {
char c = getchar();
while (c != 'N' && c != 'W') c = getchar();
return c == 'W';
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n + 9; i++) d[i] = num[i] = head[i] = 0;
bool flag = 0;
edgenum = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
num[d[u]]--, num[d[v]]--;
d[u]++, d[v]++;
num[d[u]]++, num[d[v]]++;
if (d[u] >= 4 || d[v] >= 4) flag = 1;
if (num[3] >= 3) flag = 1;
}
int x = n;
for (int i = 1; i <= x; i++) {
if (read() && !flag) {
add(i, ++n);
add(n, i);
num[d[i]]--, num[d[n]]--;
d[i]++, d[n]++;
num[d[i]]++, num[d[n]]++;
add(n, ++n);
add(n, n - 1);
num[d[n]]--, num[d[n - 1]]--;
d[n]++, d[n - 1]++;
num[d[n]]++, num[d[n - 1]]++;
add(n - 1, ++n);
add(n, n - 2);
num[d[n]]--, num[d[n - 2]]--;
d[n]++, d[n - 2]++;
num[d[n]]++, num[d[n - 2]]++;
if (d[i] >= 4 || d[n - 2] >= 4 || d[n - 1] >= 4 || d[n] >= 4) flag = 1;
if (num[3] >= 3) flag = 1;
}
}
int xx = 0;
for (int i = 1; i <= n; i++) {
if (d[i] == 3) {
int x = 0;
for (int hd = head[i]; hd; hd = e[hd].next) {
int to = e[hd].to;
if (d[to] > 1) x++;
}
if (x >= 2) flag = 1;
if (x == 1) xx++;
}
}
if (xx == 2) {
if (num[2] & 1) flag = 1;
}
if (flag)
printf("White\n");
else
printf("Draw\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve(int n) {
int i, a[n], f = 0, g = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (i % 2 != a[i] % 2) {
if (i % 2 == 0)
f++;
else
g++;
}
}
if (f != g)
cout << -1 << endl;
else
cout << f << endl;
}
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
solve(n);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
pair<int, int> p[N];
int main() {
int x, y, a, b, i, j, m, contador;
scanf("%d %d %d %d", &x, &y, &a, &b);
contador = 0;
m = 0;
for (i = b; i <= y; i = i + 1) {
for (j = a; j <= x; j = j + 1) {
if (j > i) {
contador = contador + 1;
p[m].first = j;
p[m].second = i;
m = m + 1;
}
}
}
printf("%d\n", contador);
sort(p + 0, p + m);
for (i = 0; i < m; i = i + 1) {
printf("%d %d\n", p[i].first, p[i].second);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < s.size(); i++) {
int left = 0;
int both = 0;
for (int j = i; j < s.size(); j++) {
if (s[j] == '(')
left += 1;
else if (s[j] == '?')
both += 1;
else {
if (left > 0)
left -= 1;
else if (both > 0)
both -= 1;
else
break;
}
while (left < both) {
left += 1;
both -= 1;
}
if ((j - i) % 2 == 0) continue;
if (left > both) continue;
ans += 1;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)(3e5 + 5);
const long long mod = (long long)(998244353);
int a[maxn], bit[maxn];
void update(int idx, int val, int n) {
assert(idx != 0);
while (idx <= n) {
bit[idx] = max(bit[idx], val);
idx += idx & -idx;
}
}
int query(int idx) {
int ret = 0;
while (idx > 0) {
ret = max(ret, bit[idx]);
idx -= idx & -idx;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t > 0) {
int n;
cin >> n;
vector<int> first(n + 1, -1), last(n + 1, -1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
last[a[i]] = i;
}
for (int i = n; i >= 1; i--) {
first[a[i]] = i;
}
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++) {
if (first[i] != -1) {
v.push_back({first[i], last[i]});
}
}
vector<int> dp(v.size());
int res = 1;
dp[0] = 1;
for (int i = 1; i < v.size(); i++) {
if (v[i - 1].second < v[i].first) {
dp[i] = dp[i - 1] + 1;
} else {
dp[i] = 1;
}
res = max(res, dp[i]);
}
cout << (v.size() - res) << endl;
t--;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cnt[10];
int need[10];
int length(int val) {
if (val == 0) {
return 1;
}
int ans = 0;
while (val) {
++ans;
val /= 10;
}
return ans;
}
string conv(int val) {
if (val == 0) {
return "0";
}
string ans = "";
while (val) {
ans += (char)(val % 10 + '0');
val /= 10;
}
reverse((ans).begin(), (ans).end());
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
string a, b;
cin >> a >> b;
if (a == "01" || a == "10") {
cout << "0\n";
return 0;
}
for (int i = 0; i < (int)(a).size(); ++i) {
++cnt[a[i] - '0'];
}
int len;
for (len = 1;; ++len) {
if (len + length(len) > (int)(a).size()) {
--len;
break;
}
}
string tmp = conv(len);
for (int i = 0; i < (int)(tmp).size(); ++i) {
--cnt[tmp[i] - '0'];
}
for (int i = 0; i < (int)(b).size(); ++i) {
++need[b[i] - '0'];
}
bool profit = false;
for (int i = 0; i < (int)(b).size() - 1; ++i) {
if (b[i] > b[i + 1]) {
profit = false;
break;
} else if (b[i] < b[i + 1]) {
profit = true;
break;
}
}
string ans = "";
int pos = 0;
if (b[0] != '0') {
ans = b;
for (int i = 0; i < (int)(b).size(); ++i) {
--cnt[b[i] - '0'];
}
for (int i = 0; i < 10; ++i) {
while (cnt[i]) {
ans += (char)(i + '0');
--cnt[i];
}
}
} else {
int first;
for (int i = 1; i < 10; ++i) {
if (cnt[i] - 1 >= need[i]) {
first = i;
break;
}
}
ans = (char)(first + '0');
--cnt[first];
for (int i = 0; i < (int)(b).size(); ++i) {
ans += b[i];
--cnt[b[i] - '0'];
}
for (int i = 0; i < 10; ++i) {
while (cnt[i]) {
ans += (char)(i + '0');
--cnt[i];
}
}
pos = 1;
}
for (int i = pos + (int)(b).size(); i < (int)(ans).size(); ++i) {
++cnt[ans[i] - '0'];
}
string t = "";
if (pos == 1) {
t += ans[0];
}
for (;; ++pos) {
int least = -1;
for (int i = 0; i < 10; ++i) {
if (pos == 0 && i == 0) {
continue;
}
if (cnt[i]) {
least = i;
break;
}
}
if (least == -1) {
break;
}
if (least < b[0] - '0' || (least == b[0] - '0' && profit)) {
--cnt[least];
t += (char)(least + '0');
} else {
break;
}
}
for (int i = 0; i < (int)(b).size(); ++i) {
t += b[i];
}
for (int i = 0; i < 10; ++i) {
while (cnt[i]) {
t += (char)(i + '0');
--cnt[i];
}
}
string ANS = t;
for (int i = 0; i < (int)(t).size(); ++i) {
++cnt[t[i] - '0'];
}
ans = "";
t = "";
{
int first = -1;
for (int i = 1; i < 10; ++i) {
if (cnt[i] - 1 >= need[i]) {
first = i;
break;
}
}
if (first == -1) {
cout << ANS << "\n";
return 0;
}
ans = (char)(first + '0');
--cnt[first];
for (int i = 0; i < (int)(b).size(); ++i) {
ans += b[i];
--cnt[b[i] - '0'];
}
for (int i = 0; i < 10; ++i) {
while (cnt[i]) {
ans += (char)(i + '0');
--cnt[i];
}
}
pos = 1;
}
for (int i = pos + (int)(b).size(); i < (int)(ans).size(); ++i) {
++cnt[ans[i] - '0'];
}
t = "";
if (pos == 1) {
t += ans[0];
}
for (;; ++pos) {
int least = -1;
for (int i = 0; i < 10; ++i) {
if (pos == 0 && i == 0) {
continue;
}
if (cnt[i]) {
least = i;
break;
}
}
if (least == -1) {
break;
}
if (least < b[0] - '0' || (least == b[0] - '0' && profit)) {
--cnt[least];
t += (char)(least + '0');
} else {
break;
}
}
for (int i = 0; i < (int)(b).size(); ++i) {
t += b[i];
}
for (int i = 0; i < 10; ++i) {
while (cnt[i]) {
t += (char)(i + '0');
--cnt[i];
}
}
ANS = min(ANS, t);
cout << ANS << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool sortmahstyle(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first && a.second < b.second) return true;
return false;
}
long long int b[1000006], c[1000006];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
long long int n;
cin >> n;
long long int a[n + 1][n + 1];
long long int x1, y1, x2, y2;
for (long long int i = 1; i < n + 1; i++)
for (long long int j = 1; j < n + 1; j++) {
cin >> a[i][j];
b[i + j] += a[i][j];
c[i - j + n] += a[i][j];
}
long long int ans1, ans2, ans3, ans4;
ans1 = ans2 = ans3 = ans4 = LLONG_MIN;
long long int A[4], B[4];
for (long long int i = 1; i < n + 1; i++)
for (long long int j = 1; j < n + 1; j++) {
if ((i + j) % 2 != 0) {
if (b[i + j] + c[i - j + n] - a[i][j] > ans1) {
ans1 = b[i + j] + c[i - j + n] - a[i][j];
A[0] = i, A[1] = j;
}
}
if ((i + j) % 2 == 0) {
if (b[i + j] + c[i - j + n] - a[i][j] > ans3) {
ans3 = b[i + j] + c[i - j + n] - a[i][j];
A[2] = i, A[3] = j;
}
}
}
cout << ans1 + ans3 << "\n";
for (long long int i = 0; i < 4; i++) cout << A[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y, z;
cin >> x >> y >> z;
if (z != 0 && z != 1 && z != -1) {
if (z > 0)
while (x < y) {
x = x + z;
}
else
while (x > y) {
x = x + z;
}
if (x == y)
cout << "YES";
else
cout << "NO";
} else if (z == 0 && x == y && z != 1 && z != -1)
cout << "YES";
else if (z == 0 && x != y && z != 1 && z != -1)
cout << "NO";
else if ((z == 1 && y >= x) || (z == -1 && y <= x))
cout << "YES";
else if ((z == 1 && y < x) || (z == -1 && y > x))
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, a, b;
long long gcd(long long xx, long long yy) {
if (!yy) return xx;
return gcd(yy, xx % yy);
}
int main() {
cin >> x >> y >> a >> b;
long long o = x * y / gcd(max(x, y), min(x, y));
long long ans = 0;
ans = b / o;
ans -= (a - 1) / o;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, s;
cin >> a >> b >> s;
a = abs(a);
b = abs(b);
if (a + b == s || (a + b < s && (s - (a + b)) % 2 == 0))
cout << "Yes"
<< "\n";
else if (s % 2 == 0 && a == 0 && b == 0)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<pair<int, int>> a(n * 2);
vector<pair<int, int>> ans;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[n + i].first;
a[n + i].second = 1;
}
sort(a.begin(), a.end());
int z = 0;
for (int i = 0; i < n * 2; i++)
if (a[i].second == 0) {
z++;
if (z == k) ans.push_back({a[i].first, 0});
} else {
if (z == k) ans.back().second = a[i].first;
z--;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
char a[MAXN], c[MAXN];
int b, d, n, m;
struct Node {
int l, r;
Node(int l = -1, int r = -1) : l(l), r(r) {}
} pos[MAXN];
int main() {
scanf("%d%d", &b, &d);
scanf("%s%s", a, c);
n = strlen(a), m = strlen(c);
pos[0] = Node(0, 0);
int l = 0, r = 0, j = 0;
while (l < b) {
for (int i = 0; i < n; i++) {
if (a[i] == c[j]) j++;
if (j == m) {
j = 0;
r++;
}
}
l++;
if (~pos[j].l) break;
pos[j] = Node(l, r);
}
if (pos[j].l == -1 && pos[j].r == -1) {
printf("%d\n", r / d);
return 0;
}
int t = (b - l) / (l - pos[j].l);
l += (l - pos[j].l) * t;
r += (r - pos[j].r) * t;
while (l < b) {
for (int i = 0; i < n; i++) {
if (a[i] == c[j]) j++;
if (j == m) {
j = 0;
r++;
}
}
l++;
}
printf("%d\n", r / d);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 100005;
const int mod = 998244353;
int a[mx], y, z;
long long sum[mx];
int as[mx], bs[mx];
bool v[mx];
map<int, int> r[mx];
int query(long long i, int x) {
long long ans = 0;
if (i == 0) return 0;
if (x == 1) return sum[i];
if (x < 20) {
int d = r[i][x];
if (d != 0) return d;
}
if (x == as[i]) {
return bs[i];
}
if (a[i] <= x)
z = a[i];
else {
y = (x + a[i] - 1) / x;
ans = (ans + i * (y - 1)) % mod;
z = a[i] / y;
}
int k = (ans + query(i - 1, z)) % mod;
if (x < 20) {
r[i][x] = k;
} else {
as[i] = x;
bs[i] = k;
}
return k;
}
void oyl(int n) {
long long ans = 0;
for (long long i = 1; i <= n; i++) {
scanf("%d", a + i);
sum[i] = (sum[i - 1] + i * a[i] - i) % mod;
}
for (int i = 1; i <= n; i++) {
ans = (ans + query(i - 1, a[i])) % mod;
}
printf("%lld\n", ans);
return;
}
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
oyl(n);
if (t != 0)
for (int _ = 1; _ <= n; _++) {
r[_].clear();
as[_] = 0;
bs[_] = 0;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2004;
const long long mod = 1e9 + 7;
long long n, h, dp[N][N], a[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> h;
for (long long i = 1; i <= n; i++) cin >> a[i];
if (a[1] + 1 == h || a[1] == h) dp[1][0] = 1;
if (a[1] + 1 == h) dp[1][1] = 1;
for (long long i = 2; i <= n; i++) {
for (long long j = 0; j <= h; j++) {
if (a[i] + j == h) {
dp[i][j] = dp[i][j] + dp[i - 1][j - 1];
dp[i][j] %= mod;
dp[i][j] = dp[i][j] + dp[i - 1][j];
dp[i][j] %= mod;
} else if (a[i] + j + 1 == h) {
dp[i][j] = dp[i][j] + dp[i - 1][j + 1] * (j + 1);
dp[i][j] %= mod;
dp[i][j] = dp[i][j] + dp[i - 1][j];
dp[i][j] %= mod;
dp[i][j] = dp[i][j] + dp[i - 1][j] * j;
dp[i][j] %= mod;
}
}
}
cout << dp[n][0];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
int b[222];
void fmain(int tid) {
for (int i = 4; i <= 100; i++) {
b[i] = i * (i - 1) * (i - 2) * (i - 3) / 24;
}
scanf("%d", &n);
map<int, int> mp;
for (int i = 70, x = n; i > 3; i--) {
while (x >= b[i]) {
mp[i]++;
x -= b[i];
}
}
int pre = 0;
for (auto p : mp) {
for (int(j) = 0; (j) < (int)(p.first - pre); (j)++) printf("a");
for (int(j) = 0; (j) < (int)(p.second); (j)++) printf("b");
pre = p.first;
}
printf(" aaaab");
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[51][51], b[51][51];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &b[i][j]);
if (b[i][j] < a[i][j]) swap(b[i][j], a[i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j < m; j++)
if (a[i][j] >= a[i][j + 1] || b[i][j] >= b[i][j + 1]) {
printf("Impossible\n");
return 0;
}
for (int j = 1; j <= m; j++)
for (int i = 1; i < n; i++)
if (a[i][j] >= a[i + 1][j] || b[i][j] >= b[i + 1][j]) {
printf("Impossible\n");
return 0;
}
printf("Possible\n");
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int MAXN = 2e5+10;
int n, ca[2], cb[2], cc[2];
string a,b,c;
inline string get(string x, string y, char ch){
// cout << "x:" << x << " y:" << y << " ch:" << ch << endl;
string ret = "";
int ptx = 0, pty = 0;
while(ptx<2*n || pty<2*n){
// cout << "ret:" << ret << " ptx:" << ptx << " pty:" << pty << endl;
if(ptx<2*n && x[ptx]!=ch){
ret+=(ch=='0'?'1':'0');
ptx++; continue;
}
if(pty<2*n && y[pty]!=ch){
ret+=(ch=='0'?'1':'0');
pty++; continue;
}
if(ptx<2*n && pty<2*n && x[ptx]==ch && y[pty]==ch){
ret+=ch;
ptx++; pty++; continue;
}
if(ptx<2*n && x[ptx]==ch){
ret+=ch;
ptx++;
}
if(pty<2*n && y[pty]==ch){
ret+=ch;
pty++;
}
}
return ret;
}
inline void slv(){
cin >> n >> a >> b >> c;
ca[0] = ca[1] = cb[0] = cb[1] = cc[0] = cc[1] = 0;
for(int i = 0; i < 2*n; i++){
ca[a[i]-'0']++;
cb[b[i]-'0']++;
cc[c[i]-'0']++;
}
// cout << n << " " << a << " " << b << " " << c << endl;
if(ca[0]>=n && cb[0]>=n) cout << get(a,b,'0') << '\n';
else if(ca[1]>=n && cb[1]>=n) cout << get(a,b,'1') << '\n';
else if(ca[0]>=n && cc[0]>=n) cout << get(a,c,'0') << '\n';
else if(ca[1]>=n && cc[1]>=n) cout << get(a,c,'1') << '\n';
else if(cb[0]>=n && cc[0]>=n) cout << get(b,c,'0') << '\n';
else if(cb[1]>=n && cc[1]>=n) cout << get(b,c,'1') << '\n';
return;
}
int main()
{
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int t;
cin >> t;
while(t--) slv();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long fac[200010], infact[200010];
long long qmi(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) {
res = res * a % mod;
}
b >>= 1;
a = a * a % mod;
}
return res;
}
void init() {
fac[0] = 1;
infact[0] = 1;
for (int i = 1; i <= 200000; i++) {
fac[i] = i * fac[i - 1] % mod;
infact[i] = qmi(fac[i], mod - 2) % mod;
}
}
int main() {
int t;
cin >> t;
init();
while (t--) {
int fir[2] = {0}, sec[2] = {0};
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (sec[0] == num) {
sec[1]++;
} else if (fir[0] == num) {
fir[1]++;
} else if (fir[0] < num) {
sec[0] = fir[0];
sec[1] = fir[1];
fir[0] = num;
fir[1] = 1;
} else if (num > sec[0]) {
sec[0] = num;
sec[1] = 1;
}
}
if (fir[1] > 1) {
cout << fac[n] << endl;
continue;
} else if (fir[0] - sec[0] >= 2) {
cout << 0 << endl;
continue;
} else {
long long ans;
ans = (fac[n] * infact[n - sec[1] - 1] % mod * infact[sec[1] + 1] % mod +
mod) %
mod;
int k =
fac[sec[1]] * (sec[1]) % mod * fac[n - sec[1] - 1] % mod * ans % mod;
cout << k % mod << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char a[3001];
int b[3001];
int main() {
int n, move = 0, ind = -1;
int res = 0;
cin >> n;
scanf("%s", a);
for (int i = 0; i < n; i++) {
if (a[i] == 'L') {
b[i] = -1;
} else if (a[i] == 'R') {
b[i] = 1;
} else {
b[i] = 0;
}
}
for (int i = 0; i < n; i++) {
}
for (int i = 0; i < n; i++) {
if (b[i]) {
if (move == 0 && b[i] == 1) {
res += i;
}
if (b[i] == 1 && move == -1) {
res += i - ind - 1;
}
if (b[i] == -1 && move == 1) {
if ((i - ind) % 2 == 0) {
res += 1;
}
}
move = b[i];
ind = i;
}
}
if (ind == -1) {
res = n;
} else if (move == -1) {
res += n - ind - 1;
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 7;
const long long INF = 1e9 + 7;
vector<long long> g[MAXN];
bool bad[MAXN];
long long best = -1;
long long besth = -1;
void jfs(long long u, long long parent, long long h) {
if (besth < h) {
best = u;
besth = h;
}
for (long long v : g[u]) {
if (v == parent) continue;
if (bad[v]) continue;
jfs(v, u, h + 1);
}
}
pair<long long, long long> getd(long long u, long long parent, long long h) {
pair<long long, long long> res = {h, u};
for (long long v : g[u]) {
if (v == parent) continue;
if (bad[v]) continue;
pair<long long, long long> nr = getd(v, u, h + 1);
res = max(res, nr);
}
return res;
}
bool go(long long u, long long parent, long long want) {
if (u == want) {
bad[u] = true;
return true;
}
for (long long v : g[u]) {
if (v == parent) continue;
if (go(v, u, want)) {
bad[u] = true;
return true;
}
}
return false;
}
long long dist[MAXN];
void calc(long long u, long long parent, long long h) {
dist[u] = h;
for (long long v : g[u]) {
if (v == parent) continue;
if (bad[v]) continue;
calc(v, u, h + 1);
}
}
long long l[MAXN], r[MAXN], par[MAXN], pos[MAXN];
vector<long long> e;
void build(long long u, long long parent) {
par[u] = parent;
pos[u] = e.size();
e.push_back(u);
l[u] = e.size();
for (long long v : g[u]) {
if (v == parent) continue;
build(v, u);
}
r[u] = e.size() - 1;
}
pair<long long, long long> tree[MAXN * 4];
long long add[MAXN * 4];
void buildt(long long v, long long tl, long long tr) {
if (tl == tr) {
tree[v] = {dist[e[tl]], e[tl]};
return;
}
long long tm = (tl + tr) / 2;
buildt(v * 2 + 1, tl, tm);
buildt(v * 2 + 2, tm + 1, tr);
tree[v] = max(tree[v * 2 + 1], tree[v * 2 + 2]);
}
void push(long long v) {
tree[v * 2 + 1].first += add[v];
add[v * 2 + 1] += add[v];
tree[v * 2 + 2].first += add[v];
add[v * 2 + 2] += add[v];
add[v] = 0;
}
void relax(long long v) { tree[v] = max(tree[v * 2 + 1], tree[v * 2 + 2]); }
void upd(long long v, long long tl, long long tr, long long l, long long r,
long long x) {
if (tr < l || r < tl) return;
if (l <= tl && tr <= r) {
tree[v].first += x;
add[v] += x;
return;
}
long long tm = (tl + tr) / 2;
push(v);
upd(v * 2 + 1, tl, tm, l, r, x);
upd(v * 2 + 2, tm + 1, tr, l, r, x);
relax(v);
}
void del(long long v, long long tl, long long tr, long long p) {
if (tl == tr) {
tree[v].first = -INF;
return;
}
long long tm = (tl + tr) / 2;
push(v);
if (p <= tm) {
del(v * 2 + 1, tl, tm, p);
} else {
del(v * 2 + 2, tm + 1, tr, p);
}
relax(v);
}
void make_bad(long long u, long long n) {
bad[u] = true;
del(0, 0, n - 1, pos[u]);
upd(0, 0, n - 1, l[u], r[u], -1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
if (n == 1) {
cout << "1\n";
return 0;
}
for (long long i = 0; i < n - 1; ++i) {
long long u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
pair<long long, long long> t1 = getd(0, 0, 0);
pair<long long, long long> t2 = getd(t1.second, t1.second, 0);
go(t1.second, t1.second, t2.second);
long long curr = t2.first + 1;
cout << "1 " << curr << ' ';
for (long long i = 0; i < n; ++i) dist[i] = -INF;
for (long long i = 0; i < n; ++i) {
if (!bad[i]) continue;
for (long long j : g[i]) {
if (bad[j]) continue;
calc(j, j, 0);
}
}
long long root = t1.second;
build(root, root);
buildt(0, 0, n - 1);
for (long long it = 3; it <= n; ++it) {
if (curr == n) {
for (long long i = 0; i < n - it + 1; ++i) cout << n << ' ';
break;
}
pair<long long, long long> t = tree[0];
curr += t.first + 1;
cout << curr << ' ';
long long u = t.second;
while (!bad[u]) {
make_bad(u, n);
u = par[u];
}
}
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
char a[6000000];
int A[6000000];
int sa[6000000];
int it[6000000];
int n;
int good[6000000];
int S = 2097152;
void update(int x) {
for (x /= 2; x > 0; x /= 2) it[x] = min(it[x * 2], it[x * 2 + 1]);
}
int getmin(int x, int y) {
int mi = ((1 << 30) - 1);
while (x <= y) {
if (x % 2 == 1) mi = min(mi, it[x++]);
if (y % 2 == 0) mi = min(mi, it[y--]);
x /= 2, y /= 2;
}
return mi;
}
struct SuffixArray {
int N;
vector<int> raank, lcp, sa;
string S;
SuffixArray(string S) : S(S) {
int i, h = 0;
vector<int> tmp, tr;
N = S.size();
raank.resize(N + 1);
sa.resize(N + 1);
tmp.resize(N + 1);
for (i = 0; i < N + 1; i++) sa[i] = i, raank[i] = i == N ? -1 : S[i];
for (int k = 1; k <= N; k <<= 1) {
auto pred2 = [k, this](int& a, int& b) -> bool {
return (((a + k <= N) ? raank[a + k] : -1) <
((b + k <= N) ? raank[b + k] : -1));
};
auto pred = [pred2, k, this](int& a, int& b) -> bool {
return (raank[a] != raank[b]) ? (raank[a] < raank[b]) : pred2(a, b);
};
int x = 0;
if (k != 1)
for (i = 1; i < N + 1; i++)
if (raank[sa[i]] != raank[sa[x]])
sort(sa.begin() + x, sa.begin() + i, pred2), x = i;
sort(sa.begin() + x, sa.end(), pred);
for (i = 0; i < N + 1; i++)
tmp[sa[i]] = (i == 0) ? 0 : tmp[sa[i - 1]] + pred(sa[i - 1], sa[i]);
swap(raank, tmp);
}
lcp.resize(N + 1);
tr.resize(N + 1);
for (i = 0; i < N + 1; i++) tr[sa[i]] = i;
for (i = 0; i < N; i++) {
int j = sa[tr[i] - 1];
for (h = max(h - 1, 0); i + h < N && j + h < N; h++)
if (S[j + h] != S[i + h]) break;
lcp[tr[i] - 1] = h;
}
}
};
int main() {
int i, j, k;
scanf("%s", a);
n = strlen(a);
for (i = 0; i < n; i++) a[i + n] = a[i];
string s = string(a);
SuffixArray ssa(s);
for (i = 0; i < n * 2; i++) sa[ssa.raank[i] - 1] = i;
int now = 0;
for (i = 0; i < n * 2; i++) {
now += a[i] == '(' ? 1 : -1;
it[S + i + 1] = now;
update(S + i + 1);
}
int pad = 0;
now /= 2;
if (now < 0) pad = -now;
for (i = 0; i < n; i++) {
if (getmin(S + i, S + i + n) - it[S + i] + pad >= 0) good[i] = 1;
}
for (i = 0; i < n * 2; i++) {
if (good[sa[i]] == 1) {
for (j = now; j < 0; j++) printf("(");
for (j = sa[i]; j < sa[i] + n; j++) printf("%c", a[j]);
for (j = 0; j < now; j++) printf(")");
return 0;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> z[300005];
int s[300005], t[300005];
long long ss, st;
vector<pair<pair<int, int>, int> > r;
int main() {
scanf("%d", &n);
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int a;
scanf("%d", &a);
ss += a;
z[i] = make_pair(a, i);
}
for (int i = 0, ThxDem = n; i < ThxDem; ++i) scanf("%d", t + i), st += t[i];
if (ss != st) {
puts("NO");
return 0;
}
sort(z, z + n);
sort(t, t + n);
for (int i = 0, ThxDem = n; i < ThxDem; ++i) s[i] = z[i].first;
int j = 0;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
if (s[i] > t[i]) {
puts("NO");
return 0;
}
j = max(j, i + 1);
while (s[i] < t[i]) {
while (s[j] <= t[j]) j++;
int d = min(t[i] - s[i], s[j] - t[j]);
r.push_back(make_pair(make_pair(z[i].second, z[j].second), d));
s[i] += d;
s[j] -= d;
}
}
printf("YES\n%d\n", ((int)(r).size()));
for (auto p : r)
printf("%d %d %d\n", p.first.first + 1, p.first.second + 1, p.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, x1, y1, x2, y2, r1, r2, a, b;
cin >> n >> x1 >> y1 >> x2 >> y2;
vector<pair<long long, long long> > dist(n);
while (n--) {
cin >> a >> b;
r1 = (x1 - a) * (x1 - a) + (y1 - b) * (y1 - b);
r2 = (x2 - a) * (x2 - a) + (y2 - b) * (y2 - b);
dist.push_back({r1, r2});
}
long long ans = LLONG_MAX;
for (auto x : dist) {
long long r1 = x.first;
long long r2 = 0;
for (auto y : dist) {
if (y.first > r1) r2 = max(r2, y.second);
}
ans = min(ans, r1 + r2);
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
double d = sqrt(b * b - 4 * a * c);
double x = -(b + d) / 2 / a;
double y = -(b - d) / 2 / a;
if (a < 0) {
swap(x, y);
}
cout << setprecision(9) << y << "\n" << setprecision(9) << x;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 1e6 + 1;
int a[N], lt[N], rt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
fill(lt, lt + m + 1, n + 1);
fill(rt, rt + m + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
lt[a[i]] = min(lt[a[i]], i);
rt[a[i]] = i;
}
int llim = 1;
for (int curr = 0; llim < m; llim++) {
curr = max(curr, rt[llim]);
if (lt[llim + 1] < curr) break;
}
int rlim = m;
for (int curr = n + 1; rlim > 1; rlim--) {
curr = min(curr, lt[rlim]);
if (rt[rlim - 1] > curr) break;
}
for (int i = m - 1; i >= 1; i--) {
lt[i] = min(lt[i], lt[i + 1]);
}
for (int i = 2; i <= m; i++) {
rt[i] = max(rt[i], rt[i - 1]);
};
LL ans = 0;
for (int l = 1, r = max(rlim - 1, 1); l <= llim + 1 && l <= m; l++) {
if (r < l) r = l;
while (r < m && lt[r + 1] < rt[l - 1]) r++;
;
ans += m - r + 1;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int cont[N][N];
char str[N];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
getchar();
memset(cont, 0, sizeof(cont));
for (int i = 0; i < n; i++) {
scanf("%s", str);
int t = 0;
for (int j = m - 1; j >= 0; j--) {
if (str[j] == '0') {
cont[j][i] = 0;
t = 0;
} else {
cont[j][i] = ++t;
}
}
}
for (int i = 0; i < m; i++) sort(cont[i], cont[i] + n);
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int t = cont[i][j] * (n - j);
if (t > ans) ans = t;
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a;
cin >> n >> m >> a;
cout << ((n - 1) / a + 1) * ((m - 1) / a + 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Fenwick {
public:
Fenwick(int size) {
storage.resize(size + 1);
n = size;
}
void update(int i, int val) {
for (; i <= n; i += i & -i) storage[i] += val;
}
int sum(int i) {
int result = 0;
for (; i > 0; i -= i & -i) result += storage[i];
return result;
}
private:
vector<int> storage;
int n;
};
void update(vector<int> &count, int val, int type, int &curr) {
for (int i = 0; i < 30; i++) {
bool bit = (val >> i) & 1;
if (bit == 0) continue;
if (type == 0) {
if (count[i] == 0) curr |= 1 << i;
count[i]++;
} else {
if (count[i] == 1) curr ^= 1 << i;
count[i]--;
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> segments;
vector<vector<int>> info;
vector<int> count(30);
vector<int> a(n + 1);
for (int i = 0; i < m; i++) {
int l, r, val;
scanf("%d %d %d", &l, &r, &val);
segments.push_back(vector<int>{l, val, 0});
segments.push_back(vector<int>{r + 1, val, 1});
info.push_back(vector<int>{l, r, val});
}
sort(segments.begin(), segments.end());
deque<vector<int>> Q(segments.begin(), segments.end());
sort(info.begin(), info.end());
int curr = 0;
for (int i = 1; i <= n; i++) {
while (!Q.empty() and (Q.front())[0] == i) {
vector<int> temp = Q.front();
Q.pop_front();
update(count, temp[1], temp[2], curr);
}
a[i] = curr;
}
vector<Fenwick> F(30, Fenwick(n));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 30; j++) F[j].update(i, (a[i] >> j) & 1);
}
Q.clear();
Q.assign(info.begin(), info.end());
for (int i = 1; i <= n; i++) {
while (!Q.empty() and (Q.front())[0] == i) {
int val = 0;
vector<int> temp = Q.front();
Q.pop_front();
for (int j = 0; j < 30; j++) {
int valid = F[j].sum(temp[1]);
if (valid == temp[1] - temp[0] + 1) val |= 1 << j;
}
if (val != temp[2]) {
cout << "NO" << endl;
return 0;
}
}
for (int j = 0; j < 30; j++)
F[j].update(i, ((a[i] >> j) & 1) == 1 ? -1 : 0);
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
printf("%d", a[i]);
printf(i != n ? " " : "\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1111], b[1111];
int main() {
int N, i, k;
long long s1 = 0, s2 = 0, p;
cin >> N;
for (i = 0; i < N; i++) {
cin >> p;
s1 |= p;
}
for (i = 0; i < N; i++) {
cin >> p;
s2 |= p;
}
cout << s1 + s2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, cnt, flag, tot;
int sx, sy;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int dp[25][25][1 << 8];
int val[8], w[1 << 8];
int gx[8], gy[8];
char mp[25][25];
char s[25];
struct Node {
int x, y, k;
} cur, now;
bool issur(int nx, int ny, int tx, int ty, int j) {
if (nx == gx[j] && ny < gy[j]) {
if (tx < gx[j]) return true;
} else if (tx == gx[j] && ty < gy[j]) {
if (nx < gx[j]) return true;
}
return false;
}
void bfs() {
int i, j, t, k, nx, ny, tx, ty, nk;
queue<Node> q;
memset(dp, -1, sizeof(dp));
ans = -0x3f3f3f3f;
cur.x = sx;
cur.y = sy;
cur.k = 0;
dp[sx][sy][0] = 0;
q.push(cur);
while (!q.empty()) {
now = q.front();
q.pop();
nx = now.x;
ny = now.y;
nk = now.k;
if (nx == sx && ny == sy) ans = max(ans, w[nk] - dp[nx][ny][nk]);
for (i = 0; i < 4; i++) {
tx = nx + dx[i];
ty = ny + dy[i];
k = nk;
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
if (!(mp[tx][ty] == 'S' || mp[tx][ty] == '.')) continue;
for (j = 0; j <= cnt; j++) {
if (issur(nx, ny, tx, ty, j)) k ^= (1 << j);
}
if (dp[tx][ty][k] != -1 && dp[tx][ty][k] <= dp[nx][ny][nk] + 1) continue;
cur.x = tx;
cur.y = ty;
cur.k = k;
dp[tx][ty][k] = dp[nx][ny][nk] + 1;
q.push(cur);
}
}
}
int main() {
int i, j, t;
while (~scanf("%d%d", &n, &m)) {
cnt = -1;
for (i = 1; i <= n; i++) {
scanf("%s", s);
for (j = 1; j <= m; j++) {
mp[i][j] = s[j - 1];
if (mp[i][j] == 'S') sx = i, sy = j;
if (mp[i][j] >= '1' && mp[i][j] <= '8') {
t = mp[i][j] - '1';
cnt++;
gx[t] = i, gy[t] = j;
}
}
}
for (i = 0; i <= cnt; i++) {
scanf("%d", &val[i]);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (mp[i][j] == 'B') gx[++cnt] = i, gy[cnt] = j, val[cnt] = -10000;
}
}
memset(w, 0, sizeof(w));
tot = 1 << (cnt + 1);
for (i = 0; i < tot; i++) {
for (j = 0; j <= cnt; j++) {
if (i & (1 << j)) w[i] += val[j];
}
}
bfs();
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
string final;
long long int id = -1, count = 0, r = 0, l = 0;
for (long long int i = 0; i < (long long int)s.length(); i++) {
if (s[i] == '#') {
id = i;
count++;
}
if (s[i] == '(') r++;
if (s[i] == ')') l++;
}
vector<long long int> ans;
for (long long int i = 0; i < (long long int)s.length(); i++) {
if (i == id) {
long long int num = r - l - (count - 1);
if (num <= 0) {
cout << -1 << endl;
return;
}
ans.push_back(num);
while (num--) {
final += ')';
}
i++;
}
if (s[i] == ')')
final += ')';
else if (s[i] == '(')
final += '(';
if (s[i] == '#') {
ans.push_back(1);
final += ')';
}
}
l = 0, r = 0;
for (long long int i = 0; i < (long long int) final.length(); i++) {
if (l > r) {
cout << -1 << endl;
return;
}
if (final[i] == '(')
r++;
else
l++;
}
if (l != r) {
cout << -1 << endl;
return;
}
for (long long int i = 0; i < (long long int)ans.size(); i++) {
cout << ans[i] << endl;
}
}
int main() {
long long int t = 1;
for (long long int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int pd[510][1010];
vector<int> vet[510 * 2];
int n, tam;
int in[510], out[510], w[510], s[510], v[510];
int busca(int pos, int atual) {
if (pd[pos][atual] != -1) {
return pd[pos][atual];
}
int aux[2 * 510];
aux[in[pos]] = 0;
int i, j, k;
for (i = in[pos] + 1; i <= out[pos]; i++) {
aux[i] = aux[i - 1];
for (j = 0; j < vet[i].size(); j++) {
int k = vet[i][j];
if (k != pos && in[k] >= in[pos] && w[k] <= atual) {
int teste = busca(k, min(atual - w[k], s[k]));
aux[i] = max(aux[i], teste + aux[in[k]]);
}
}
}
return pd[pos][atual] = aux[out[pos]] + v[pos];
}
int main() {
scanf("%d %d", &n, &tam);
int i, j;
for (i = 1; i <= n; i++) {
scanf("%d %d %d %d %d", &in[i], &out[i], &w[i], &s[i], &v[i]);
vet[out[i]].push_back(i);
}
in[0] = 0;
out[0] = 2 * n;
v[0] = 0;
memset(pd, -1, sizeof(pd));
printf("%d\n", busca(0, tam));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline bool vow(char c) {
if (c == 'a') return true;
if (c == 'e') return true;
if (c == 'i') return true;
if (c == 'o') return true;
if (c == 'u') return true;
return false;
}
char s[1005], t[1005];
int main() {
scanf("%s%s", s, t);
int n = strlen(s);
int m = strlen(t);
bool ok = true;
if (n != m) ok = false;
for (int i = (0); i < ((n)); i++)
if (vow(s[i]) ^ vow(t[i])) ok = false;
if (ok)
printf("Yes\n");
else
printf("No\n");
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.