solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v;
set<pair<long long int, long long int> > s;
long long a[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, x, y, x1, y1;
cin >> n >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> x1 >> y1;
v.push_back(make_pair(x1, y1));
}
sort((v).begin(), (v).end());
s.insert(make_pair(v[0].second, 1));
a[1] = v[0].second;
long long ans = x + (v[0].second - v[0].first) * y;
int cnt = 1;
long long c, d;
set<pair<long long int, long long int> >::iterator it;
for (int i = 1; i < v.size(); i++) {
it = s.lower_bound({v[i].first, -1000000007});
if (it != s.begin()) {
it--;
c = it->first;
d = it->second;
if ((v[i].first - c) * y < x && a[d] <= c) {
s.erase(it);
s.insert(make_pair(v[i].second, d));
a[d] = v[i].second;
ans += (v[i].second - c) * y;
} else {
cnt++;
s.insert(make_pair(v[i].second, cnt));
a[cnt] = v[i].second;
ans += (x + y * (v[i].second - v[i].first));
}
} else {
cnt++;
s.insert(make_pair(v[i].second, cnt));
a[cnt] = v[i].second;
ans += (x + y * (v[i].second - v[i].first));
}
ans %= 1000000007;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main() {
int n, k;
scanf("%d %d", &n, &k);
int i, c = 0, a[n], b[k];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < k; i++) scanf("%d", &b[i]);
sort(b, b + k, comp);
for (i = 0; i < n; i++) {
if (a[i] == 0) {
a[i] = b[c];
c++;
}
}
bool flag = true;
for (i = 1; i < n; i++) {
if (a[i] > a[i - 1])
flag = true;
else {
flag = false;
break;
}
}
if (!flag)
printf("Yes");
else
printf("No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
getline(cin, s1);
getline(cin, s2);
int e1 = s1.length() - 1, e2 = s2.length() - 1;
int p = 0;
while (e1 >= 0 && e2 >= 0 && s1[e1] == s2[e2]) {
p++;
e1--;
e2--;
}
cout << s1.length() + s2.length() - 2 * p << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("unroll-loops")
using namespace std;
int n;
vector<pair<int, int> > ans;
vector<vector<int> > G;
int maxs;
void dfs(int u, int &clock, int pret = -1, int fa = -1) {
ans.push_back(make_pair(u, clock));
int child = 0;
for (auto to : G[u])
if (to != fa) child++;
for (auto to : G[u]) {
if (to == fa) continue;
if (clock == maxs) {
clock = pret - 1 - child;
ans.push_back(make_pair(u, clock));
}
clock++;
dfs(to, clock, clock, u);
ans.push_back(make_pair(u, clock));
child--;
}
if (fa == -1) return;
if (clock >= pret) {
clock = pret - 1;
ans.push_back(make_pair(u, clock));
}
clock++;
}
void solve() {
scanf("%d", &n);
G.resize(n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
G[u].push_back(v), G[v].push_back(u);
}
int clock = 0;
for (int i = 0; i < n; i++) maxs = max(maxs, (int)(G[i].size()));
dfs(0, clock);
printf("%d\n", ans.size());
for (auto t : ans) printf("%d %d\n", t.first + 1, t.second);
return;
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int num[100100], resp[100100];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", num + i);
sort(num, num + n);
bool td1 = (num[n - 1] == 1);
if (n == 1 && td1)
printf("2\n");
else {
resp[0] = 1;
for (int i = 1; i < n; ++i) {
if (i != n - 1 || !td1)
resp[i] = num[i - 1];
else
resp[i] = 2;
}
printf("%d", resp[0]);
for (int i = 1; i < n; ++i) printf(" %d", resp[i]);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int ad[maxN];
int main() {
long long n, ma = 0, x, y, z;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (x > ma) {
ma = x;
}
ad[x]++;
}
x = 0;
y = ad[1];
for (long long i = 2; i <= ma; i++) {
z = max(ad[i] * i + x, y);
x = y;
y = z;
}
cout << y;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100000], b[100000];
for (int i = 0; i < n; i++) cin >> a[i];
b[n - 1] = 0;
int mx = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (a[i] > mx) {
mx = a[i];
b[i] = 0;
} else
b[i] = 1 + mx - a[i];
}
for (int i = 0; i < n; i++) printf("%d ", b[i]);
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int n, k;
int a[2011];
long long pre[1 << 11 + 1];
long long cur[1 << 11 + 1];
void solve() {
memset(pre, 0, sizeof(pre));
pre[0] = 1;
for (int i = 0; i < n; i++) {
memset(cur, 0, sizeof(cur));
for (int j = 0; j < (1 << k) + 1; j++) {
if (a[i] == 2 || a[i] == 0) {
int nj = min(j + 2, 1 << k);
cur[nj] = (cur[nj] + pre[j]) % mod;
}
if (a[i] == 4 || a[i] == 0) {
int nj = min(j + 4, 1 << k);
if ((j & 2) != 0) {
nj = 4;
}
cur[nj] = (cur[nj] + pre[j]) % mod;
}
}
memcpy(pre, cur, sizeof(cur));
}
cout << pre[1 << k] << endl;
}
void coding() {
while (cin >> n >> k) {
for (int i = 0; i < n; i++) cin >> a[i];
solve();
}
}
int main() { coding(); }
| 6 |
#include <bits/stdc++.h>
using namespace std;
void debug() { cout << endl; }
template <typename T, typename... Args>
void debug(T a, Args... args) {
cout << a << ' ';
debug(args...);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<double, int>> v;
for (int i = 0, gon = n; i < gon; ++i) {
int x;
cin >> x;
v.push_back({x, 1});
int sz = v.size();
while (sz > 1 && v[sz - 1].first <= v[sz - 2].first) {
double a = v[sz - 2].first * v[sz - 2].second;
double b = v[sz - 1].first * v[sz - 1].second;
double c = v[sz - 1].second + v[sz - 2].second;
v.pop_back();
v.pop_back();
v.push_back({(a + b) / c, c});
sz--;
}
}
cout << fixed << setprecision(10);
for (auto &x : v) {
while (x.second--) {
cout << x.first << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int ddx[] = {1, 0};
int ddy[] = {1, 1};
vector<int> pos[30];
string s;
long long int pre[100001];
int n;
long long int value[100001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 0; i < 26; i++) cin >> value[i];
cin >> s;
for (int i = 0; i < int(s.size()); i++) {
pre[i + 1] = pre[i] + value[s[i] - 'a'];
pos[s[i] - 'a'].push_back(i);
}
long long int ans = 0;
for (int i = 0; i < 26; i++) {
map<long long int, int> sum;
char aux = i + 'a';
for (int j = 0; j < int(pos[i].size()); j++) {
int atual = pos[i][j];
ans += sum[pre[atual]];
sum[pre[atual + 1]]++;
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e6 + 5);
long long mult(long long a, long long b, long long p = (int)(1e9 + 7)) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = (int)(1e9 + 7)) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = (int)(1e9 + 7)) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
int main() {
long long mini = 1e18;
long long n;
cin >> n;
long long a[2 * n];
for (int i = 0; i < 2 * n; i++) cin >> a[i];
sort(a, a + 2 * n);
mini = min(mini, (a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]));
for (int i = 1; i < n; i++) {
mini = min(mini, 1LL * abs(a[2 * n - 1] - a[0]) * abs(a[i] - a[n + i - 1]));
}
cout << mini;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
const int INF = INT_MAX;
const long long INFF = INT64_MAX;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int moveX[] = {-1, 0, 1, 0};
const int moveY[] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, tmp = 1, len = 1;
cin >> a;
while (tmp <= a) {
tmp *= 2;
len++;
}
cout << "2 3\n";
cout << tmp + a << ' ' << a << ' ' << 0 << '\n';
cout << tmp << ' ' << tmp + a << ' ' << tmp - 1 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int fa[200010], sf[200010];
struct bian {
int x, y;
long long w;
} eg[200010];
bool pd(bian i, bian j) { return i.w > j.w; }
int find(int o) { return fa[o] == o ? o : fa[o] = find(fa[o]); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%lld", &eg[i].x, &eg[i].y, &eg[i].w);
}
for (int i = 1; i <= n; ++i) {
fa[i] = i;
}
sort(eg + 1, eg + 1 + m, pd);
long long ans = 0;
for (int i = 1; i <= m; ++i) {
int x = eg[i].x, y = eg[i].y;
long long w = eg[i].w;
if (find(fa[x]) == find(fa[y])) {
if (sf[find(fa[x])] == 0) {
sf[find(fa[x])] = 1;
ans += w;
}
} else if (find(fa[x]) != find(fa[y])) {
if (sf[find(fa[x])] + sf[find(fa[y])] != 2) {
sf[find(fa[x])] = sf[find(fa[x])] | sf[find(fa[y])];
sf[find(fa[y])] = sf[find(fa[x])] | sf[find(fa[y])];
fa[find(fa[x])] = find(fa[y]);
ans += w;
}
}
}
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkMax(T &first, T second) {
if (second > first) first = second;
}
template <typename T>
void chkMin(T &first, T second) {
if (second < first) first = second;
}
template <typename T>
inline void read(T &f) {
f = 0;
T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
const int MAX_N = 2e5 + 10, MAX_M = 1e6 + 10;
bool ok(string first, int k) {
sort(first.begin(), first.end());
int d = unique(first.begin(), first.end()) - first.begin();
return d <= k;
}
void solve() {
string n;
int k;
cin >> n >> k;
if (ok(n, k)) {
cout << n << '\n';
return;
}
for (int i = n.size() - 1; i >= 0; i--) {
for (n[i]++; n[i] <= '9'; n[i]++) {
for (char j = '0'; j <= '9'; j++) {
for (int k = i + 1; k < n.size(); k++) {
n[k] = j;
}
if (ok(n, k)) {
cout << n << '\n';
goto nex;
}
}
}
}
nex:;
return;
}
int main() {
int T = 1;
read(T);
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int i, k, j, mod = 1e9 + 7, val[500];
long long ans = 1;
string s;
int main() {
k = 0;
for (i = 0; i <= 9; i++) val[i + 48] = k++;
for (i = 'A'; i <= 'Z'; i++) val[i] = k++;
for (i = 'a'; i <= 'z'; i++) val[i] = k++;
val['-'] = 62;
val['_'] = 63;
cin >> s;
for (i = 0; i < s.length(); i++)
for (j = 0; j < 6; j++)
if (!(val[s[i]] & (1 << j))) ans = (ans * 3) % mod;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int MAXR = 1e6 + 5;
const int R = 1e6;
int left(int x) { return (x << 1); }
int right(int x) { return (x << 1) + 1; }
bool in(int l, int r, int i, int j) { return (i <= l && j >= r); }
bool out(int l, int r, int i, int j) { return (l > j || r < i); }
int n, m, q, a[MAXN], b[MAXN];
int st[4 * MAXR], lazy[4 * MAXR];
void propagate(int p) {
st[left(p)] += lazy[p];
st[right(p)] += lazy[p];
lazy[left(p)] += lazy[p];
lazy[right(p)] += lazy[p];
lazy[p] = 0;
}
void build(int p, int l, int r) {
if (l == r) {
st[p] = 0;
} else {
int mid = (l + r) / 2;
build(left(p), l, mid);
build(right(p), mid + 1, r);
int p1 = st[left(p)], p2 = st[right(p)];
st[p] = max(p1, p2);
}
}
void upd(int p, int l, int r, int i, int j, int val) {
if (out(l, r, i, j)) return;
if (in(l, r, i, j)) {
st[p] += val;
lazy[p] += val;
return;
}
int mid = (l + r) / 2;
propagate(p);
upd(left(p), l, mid, i, j, val);
upd(right(p), mid + 1, r, i, j, val);
st[p] = max(st[left(p)], st[right(p)]);
}
int query(int p, int l, int r, int i, int j) {
if (out(l, r, i, j)) return -R;
if (in(l, r, i, j)) {
return st[p];
}
int mid = (l + r) / 2;
propagate(p);
int p1 = query(left(p), l, mid, i, j);
int p2 = query(right(p), mid + 1, r, i, j);
return max(p1, p2);
}
int query2(int p, int l, int r) {
propagate(p);
if (l == r) return (st[p] > 0) ? l : -1;
int mid = (l + r) / 2;
if (st[right(p)] > 0) {
return query2(right(p), mid + 1, r);
} else {
return query2(left(p), l, mid);
}
}
int getAns() {
int l = 1, r = R;
while (l < r) {
int mid = (l + r) / 2 + 1;
int tmp = query(1, 0, R, mid, R);
if (tmp > 0) {
l = mid;
} else {
r = mid - 1;
}
}
int tmp = query(1, 0, R, l, R);
if (tmp <= 0) return -1;
return l;
}
int main() {
build(1, 0, R);
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
upd(1, 0, R, 0, a[i], 1);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &b[i]);
upd(1, 0, R, 0, b[i], -1);
}
scanf("%d", &q);
while (q--) {
int typ, i, x;
scanf("%d %d %d", &typ, &i, &x);
i--;
if (typ == 1) {
upd(1, 0, R, 0, a[i], -1);
a[i] = x;
upd(1, 0, R, 0, a[i], 1);
} else {
upd(1, 0, R, 0, b[i], 1);
b[i] = x;
upd(1, 0, R, 0, b[i], -1);
}
printf("%d\n", getAns());
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int n, m, s;
cin >> n >> m >> s;
long long int a = n / s;
long long int b = m / s;
long long int c = n % s;
long long int d = m % s;
if (c == 0) {
c = s;
} else {
a++;
}
if (d == 0) {
d = s;
} else {
b++;
}
long long int ans = a * b * c * d;
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
long t, a, b, res;
cin >> t;
for (int i = 1; i <= t; i++) {
res = 0;
cin >> a >> b;
if (a == b) {
cout << res << endl;
} else {
if (abs(a - b) % 10 == 0) {
res += abs(a - b) / 10;
} else {
res += abs(a - b) / 10 + 1;
}
cout << res << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> fun(long long x, long long n) {
long long i = 0, j = 0, k = 0, tmp1 = 0, tmp2 = 0, tmp3 = 0, tmp = 0,
tmp4 = 0, tmp5 = 0, flag = 0, T = 0, N = 0, Q = 0;
tmp = 6 * x - n + n * n * n;
if (tmp == 0) return make_pair(-1, -1);
if (tmp % 3) return make_pair(-1, -1);
tmp /= 3;
if (tmp % n) return make_pair(-1, -1);
tmp /= n;
if (tmp % (n + 1)) return make_pair(-1, -1);
tmp /= (n + 1);
if (n > tmp) return make_pair(-1, -1);
return make_pair(n, tmp);
}
int main() {
long long i = 0, j = 0, k = 0, tmp1 = 0, tmp2 = 0, tmp3 = 0, tmp = 0,
tmp4 = 0, tmp5 = 0, flag = 0, T = 0, N = 0, Q = 0;
long long x;
pair<long long, long long> pr;
cin >> x;
vector<pair<long long, long long> > ans;
double lp = pow(x, 0.34);
for (i = 1; i < lp * 2 + 1; i++) {
pr = fun(x, i);
if (pr.first != -1) ans.push_back(pr);
}
if (ans.size() == 0) {
printf("Empty");
return 0;
}
if (ans.back().first == ans.back().second) {
printf("%d\n", 2 * ans.size() - 1);
for (i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
if (ans.size() > 1)
for (i = ans.size() - 2; i > -1; i--) {
cout << ans[i].second << " " << ans[i].first << endl;
}
} else {
printf("%d\n", 2 * ans.size());
for (i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
for (i = ans.size() - 1; i > -1; i--) {
cout << ans[i].second << " " << ans[i].first << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, INF = 2e9 + 1;
vector<vector<int>> nodes;
vector<int> comp;
vector<int> x, y;
map<int, vector<pair<int, int>>> sameX, sameY;
int mulMod(long long, long long);
int addMod(int, int);
void readArray(int *, int);
void printArray(int *, int);
void dfs(int u, int id) {
comp[u] = id;
for (int &c : nodes[u])
if (comp[c] == 0) dfs(c, id);
}
bool check(int curr, int t) {
if (curr == 2) {
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (comp[i] == comp[j]) continue;
if (x[i] == x[j] && abs(y[i] - y[j]) <= 2 * t) return true;
if (y[i] == y[j] && abs(x[i] - x[j]) <= 2 * t) return true;
if (abs(x[i] - x[j]) <= t && abs(y[i] - y[j]) <= t) return true;
}
return false;
} else if (curr == 3) {
vector<pair<int, int>> seg;
for (auto &p : sameX) {
for (int i = 1; i < (int)p.second.size(); i++)
if (comp[p.second[i].second] != comp[p.second[i - 1].second])
seg.push_back({p.second[i].second, p.second[i - 1].second});
}
for (auto &p : sameY) {
for (int i = 1; i < (int)p.second.size(); i++)
if (comp[p.second[i].second] != comp[p.second[i - 1].second])
seg.push_back({p.second[i].second, p.second[i - 1].second});
}
for (auto &el : seg) {
int i = el.first, j = el.second;
for (int k = 0; k < n; k++) {
if (comp[k] == comp[i] || comp[k] == comp[j]) continue;
if (x[i] == x[j]) {
if (min(y[i], y[j]) >= y[k] || max(y[i], y[j]) <= y[k]) continue;
if (abs(x[i] - x[k]) > t) continue;
if (abs(y[i] - y[k]) <= t && abs(y[j] - y[k]) <= t) return true;
} else {
if (min(x[i], x[j]) >= x[k] || max(x[i], x[j]) <= x[k]) continue;
if (abs(y[i] - y[k]) > t) continue;
if (abs(x[i] - x[k]) <= t && abs(x[j] - x[k]) <= t) return true;
}
}
}
return false;
}
vector<pair<int, int>> segX, segY;
for (auto &p : sameX) {
for (int i = 1; i < (int)p.second.size(); i++)
if (comp[p.second[i].second] != comp[p.second[i - 1].second])
segX.push_back({p.second[i].second, p.second[i - 1].second});
}
for (auto &p : sameY) {
for (int i = 1; i < (int)p.second.size(); i++)
if (comp[p.second[i].second] != comp[p.second[i - 1].second])
segY.push_back({p.second[i].second, p.second[i - 1].second});
}
for (auto &el1 : segX)
for (auto &el2 : segY) {
int a = el1.first, b = el1.second, c = el2.first, d = el2.second;
if (comp[a] == comp[c] || comp[a] == comp[d] || comp[b] == comp[c] ||
comp[b] == comp[d])
continue;
if (min(y[a], y[b]) >= y[c]) continue;
if (max(y[a], y[b]) <= y[c]) continue;
if (min(x[c], x[d]) >= x[a]) continue;
if (max(x[c], x[d]) <= x[a]) continue;
int x0 = x[a], y0 = y[c];
if (abs(y[a] - y0) <= t && abs(y[b] - y0) <= t)
if (abs(x[c] - x0) <= t && abs(x[d] - x0) <= t) return true;
}
return false;
}
bool ok(int t) {
nodes.clear();
nodes.resize(n);
comp.assign(n, 0);
for (auto &p : sameX) {
for (int i = 1; i < (int)p.second.size(); i++)
if (p.second[i].first - p.second[i - 1].first <= t) {
nodes[p.second[i].second].push_back(p.second[i - 1].second);
nodes[p.second[i - 1].second].push_back(p.second[i].second);
}
}
for (auto &p : sameY) {
for (int i = 1; i < (int)p.second.size(); i++)
if (p.second[i].first - p.second[i - 1].first <= t) {
nodes[p.second[i].second].push_back(p.second[i - 1].second);
nodes[p.second[i - 1].second].push_back(p.second[i].second);
}
}
int curr = 1;
for (int i = 0; i < n; i++) {
if (comp[i] != 0) continue;
dfs(i, curr);
curr++;
}
curr--;
if (curr > 4) return false;
if (curr == 1) return true;
return check(curr, t);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
x.resize(n), y.resize(n);
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) {
sameX[x[i]].push_back({y[i], i});
sameY[y[i]].push_back({x[i], i});
}
for (auto &p : sameX) sort(p.second.begin(), p.second.end());
for (auto &p : sameY) sort(p.second.begin(), p.second.end());
long long l = 1, r = INF, mid, ans = INF;
while (l <= r) {
mid = (l + r) >> 1LL;
if (ok(mid)) {
ans = min(ans, mid);
r = mid - 1;
} else
l = mid + 1;
}
cout << (ans == INF ? -1 : ans) << endl;
return 0;
}
int mulMod(long long a, long long b) {
a *= b;
a %= 1000000007;
return (int)a;
}
int addMod(int a, int b) {
long long c = a + b;
if (c >= 1000000007) {
c -= 1000000007;
}
return (int)c;
}
void readArray(int *nums, int n) {
for (int i = 0; i < n; i++) cin >> nums[i];
}
void printArray(int *nums, int n) {
for (int i = 0; i < n; i++) cout << nums[i] << " ";
cout << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3;
string a[N];
int d[N];
void finish() {
cout << "Impossible" << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
for (int i = 0; i < N; i++) cin >> a[i];
for (int i = 0; i < N; i++)
if (a[i][1] == '>')
d[a[i][0] - 'A']++;
else
d[a[i][2] - 'A']++;
for (int i = 0; i < N; i++)
for (int j = 0; j < i; j++)
if (d[i] == d[j]) finish();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++)
if (d[j] == i) cout << char('A' + j);
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void single(int n) {
switch (n) {
case 0: {
cout << "zero";
break;
}
case 1: {
cout << "one";
break;
}
case 2: {
cout << "two";
break;
}
case 3: {
cout << "three";
break;
}
case 4: {
cout << "four";
break;
}
case 5: {
cout << "five";
break;
}
case 6: {
cout << "six";
break;
}
case 7: {
cout << "seven";
break;
}
case 8: {
cout << "eight";
break;
}
case 9: {
cout << "nine";
break;
}
}
}
void tens(int n) {
n = (n % 10);
switch (n) {
case 0: {
cout << "ten";
break;
}
case 1: {
cout << "eleven";
break;
}
case 2: {
cout << "twelve";
break;
}
case 3: {
cout << "thirteen";
break;
}
case 4: {
cout << "fourteen";
break;
}
case 5: {
cout << "fifteen";
break;
}
case 6: {
cout << "sixteen";
break;
}
case 7: {
cout << "seventeen";
break;
}
case 8: {
cout << "eighteen";
break;
}
case 9: {
cout << "nineteen";
break;
}
}
}
void fun1(int n) {
switch (n) {
case 1: {
cout << "-one";
break;
}
case 2: {
cout << "-two";
break;
}
case 3: {
cout << "-three";
break;
}
case 4: {
cout << "-four";
break;
}
case 5: {
cout << "-five";
break;
}
case 6: {
cout << "-six";
break;
}
case 7: {
cout << "-seven";
break;
}
case 8: {
cout << "-eight";
break;
}
case 9: {
cout << "-nine";
break;
}
}
}
void fun(int n) {
int val = n % 10;
switch (n / 10) {
case 2: {
cout << "twenty";
fun1(val);
break;
}
case 3: {
cout << "thirty";
fun1(val);
break;
}
case 4: {
cout << "forty";
fun1(val);
break;
}
case 5: {
cout << "fifty";
fun1(val);
break;
}
case 6: {
cout << "sixty";
fun1(val);
break;
}
case 7: {
cout << "seventy";
fun1(val);
break;
}
case 8: {
cout << "eighty";
fun1(val);
break;
}
case 9: {
cout << "ninety";
fun1(val);
break;
}
}
}
int main() {
int n;
cin >> n;
if (n / 10 == 0)
single(n);
else if (n / 10 == 1)
tens(n);
else
fun(n);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
deque<long long int> v;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end(), greater<long long int>());
long long int sum = 0, cnt = 0;
long long int z = accumulate(v.begin(), v.end(), 0);
for (int i = 0; i < n; i++) {
sum = sum + v[i];
z = z - v[i];
cnt++;
if (sum > z) {
break;
}
}
cout << cnt << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2000000;
bool pierwsza[MAX], pal[MAX];
long long pi[MAX], rub[MAX];
inline bool jest_pal(long long n) {
long long c[10], roz = 0;
while (n > 0) {
c[roz++] = n % 10;
n /= 10;
}
for (long long i = 0; i < (roz); i++)
if (c[i] != c[roz - 1 - i]) return false;
return true;
}
void wypelnij_rub() {
rub[0] = 0;
for (long long i = (1); i <= (MAX - 1); i++) {
pal[i] = jest_pal(i);
rub[i] = rub[i - 1] + (pal[i] ? 1 : 0);
}
}
void wypelnij_pi() {
fill(pierwsza, pierwsza + MAX, true);
pierwsza[0] = pierwsza[1] = false;
for (long long i = (2); i <= (MAX - 1); i++)
for (long long j = i * i; j < MAX; j += i) pierwsza[j] = false;
pi[0] = 0;
for (long long i = (1); i <= (MAX - 1); i++)
pi[i] = pi[i - 1] + (pierwsza[i] ? 1 : 0);
}
void rozwiaz(long long p, long long q) {
for (long long n = (MAX - 1); n >= (0); n--)
if (q * pi[n] <= p * rub[n]) {
cout << n << '\n';
return;
}
assert(false);
}
void zrob_test() {
wypelnij_rub();
wypelnij_pi();
long long p, q;
cin >> p >> q;
rozwiaz(p, q);
}
int main() {
ios_base::sync_with_stdio(0);
zrob_test();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y, i;
cin >> i;
while (i--) {
cin >> x >> y;
long long int sum = y + 9 * (x - 1);
cout << sum << endl;
}
}
| 1 |
#include <bits/stdc++.h>
int read() {
int res = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) res = res * 10 + ch - 48, ch = getchar();
return res * flag;
}
using namespace std;
struct node {
int x, y;
bool operator==(const node& z) const { return x == z.x && y == z.y; }
};
struct node_hash {
std::size_t operator()(const node& z) const { return z.x * 300000 + z.y; }
};
int t, _, n, i, j, u, q, v, k, tot = 0, vis[300005], dep[300005], st1, lst,
cnt[2], hd[2], sq;
const int inf = 1e9;
vector<int> s[2][300005];
unordered_map<node, int, node_hash> mp;
unordered_map<node, int, node_hash>::iterator it;
void insert(int p) {
int i, x;
cnt[p]++;
for (i = 1; i <= k; i++) {
x = read();
s[p][cnt[p]].push_back(x);
}
}
int follow(int p, int w) {
int i, st1 = 0, lst = inf;
for (i = 0; i < s[p][w].size(); i++) {
if (vis[s[p][w][i]] < tot)
st1 = 0;
else {
if (!st1 && lst < dep[s[p][w][i]]) return 1;
st1 = 1;
lst = dep[s[p][w][i]];
}
}
return 0;
}
int main() {
t = read();
sq = 70;
for (_ = 1; _ <= t; _++) {
mp.clear();
n = read(), q = read();
for (i = 1; i <= q; i++) {
k = read();
if (k <= sq)
insert(0);
else
insert(1);
}
for (i = hd[0] + 1; i <= cnt[0]; i++) {
for (j = 0; j < s[0][i].size() - 1; j++) {
for (v = j + 1; v < s[0][i].size(); v++) {
it = mp.find((node){s[0][i][j], s[0][i][v]});
if (it == mp.end())
mp[(node){s[0][i][j], s[0][i][v]}] = s[0][i][j + 1];
else if (it->second != s[0][i][j + 1]) {
printf("Human\n");
goto tag;
}
}
}
}
for (i = hd[1] + 1; i <= cnt[1]; i++) {
tot++;
for (j = 0; j < s[1][i].size(); j++) {
vis[s[1][i][j]] = tot;
dep[s[1][i][j]] = j + 1;
}
for (j = hd[0] + 1; j <= cnt[0]; j++) {
if (follow(0, j)) {
printf("Human\n");
goto tag;
}
}
for (j = hd[1] + 1; j <= cnt[1]; j++) {
if (follow(1, j)) {
printf("Human\n");
goto tag;
}
}
}
printf("Robot\n");
tag:
hd[0] = cnt[0];
hd[1] = cnt[1];
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<int>());
long long sum = a[0];
for (int i = 1; i < n; i++) sum = (2 * sum + a[i]) % mod;
for (int i = 0; i < n; i++) a[i] = -a[i];
sort(a, a + n, greater<int>());
long long sum2 = a[0];
for (int i = 1; i < n; i++) sum2 = (2 * sum2 + a[i]) % mod;
cout << (sum + sum2 + mod) % mod << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 200 + 10;
const long long MXM = 5e2 + 10;
const long long MX5 = 1e5 + 10;
const long long MX6 = 1e6 + 10;
const long long LOG = 20;
const long long INF = 8e18;
const double eps = 1e-9;
const long long MOD = 1e9 + 7;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
long long bmm(long long a, long long b) {
return (a % b == 0 ? b : bmm(b, a % b));
}
string base2(long long n) {
string a = "";
while (n >= 2) {
a += (char)(n % 2 + '0');
n /= 2;
}
a += (char)(n + '0');
reverse((a).begin(), (a).end());
return a;
}
long long n, m, k, dis[MX5], Mol[MX5];
long long par[MX5], SZ[MX5];
vector<pair<long long, long long> > G[MX5], E1;
set<pair<long long, long long> > q;
bool vis[MX5];
vector<pair<pair<long long, long long>, long long> > E;
vector<pair<long long, pair<long long, long long> > > Edge;
map<pair<long long, long long>, bool> mp;
map<pair<long long, long long>, long long> cost;
void init() {
for (int i = 1; i <= n; i++) {
SZ[i] = 1;
par[i] = i;
dis[i] = INF;
}
return;
}
long long Find(long long u) {
if (par[u] == u) {
return u;
}
par[u] = Find(par[u]);
return par[u];
}
bool Union(long long u, long long v) {
long long p1 = Find(u), p2 = Find(v);
if (p1 == p2) {
return 0;
}
if (SZ[p1] > SZ[p2]) {
par[p2] = p1;
SZ[p1] += SZ[p2];
} else {
par[p1] = p2;
SZ[p2] += SZ[p1];
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
init();
for (int i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
G[u].push_back({v, w});
G[v].push_back({u, w});
E.push_back({{u, v}, w});
}
cin >> k;
for (int i = 0; i < k; i++) {
long long u;
cin >> u;
dis[u] = 0;
Mol[u] = u;
vis[u] = 1;
}
for (int i = 1; i <= n; i++) {
q.insert({dis[i], i});
}
while (!q.empty()) {
auto itr = q.begin();
long long u = itr->second, c = itr->first;
vis[u] = 1;
q.erase(itr);
for (auto Pr : G[u]) {
long long v = Pr.first, w = Pr.second;
if (!vis[v] && w + c < dis[v]) {
auto Trash = q.lower_bound({dis[v], v});
q.erase(Trash);
dis[v] = w + c;
Mol[v] = Mol[u];
q.insert({dis[v], v});
}
}
}
for (int i = 0; i < m; i++) {
long long u = E[i].first.first, v = E[i].first.second, w = E[i].second;
long long m1 = Mol[u], m2 = Mol[v];
if (m1 != m2) {
if (mp[{m1, m2}]) {
cost[{m1, m2}] = min(cost[{m1, m2}], dis[u] + dis[v] + w);
cost[{m2, m1}] = cost[{m1, m2}];
continue;
}
mp[{m1, m2}] = 1;
mp[{m2, m1}] = 1;
E1.push_back({m1, m2});
cost[{m1, m2}] = dis[u] + dis[v] + w;
cost[{m2, m1}] = cost[{m1, m2}];
}
}
for (int i = 0; i < E1.size(); i++) {
long long u = E1[i].first, v = E1[i].second;
long long w = cost[{u, v}];
Edge.push_back({w, {u, v}});
}
sort(((Edge)).begin(), ((Edge)).end());
long long ans = 0;
for (int i = 0; i < Edge.size(); i++) {
long long u = Edge[i].second.first, v = Edge[i].second.second,
w = Edge[i].first;
bool f = Union(u, v);
if (f) ans += w;
}
cout << ans + dis[1];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
char str[N];
int k;
int n;
int ara[N];
int check(int wid) {
int lines = 1;
int cnt = 0;
int pos = 0;
while (pos < n) {
if (cnt + ara[pos] > wid) {
lines++;
cnt = 0;
} else {
cnt += ara[pos];
pos++;
}
if (lines > k) return 0;
}
if (lines > k) return 0;
return 1;
}
int main() {
scanf("%d", &k);
getchar();
gets(str);
int cnt = 0;
int MN = 1e9;
for (int i = 0; str[i]; i++) {
cnt++;
if (str[i] == '-' or str[i] == ' ') {
ara[n++] = cnt;
cnt = 0;
}
}
ara[n++] = cnt;
for (int i = 0; i < n; i++) MN = min(MN, ara[i]);
int lo = MN, hi = N, mid, ans;
while (lo <= hi) {
mid = (lo + hi) / 2;
int x = check(mid);
if (x) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
int n, m;
long long Hidan, Aria;
long long a[100001];
long long b[100001];
long long random(long long l, long long r) {
long long a = rand();
a = a * rand();
a = a * rand();
a %= r - l + 1;
if (a < 0) a += r - l + 1;
return a + l;
}
int main() {
srand(time(NULL));
read(n);
read(Hidan);
for (int i = (1); i <= (n); i++) read(a[i]);
read(m);
read(Aria);
for (int i = (1); i <= (m); i++) read(b[i]);
if (n == 1 && m == 1) {
writeln(2);
return 0;
}
int ans = 2;
int lim = 6;
for (int cnt = (1); cnt <= (lim); cnt++) {
long long pa = a[random(1, n)];
long long push_back = b[random(1, m)];
while (pa == push_back) {
pa = a[random(1, n)];
push_back = b[random(1, m)];
}
long long c = abs(pa - push_back);
int c2 = 0;
while (c % 2 == 0) {
c2++;
c /= 2;
}
long long x = 1;
for (int i = (0); i <= (c2); i++) {
long long x2 = x * 2;
long long amx2 = pa % x2;
long long bmx2 = push_back % x2;
if ((pa % x2 + x - push_back) % (x2) == 0) {
int res = 0;
for (int i = (1); i <= (n); i++) res += (a[i] % x2) == amx2;
for (int i = (1); i <= (m); i++) res += (b[i] % x2) == bmx2;
ans = max(ans, res);
}
x = x2;
}
}
for (int cnt = (1); cnt <= (lim); cnt++) {
if (n == 1) break;
if ((n == 2) && ((a[1] - a[2]) % 2)) break;
long long pa0 = a[random(1, n)];
long long pa1 = a[random(1, n)];
while ((pa0 == pa1) || ((pa0 - pa1) % 2)) {
pa0 = a[random(1, n)];
pa1 = a[random(1, n)];
}
long long c = abs(pa0 - pa1);
int c2 = 0;
while (c % 2 == 0) {
c2++;
c /= 2;
}
c2--;
long long x = 1;
for (int i = (0); i <= (c2); i++) {
long long x2 = x * 2;
long long amx2 = pa0 % x2;
long long bmx2 = (pa0 + x) % x2;
int res = 0;
for (int i = (1); i <= (n); i++) res += (a[i] % x2) == amx2;
for (int i = (1); i <= (m); i++) res += (b[i] % x2) == bmx2;
ans = max(ans, res);
x = x2;
}
}
for (int cnt = (1); cnt <= (lim); cnt++) {
if (m == 1) break;
if ((m == 2) && ((b[1] - b[2]) % 2)) break;
long long pb0 = b[random(1, m)];
long long pb1 = b[random(1, m)];
while ((pb0 == pb1) || ((pb0 - pb1) % 2)) {
pb0 = b[random(1, m)];
pb1 = b[random(1, m)];
}
long long c = abs(pb0 - pb1);
int c2 = 0;
while (c % 2 == 0) {
c2++;
c /= 2;
}
c2--;
long long x = 1;
for (int i = (0); i <= (c2); i++) {
long long x2 = x * 2;
long long bmx2 = pb0 % x2;
long long amx2 = (pb0 + x) % x2;
int res = 0;
for (int i = (1); i <= (n); i++) res += (a[i] % x2) == amx2;
for (int i = (1); i <= (m); i++) res += (b[i] % x2) == bmx2;
ans = max(ans, res);
x = x2;
}
}
writeln(ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, sum;
struct Can {
int a, id;
bool operator<(const Can &b) const { return a > b.a; }
} c[1005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i].a), c[i].id = i;
sort(c + 1, c + 1 + n);
for (int i = 1; i <= n; i++) sum += c[i].a * (i - 1) + 1;
printf("%d\n", sum);
for (int i = 1; i <= n; i++) printf("%d ", c[i].id);
puts("");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
for (int p = 0; p < t; p++) {
long long int n, k;
cin >> n >> k;
double ans = (1.0 * n * k) / (n - 1);
long long int m = ans;
if (m == ans) {
if (((m - 1) - (m - 1) / n) == k)
cout << m - 1 << endl;
else {
cout << m << endl;
}
} else {
cout << m << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cn[510][510];
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < N; i++) {
cn[i][i] = true;
}
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
cn[u - 1][v - 1] = cn[v - 1][u - 1] = true;
}
string S(N, 0);
int aind = -1;
for (int i = 0; i < N; i++) {
bool isb = true;
for (int j = 0; j < N; j++) {
isb &= cn[i][j];
}
if (isb) {
S[i] = 'b';
} else if (aind != -1 && !cn[aind][i]) {
S[i] = 'c';
} else {
aind = i;
S[i] = 'a';
}
}
bool ok = true;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
ok &= cn[i][j] == (abs(S[i] - S[j]) <= 1);
}
}
if (ok) {
cout << "Yes" << endl;
cout << S << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, T;
char s[10000];
while (cin >> n >> T) {
for (int i = 0; i < n; i++) cin >> s[i];
for (int j = 0; j < T; j++)
for (int i = 0; i < n - 1;)
if (s[i] == 'B' && s[i + 1] == 'G') {
s[i] = 'G';
s[i + 1] = 'B';
i += 2;
} else
i++;
for (int i = 0; i < n; i++) cout << s[i];
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> a(N + 2);
for (int i = 1; i <= N; ++i) cin >> a[i], a[i] = " " + a[i];
vector<int> row(N + 2, 0), col(N + 2, 0);
reverse(a.begin() + 1, a.begin() + N + 1);
int sol = 0;
for (int i = 1; i < N; ++i)
for (int j = 1; j <= N - i; ++j) {
int v = a[i][j] - '0';
v ^= row[i] ^ col[j];
if (v == 1) {
++sol;
row[i] ^= 1;
col[j] ^= 1;
}
}
for (int i = 1; i <= N; ++i) {
int v = a[i][N - i + 1] - '0';
v ^= row[i] ^ col[N - i + 1];
a[i][N - i + 1] = v + '0';
}
row = col = vector<int>(N + 2, 0);
for (int i = N; i > 1; --i)
for (int j = N; j > N - i + 1; --j) {
int v = a[i][j] - '0';
v ^= row[i] ^ col[j];
if (v == 1) {
++sol;
row[i] ^= 1;
col[j] ^= 1;
}
}
for (int i = 1; i <= N; ++i) {
int v = a[i][N - i + 1] - '0';
v ^= row[i] ^ col[N - i + 1];
if (v == 1) {
++sol;
}
}
cout << sol;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string second;
cin >> second;
bool ver = false;
bool gar = false;
for (int i = 0; i < second.size(); i++) {
if (second[i] == '0') {
if (!ver) {
cout << "1 1";
} else {
cout << "3 1";
}
ver ^= true;
} else {
if (!gar) {
cout << "4 3";
} else {
cout << "4 1";
}
gar ^= true;
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
if (x > (y + z))
cout << "+" << endl;
else if (y > (x + z))
cout << "-" << endl;
else if (x == y && z == 0)
cout << "0" << endl;
else
cout << "?" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> isAvail;
int main() {
char heading[201];
char toText[201];
bool okay = true;
cin.getline(heading, 200);
cin.getline(toText, 200);
int i;
for (i = 0; heading[i]; ++i) isAvail[heading[i]]++;
for (i = 0; toText[i]; ++i) {
if (toText[i] != ' ') {
if (!isAvail[toText[i]])
break;
else
isAvail[toText[i]] -= 1;
}
}
if (toText[i])
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][10001];
signed main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n);
for (int i = 0; i < n; i++) {
int k;
cin >> k;
a[i].assign(k, 0);
for (int j = 0; j < k; j++) cin >> a[i][j];
}
vector<vector<int>> val(n);
for (int i = 0; i < n; i++) val[i].assign(a[i].size() + 1, 0);
for (int i = 0; i < n; i++) {
int loc = a[i].size();
vector<int> pref(loc, 0);
for (int j = 0; j < loc; j++) {
pref[j] = a[i][j];
if (j != 0) pref[j] += pref[j - 1];
}
for (int l = 0; l < loc; l++) val[i][l + 1] = max(val[i][l + 1], pref[l]);
int sum = 0;
for (int j = loc - 1; j >= 0; j--) {
sum += a[i][j];
val[i][loc - j] = max(val[i][loc - j], sum);
}
for (int len = 1; len <= loc; len++) {
for (int l = 0; l + len - 1 < loc; l++) {
int k = pref[l + len - 1] - (l != 0 ? pref[l - 1] : 0);
val[i][loc - len] = max(val[i][loc - len], sum - k);
}
}
}
for (int i = 0; i < n; i++) {
swap(dp[0], dp[1]);
for (int j = 0; j <= m; j++) {
for (int k = 0; k <= min((int)a[i].size(), j); k++)
dp[1][j] = max(dp[1][j], dp[0][j - k] + val[i][k]);
}
}
cout << dp[1][m];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6600;
int n, val[maxn];
int Adj[maxn], Size;
struct Edge {
int to, next;
} edge[maxn * 2];
void init_edge() {
memset(Adj, -1, sizeof(Adj));
Size = 0;
}
void add_edge(int u, int v) {
edge[Size].to = v;
edge[Size].next = Adj[u];
Adj[u] = Size++;
}
int range[maxn], rn;
int dp[maxn], ans = 1;
void dfs(int u, int fa) {
for (int i = Adj[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (v == fa) continue;
int oldV;
bool oldRn = false;
int POS = lower_bound(range, range + rn, val[v]) - range;
oldV = range[POS];
range[POS] = val[v];
dp[v] = max(dp[v], POS + 1);
if (POS == rn) {
oldRn = true;
rn++;
}
dfs(v, u);
if (oldRn) rn--;
range[POS] = oldV;
}
}
int main() {
init_edge();
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", val + i);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
for (int rt = 1; rt <= n; rt++) {
rn = 0;
range[rn++] = val[rt];
dp[rt] = max(dp[rt], 1);
dfs(rt, 0);
}
for (int i = 1; i <= n; i++) ans = max(ans, dp[i]);
cout << ans << endl;
return 0;
}
| 7 |
#include <iostream>
#include <vector>
#include <climits>
#define forn(i, n) for (int i = 0; i < n; i++)
using namespace std;
const int oo = 2e5+1;
int t,n,m;
vector<int> clownconns[oo];
vector<int> downconns[oo];
vector<int> upconns[oo];
int values[oo];
int dp[oo];
int getdp(int node);
void cheapdfs(int node);
bool researched[oo];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> m;
forn(i, m) {
int a,b;
cin >> a >> b;
a--; b--;
clownconns[a].push_back(b);
}
forn(i, n) values[i] = -1;
forn(i, n) researched[i] = false;
int c = 0;
vector<int> toresearch {0};
vector<int> next;
while (toresearch.size() != 0) {
for (int i: toresearch) {
if (values[i]!=-1) continue;
values[i]=c;
for (int e: clownconns[i]) {
if (values[e]!=-1) continue;
next.push_back(e);
}
}
c++;
toresearch.clear();
toresearch = next;
next.clear();
}
cheapdfs(0);
forn(i, n) dp[i]=-1;
forn(i, n) cout << getdp(i) << " ";
cout << endl;
forn(i, n) clownconns[i].clear();
forn(i, n) downconns[i].clear();
forn(i, n) upconns[i].clear();
}
}
void cheapdfs(int node) {
if (researched[node]) return;
researched[node] = true;
for (int e: clownconns[node]) {
if (values[e] <= values[node]) upconns[node].push_back(e);
else {
downconns[node].push_back(e);
cheapdfs(e);
}
}
}
int getdp(int node) {
if (dp[node]!=-1) return dp[node];
dp[node] = values[node];
for (int e: downconns[node]) dp[node] = min(dp[node], getdp(e));
for (int e: upconns[node]) dp[node] = min(dp[node], values[e]);
return dp[node];
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2000 + 5;
vector<pair<long long, pair<int, int> > > vec;
long long lca_d(long long u, long long v) {
int r = 0;
int p1 = 63, p2 = 63;
while ((u >> p1 & 1) == 0) p1--;
while ((v >> p2 & 1) == 0) p2--;
long long fa = 0;
while ((u >> p1 & 1) == (v >> p2 & 1) && p1 >= 0 && p2 >= 0) r++, p1--, p2--;
return r;
}
void add(long long u, long long v, long long w) {
long long fa = lca_d(u, v);
vec.push_back({u, {fa, w}});
vec.push_back({v, {fa, w}});
}
long long dis(long long a, long long b) {
long long r = 0;
int fa = lca_d(a, b);
for (int i = 0; i < (int)vec.size(); i++) {
int pa, pb;
pa = lca_d(a, vec[i].first), pb = lca_d(b, vec[i].first);
if (pa > fa && pa > vec[i].second.first)
r += (long long)(pa - max(fa, vec[i].second.first)) *
(long long)vec[i].second.second;
if (pb > fa && pb > vec[i].second.first)
r += (long long)(pb - max(fa, vec[i].second.first)) *
(long long)vec[i].second.second;
}
return r;
}
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int id;
cin >> id;
long long u, v, w;
if (id == 1)
cin >> u >> v >> w, add(u, v, w);
else
cin >> u >> v, cout << dis(u, v) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void mini(T &l, T r) {
l = min(l, r);
}
template <class T>
void maxi(T &l, T r) {
l = max(l, r);
}
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
using llint = long long;
const int N = 60;
int n;
char s[N];
string pat = "aeiou13579";
void run() {
scanf("%s", s);
int c = 0;
for (int i = 0; s[i]; ++i) {
if (find(pat.begin(), pat.end(), s[i]) != pat.end()) {
++c;
}
}
printf("%d\n", c);
}
int main() {
run();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100005], b[100005], fa[100005], s[100005], q[100005], l,
p = -2147483647;
inline long long find(long long x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
inline long long M(long long u, long long v) { return u > v ? u : v; }
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= n; i++) scanf("%lld", &b[i]);
for (long long i = n; i >= 1; i--) {
long long k = b[i];
if (!fa[k]) fa[k] = k, s[k] = a[k];
long long fk = find(k);
if (fa[k - 1] && k - 1 > 0) {
long long fl = find(k - 1);
if (fk != fl) s[k] += s[fl], s[fl] = 0, fa[fl] = k;
}
if (fa[k + 1] && k + 1 <= n) {
long long fr = find(k + 1);
if (fk != fr) s[k] += s[fr], s[fr] = 0, fa[fr] = k;
}
p = M(p, s[k]), q[++l] = p;
}
for (long long i = n - 1; i >= 0; i--) printf("%lld\n", q[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
char img1[200][200], img2[200][200], img3[200][200];
cin >> w >> h;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) cin >> img1[i][j];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) img2[j][i] = img1[i][j];
for (int i = 0; i < w; i++)
for (int j = 0; j < h; j++) {
img3[2 * i][2 * j] = img2[i][j];
img3[2 * i][2 * j + 1] = img2[i][j];
img3[2 * i + 1][2 * j] = img2[i][j];
img3[2 * i + 1][2 * j + 1] = img2[i][j];
}
for (int i = 0; i < 2 * w - 1; i++) {
for (int j = 0; j < 2 * h; j++) cout << img3[i][j];
cout << "\n";
}
for (int i = 0; i < 2 * h; i++) cout << img3[2 * w - 1][i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int wiresnumber;
cin >> wiresnumber;
vector<int>* wires = new vector<int>[wiresnumber];
for (int i = 0; i < wiresnumber; i++) {
int size;
cin >> size;
for (int k = 0; k < size; k++) {
wires[i].push_back(1);
}
}
int shoots;
cin >> shoots;
for (int i = 0; i < shoots; i++) {
int w, b;
cin >> w >> b;
int size = wires[w - 1].size();
for (int l = 0; l < b - 1; l++) {
if (w > 1) wires[w - 2].push_back(1);
}
for (int i = b; i < size; i++) {
if (w < wiresnumber) wires[w].push_back(1);
}
wires[w - 1].clear();
}
for (int i = 0; i < wiresnumber; i++) {
cout << wires[i].size() << endl;
}
delete[] wires;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.push_back(x);
return move(v);
}
template <typename T, typename... Args>
inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (int i = 0; i < n - 1; i++) s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
inline void __evars_begin(int line) { cerr << "#" << line << ": "; }
template <typename T>
inline void __evars_out_var(vector<T> val) {
cerr << arrStr(val, val.size());
}
template <typename T>
inline void __evars_out_var(T* val) {
cerr << arrStr(val, 10);
}
template <typename T>
inline void __evars_out_var(T val) {
cerr << val;
}
inline void __evars(vector<string>::iterator it) { cerr << endl; }
template <typename T, typename... Args>
inline void __evars(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << "=";
__evars_out_var(a);
cerr << "; ";
__evars(++it, args...);
}
template <typename T_vector>
void output_vector(const T_vector& v, bool add_one = false, int start = -1,
int end = -1) {
if (start < 0) start = 0;
if (end < 0) end = int(v.size());
for (int i = start; i < end; i++)
cout << v[i] + (add_one ? 1 : 0) << (i < end - 1 ? ' ' : '\n');
}
const long long MaxN = 5e5 + 5;
vector<long long> st(4 * MaxN, INT_MAX);
long long f(long long x, long long y) { return min(x, y); }
void build(long long a[], long long node, long long start, long long end) {
if (start == end) {
st[node] = a[end];
} else {
long long mid = (start + end) / 2;
build(a, 2 * node + 1, start, mid);
build(a, 2 * node + 2, mid + 1, end);
st[node] = f(st[2 * node + 1], st[2 * node + 2]);
}
}
void update(long long node, long long start, long long end, long long pos,
long long val) {
if (pos < start || pos > end)
return;
else if (start == end && pos == start) {
st[node] = val;
return;
}
long long mid = (start + end) / 2;
update(2 * node + 1, start, mid, pos, val);
update(2 * node + 2, mid + 1, end, pos, val);
st[node] = f(st[2 * node + 1], st[2 * node + 2]);
}
long long query(long long start, long long end, long long l, long long r,
long long node) {
if (r < start || l > end)
return INT_MAX;
else if (start >= l && end <= r)
return st[node];
long long mid = (start + end) / 2;
return f(query(start, mid, l, r, 2 * node + 1),
query(mid + 1, end, l, r, 2 * node + 2));
}
long long find(long long k, long long node, long long l, long long r) {
if (l == r) return l;
long long mid = (l + r) / 2;
long long t = st[node * 2 + 1];
if (k < t) {
return find(k, node * 2 + 1, l, mid);
} else {
return find(k - t, node * 2 + 2, mid + 1, r);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t clk = clock();
int t = 1;
for (int tc = 0; tc < t; tc++) {
string s;
long long k;
cin >> s >> k;
long long a[(long long)s.size()];
for (int i = 0; i < (long long)s.size(); i++) {
a[i] = (int)(s[i] - 'a' + 1);
}
long long n = (long long)s.size();
build(a, 0, 0, n - 1);
cout << "Mike" << endl;
for (int i = 1; i < n; i++) {
long long qry = query(0, n - 1, 0, i - 1, 0);
if (qry < a[i]) {
cout << "Ann"
<< "\n";
} else {
cout << "Mike"
<< "\n";
}
}
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
int a, b = 0;
std::cin >> a;
while (a - 100 >= 0) {
a = a - 100;
b++;
}
while (a - 20 >= 0) {
a = a - 20;
b++;
}
while (a - 10 >= 0) {
a = a - 10;
b++;
}
while (a - 5 >= 0) {
a = a - 5;
b++;
}
while (a - 1 >= 0) {
a = a - 1;
b++;
}
std::cout << b;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-8;
int tot = 0;
int cnt[8];
int lvl[8];
int loy[8];
int n, k, A;
double ans = 0;
void gao() {
double curWin = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
int winnum = 0;
double B = 0;
double pers = 1;
for (int i = 0; i < n; ++i) {
if (mask & (1 << i)) {
++winnum;
pers *= 1.0 * loy[i] / 100;
} else {
B += lvl[i];
pers *= 1 - 1.0 * loy[i] / 100;
}
}
if (winnum <= n - winnum) {
curWin += 1.0 * pers * A / (A + B);
} else
curWin += pers;
}
if (curWin > ans) ans = curWin;
}
void dfs(int p, int left) {
if (p == n - 1) {
left = min(left, (100 - loy[p]) / 10);
loy[p] += left * 10;
gao();
loy[p] -= left * 10;
} else {
for (int i = 0; i <= left && loy[p] + i * 10 <= 100; ++i) {
loy[p] += i * 10;
dfs(p + 1, left - i);
loy[p] -= i * 10;
}
}
}
int main(int argc, char *argv[]) {
scanf("%d%d%d", &n, &k, &A);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &lvl[i], &loy[i]);
}
dfs(0, k);
printf("%.6lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n, m;
while (t-- > 0) {
cin >> n >> m;
if (n == 1 || m == 1) {
cout << "YES\n";
continue;
}
if (n == 2 && m == 2) {
cout << "YES\n";
continue;
}
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str;
bool flag;
long long v;
pair<long long, long long> calc(int l, int r) {
long long x = 0;
long long y = flag ? v : 1ll * (str[l] - '0');
for (int i = l + 1; i < r; i += 2) {
if (str[i] == '+') {
x += y;
y = str[i + 1] - '0';
} else {
y *= str[i + 1] - '0';
}
}
return make_pair(x, y);
}
long long work() {
long long ret = 0;
vector<int> vt(0);
int len = str.length();
for (int i = 1; i < len; i += 2)
if (str[i] == '*') {
vt.push_back(i);
}
for (int i = 0; i < vt.size(); i++) {
for (int j = i + 1; j < vt.size(); j++) {
flag = false;
pair<long long, long long> cur = calc(0, vt[i] - 1);
long long x = cur.first;
long long y = cur.second;
cur = calc(vt[i] + 1, vt[j] - 1);
y *= (cur.first + cur.second);
flag = true;
v = y;
cur = calc(vt[j] - 1, len - 1);
ret = max(ret, x + cur.first + cur.second);
}
}
return ret;
}
int main() {
cin >> str;
str = "1*" + str + "*1";
printf("%I64d\n", work());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string email;
getline(cin, email);
vector<int> leftPart((int)email.size());
{
int cntLetter = 0;
for (int i = 0; i < (int)email.size(); ++i) {
if (email[i] == '@') {
leftPart[i] = cntLetter;
cntLetter = 0;
} else {
if (isalpha(email[i])) {
++cntLetter;
} else if (isdigit(email[i]) || email[i] == '_') {
continue;
} else {
cntLetter = 0;
}
}
}
}
long long res = 0;
vector<int> rightPart((int)email.size());
{
for (int i = 0; i < (int)email.size(); ++i) {
bool foundDot = false;
if (email[i] == '@') {
int const k = i;
++i;
bool ok = true;
int beforeDomain = 0;
for (; i < (int)email.size(); ++i) {
if (!foundDot) {
if (email[i] == '.')
foundDot = true;
else if (!isalnum(email[i])) {
ok = false;
break;
} else {
++beforeDomain;
}
} else {
if (beforeDomain && isalpha(email[i])) {
++rightPart[k];
} else {
break;
}
}
}
if (!ok) {
rightPart[k] = 0;
}
--i;
res += (long long)leftPart[k] * rightPart[k];
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = (int)1e6 + 5;
string s[N];
vector<int> g[N];
int used[N];
int cnt;
string res;
void dfs(int v) {
used[v] = 1;
++cnt;
res += (char)v;
for (auto to : g[v]) {
if (!used[to]) {
dfs(to);
}
}
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> s[i];
map<int, int> mp;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < s[i].size(); ++j) {
if (j + 1 < (int)s[i].size()) g[s[i][j]].push_back(s[i][j + 1]);
mp[(int)s[i][j]]++;
}
}
string mal;
for (char c = 'a'; c <= 'z'; ++c) {
bool ok = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < s[i].size(); ++j) ok &= (s[i][j] != c);
}
if (ok && mp[(int)c]) {
dfs(c);
mal += res;
res.clear();
}
}
cout << mal;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[600005][30], DP[600005][3], f[600000];
char s[600000];
int main() {
memset(DP, -1, sizeof(DP));
scanf("%d%d", &n, &k);
scanf("%s", s);
for (int i = 0; i < n; i++) f[i + 1] = s[i] - 'A' + 1;
for (int i = 1; i <= n; i++) {
for (int q = 1; q <= k; q++) {
if (dp[i - 1][q] == DP[i - 1][1])
dp[i][q] = DP[i - 1][2];
else
dp[i][q] = DP[i - 1][1];
if (dp[i][q] == -1) dp[i][q]++;
if (f[i] != q) dp[i][q]++;
if (DP[i][1] == -1 || DP[i][1] > dp[i][q]) {
DP[i][2] = DP[i][1];
DP[i][1] = dp[i][q];
} else {
if (DP[i][2] == -1 || DP[i][2] > dp[i][q]) DP[i][2] = dp[i][q];
}
}
}
int Y = n;
while (n > 0) {
int mn = 600000;
for (int i = 1; i <= k; i++) {
if (dp[n][i] < mn && i != f[n + 1]) {
mn = dp[n][i];
f[n] = i;
}
}
n--;
}
printf("%d\n", DP[Y][1]);
for (int i = 1; i <= Y; i++) printf("%c", f[i] + 'A' - 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 1000;
const int MAXM = 30000;
int n, m, s, t;
int ghead[MAXN], gnxt[2 * MAXM], gto[2 * MAXM], gcost[MAXM];
bool dead[MAXM];
int calcidx;
int d[MAXN], mind[MAXN], par[MAXN];
bool been[MAXN], hast[MAXN];
void dfs(int at) {
been[at] = true, hast[at] = at == t;
mind[at] = d[at] = par[at] == -1 ? 0 : d[gto[par[at]]] + 1;
for (int x = ghead[at]; x != -1; x = gnxt[x])
if (!dead[x >> 1]) {
int to = gto[x];
if (!been[to]) {
par[to] = x ^ 1;
dfs(to);
if (hast[to]) hast[at] = true;
mind[at] = min(mind[at], mind[to]);
if (mind[to] > d[at] && hast[to]) {
if (calcidx == -1 || gcost[x >> 1] < gcost[calcidx]) calcidx = x >> 1;
}
} else if (x != par[at]) {
mind[at] = min(mind[at], d[to]);
}
}
}
int calc() {
for (int i = (0); i < (n); ++i) been[i] = hast[i] = false, par[i] = -1;
calcidx = -1;
dfs(s);
if (!hast[s]) return -1;
if (calcidx == -1) return -2;
return calcidx;
}
int retcost, ret[2], nret;
int q[MAXN], back[MAXN], qhead, qtail;
bool onpath[MAXM];
void findpath() {
for (int i = (0); i < (n); ++i) back[i] = -1;
qhead = qtail = 0;
back[s] = -2, q[qhead++] = s;
while (qtail < qhead) {
int at = q[qtail++];
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (back[to] == -1) back[to] = x ^ 1, q[qhead++] = to;
}
}
for (int i = (0); i < (m); ++i) onpath[i] = false;
if (back[t] == -1) return;
for (int x = t; x != s; x = gto[back[x]]) onpath[back[x] >> 1] = true;
}
void run() {
scanf("%d%d%d%d", &n, &m, &s, &t);
--s, --t;
for (int i = (0); i < (n); ++i) ghead[i] = -1;
for (int i = (0); i < (m); ++i) {
int a, b;
scanf("%d%d%d", &a, &b, &gcost[i]);
--a, --b;
gnxt[2 * i + 0] = ghead[a];
ghead[a] = 2 * i + 0;
gto[2 * i + 0] = b;
gnxt[2 * i + 1] = ghead[b];
ghead[b] = 2 * i + 1;
gto[2 * i + 1] = a;
}
nret = -1;
for (int i = (0); i < (m); ++i) dead[i] = false;
findpath();
for (int i = (-1); i < (m); ++i) {
if (i != -1 && !onpath[i]) continue;
if (i != -1) dead[i] = true;
int cur = calc();
if (cur != -2) {
int curcost = 0;
if (cur != -1) curcost += gcost[cur];
if (i != -1) curcost += gcost[i];
if (nret == -1 || curcost < retcost) {
retcost = curcost, nret = 0;
if (i != -1) ret[nret++] = i;
if (cur != -1) ret[nret++] = cur;
}
}
if (i != -1) dead[i] = false;
}
if (nret == -1) {
printf("-1\n");
return;
}
printf("%d\n%d\n", retcost, nret);
for (int i = (0); i < (nret); ++i) {
if (i != 0) printf(" ");
printf("%d", ret[i] + 1);
}
puts("");
}
int main() {
run();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double e = 2.718281828;
const double pi = 3.1428571428;
const double EPS = 1e-9;
void OpenFiles() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
priority_queue<int> Q;
int n, t, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
sum += t;
Q.push(-t);
}
int res = 0, cur_sum = 0;
while ((int)(Q).size()) {
if (cur_sum <= -Q.top()) {
cur_sum += (-Q.top());
sum -= (-Q.top());
Q.pop();
res++;
} else
Q.pop();
}
cout << res;
return 44 / 77;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
int res = 1;
for (int i = 1; i < n; i++) res += i * 12;
printf("%d\n", res);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &num) {
T x = 0, f = 1;
char ch = getchar();
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch <= '9' && ch >= '0'; ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ '0');
num = x * f;
}
int n, a[1000005], b[1000005], o[1000005], tt, ans[1000005];
bool vis[1000005];
pair<int, int> tr[1000005 << 2];
void build(int ind, int l, int r) {
if (l == r) return tr[ind] = make_pair(b[l], l), void();
int mid = (l + r) >> 1;
build(ind << 1, l, mid);
build(ind << 1 | 1, mid + 1, r);
tr[ind] = max(tr[ind << 1], tr[ind << 1 | 1]);
}
void update(int ind, int l, int r, int x) {
if (l == r) return tr[ind] = make_pair(0, 0), void();
int mid = (l + r) >> 1;
if (x <= mid)
update(ind << 1, l, mid, x);
else
update(ind << 1 | 1, mid + 1, r, x);
tr[ind] = max(tr[ind << 1], tr[ind << 1 | 1]);
}
pair<int, int> query(int ind, int l, int r, int x, int y) {
if (x <= l && r <= y) return tr[ind];
int mid = (l + r) >> 1;
if (x > mid)
return query(ind << 1 | 1, mid + 1, r, x, y);
else if (y <= mid)
return query(ind << 1, l, mid, x, y);
else
return max(query(ind << 1, l, mid, x, y),
query(ind << 1 | 1, mid + 1, r, x, y));
}
void dfs(int x) {
vis[x] = 1;
update(1, 1, n, x);
if (b[x] <= n && !vis[b[x]]) dfs(b[x]);
if (a[x] > 1) {
while (1) {
pair<int, int> now = query(1, 1, n, 1, a[x] - 1);
if (now.first > x)
dfs(now.second);
else
break;
}
}
o[++tt] = x;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
if (~a[i])
b[a[i]] = i;
else
a[i] = n + 1;
}
for (int i = 1; i <= n; i++)
if (!b[i]) b[i] = n + 1;
build(1, 1, n);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; i++) ans[o[i]] = i;
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char s[100000 + 10];
int main() {
cin >> s;
int len = strlen(s), ok = 0, mn = 0, num = s[len - 1] - '0';
for (int i = 0; i < len - 1; ++i)
if (!((s[i] - '0') & 1)) {
ok = 1;
mn = max(mn, i);
if (s[i] - '0' < num) {
swap(s[i], s[len - 1]);
cout << s << endl;
return 0;
}
}
if (ok) {
swap(s[mn], s[len - 1]);
cout << s << endl;
} else
cout << -1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
public:
struct Node *children[26];
bool isEnd{};
Node() {
isEnd = true;
for (long long i = 0; i < 26; ++i) {
children[i] = nullptr;
}
}
};
Node *root = new Node;
map<Node *, bool> win, lose;
void insert(string s) {
long long n = s.size();
Node *node = root;
for (char i : s) {
node->isEnd = false;
if (!node->children[i - 'a']) {
node->children[i - 'a'] = new Node;
}
node = node->children[i - 'a'];
}
}
void dp(Node *node) {
if (node->isEnd) {
win[node] = false;
lose[node] = true;
return;
}
win[node] = false;
lose[node] = false;
for (long long i = 0; i < 26; ++i) {
if (node->children[i]) {
dp(node->children[i]);
win[node] |= !win[node->children[i]];
lose[node] |= !lose[node->children[i]];
}
}
}
int32_t main() {
long long T{1};
while (T--) {
long long n, k;
cin >> n >> k;
vector<string> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
insert(a[i]);
}
dp(root);
if (!win[root]) {
cout << "Second";
} else if (lose[root]) {
cout << "First";
} else {
cout << ((k % 2 == 1) ? "First" : "Second");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 2e5 + 5;
int a[N];
long long f[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int itest;
cin >> itest;
while (itest--) {
int n;
cin >> n;
int p;
cin >> p;
int k;
cin >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) {
if (i < k)
f[i] = f[i - 1] + a[i];
else
f[i] = f[i - k] + a[i];
}
int ans = 0;
for (int i = 1; i <= n; ++i)
if (f[i] <= p) ans = i;
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> a;
stack<string> st;
int main() {
string s;
cin >> s;
int pre = 0, ok = 0, last = 0;
long long ans = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] <= 'Z' && s[i] >= 'A') {
if (!ok) pre = i;
ok = 1;
last = i;
} else {
if (ok) {
string tmp = s.substr(pre, last - pre + 1);
ans += a[tmp];
a[tmp]++;
st.push(tmp);
}
ok = 0;
if (s[i] == '.') a[st.top()]--, st.pop();
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int Mod = 998244353;
map<int, int> mp;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) mp[a[i]] = i;
int right = 1;
long long ans = 1;
for (int i = 1; i <= n; i++) {
if (right >= i)
right = max(right, mp[a[i]]);
else {
ans = ans * 2LL % Mod;
right = max(right, mp[a[i]]);
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (T x : p) os << x << " ";
os << "]" << endl;
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "{ ";
for (T x : p) os << x << " ";
os << "}" << endl;
return os;
}
template <typename Tk, typename Tv>
ostream& operator<<(ostream& os, const map<Tk, Tv>& p) {
os << "{ ";
for (pair<Tk, Tv> x : p) os << x << " ";
os << "}" << endl;
return os;
}
template <typename Tk, typename Tv>
ostream& operator<<(ostream& os, const pair<Tk, Tv>& p) {
os << "{" << p.first << ',' << p.second << "}";
return os;
}
const int MOD = 1000000000 + 7;
const int INF = 1000000000 + 5;
const int MAX = 300005;
long long power(long long n, long long m) {
if (m == 0) return 1;
long long x = power(n, m / 2);
if (!(m & 1))
return (x * x) % 1000000007;
else
return (((x * x) % 1000000007) * n) % 1000000007;
}
long long p2[MAX + 5];
int main() {
int n;
scanf("%d", &n);
vector<long long> x(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x[i]);
}
sort(x.begin(), x.end());
p2[0] = 1;
for (int i = 1; i < MAX; i++) {
p2[i] = (p2[i - 1] << 1);
if (p2[i] >= 1000000007) p2[i] -= 1000000007;
}
vector<long long> X(n), P(n);
for (int i = 0; i < n; i++) {
long long p = p2[i];
X[i] = (x[i] * p) % 1000000007;
P[i] = p;
}
for (int i = n - 2; i >= 0; i--) {
X[i] += X[i + 1];
if (X[i] >= 1000000007) X[i] -= 1000000007;
P[i] += P[i + 1];
if (P[i] >= 1000000007) P[i] -= 1000000007;
}
long long Answer = 0;
for (int i = 0; i < n - 1; i++) {
long long ans =
(X[i + 1] + 1000000007 - (x[i] * P[i + 1]) % 1000000007) % 1000000007;
ans *= power(p2[i + 1], 1000000007 - 2);
ans %= 1000000007;
Answer += ans;
if (Answer >= 1000000007) Answer -= 1000000007;
}
cout << Answer << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char ch;
bool a[74][74];
int b[74][74];
bool u[74][74];
void dfs(int i, int j) {
u[i][j] = 1;
if (j > 0) {
if (a[i][j - 1] && !u[i][j - 1]) {
dfs(i, j - 1);
}
}
if (j < m - 1) {
if (a[i][j + 1] && !u[i][j + 1]) {
dfs(i, j + 1);
}
}
if (i > 0) {
if (a[i - 1][j] && !u[i - 1][j]) {
dfs(i - 1, j);
}
}
if (i < n - 1) {
if (a[i + 1][j] && !u[i + 1][j]) {
dfs(i + 1, j);
}
}
}
int f(int y, int x) {
int r = 0;
if (y > 0)
if (a[y - 1][x]) ++r;
if (y < n + 1)
if (a[y + 1][x]) ++r;
if (x > 0)
if (a[y][x - 1]) ++r;
if (x < m - 1)
if (a[y][x + 1]) ++r;
return r;
}
int main() {
cin >> n >> m;
int q = 0;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j)) {
cin >> ch;
if (ch == '#') {
a[i][j] = 1;
++q;
} else
a[i][j] = 0;
}
if (q < 3 || (n == 1 && m == 1)) {
cout << "-1\n";
return 0;
}
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j)) {
b[i][j] = f(i, j);
if (b[i][j] == 1 && a[i][j]) {
cout << "1\n";
return 0;
}
}
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j)) {
if (a[i][j]) {
memset(u, 0, sizeof(u));
a[i][j] = 0;
int py = 0, px = 0;
if (j > 0)
if (a[i][j - 1]) {
py = i;
px = j - 1;
}
if (j < m - 1)
if (a[i][j + 1]) {
py = i;
px = j + 1;
}
if (i > 0)
if (a[i - 1][j]) {
py = i - 1;
px = j;
}
if (i < n - 1)
if (a[i + 1][j]) {
py = i + 1;
px = j;
}
dfs(py, px);
bool bb = 0;
for (int(x) = (0); (x) < (n); ++(x))
for (int(y) = (0); (y) < (m); ++(y))
if (a[x][y] && !u[x][y]) {
cout << "1\n";
return 0;
}
a[i][j] = 1;
}
}
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j))
for (int(ii) = (0); (ii) < (n); ++(ii))
for (int(jj) = (0); (jj) < (m); ++(jj)) {
if (a[i][j] && a[ii][jj]) {
memset(u, 0, sizeof(u));
a[i][j] = 0;
a[ii][jj] = 0;
int py = 0, px = 0;
if (j > 0)
if (a[i][j - 1]) {
py = i;
px = j - 1;
}
if (j < m - 1)
if (a[i][j + 1]) {
py = i;
px = j + 1;
}
if (i > 0)
if (a[i - 1][j]) {
py = i - 1;
px = j;
}
if (i < n - 1)
if (a[i + 1][j]) {
py = i + 1;
px = j;
}
dfs(py, px);
bool bb = 0;
for (int(x) = (0); (x) < (n); ++(x))
for (int(y) = (0); (y) < (m); ++(y))
if (a[x][y] && !u[x][y]) {
cout << "2\n";
return 0;
}
a[i][j] = 1;
a[ii][jj] = 1;
}
}
cout << "3\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[200010];
string s;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
arr[i] = s[i] - '0';
}
int cur1, cur2, ans, ind;
for (int i = 0; i <= 10; i++) {
for (int j = 0; j < n; j++) {
if (arr[j] > i) {
ind = j;
break;
}
}
ans = i;
bool flag = 1;
cur1 = 0;
cur2 = 0;
for (int j = 0; j < n; j++) {
int look = arr[j];
if (look < i) {
if (look < cur1) {
flag = 0;
} else {
cur1 = look;
}
} else if (look > i) {
if (look < cur2) {
flag = 0;
} else {
cur2 = look;
}
} else {
if (j > ind) {
if (look < cur1) {
flag = 0;
} else {
cur1 = look;
}
}
}
}
if (flag == 1) {
break;
}
}
if (ans <= 9) {
for (int i = 0; i < n; i++) {
if (arr[i] < ans) {
cout << "1";
} else if (arr[i] > ans) {
cout << "2";
} else {
if (i < ind) {
cout << "2";
} else {
cout << "1";
}
}
}
cout << endl;
} else {
cout << '-' << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[101];
int n;
cin >> n;
int i;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
int ans = 0;
int vis[1000];
memset(vis, 0, sizeof(vis));
int t = 1;
int r = n;
while (r > 0) {
t = 0;
for (i = 1; i <= n; i++) {
if (vis[i] != 1)
if (a[i] >= t) {
t++;
vis[i] = 1;
r--;
}
}
ans++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, d, mn[1069];
int main() {
long long i, k, l, z = 0;
scanf("%lld%lld%lld", &n, &m, &d);
for (i = 1; i <= m; i++) {
mn[i] = 1e18;
}
for (i = 0; i < n; i++) {
scanf("%lld%lld", &k, &l);
mn[k] = min(mn[k], l);
}
for (i = 1; i <= m; i++) {
z += mn[i];
}
printf("%lld\n", min(z, d));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
if (n <= 2) {
cout << n + 2 << endl;
} else {
cout << n - 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1000005][4][4], MOD = 1e9 + 7;
string ar;
long long f(int i, int last, int now) {
if (i == ar.size() - 1) {
if (i == 0) {
if (ar[i] == '0') return 1;
if (ar[i] == '*') return 1;
if (ar[i] == '?') return 2;
}
if (ar[i] != '?') {
if (now == 0 && ar[i] != '0') return 0;
if (now == 1 && ar[i] != '1') return 0;
if (now == 2 && ar[i] != '2') return 0;
if (now == 3 && ar[i] != '*') return 0;
}
if (last == 0 && now == 0) return 1;
if (last == 0 && now == 1) return 0;
if (last == 1 && now == 3) return 1;
if (last == 3 && now == 1) return 1;
if (last == 3 && now == 3) return 1;
if (last == 3 && now == 2) return 0;
if (last == 1 && now == 0) return 1;
if (last == 1 && now == 1) return 0;
if (last == 2 && now == 3) return 1;
}
if (dp[i][last][now] != -1) return dp[i][last][now];
long long value = 0;
if (i == 0) {
if (ar[i] == '?') {
value += f(i + 1, 0, 1);
value += f(i + 1, 0, 0);
value += f(i + 1, 3, 1);
value += f(i + 1, 3, 2);
value += f(i + 1, 3, 3);
value += f(i + 1, 1, 3);
} else if (ar[i] == '0') {
value += f(i + 1, 0, 1);
value += f(i + 1, 0, 0);
} else if (ar[i] == '1') {
value += f(i + 1, 1, 3);
} else if (ar[i] == '2') {
return dp[i][last][now] = 0;
} else {
value += f(i + 1, 3, 1);
value += f(i + 1, 3, 2);
value += f(i + 1, 3, 3);
}
} else {
if (ar[i] != '?') {
if (now == 0 && ar[i] != '0') return dp[i][last][now] = 0;
if (now == 1 && ar[i] != '1') return dp[i][last][now] = 0;
if (now == 2 && ar[i] != '2') return dp[i][last][now] = 0;
if (now == 3 && ar[i] != '*') return dp[i][last][now] = 0;
}
if (last == 0 && now == 0) {
value += f(i + 1, 0, 1);
value += f(i + 1, 0, 0);
}
if (last == 1 && now == 0) {
value += f(i + 1, 0, 1);
value += f(i + 1, 0, 0);
}
if (last == 0 && now == 1) {
value += f(i + 1, 1, 3);
}
if (last == 1 && now == 3) {
value += f(i + 1, 3, 1);
value += f(i + 1, 3, 3);
value += f(i + 1, 3, 2);
}
if (last == 1 && now == 1) {
value += f(i + 1, 1, 3);
}
if (last == 3 && now == 1) {
value += f(i + 1, 1, 0);
value += f(i + 1, 1, 1);
}
if (last == 3 && now == 2) {
value += f(i + 1, 2, 3);
}
if (last == 3 && now == 3) {
value += f(i + 1, 3, 3);
value += f(i + 1, 3, 1);
value += f(i + 1, 3, 2);
}
if (last == 2 && now == 3) {
value += f(i + 1, 3, 1);
value += f(i + 1, 3, 3);
value += f(i + 1, 3, 2);
}
}
return dp[i][last][now] = value % MOD;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> ar;
memset(dp, -1, sizeof(dp));
cout << f(0, 0, 0) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
vector<int> arr;
};
bool cycle(vector<Node> &arr, vector<bool> &visited, int idx, int parent) {
Node &n = arr[idx];
int Q = n.arr.size();
int flag = false;
for (int q = (0); q < (Q); ++q) {
int to = n.arr[q];
if (to != parent) {
if (visited[to]) {
flag = true;
} else {
visited[to] = true;
flag |= cycle(arr, visited, to, idx);
}
}
}
return flag;
}
int main() {
int N, M;
cin >> N >> M;
vector<Node> arr(N);
vector<bool> vis(N, false);
for (int n = (0); n < (M); ++n) {
int a, b;
cin >> a >> b;
a--;
b--;
arr[a].arr.push_back(b);
arr[b].arr.push_back(a);
}
int sum = 0;
for (int n = (0); n < (N); ++n) {
if (!vis[n]) {
vis[n] = true;
sum += 1 - (cycle(arr, vis, n, n));
}
}
cout << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct mat {
long long T[100][100];
void O() {
for (int i = 0; i < 100; i++)
for (int j = 0; j < 100; j++) T[i][j] = 1e18;
}
void I() {
for (int i = 0; i < 100; i++)
for (int j = 0; j < 100; j++) T[i][j] = i == j;
}
};
mat mult(mat a, mat b) {
mat ret;
ret.O();
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
for (int k = 0; k < 100; k++) {
ret.T[i][j] = min(ret.T[i][j], a.T[i][k] + b.T[k][j]);
}
}
}
return ret;
}
mat exp(mat &x, int n) {
if (n == 1) return x;
mat tmp = exp(x, n / 2);
if (n % 2)
return mult(mult(tmp, tmp), x);
else
return mult(tmp, tmp);
}
int X, K, N, Q;
int C[10];
pair<int, int> W[30];
map<int, int> chk;
vector<int> Mask;
int inv[256];
mat P, Y, A;
int main() {
scanf("%d %d %d %d", &X, &K, &N, &Q);
for (int i = 1; i <= K; i++) {
scanf("%d", &C[i]);
}
for (int i = 0; i < Q; i++) {
scanf("%d %d", &W[i].first, &W[i].second);
W[i].first--;
chk[W[i].first] = W[i].second;
}
sort(W, W + Q);
for (int i = 0; i < (1 << K); i++) {
int cnt = 0;
for (int j = 0; j < K; j++)
if (i & (1 << j)) cnt++;
if (cnt == X) Mask.push_back(i);
}
for (int i = 0; i < Mask.size(); i++) inv[Mask[i]] = i;
A.O();
A.T[inv[((1 << X) - 1)]][0] = 0;
P.O();
for (int i = 0; i < Mask.size(); i++) {
int mask = Mask[i];
if (!(mask & 1)) {
P.T[i][inv[mask >> 1]] = 0;
continue;
}
for (int j = 1; j <= K; j++) {
if (mask & (1 << j)) continue;
int mask2 = mask ^ (1 << j);
mask2 >>= 1;
P.T[i][inv[mask2]] = C[j];
}
}
int cur_len = X;
for (int q = Q - 1; q >= 0; q--) {
int len = N - W[q].first;
if (len > cur_len) {
A = mult(exp(P, len - cur_len), A);
cur_len = len;
}
while (cur_len < N - W[q].first + K && cur_len < N) {
int p = N - cur_len - 1;
Y.O();
for (int i = 0; i < Mask.size(); i++) {
int mask = Mask[i];
if (!(mask & 1)) {
Y.T[i][inv[mask >> 1]] = 0;
continue;
}
for (int j = 1; j <= K; j++) {
if (mask & (1 << j)) continue;
int mask2 = mask ^ (1 << j);
mask2 >>= 1;
Y.T[i][inv[mask2]] =
C[j] + (chk.find(p + j) != chk.end() ? chk[p + j] : 0);
}
}
A = mult(Y, A);
cur_len++;
}
}
if (N > cur_len) {
A = mult(exp(P, N - cur_len), A);
}
printf("%lld", A.T[inv[(1 << X) - 1]][0]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int n, i, j, k, p;
int V[110][110], l[110], r[110];
int ans1, ans2, c[110];
int main() {
read(n);
for (i = 1; i <= n; i++) {
read(V[i][0]);
for (j = 1; j <= V[i][0]; j++) read(V[i][j]);
for (j = 1; j <= V[i][0] / 2; j++) ans1 += V[i][j];
for (j = V[i][0]; j >= V[i][0] - (V[i][0] / 2) + 1; j--) ans2 += V[i][j];
if (V[i][0] & 1) c[++c[0]] = V[i][(V[i][0] + 1) / 2];
}
sort(c + 1, c + 1 + c[0], greater<int>());
for (i = 1; i <= n; i++)
if (i & 1)
ans1 += c[i];
else
ans2 += c[i];
printf("%d %d\n", ans1, ans2);
scanf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long m;
vector<long long> a;
vector<pair<long long, long long>> b;
int main() {
cin >> m;
a.resize(m);
b.resize(m);
for (int i = 0; i < m; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> b[i].first;
b[i].second = i;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
vector<long long> p(m);
for (int i = 0; i < m; i++) {
p[b[i].second] = a[i];
}
for (int i = 0; i < m; i++) cout << p[i] << (i == m - 1 ? "\n" : " ");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int a[n], b[n];
int c[n];
int d[n];
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
}
for (int i = 0; i <= n - 1; i++) {
cin >> b[i];
}
if (n == 1) {
cout << "YES";
} else {
int e = a[0], f = b[0];
for (int i = 0; i <= n - 1; i++) {
a[i] -= e;
b[i] -= f;
}
for (int i = 0; i <= n - 2; i++) {
c[i] = (a[i + 1] - a[i]);
d[i] = b[i + 1] - b[i];
}
c[n - 1] = l - (a[n - 1]);
d[n - 1] = l - (b[n - 1]);
vector<int> v;
for (int i = 0; i <= n - 1; i++) {
if (c[i] == d[0]) v.push_back(i);
}
int flag2 = 0;
for (int i = 0; i < v.size(); i++) {
int flag = 0;
for (int j = 0; j <= n - 1; j++) {
if (c[(v[i] + j) % n] != d[(0 + j) % n]) {
flag = 1;
break;
}
}
if (flag == 1) continue;
if (flag == 0) {
flag2 = 1;
break;
}
}
if (flag2 == 1)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using std::lower_bound;
using std::max;
using std::min;
using std::random_shuffle;
using std::reverse;
using std::sort;
using std::swap;
using std::unique;
using std::upper_bound;
using std::vector;
void open(const char *s) {}
void open2(const char *s) {}
int rd() {
int s = 0, c, b = 0;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-') {
c = getchar();
b = 1;
}
do {
s = s * 10 + c - '0';
} while ((c = getchar()) >= '0' && c <= '9');
return b ? -s : s;
}
void put(int x) {
if (!x) {
putchar('0');
return;
}
static int c[20];
int t = 0;
while (x) {
c[++t] = x % 10;
x /= 10;
}
while (t) putchar(c[t--] + '0');
}
int upmin(int &a, int b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int upmax(int &a, int b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
const int N = 1010;
namespace seg {
int s[1 << 21];
int t[1 << 21];
void add(int p, int l, int r, int v, int L, int R) {
if (l <= L && r >= R) {
t[p] = max(t[p], v);
s[p] = max(s[p], v);
return;
}
if (l <= ((L + R) >> 1)) add((p << 1), l, r, v, L, ((L + R) >> 1));
if (r > ((L + R) >> 1)) add(((p << 1) | 1), l, r, v, ((L + R) >> 1) + 1, R);
s[p] = max(min(s[(p << 1)], s[((p << 1) | 1)]), t[p]);
}
int query(int p, int l, int r, int L, int R) {
if (l <= L && r >= R) return s[p];
int res = 0x7fffffff;
if (l <= ((L + R) >> 1))
res = min(res, query((p << 1), l, r, L, ((L + R) >> 1)));
if (r > ((L + R) >> 1))
res = min(res, query(((p << 1) | 1), l, r, ((L + R) >> 1) + 1, R));
res = max(res, t[p]);
return res;
}
} // namespace seg
struct info {
int x1, y1, x2, y2, v;
};
info c[N * N];
int t;
int cmp(info a, info b) { return a.x1 < b.x1; }
int dx[N * N], dy[N * N], tx, ty;
int a[N][N];
int ax[N][N], ay[N][N];
int n, vx, vy;
int main() {
open("cf243d");
scanf("%d%d%d", &n, &vx, &vy);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) {
ax[i][j] = (long long)vy * j + (long long)vx * i;
ay[i][j] = (long long)vx * j - (long long)vy * i;
dx[++tx] = ax[i][j];
dy[++ty] = ay[i][j];
}
sort(dx + 1, dx + tx + 1);
sort(dy + 1, dy + ty + 1);
tx = unique(dx + 1, dx + tx + 1) - dx - 1;
ty = unique(dy + 1, dy + ty + 1) - dy - 1;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) {
ax[i][j] = lower_bound(dx + 1, dx + tx + 1, ax[i][j]) - dx;
ay[i][j] = lower_bound(dy + 1, dy + ty + 1, ay[i][j]) - dy;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
t++;
c[t].x1 =
min(min(ax[i][j], ax[i][j - 1]), min(ax[i - 1][j], ax[i - 1][j - 1]));
c[t].x2 =
max(max(ax[i][j], ax[i][j - 1]), max(ax[i - 1][j], ax[i - 1][j - 1]));
c[t].y1 =
min(min(ay[i][j], ay[i][j - 1]), min(ay[i - 1][j], ay[i - 1][j - 1]));
c[t].y2 =
max(max(ay[i][j], ay[i][j - 1]), max(ay[i - 1][j], ay[i - 1][j - 1]));
c[t].v = a[i][j];
}
sort(c + 1, c + t + 1, cmp);
long long ans = 0;
for (int i = 1; i <= t; i++) {
int s = seg::query(1, c[i].y1, c[i].y2 - 1, 1, ty);
if (s < c[i].v) {
ans += c[i].v - s;
seg::add(1, c[i].y1, c[i].y2 - 1, c[i].v, 1, ty);
}
}
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, dp[14][(1 << 13)], a[105], b[105], c[105], u[14], v[14];
long long dfs(long long now, long long S) {
if (~dp[now][S]) return dp[now][S];
long long Fuck = S ^ (1 << (now - 1));
dp[now][S] = 0;
long long moved = 1;
while (!(Fuck & (1 << (moved - 1)))) ++moved;
for (long long T = Fuck; T; T = (T - 1) & Fuck) {
long long cnt = 0, to = 0;
if (!(T & (1 << (moved - 1)))) continue;
for (long long i = 1; i <= q; ++i)
if (now == c[i] && (T & (1 << (a[i] - 1))) && (T & (1 << (b[i] - 1))))
goto fail;
for (long long i = 1; i <= q; ++i) {
if ((T & (1 << (c[i] - 1)))) {
if (!(T & (1 << (a[i] - 1))) || !(T & (1 << (b[i] - 1)))) goto fail;
}
}
for (long long i = 1; i <= m; ++i) {
if (u[i] == now || v[i] == now) continue;
if ((T & (1 << (u[i] - 1))) && !(T & (1 << (v[i] - 1)))) goto fail;
if (!(T & (1 << (u[i] - 1))) && (T & (1 << (v[i] - 1)))) goto fail;
}
for (long long i = 1; i <= m; ++i) {
if (u[i] == now) {
if ((T & (1 << (v[i] - 1)))) ++cnt, to = v[i];
} else if (v[i] == now) {
if ((T & (1 << (u[i] - 1)))) ++cnt, to = u[i];
}
}
if (cnt == 0) {
for (long long i = 1; i <= n; ++i)
if ((T & (1 << (i - 1))))
dp[now][S] += dfs(i, T) * dfs(now, Fuck ^ T ^ (1 << (now - 1)));
} else if (cnt == 1) {
dp[now][S] += dfs(to, T) * dfs(now, Fuck ^ T ^ (1 << (now - 1)));
}
fail:;
}
return dp[now][S];
}
int main() {
cin >> n >> m >> q;
memset(dp, -1, sizeof dp);
for (long long i = 1; i <= n; ++i) dp[i][1 << (i - 1)] = 1;
for (long long i = 1; i <= m; ++i) cin >> u[i] >> v[i];
for (long long i = 1; i <= q; ++i) cin >> a[i] >> b[i] >> c[i];
dfs(1, (1 << n) - 1);
cout << dp[1][(1 << n) - 1] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
pair<int, int> operator*(const pair<int, int> &p, const pair<int, int> &x) {
pair<int, int> np = make_pair(p.first * x.first, p.second * x.second);
return np;
}
pair<long long, long long> operator%(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first % x.first, p.second % x.second);
return np;
}
pair<long long, long long> operator*(const pair<long long, long long> &p,
const pair<int, int> &x) {
pair<long long, long long> np =
make_pair(p.first * x.first, p.second * x.second);
return np;
}
pair<long long, long long> operator*(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first * x.first, p.second * x.second);
return np;
}
pair<long long, long long> operator+(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first + x.first, p.second + x.second);
return np;
}
pair<long long, long long> operator-(const pair<long long, long long> &p,
const pair<long long, long long> &x) {
pair<long long, long long> np =
make_pair(p.first - x.first, p.second - x.second);
return np;
}
pair<int, int> operator+(const pair<int, int> &p, const pair<int, int> &x) {
pair<int, int> np = make_pair(p.first + x.first, p.second + x.second);
return np;
}
pair<int, int> operator-(const pair<int, int> &p, const pair<int, int> &x) {
pair<int, int> np = make_pair(p.first - x.first, p.second - x.second);
return np;
}
vector<int> prime;
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second) return a.first > b.first;
return a.second > b.second;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second) return a.first > b.first;
return (a.second < b.second);
}
long long powerm(long long a, long long k) {
if (!k) {
return 1;
}
long long b = powerm(a, k / 2);
b = b * b % 998244353;
if (k % 2) {
return a * b % 998244353;
} else {
return b;
}
}
long long power(long long a, long long b) {
if (b == 1) return a;
if (b == 0) return 1;
long long m1 = power(a, b / 2);
if (b % 2) return m1 * m1 * a;
return m1 * m1;
}
void PFactor(int x) {
prime.clear();
for (int i = 2; i <= x / i; i++)
if (x % i == 0) {
while (x % i == 0) x /= i, prime.push_back(i);
}
if (x > 1) prime.push_back(x);
}
bool isprime(long long a) {
if (a <= 1) return false;
if (a == 2 || a == 3) return true;
if (a % 2 == 0 || a % 3 == 0) return false;
for (long long i = 5; i * i <= a; i = i + 6) {
if (a % i == 0 || a % (i + 2) == 0) return false;
}
return true;
}
long long read() {
long long a = 0;
char b = 1, c;
do
if ((c = getchar()) == 45) b = -1;
while (c < 48 || c > 57);
do a = (a << 3) + (a << 1) + (c & 15);
while ((c = getchar()) > 47 && c < 58);
return a * b;
}
void write(long long x, char c) {
if (x < 0) putchar(45), x = -x;
char a[20], s = 0;
do a[++s] = x % 10 | 48;
while (x /= 10);
do putchar(a[s]);
while (--s);
putchar(c);
}
const int LOGN = 20;
const int N = (1 << LOGN);
vector<int> g[N];
long long n = 0, m = 0, k = 0;
int a = 0, b = 0, c = 0;
string str;
int d[N] = {0};
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m >> k;
if (n > m + 1 || m > (n * (n - 1)) / 2) {
cout << "NO\n";
continue;
}
if (n == 1 && m == 0) {
if (k >= 2)
cout << "YES\n";
else
cout << "NO\n";
continue;
}
if (m == n * (n - 1) / 2) {
if (k >= 3)
cout << "YES\n";
else
cout << "NO\n";
} else if (k >= 4)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
set<long long> need;
for (int i = 1; i <= n; i++) need.insert(i);
vector<long long> rem;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (need.find(x) != need.end())
need.erase(x);
else
rem.push_back(x);
}
sort(rem.begin(), rem.end());
int fl = 0;
long long count = 0;
for (int i = 0; i < rem.size(); i++) {
long long curr = rem[i];
long long maxP = (curr - 1) / 2;
auto it = need.begin();
long long currNeed = *it;
if (currNeed > maxP) {
fl = 1;
break;
} else {
need.erase(currNeed);
count++;
}
}
if (fl == 1)
cout << "-1\n";
else
cout << count << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100010];
int start_map[100010];
int end_map[100010];
long long sum(int idx) {
if (idx == 0) return 0;
long long sum = 0;
while (idx > 0) {
sum += dp[idx];
idx -= (idx & -idx);
}
return sum % 1000000007;
}
long long M(long v) {
v %= 1000000007;
if (v < 0) v += 1000000007;
return v;
}
void add(int idx, long long to_add, int MAXVAL) {
while (idx <= MAXVAL) {
dp[idx] = (dp[idx] + to_add) % 1000000007;
idx += (idx & -idx);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pair<int, int> > buses;
vector<pair<int, int> > starts;
vector<pair<int, int> > ends;
memset(dp, 0, sizeof(dp));
memset(start_map, 255, sizeof(start_map));
memset(end_map, 255, sizeof(end_map));
buses.push_back(make_pair(0, 0));
buses.push_back(make_pair(0, 0));
buses.push_back(make_pair(n + 1, n));
for (int i = 0; i < m; i++) {
int s, t;
scanf("%d%d", &s, &t);
buses.push_back(make_pair(t, s));
}
sort(buses.begin(), buses.end());
for (int i = 0; i < buses.size(); i++) {
starts.push_back(make_pair(buses[i].second, i));
ends.push_back(make_pair(buses[i].first, i));
}
sort(starts.begin(), starts.end());
sort(ends.begin(), ends.end());
int j = 1;
for (int i = 1; i < ends.size(); i++) {
int cur_idx = ends[i].second;
while (j < starts.size() && starts[j].first <= ends[i].first) {
int set_idx = starts[j].second;
if (starts[j].first <= ends[i].first &&
buses[set_idx].first > ends[i].first)
start_map[set_idx] = cur_idx - 1;
j++;
}
}
for (int i = 1; i < ends.size();) {
int orig = ends[i].first;
int orig_idx = ends[i].second;
while (i < ends.size() && ends[i].first == orig) {
end_map[ends[i].second] = orig_idx - 1;
i++;
}
}
add(1, 1, buses.size() - 1);
for (int i = 2; i < buses.size(); i++) {
int start = start_map[i];
int end = end_map[i];
if (start == -1 || end == -1) continue;
add(i, M(sum(end) - sum(start)), buses.size() - 1);
}
printf("%lld\n", M(sum(buses.size() - 1) - sum(buses.size() - 2)));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int a[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
if (n == 1) {
printf("%d\n", a[0][0]);
break;
}
int sum = 0;
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < n - 1; j++) {
sum += a[i][j];
}
}
sum += a[0][0] + a[0][n - 1] + a[n - 1][n - 1] + a[n - 1][0];
sum += a[0][(n - 1) / 2] + a[n - 1][(n - 1) / 2] + a[(n - 1) / 2][0] +
a[(n - 1) / 2][n - 1];
printf("%d\n", sum);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[100100];
const int p = 31;
long long p_pow[100100];
map<long long, vector<long long> > pos;
long long h[100100];
bool getHach(long long i1, long long i2, long long len) {
long long h1 = h[i1 + len - 1];
if (i1) h1 -= h[i1 - 1];
long long h2 = h[i2 + len - 1];
if (i2) h2 -= h[i2 - 1];
if (i1 < i2 && h1 * p_pow[i2 - i1] == h2 ||
i1 > i2 && h1 == h2 * p_pow[i1 - i2])
return 1;
return 0;
}
vector<long long> nums;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
pos[a[i]].push_back(i);
if (pos[a[i]].size() == 1) nums.push_back(a[i]);
}
p_pow[0] = 1;
for (size_t i = 1; i < n; ++i) p_pow[i] = p_pow[i - 1] * p;
for (size_t i = 0; i < n; ++i) {
h[i] = (a[i] + 1) * p_pow[i];
if (i) h[i] += h[i - 1];
}
long long lastDel = -1;
vector<pair<long long, long long> > w;
vector<pair<long long, long long> > dd;
for (int i = 0; i < nums.size(); i++) {
long long x = nums[i];
vector<long long> ps = pos[x];
for (int i = 0; i < ps.size(); i++) {
for (int j = i + 1; j < ps.size(); j++) {
long long id1 = ps[i];
long long id2 = ps[j];
long long dis = id2 - id1;
if (dis + id2 - 1 < n && getHach(id1, id2, dis)) {
dd.push_back({dis, id1});
}
}
}
}
sort(dd.begin(), dd.end());
long long cur = 0;
for (int i = 0; i < dd.size(); i++) {
long long id1 = dd[i].second;
long long dis = dd[i].first;
long long id2 = dd[i].second + dis;
if (id1 >= cur) {
cur = id2;
}
}
cout << n - cur << endl;
for (int i = cur; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd1(long long a, long long b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long modx(long long base, long long ex) {
long long ans = 1LL, val = base;
while (ex > 0LL) {
if (ex & 1LL) ans = (ans * val) % 1000000009LL;
val = (val * val) % 1000000009LL;
ex = ex >> 1LL;
}
return ans;
}
int n;
long long s, v[1005], minn, sum;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
minn = 20000000000000LL;
for (int i = 1; i <= n; i++) {
cin >> v[i];
minn = min(minn, v[i]);
sum += v[i];
}
if (sum < s) {
cout << "-1" << endl;
return 0;
}
for (int i = 1; i <= n && s > 0; i++) {
s -= (v[i] - minn);
v[i] = minn;
}
if (s <= 0) {
cout << minn << endl;
return 0;
}
if (s % n == 0)
minn -= s / n;
else
minn -= (s / n + 1);
cout << minn << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[110], b[110];
long long n, K;
long long dp[110][100100];
long long F(long long pos, long long sum) {
if (pos > n) {
if (sum == 0)
return 0;
else
return -1e18;
}
long long &ret = dp[pos][sum];
if (ret != -1) return ret;
ret = max(a[pos] + F(pos + 1, sum + a[pos] - K * b[pos]), F(pos + 1, sum));
return ret;
}
int main() {
scanf("%lld", &n);
scanf("%lld", &K);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= n; i++) scanf("%lld", &b[i]);
memset(dp, -1, sizeof dp);
long long ans = F(1, 0);
if (ans <= 0)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
set<string> f;
string s;
void rotatey(string &x) {
string ret = x;
ret[0] = x[5];
ret[1] = x[1];
ret[2] = x[4];
ret[3] = x[3];
ret[4] = x[0];
ret[5] = x[2];
x = ret;
}
void rotatex(string x) {
string y = x;
f.insert(y);
y[0] = x[3];
y[1] = x[0];
y[2] = x[1];
y[3] = x[2];
y[4] = x[4];
y[5] = x[5];
f.insert(y);
x = y;
y[0] = x[3];
y[1] = x[0];
y[2] = x[1];
y[3] = x[2];
y[4] = x[4];
y[5] = x[5];
f.insert(y);
x = y;
y[0] = x[3];
y[1] = x[0];
y[2] = x[1];
y[3] = x[2];
y[4] = x[4];
y[5] = x[5];
f.insert(y);
x = y;
y[0] = x[3];
y[1] = x[0];
y[2] = x[1];
y[3] = x[2];
y[4] = x[4];
y[5] = x[5];
f.insert(y);
x = y;
}
void rotatez(string x) {
string y = x;
f.insert(y);
y[0] = x[0];
y[1] = x[5];
y[2] = x[2];
y[3] = x[4];
y[4] = x[1];
y[5] = x[3];
f.insert(y);
x = y;
y[0] = x[0];
y[1] = x[5];
y[2] = x[2];
y[3] = x[4];
y[4] = x[1];
y[5] = x[3];
f.insert(y);
x = y;
y[0] = x[0];
y[1] = x[5];
y[2] = x[2];
y[3] = x[4];
y[4] = x[1];
y[5] = x[3];
f.insert(y);
x = y;
y[0] = x[0];
y[1] = x[5];
y[2] = x[2];
y[3] = x[4];
y[4] = x[1];
y[5] = x[3];
f.insert(y);
x = y;
}
void rotate(string x) {
rotatey(x);
rotatex(x);
rotatez(x);
rotatey(x);
rotatex(x);
rotatez(x);
rotatey(x);
rotatex(x);
rotatez(x);
rotatey(x);
rotatex(x);
rotatez(x);
rotatey(x);
rotatex(x);
rotatez(x);
}
int main() {
cin >> s;
int ans = 0;
sort(s.begin(), s.end());
do {
if (!f.count(s)) ++ans;
rotate(s);
} while (next_permutation(s.begin(), s.end()));
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
vector<int> x(1 + n);
vector<int> y(1 + n);
vector<int> z(1 + n);
for (int i = 1; i <= n; i++) {
switch (s[i - 1]) {
case 'x':
x[i] = 1;
break;
case 'y':
y[i] = 1;
break;
case 'z':
z[i] = 1;
break;
}
}
for (int i = 1; i <= n; i++) {
x[i] = x[i - 1] + x[i];
y[i] = y[i - 1] + y[i];
z[i] = z[i - 1] + z[i];
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
int nx, ny, nz;
nx = x[r] - x[l - 1];
ny = y[r] - y[l - 1];
nz = z[r] - z[l - 1];
vector<int> a = {nx, ny, nz};
sort(a.begin(), a.end());
if (r - l < 2 || a[2] - a[0] <= 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, Q, M;
const int B = 500;
int st[100005];
int ans[100005];
vector<int> cache[100005];
vector<int> graph[100005];
int bit[100005];
void upd(int n, int v) {
while (n <= N) {
bit[n] = max(bit[n], v);
n += n & -n;
}
}
int query(int n) {
int ret = n;
while (n) {
ret = max(ret, bit[n]);
n -= n & -n;
}
return ret;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (int i = 1; i <= M; i++) {
int a, b;
cin >> a >> b;
st[b] = a;
graph[a].push_back(b);
}
for (int i = B; i <= N; i += B) {
cache[i].resize(N + 1);
fill(bit + 1, bit + 1 + N, 0);
for (int j = i; j; j--) {
int bst = j;
for (int e : graph[j]) {
if (e <= i) {
bst = max(bst, e);
}
}
bst = query(bst);
cache[i][j] = bst;
upd(j, bst);
}
}
cin >> Q;
while (Q--) {
int l, r;
cin >> l >> r;
int blk = r / B * B;
int bst = l;
if (blk >= l) {
bst = cache[blk][l];
} else {
blk = l;
}
for (int i = blk; i <= r; i++) {
if (st[i] <= bst && st[i] >= l) {
bst = i;
}
}
cout << bst << "\n";
}
}
| 11 |
# include <bits/stdc++.h>
using namespace std;
long long int solve(vector<pair<long long int,long long int>> &items,int n){
sort(items.begin(),items.end());
int i=0,j=n-1;
long long int count=0,spent=0;
while(i<=j){
if(count>=items[i].first)
{
count+=items[i].second;
spent+=items[i].second;
i++;
}
else if(count+items[j].second>=items[i].first){
long long int fromj=items[i].first-count;
items[j].second-=fromj;
long long int fromi=items[i].second;
spent+=fromi+2*fromj;
count+=fromi+fromj;
i++;
}
else{
long long int fromj=items[j].second;
spent+=2*fromj;
count+=fromj;
j--;
}
}
return spent;
}
int main() {
int n;
cin>>n;
vector<pair<long long int,long long int>> items;
for(int i=0;i<n;i++)
{
long long int x,y;
cin>>x>>y;
items.push_back({y,x});
}
cout<<solve(items,n);
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long int my_pow(long long int n, long long int k) {
long long int result = 1;
while (k) {
if (k & 1) {
result *= n;
}
n *= n;
k /= 2;
}
return result;
}
void precompute() {}
void test_case() {
long long int n, k;
cin >> n >> k;
if (k * (k - 1) < n) {
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
long long int cnt = 0;
for (long long int i = 1; i <= k - 1; i++) {
for (long long int j = i + 1; j <= k; j++) {
if (cnt == n) {
return;
}
cout << i << " " << j << '\n';
cnt++;
if (cnt == n) {
return;
}
cout << j << " " << i << '\n';
cnt++;
}
}
}
int32_t main() {
srand(time(0));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
precompute();
long long int T = 1;
for (long long int TT = 1; TT <= T; TT++) {
test_case();
}
cerr << "Time : "
<< 1000 * ((long double)clock()) / (long double)CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
using ll = int64_t;
using Pii = pair<int, int>;
using ull = uint64_t;
using Vi = vector<int>;
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
run();
return 0;
}
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
const size_t HXOR = mt19937_64(time(0))();
template <class T>
struct SafeHash {
size_t operator()(const T& first) const { return hash<T>()(first ^ T(HXOR)); }
};
unordered_map<int, int, SafeHash<int>> mods[10];
int len(int first) {
int m = 10;
for (int i = 1;; i++) {
if (first < m) return i;
m *= 10;
}
}
void run() {
int n, k;
cin >> n >> k;
Vi elems(n);
ll ans = 0;
for (auto& e : (elems)) {
cin >> e;
uint64_t m = e;
for (int i = (0); i < (10); i++) {
m *= 10;
mods[i][int(m % k)]++;
}
ll tmp = 10;
while (tmp <= e) tmp *= 10;
uint64_t cand = uint64_t(e) * tmp + e;
if (cand % k == 0) ans--;
}
for (auto& e : (elems)) {
int m = e % k;
if (m > 0) m = k - m;
ans += mods[len(e) - 1][m];
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 15;
using namespace std;
int mark[maxn], id[maxn], cl[maxn], n, m, a, b, ans, comp;
vector<int> vec[maxn], d[maxn];
bool finish[maxn];
void dfs(int v, int c) {
id[v] = c;
for (int u : vec[v])
if (!id[u]) dfs(u, c);
}
void cycle(int v) {
mark[v] = 1;
for (int u : d[v])
if (mark[u]) {
if (!finish[u]) cl[id[v]] = true;
} else
cycle(u);
finish[v] = true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--, b--;
vec[a].push_back(b);
d[a].push_back(b);
vec[b].push_back(a);
}
ans = n;
for (int i = 0; i < n; i++) {
if (!id[i]) {
dfs(i, ++comp);
ans--;
}
}
for (int i = 0; i < n; i++)
if (!mark[i]) cycle(i);
for (int i = 1; i <= comp; i++)
if (cl[i]) ans++;
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
int a = 0, len = 0;
for (std::string::iterator it = s.begin(); it != s.end(); ++it) {
len += 1;
if (*it == 'a') {
a += 1;
}
}
if (a <= len / 2) {
std::cout << 2 * a - 1;
} else {
std::cout << len;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void write(vector<int> &v) {
for (auto i : v) cout << i << " ";
cout << "\n";
}
void read(vector<int> &v) {
for (auto &i : v) cin >> i;
}
const int INF = 1e9;
const int64_t INFF = 1e18;
const int N = 1e6 + 69;
void solve() {
int n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
int ans = 0;
vector<int> pos(n, 1);
for (int i = 0; i < n; i++) {
if (s2[i] == '1') {
if (s1[i] == '0') {
ans++;
pos[i] = 0;
} else if (i > 0 && s1[i - 1] == '1' && pos[i - 1]) {
ans++;
pos[i - 1] = 0;
} else if (i < n - 1 && s1[i + 1] == '1' && pos[i + 1]) {
ans++;
pos[i + 1] = 0;
}
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, ans = 0;
char s[5005];
scanf("%s", s);
int len = strlen(s);
for (i = 0; i < len; i++) {
int l = 0, r = 0;
for (j = i; j < len; j++) {
if (s[j] == '(') {
l++;
} else if (s[j] == ')') {
l--;
} else {
l--;
r++;
}
if (l == 0) {
ans++;
}
if (l < 0) {
if (r == 0) {
break;
} else {
l += 2;
r--;
}
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> vows = {'a', 'e', 'o', 'u', 'i'};
set<char> evens = {'0', '2', '4', '6', '8'};
int cnt = 0;
for (int i = 0; i < s.size(); i++)
if (vows.count(s[i]) || (!evens.count(s[i]) && isdigit(s[i]))) cnt++;
cout << cnt;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[200];
int main() {
int n;
cin >> n;
long long ans = 0;
int maxi = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
maxi = max(maxi, A[i]);
}
for (int i = 0; i < n; i++) ans += maxi - A[i];
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--){
long long n;
cin>>n;
long long a[n];
map<long long,long long>m;
vector<long long> vi,vx;
set<long long>v;
for(int i=0;i<n;i++)
{
cin>>a[i];
m[a[i]]++;
}
for(long long i=1;i<=n;i++)
{
if(m[i]==0)
v.insert(i);
}
set<long long > v2;
v2=v;
for(int i=0;i<n;i++)
{
int p;
if(i==0){
vi.push_back(a[i]);
vx.push_back(a[i]);
p=a[i];
}
if(a[i]!=a[i-1])
{
vi.push_back(a[i]);
vx.push_back(a[i]);
p=a[i];
}
if(a[i]==a[i-1])
{
p=a[i];
set<long long>::iterator lower, upper,it;
it=v.begin();
vi.push_back(*it);
v.erase(it);
//set<long long>::iterator lower, upper;
lower = v2.lower_bound(p);
lower--;
vx.push_back(*lower);
v2.erase(lower);
//cout<<*it<<" "<<*lower<<endl;
}
}
for (auto it = vi.begin()+1; it != vi.end(); it++)
cout << *it << " ";
cout<<endl;
for (auto it = vx.begin()+1; it != vx.end(); it++)
cout << *it << " ";
cout<<endl;
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int f[200001];
vector<int> path;
long long in[200001];
void dfs(int u, int p, vector<int> adj[]) {
f[u] = path.size();
path.push_back(u);
in[u] = 1;
for (auto v : adj[u]) {
if (v != p) {
dfs(v, u, adj);
in[u] += in[v];
}
}
}
void find(vector<int> adj[], int n) { dfs(0, -1, adj); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, q;
cin >> n >> q;
vector<int> adj[n];
for (int i = 1; i < n; i++) {
int p;
cin >> p;
p--;
adj[p].push_back(i);
adj[i].push_back(p);
}
for (int i = 0; i < n; i++) {
sort(adj[i].begin(), adj[i].end());
}
find(adj, n);
for (int i = 0; i < q; i++) {
int u, k;
cin >> u >> k;
u--;
if (in[u] < k) {
cout << -1 << endl;
} else {
int ind = f[u];
if (ind + k - 1 < path.size())
cout << path[ind + k - 1] + 1 << endl;
else
cout << -1 << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int __gcd(int a, int b) { return b == 0 ? a : __gcd(b, a % b); }
int power(int x, int n) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
int y = power(x, n / 2);
return y * y;
} else
return x * power(x, n - 1);
}
int z[1000010];
int cnt[1000010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string s;
cin >> s;
int n = s.size(), i, t;
memset(z, 0, sizeof(z));
z[0] = 0;
int l = 0, r = 0;
for (i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (r < n && s[r - l] == s[r]) r++;
z[i] = r - l;
r--;
} else {
int k = i - l;
if (z[k] < r - i + 1) {
z[i] = z[k];
} else {
l = i;
while (r < n && s[r - l] == s[r]) r++;
z[i] = r - l;
r--;
}
}
}
int ma = -1, ans = -1;
for (i = 1; i < n; i++) {
if (i + z[i] == n && ma >= z[i]) {
ans = max(z[i], ans);
}
ma = max(ma, z[i]);
}
if (ans == -1)
cout << "Just a legend" << '\n';
else {
for (i = 0; i < ans; i++) cout << s[i];
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
const int mod = 1e3 + 5;
const long long inf = 0x3f3f3f3f3f3f3f;
const int maxn = 1e5 + 5;
using namespace std;
int n, c, a[maxn];
int main() {
cin >> n >> c;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int cn = 1;
for (int i = 2; i <= n; i++) {
if (a[i] <= a[i - 1] + c) {
cn++;
} else
cn = 1;
}
cout << cn << endl;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.