solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool used[1234567] = {0};
int a[12345];
int main() {
int n;
scanf("%d", &n);
long long res = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
if (!used[a[i]]) {
used[a[i]] = 1;
} else {
while (used[a[i]]) {
a[i]++;
res++;
}
used[a[i]] = 1;
}
}
printf("%lld\n", res);
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int TREE = 1002000;
vector<int> xx;
vector<int> yy;
int n, m;
int x[TREE], y[TREE];
char o[TREE];
map<int, bool> ux;
map<int, bool> uy;
int tx[TREE * 5], ty[TREE * 5];
map<int, int> mx;
map<int, int> my;
int getx(int v, int l, int r, int pos) {
if (pos > r || pos < l) return 0;
int ans = tx[v];
if (l == r) return ans;
int m = (l + r) / 2;
int f1 = getx(v + v, l, m, pos);
int f2 = getx(v + v + 1, m + 1, r, pos);
f1 = max(f1, f2);
return max(f1, ans);
}
int gety(int v, int l, int r, int pos) {
if (pos > r || pos < l) return 0;
int ans = ty[v];
if (l == r) return ans;
int m = (l + r) / 2;
int f1 = gety(v + v, l, m, pos);
int f2 = gety(v + v + 1, m + 1, r, pos);
f1 = max(f1, f2);
return max(f1, ans);
}
void updatey(int v, int l, int r, int ll, int rr, int val) {
if (max(l, ll) > min(r, rr)) return;
if (ll <= l && r <= rr) {
ty[v] = max(ty[v], val);
return;
}
int m = (l + r) / 2;
updatey(v + v, l, m, ll, rr, val);
updatey(v + v + 1, m + 1, r, ll, rr, val);
}
void updatex(int v, int l, int r, int ll, int rr, int val) {
if (max(l, ll) > min(r, rr)) return;
if (ll <= l && r <= rr) {
tx[v] = max(tx[v], val);
return;
}
int m = (l + r) / 2;
updatex(v + v, l, m, ll, rr, val);
updatex(v + v + 1, m + 1, r, ll, rr, val);
}
void updx(int l, int r, int val) {
l = mx[l], r = mx[r];
updatex(1, 0, TREE, l, r, val);
}
void updy(int l, int r, int val) {
l = my[l], r = my[r];
updatey(1, 0, TREE, l, r, val);
}
int getx(int val) {
val = mx[val];
return getx(1, 0, TREE, val);
}
int gety(int val) {
val = my[val];
return gety(1, 0, TREE, val);
}
int main() {
ios::sync_with_stdio(false);
int q;
cin >> n >> q;
xx.push_back(0);
yy.push_back(0);
for (int i = 0; i < q; ++i) {
cin >> x[i] >> y[i] >> o[i];
xx.push_back(x[i]);
yy.push_back(y[i]);
}
int cnt;
sort(xx.begin(), xx.end());
cnt = 0;
for (int i = 0; i < xx.size(); ++i) {
if (i == 0 || xx[i] != xx[i - 1]) {
mx[xx[i]] = ++cnt;
}
}
sort(yy.begin(), yy.end());
cnt = 0;
for (int i = 0; i < yy.size(); ++i) {
if (i == 0 || yy[i] != yy[i - 1]) {
my[yy[i]] = ++cnt;
}
}
for (int i = 0; i < q; ++i) {
if (o[i] == 'U') {
if (ux[x[i]]) {
cout << 0 << endl;
continue;
}
ux[x[i]] = true;
int val = getx(x[i]);
cout << y[i] - val << endl;
updy(val, y[i], x[i]);
continue;
} else {
if (uy[y[i]]) {
cout << 0 << endl;
continue;
}
uy[y[i]] = true;
int val = gety(y[i]);
cout << x[i] - val << endl;
updx(val, x[i], y[i]);
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
class RangeQuerySolver {
public:
RangeQuerySolver() {}
virtual int fnd(int l, int r) = 0;
};
class SegmentTree : public RangeQuerySolver {
public:
SegmentTree(vector<int> a) {
sz = 1;
int n = ((int)(a).size());
while (sz < n) sz <<= 1;
addend.assign(2 * sz, 0);
saved_a = a;
}
void init() {
t.assign(2 * sz, default_value());
for (int i = int(0); i < int(((int)(saved_a).size())); ++i) {
t[i + sz] = saved_a[i];
}
for (int i = int(sz) - 1; i >= int(1); --i) {
t[i] = relax(t[2 * i], t[2 * i + 1]);
}
}
virtual int default_value() = 0;
virtual int relax(int botva, int sdkfjsokdf) = 0;
void push(int v) {
if (v >= 2 * sz) {
return;
}
t[v] += addend[v];
if (v < sz) {
addend[2 * v] += addend[v];
addend[2 * v + 1] += addend[v];
}
addend[v] = 0;
}
void add(int l, int r, int k) {
if (l > r) {
return;
}
upd(1, 0, sz - 1, l, r, k);
}
void upd(int i, int k) {
int res = fnd(i, i);
add(i, i, k - res);
}
void upd(int i, int x, int y, int l, int r, int k) {
push(i);
if (x > r || y < l) {
return;
}
if (x >= l && y <= r) {
addend[i] += k;
push(i);
return;
}
upd(2 * i, x, (x + y) >> 1, l, r, k);
upd(2 * i + 1, ((x + y) >> 1) + 1, y, l, r, k);
if (i < sz) {
t[i] = relax(t[2 * i], t[2 * i + 1]);
}
}
int fnd(int l, int r) override { return fnd(1, 0, sz - 1, l, r); }
int fnd(int i, int x, int y, int l, int r) {
push(i);
if (x > r || y < l) {
return default_value();
}
if (x >= l && y <= r) {
return t[i];
}
return relax(fnd(2 * i, x, (x + y) >> 1, l, r),
fnd(2 * i + 1, ((x + y) >> 1) + 1, y, l, r));
}
protected:
vector<int> t;
vector<int> saved_a;
vector<int> addend;
int sz;
};
class MinTree : public SegmentTree {
public:
MinTree(vector<int> a) : SegmentTree(a) {}
int default_value() override { return (1 << 30); }
int relax(int botva, int sdkfjsokdf) { return min(botva, sdkfjsokdf); }
};
class MaxTree : public SegmentTree {
public:
MaxTree(vector<int> a) : SegmentTree(a) {}
int default_value() override { return 0; }
int relax(int botva, int sdkfjsokdf) { return max(botva, sdkfjsokdf); }
};
class SlowMinimumQuerySolver : public RangeQuerySolver {
public:
SlowMinimumQuerySolver(vector<int> a) : a(a) {}
int fnd(int l, int r) override {
int minn = a[l];
for (int i = l + 1; i <= r; ++i) {
umn(minn, a[i]);
}
return minn;
}
private:
vector<int> a;
};
void build_tree(int l, int r, int dist, vector<int>& a, const vector<int>& posp,
RangeQuerySolver& tree) {
if (r < l) {
return;
}
int val = tree.fnd(l, r);
int pos = posp[val];
a[pos] = dist;
build_tree(l, pos - 1, dist + 1, a, posp, tree);
build_tree(pos + 1, r, dist + 1, a, posp, tree);
}
struct Input {
int n;
vector<int> p;
vector<int> posp;
bool read() {
if (scanf("%d", &n) != 1) {
return 0;
}
p.resize(n);
posp.resize(n);
for (int i = int(0); i < int(n); ++i) {
cin >> p[i];
--p[i];
posp[p[i]] = i;
}
return 1;
}
void gen() {
n = 5;
p = vector<int>(n);
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
random_shuffle((p).begin(), (p).end());
posp = vector<int>(n);
for (int i = int(0); i < int(n); ++i) {
posp[p[i]] = i;
}
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
pair<int, int> ans;
void write() { cout << ans.first << ' ' << ans.second << "\n"; }
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct CleverSolution : Data {
vector<int> botva, sdkfjsokdf;
void solve() {
vector<int> a(n);
MinTree min_tree(p);
min_tree.init();
build_tree(0, n - 1, 0, a, posp, min_tree);
MaxTree max_tree(a);
max_tree.init();
ans.first = max_tree.fnd(0, n - 1);
ans.second = 0;
set<int> s;
botva.resize(n);
sdkfjsokdf.resize(n);
for (int i = int(0); i < int(n); ++i) {
if (i == 0) {
botva[posp[i]] = sdkfjsokdf[posp[i]] = -1;
s.insert(posp[i]);
continue;
}
s.insert(posp[i]);
if (*s.begin() != posp[i]) {
botva[posp[i]] = *(--s.lower_bound(posp[i]));
} else {
botva[posp[i]] = *(--s.end());
}
if (*(--s.end()) != posp[i]) {
sdkfjsokdf[posp[i]] = *(s.upper_bound(posp[i]));
} else {
sdkfjsokdf[posp[i]] = *s.begin();
}
};
;
for (int i = int(0); i < int(n); ++i) {
if (p[i] == 0) {
continue;
}
if (sdkfjsokdf[i] < i) {
max_tree.add(0, sdkfjsokdf[i] - 1, -1);
max_tree.add(i + 1, n - 1, -1);
} else {
max_tree.add(i + 1, sdkfjsokdf[i] - 1, -1);
}
max_tree.upd(i, max_tree.fnd(botva[i], botva[i]) + 1);
if (botva[i] > i) {
max_tree.add(0, i - 1, 1);
max_tree.add(botva[i] + 1, n - 1, 1);
} else {
max_tree.add(botva[i] + 1, i - 1, 1);
}
if (umn(ans.first, max_tree.fnd(0, n - 1))) {
ans.second = i + 1;
}
}
++ans.first;
}
void clear() { *this = CleverSolution(); }
};
struct StupidSolution : Data {
void solve() {
ans = make_pair(1 << 30, -1);
for (int i = int(0); i < int(n); ++i) {
vector<int> a(n);
SlowMinimumQuerySolver solver(p);
build_tree(0, n - 1, 0, a, posp, solver);
;
pair<int, int> res = make_pair(-1, -1);
for (int j = int(0); j < int(n); ++j) {
if (res.first < a[j]) {
res = make_pair(a[j], i);
}
}
umn(ans, res);
int p0 = p[0];
for (int j = int(0); j < int(((int)(p).size()) - 1); ++j) {
p[j] = p[j + 1];
}
p[n - 1] = p0;
for (int j = int(0); j < int(n); ++j) {
posp[p[j]] = j;
}
}
++ans.first;
}
void clear() { *this = StupidSolution(); }
};
CleverSolution clever_sol;
StupidSolution stupid_sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
clever_sol.read();
clever_sol.solve();
clever_sol.write();
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 10000;
vector<pair<int, int>> graph[MAX_N + 1];
queue<int> q;
int n;
int mx[MAX_N + 1], my[MAX_N + 1];
int lvl[MAX_N + 1];
int finlev, cut;
bool bfs() {
bool res = false;
int now, sz, target;
finlev = n + 100;
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) {
if (mx[i] < 0) {
lvl[i] = 0;
q.push(i);
} else {
lvl[i] = finlev;
}
}
while (!q.empty()) {
now = q.front();
q.pop();
sz = graph[now].size();
if (lvl[now] > finlev) break;
for (int i = 0; i < sz; i++) {
if (graph[now][i].first > cut) continue;
target = my[graph[now][i].second];
if (target < 0) {
finlev = lvl[now];
} else if (lvl[target] == n + 100) {
lvl[target] = lvl[now] + 1;
q.push(target);
}
}
}
return (finlev < (n + 100));
}
int dfs(int now) {
int sz = graph[now].size(), target;
for (int i = 0; i < sz; i++) {
if (graph[now][i].first > cut) continue;
int target = my[graph[now][i].second];
if (target < 0) {
my[graph[now][i].second] = now;
mx[now] = graph[now][i].second;
return 1;
} else if (lvl[target] == lvl[now] + 1) {
if (dfs(target)) {
my[graph[now][i].second] = now;
mx[now] = graph[now][i].second;
return 1;
}
}
}
lvl[now] = n + 100;
return 0;
}
int hopcroft() {
int matching = 0;
for (int i = 1; i <= MAX_N; i++) {
mx[i] = -1;
my[i] = -1;
}
while (bfs()) {
for (int i = 1; i <= n; i++) {
if (lvl[i] == 0) matching += dfs(i);
}
}
return matching;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, d;
cin >> u >> v >> d;
graph[u].emplace_back(d, v);
}
cut = (int)1e9 + 2;
if (hopcroft() != n) {
cout << "-1\n";
return 0;
}
int l = 0, r = (int)1e9 + 2;
while (l + 1 < r) {
cut = (l + r - 1) / 2;
memset(mx, 0, sizeof(mx));
memset(my, 0, sizeof(my));
memset(lvl, 0, sizeof(lvl));
q = queue<int>();
finlev = 0;
if (hopcroft() == n)
r = cut + 1;
else
l = cut + 1;
}
cout << l << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100 + 7;
const long long MOD = 1e9 + 7;
long long a[MAXN], b[MAXN], c[MAXN];
long long cge[3][105][MAXN];
int main() {
int n, T, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) cge[1][0][i] = cge[2][0][i] = i;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cge[1][i][j] = cge[1][i - 1][a[j]];
cge[2][i][a[j]] = cge[2][i - 1][j];
}
}
int ans1 = -1, ans2 = -1;
for (int i = 0; i <= m; i++) {
int flag = 0;
for (int j = 1; j <= n; j++) {
if (cge[1][i][j] == b[j]) {
continue;
} else {
flag = 1;
break;
}
}
if (flag) {
continue;
} else {
ans1 = i;
break;
}
}
for (int i = 0; i <= m; i++) {
int flag = 0;
for (int j = 1; j <= n; j++) {
if (cge[2][i][j] == b[j]) {
continue;
} else {
flag = 1;
break;
}
}
if (flag) {
continue;
} else {
ans2 = i;
break;
}
}
if (ans1 == 0) {
if (m == 0)
return puts("YES"), 0;
else
return puts("NO"), 0;
}
if (ans1 == 1) {
if (m == 1)
return puts("YES"), 0;
else if (m % 2 && ans2 != 1)
return printf("YES\n"), 0;
}
if (ans2 == 1) {
if (m == 1)
return puts("YES"), 0;
else if (m % 2 && ans1 != 1)
return printf("YES\n"), 0;
}
if (ans1 > 1 && (m - ans1) % 2 == 0) return puts("YES"), 0;
if (ans2 > 1 && (m - ans2) % 2 == 0) return puts("YES"), 0;
return puts("NO"), 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, n2, i, j, x, s;
int L[151], R[151];
char A[151][151];
int main() {
scanf("%d%d", &n, &m);
n2 = -1;
for (i = 0; i < n; i++) {
scanf("%s", A[i]);
L[i] = m;
R[i] = -1;
for (j = 0; j < m; j++)
if (A[i][j] == 'W') {
L[i] = min(L[i], j);
R[i] = max(R[i], j);
}
if (L[i] <= R[i]) n2 = i;
}
if (n2 == -1) {
printf("0");
return 0;
}
L[n] = m;
R[n] = -1;
for (i = j = 0; i <= n2; i++) {
x = j;
if (i & 1) {
if (L[i] <= R[i]) x = min(x, L[i]);
if (L[i + 1] <= R[i + 1]) x = min(x, L[i + 1]);
} else {
if (L[i] <= R[i]) x = max(x, R[i]);
if (L[i + 1] <= R[i + 1]) x = max(x, R[i + 1]);
}
s += abs(x - j) + 1;
j = x;
}
printf("%d", s - 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0, 1, -1, 1, -1};
const int dy[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int MAXN = 5e3 + 9;
const int oo = 2e9 + 9;
struct edg {
int pos, cap, rev;
};
vector<edg> gph[MAXN];
void clear() {
for (int i = 0; i < MAXN; i++) gph[i].clear();
}
void add_edge(int s, int e, int x) {
gph[s].push_back({e, x, (int)gph[e].size()});
gph[e].push_back({s, 0, (int)gph[s].size() - 1});
}
int dis[MAXN], pnt[MAXN];
bool bfs(int src, int sink) {
memset(dis, 0, sizeof(dis));
memset(pnt, 0, sizeof(pnt));
queue<int> que;
que.push(src);
dis[src] = 1;
while (!que.empty()) {
int x = que.front();
que.pop();
for (auto &e : gph[x]) {
if (e.cap > 0 && !dis[e.pos]) {
dis[e.pos] = dis[x] + 1;
que.push(e.pos);
}
}
}
return dis[sink] > 0;
}
int dfs(int x, int sink, int f) {
if (x == sink) return f;
for (; pnt[x] < gph[x].size(); pnt[x]++) {
edg e = gph[x][pnt[x]];
if (e.cap > 0 && dis[e.pos] == dis[x] + 1) {
int w = dfs(e.pos, sink, min(f, e.cap));
if (w) {
gph[x][pnt[x]].cap -= w;
gph[e.pos][e.rev].cap += w;
return w;
}
}
}
return 0;
}
long long match(int src, int sink) {
long long ret = 0;
while (bfs(src, sink)) {
int r;
while ((r = dfs(src, sink, 2e9))) ret += r;
}
return ret;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int s = n + m + 1;
int t = n + m + 2;
for (int u = 1; u <= n; u++) {
int a;
scanf("%d", &a);
add_edge(u, t, a);
}
long long sum_w = 0;
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
sum_w += w;
add_edge(s, n + i, w);
add_edge(n + i, u, oo);
add_edge(n + i, v, oo);
}
cout << sum_w - match(s, t) << "\n";
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long d1 = ({
long long x;
scanf("%lld", &x);
x;
});
long long d2 = ({
long long x;
scanf("%lld", &x);
x;
});
long long d3 = ({
long long x;
scanf("%lld", &x);
x;
});
long long ans = d1 + d2 + d3;
ans = min(ans, 2 * d1 + 2 * d3);
ans = min(ans, 2 * d2 + 2 * d3);
ans = min(ans, 2 * d1 + 2 * d2);
printf("%lld\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
pair<int, int> getRes(const string &s, int &pnt) {
char c = s[pnt++];
if (c == '0') return pair<int, int>(0, 1);
if (c == '1') return pair<int, int>(1, 1);
if (c == '?') return pair<int, int>(2, 2);
pair<int, int> p1 = getRes(s, pnt);
c = s[pnt++];
pair<int, int> p2 = getRes(s, pnt);
pnt++;
pair<int, int> res;
if (c == '^') {
if (p1 > p2) swap(p1, p2);
if (p2.first < 2) return pair<int, int>(p1.first ^ p2.first, 1);
if (p1.first < 2) return pair<int, int>(2, p2.second);
if (p1.second == 3 || p2.second == 3) return pair<int, int>(2, 3);
if (p1.second != p2.second) return pair<int, int>(2, 2);
return pair<int, int>(2, 1);
}
if (c == '&') {
if (p1 > p2) swap(p1, p2);
if (p2.first < 2) return pair<int, int>(p1.first & p2.first, 1);
if (p1.first == 0) return pair<int, int>(0, 1);
if (p1.first == 1) return pair<int, int>(2, p2.second);
return pair<int, int>(2, p1.second | p2.second | 1);
}
if (c == '|') {
if (p1 > p2) swap(p1, p2);
if (p2.first < 2) return pair<int, int>(p1.first | p2.first, 1);
if (p1.first == 0) return pair<int, int>(2, p2.second);
if (p1.first == 1) return pair<int, int>(1, 1);
return pair<int, int>(2, p1.second | p2.second | 1);
}
}
int main() {
cin >> n >> s;
int pnt = 0;
pair<int, int> res = getRes(s, pnt);
printf("%s\n", res.second & 2 ? "YES" : "NO");
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int countbit(int n) { return (n == 0) ? 0 : (1 + countbit(n & (n - 1))); }
int lowbit(int n) { return (n ^ (n - 1)) & n; }
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void checkmax(T &a, T b) {
if (b > a) a = b;
}
const int oo = 1000000000;
int n, a[20];
int f[21][1 << 10], f2[21][1 << 10];
int L[21];
int s[4], c[4][21];
int calc(int d, int set);
int calc2(int d, int set) {
if (d < 0) return 0;
int &ret = f2[d][set];
if (ret >= 0) return ret;
ret = oo;
for (int subset = 0; subset < (1 << (L[d + 1])); subset++)
checkmin(ret, calc(d, subset) + calc(d, set ^ subset));
return ret;
}
int calc(int d, int set) {
if (d < 0) return 0;
int &ret = f[d][set];
if (ret >= 0) return ret;
ret = oo;
if (d == 0 || a[d] != a[d - 1]) {
for (int subset = 0; subset < (1 << (L[d])); subset++)
checkmin(ret, calc(d - 1, subset) + calc(d - 1, set ^ subset) + 1);
} else {
if (!((set & (1 << (L[d + 1] - 1))) > 0)) {
for (int subset = 0; subset < (1 << (L[d])); subset++)
checkmin(ret, calc(d - 1, subset) + calc(d - 1, set ^ subset) + 1);
int d2 = d - 1;
for (; d2 >= 0 && a[d2] == a[d]; d2--)
;
for (int subset = 0; subset < (1 << (L[d2 + 1])); subset++)
checkmin(ret,
calc(d2, subset) + calc2(d2, set ^ subset) + (d - d2) * 2);
} else {
int newset = set - (1 << (L[d + 1] - 1));
int d2 = d - 1;
for (; d2 >= 0 && a[d2] == a[d]; d2--)
;
for (int subset = 0; subset < (1 << (L[d2 + 1])); subset++)
checkmin(ret, calc(d2, subset) + calc(d2, newset ^ subset) + (d - d2));
}
}
return ret;
}
int counter = 0;
void move(int src, int dest) {
counter--;
if (s[src] == 0 ||
s[dest] > 0 && a[c[src][s[src] - 1]] > a[c[dest][s[dest] - 1]]) {
printf("ERROR\n");
exit(0);
}
c[dest][s[dest]++] = c[src][--s[src]];
}
void construct(int d, int set, int src, int tmp, int dest);
void construct2(int d, int set, int src, int tmp, int dest, int cnt) {
int ret = calc2(d, set);
for (int subset = 0; subset < (1 << (L[d + 1])); subset++)
if (ret == calc(d, subset) + calc(d, set ^ subset)) {
construct(d, subset, src, tmp, dest);
for (int i = 0; i < cnt; i++) {
move(tmp, src);
printf("%d %d\n", tmp, src);
}
construct(d, set ^ subset, dest, tmp, src);
return;
}
}
void construct(int d, int set, int src, int tmp, int dest) {
if (d < 0) return;
int ret = calc(d, set);
if (d == 0 || a[d] != a[d - 1]) {
for (int subset = 0; subset < (1 << (L[d])); subset++)
if (ret == calc(d - 1, subset) + calc(d - 1, set ^ subset) + 1) {
construct(d - 1, subset, src, dest, tmp);
move(src, dest);
printf("%d %d\n", src, dest);
construct(d - 1, set ^ subset, tmp, src, dest);
return;
}
} else {
if (!((set & (1 << (L[d + 1] - 1))) > 0)) {
for (int subset = 0; subset < (1 << (L[d])); subset++)
if (ret == calc(d - 1, subset) + calc(d - 1, set ^ subset) + 1) {
construct(d - 1, subset, src, dest, tmp);
move(src, dest);
printf("%d %d\n", src, dest);
construct(d - 1, set ^ subset, tmp, src, dest);
return;
}
int d2 = d - 1;
for (; d2 >= 0 && a[d2] == a[d]; d2--)
;
for (int subset = 0; subset < (1 << (L[d2 + 1])); subset++)
if (ret == calc(d2, subset) + calc2(d2, set ^ subset) + (d - d2) * 2) {
construct(d2, subset, src, tmp, dest);
for (int i = 0; i < d - d2; i++) {
move(src, tmp);
printf("%d %d\n", src, tmp);
}
construct2(d2, set ^ subset, dest, tmp, src, d - d2);
return;
}
} else {
int newset = set - (1 << (L[d + 1] - 1));
int d2 = d - 1;
for (; d2 >= 0 && a[d2] == a[d]; d2--)
;
for (int subset = 0; subset < (1 << (L[d2 + 1])); subset++)
if (ret == calc(d2, subset) + calc(d2, newset ^ subset) + (d - d2)) {
construct(d2, subset, src, dest, tmp);
for (int i = 0; i < d - d2; i++) {
move(src, dest);
printf("%d %d\n", src, dest);
}
construct(d2, newset ^ subset, tmp, src, dest);
return;
}
}
}
}
int main() {
memset(f, 255, sizeof(f));
memset(f2, 255, sizeof(f2));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i <= n; i++) {
L[i] = 0;
for (int j = 0; j < i; j++)
if (j == 0 || a[j] != a[j - 1]) {
int c = 0;
for (int k = j; k < i && a[k] == a[j]; k++) c++;
if (c >= 2) L[i]++;
}
}
int R = calc(n - 1, 0);
counter = R;
printf("%d\n", R);
s[1] = s[2] = s[3] = 0;
for (int i = n - 1; i >= 0; i--) c[1][s[1]++] = i;
construct(n - 1, 0, 1, 2, 3);
if (counter != 0) printf("ERROR\n");
if (s[3] != n) printf("ERROR\n");
for (int i = 0; i < n; i++)
if (c[3][i] != n - 1 - i) printf("ERROR\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T b, T p, T m) {
T ret;
if (p == 0) return 1;
if (p & 1) {
ret = (bigmod(b, p / 2, m) % m);
return ((b % m) * ret * ret) % m;
} else {
ret = (bigmod(b, p / 2, m) % m);
return (ret * ret) % m;
}
}
int dx4[] = {1, -1, 0, 0};
int dy4[] = {0, 0, 1, -1};
int dx6[] = {0, 0, 1, -1, 0, 0};
int dy6[] = {1, -1, 0, 0, 0, 0};
int dz6[] = {0, 0, 0, 0, 1, -1};
int dx8[] = {1, -1, 0, 0, -1, 1, -1, 1};
int dy8[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dkx8[] = {-1, 1, -1, 1, -2, -2, 2, 2};
int dky8[] = {2, 2, -2, -2, 1, -1, 1, -1};
int tc = 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
const long long int mx = 1e5;
const long long int mod = 1e9 + 7;
vector<long long> year[15];
void gen(void) {
long long i, a, b, c;
a = 1989;
c = 9;
for (i = 0; i < 9; i++) {
b = a + c;
year[i + 1].push_back(a);
year[i + 1].push_back(b);
a = b + 1;
c = c * 10 + 9;
}
}
long long _pow(long long x, long long n) {
long long i, ans = 1;
for (i = 1; i <= n; i++) ans *= x;
return ans;
}
int main() {
long long i, n, x, t;
string str, sz;
gen();
cin >> t;
while (t--) {
cin >> str;
i = 4;
n = 0;
sz = "";
while (i < str.size()) sz += str[i++];
stringstream ss;
ss << sz;
ss >> n;
if (sz.size() <= 3) {
for (i = year[sz.size()][0]; i <= year[sz.size()][1]; i++) {
if (i % _pow(10, sz.size()) == n) {
cout << i << "\n";
break;
}
}
} else {
string tut, fst, lst;
for (i = 0; i < sz.size(); i++) tut += "9";
stringstream sssf, sssl;
sssf << year[sz.size()][0];
sssf >> fst;
sssl << year[sz.size()][1];
sssl >> lst;
if (sz >= fst && sz <= tut)
cout << sz << "\n";
else
cout << "1" + sz << "\n";
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, x[100010], bit[12][100010]{};
void upd(long long *bit, int i, long long v) {
while (i <= n) {
bit[i] += v;
i += i & -i;
}
}
long long query(long long *bit, int i) {
long long s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
int main() {
scanf("%I64d%I64d", &n, &k);
for (int i = 0; i < n; i++) scanf("%I64d", &x[i]);
for (int i = 0; i < n; i++) {
upd(bit[1], x[i], 1);
for (int j = 1; j <= k; j++) upd(bit[j + 1], x[i], query(bit[j], x[i] - 1));
}
printf("%I64d\n", query(bit[k + 1], n));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string a, b;
int aux[1000007][20];
int stval[1000007];
int enval[1000007];
int dp[1 << 20];
int nw[1 << 20];
void input() {
cin >> n >> m >> k;
cin >> a >> b;
for (int i = 0; i < k; ++i) {
aux[0][i] = i;
}
for (int i = 1; i <= n; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
for (int j = 0; j < k; ++j) {
aux[i][j] = aux[i - 1][j];
}
swap(aux[i][x], aux[i][y]);
}
}
void solve() {
for (int i = 0; i <= n; ++i) {
for (int j = 0; j < k; ++j) {
stval[i] += ((a[j] - '0') << aux[i][j]);
enval[i] += ((b[j] - '0') << aux[i][j]);
}
}
for (int i = 1; i <= n; ++i) {
dp[enval[i]] = nw[enval[i]] = i;
}
for (int ans = k; ans >= 0; --ans) {
for (int i = 0; i + m <= n; ++i) {
if (i + m <= dp[stval[i]]) {
cout << ans << "\n";
cout << i + 1 << " " << dp[stval[i]] << "\n";
return;
}
}
for (int i = 0; i < (1 << k); ++i) {
for (int j = 0; j < k; ++j) {
nw[i ^ (1 << j)] = max(nw[i ^ (1 << j)], dp[i]);
}
}
for (int i = 0; i < (1 << k); ++i) {
dp[i] = nw[i];
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long m, b = 0, s = 0, c = 0, nb, ns, nc, pb, ps, pc;
bool check(long long mid) {
long long nnb = mid * b, nns = mid * s, nnc = mid * c;
long long cb = nnb - nb, cs = nns - ns, cc = nnc - nc;
if (cb < 0) cb = 0;
if (cs < 0) cs = 0;
if (cc < 0) cc = 0;
long long money = cb * pb + cs * ps + cc * pc;
if (money <= m)
return 1;
else
return 0;
}
int main() {
long long mmin = 1e14;
string re;
getline(cin, re);
scanf("%lld%lld%lld", &nb, &ns, &nc);
scanf("%lld%lld%lld", &pb, &ps, &pc);
scanf("%lld", &m);
for (long long i = 0; i < re.size(); i++) {
if (re[i] == 'B') b++;
if (re[i] == 'S') s++;
if (re[i] == 'C') c++;
}
if (b != 0) {
if ((m / pb + nb) / b < mmin) mmin = (m / pb + nb) / b;
}
if (s != 0) {
if ((m / ps + ns) / s < mmin) mmin = (m / ps + ns) / s;
}
if (c != 0) {
if ((m / pc + nc) / c < mmin) mmin = (m / pc + nc) / c;
}
long long l = 0, r = mmin;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid) == 1)
l = mid + 1;
else
r = mid - 1;
}
printf("%lld", (l + r) / 2);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double d, h, v, e, pi = 3.14159265358979323846, a, ans, p;
cin >> d >> h >> v >> e;
p = (pi * d * d * e) / 4.0;
a = (pi * d * d * h) / 4.0;
if (p < v) {
cout << "YES\n";
ans = a / (v - p);
cout << setprecision(20) << ans;
} else
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m[505050];
int x[505050];
int n;
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i]);
}
ans = 0;
int ansId = -1;
for (int i = 1; i <= n; i++) {
long long cur = 0;
cur += m[i];
int mx = m[i];
for (int j = i - 1; j > 0; j--) {
mx = min(mx, m[j]);
cur += mx;
}
mx = m[i];
for (int j = i + 1; j <= n; j++) {
mx = min(mx, m[j]);
cur += mx;
}
if (cur > ans) {
ansId = i;
ans = cur;
}
}
int mx = m[ansId];
x[ansId] = m[ansId];
for (int j = ansId - 1; j > 0; j--) {
mx = min(mx, m[j]);
x[j] = mx;
}
mx = m[ansId];
for (int j = ansId + 1; j <= n; j++) {
mx = min(mx, m[j]);
x[j] = mx;
}
for (int i = 1; i <= n; i++) printf("%d ", x[i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001], b[1000001], c, d, e, n, m;
long long sum, ans, k;
string second, t, st;
char ch2[1001][1001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ch2[i][j] = '.';
for (int i = 1; i <= n; i++) {
if (i % 2) {
for (int j = 1; j <= n; j += 2) ch2[i][j] = 'C', ans++;
} else {
for (int j = 2; j <= n; j += 2) ch2[i][j] = 'C', ans++;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << ch2[i][j];
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c, inp;
vector<vector<int> > G, GT;
int n;
int calc(int ini) {
queue<int> q[3];
vector<int> cinp = inp;
int fets = 0, ans = 0;
for (int i = 0; i < n; ++i)
if (cinp[i] == 0) q[c[i]].push(i);
int on = ini;
while (fets < n) {
while (!q[on].empty()) {
int p = q[on].front();
q[on].pop();
++ans;
++fets;
for (int i = 0; i < GT[p].size(); ++i) {
int r = GT[p][i];
if ((--cinp[r]) == 0) q[c[r]].push(r);
}
}
on = (on + 1) % 3;
if (fets < n) ++ans;
}
return ans;
}
int main() {
cin >> n;
c = inp = vector<int>(n, 0);
for (int i = 0; i < n; ++i) {
cin >> c[i];
--c[i];
}
G = GT = vector<vector<int> >(n);
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
--x;
G[i].push_back(x);
inp[i]++;
GT[x].push_back(i);
}
}
cout << min(calc(0), min(calc(1), calc(2))) << endl;
}
| 9 |
#include <bits/stdc++.h>
long long int mod = 1000000007;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, t;
cin >> n >> t;
string s1, s2;
cin >> s1;
cin >> s2;
int a = 0, b = 0;
int x = (n - t);
for (int i = 0; i < n; i++) {
if (s1[i] == s2[i]) {
a++;
} else {
b++;
}
}
string ans = "";
if (x <= a) {
for (int i = 0; i < n; i++) {
if (s1[i] == s2[i] && x > 0) {
ans += s1[i];
x--;
} else {
for (char c = 'a'; c <= 'z'; c++) {
if (c != s1[i] && c != s2[i]) {
ans += c;
break;
}
}
}
}
cout << ans << endl;
return 0;
}
if (2 * (x - a) > (n - a)) {
cout << -1 << endl;
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s1[i] == s2[i]) {
ans += s1[i];
} else {
if (cnt < (x - a)) {
ans += s1[i];
cnt++;
} else if (cnt < (2 * (x - a))) {
ans += s2[i];
cnt++;
} else {
for (char c = 'a'; c <= 'z'; c++) {
if (c != s1[i] && c != s2[i]) {
ans += c;
break;
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long offset = N;
long long __abs(long long x) { return x > 0 ? x : -x; }
vector<pair<long long, long long> > pos[4 * N], neg[4 * N];
map<pair<long long, long long>, long long> label;
long long get(long long x, long long dir, long long n) {
if (dir > 0)
return n - x;
else
return x;
}
void process(std::vector<pair<long long, long long> > &v,
pair<long long, long long> cur, long long t) {
for (long long i = 0; i < v.size(); i++) {
long long x = v[i].first, y = v[i].second;
long long t1 = __abs(cur.first - x);
long long l = label[make_pair(x, y)];
if (l == 0) label[make_pair(x, y)] = t1 + t;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long> > polls;
for (long long i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
pos[offset + y - x].push_back(make_pair(x, y));
neg[offset + y + x].push_back(make_pair(x, y));
polls.push_back(make_pair(x, y));
}
pair<long long, long long> cur = make_pair(0, 0);
pair<long long, long long> dir = make_pair(1, 1);
long long t = 0;
while (1) {
long long slope = dir.first * dir.second;
long long x = cur.first, y = cur.second;
if (slope == -1) {
process(neg[x + y + offset], cur, t);
} else {
process(pos[y - x + offset], cur, t);
}
long long tx, ty;
tx = get(x, dir.first, n), ty = get(y, dir.second, m);
long long mn = min(tx, ty);
x += dir.first * mn, y += dir.second * mn;
t += mn;
if (x % n == 0 && y % m == 0) break;
if (tx < ty)
dir.first *= -1;
else
dir.second *= -1;
cur = make_pair(x, y);
}
for (long long i = 0; i < polls.size(); i++)
if (label[polls[i]])
cout << label[polls[i]] << '\n';
else
cout << -1 << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9) + 7, INF = 0x3fffffff, maxn = 1e5 + 12;
int ct[maxn * 2];
class cmp {
public:
bool operator()(const long long a, const long long b) { return a > b; }
};
int main(void) {
int n, k, b, c;
while (cin >> n >> k >> b >> c) {
for (int i = 0; i < n; i++) scanf("%d", &(ct[i])), ct[i] += 1e9;
sort(ct, ct + n);
long long ans = 1ll << 60;
if (c * 5 <= b) {
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += ct[i];
if (i >= k - 1) {
ans = min(ans, ((long long)ct[i] * k - sum) * c);
sum -= ct[i - k + 1];
}
}
} else {
for (int md = 0; md < 5; md++) {
long long sum = 0;
priority_queue<long long, vector<long long>, cmp> que;
for (int i = 0; i < n; i++) {
long long cc = (md + 5 - ct[i] % 5) % 5;
long long bb = (ct[i] + cc) / 5;
long long cost = bb * b - cc * c;
sum += cost;
que.push(cost);
if (i >= k - 1) {
ans = min(ans, (bb * k * b - sum));
sum -= que.top();
que.pop();
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50000 + 10;
int find(vector<int>& v, int x) {
return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
vector<int> val[11];
int d[maxn][11], k;
int loseId;
vector<vector<int>> LoseM, LoseQ;
vector<int> LoseNum;
set<pair<int, int>> SetM[11], SetQ[11];
void init() {
loseId = 0;
LoseM.clear(), LoseQ.clear(), LoseNum.clear();
for (int i = 0; i <= 10; i++) SetM[i].clear(), SetQ[i].clear();
}
void insert(vector<int>& Max, vector<int>& QQ, int people) {
int find = -1;
for (int j = 0; j < k && SetQ[j].size(); j++) {
auto it = SetQ[j].lower_bound({Max[j], 1});
it--;
if (it->first < Max[j] && it != SetQ[j].end()) {
for (int x = 0; x < k; x++)
if (LoseM[it->second][x] > QQ[x]) {
find = it->second;
}
if (find != -1) {
break;
}
}
}
if (find != -1) {
for (int j = 0; j < k; j++) {
SetM[j].erase({LoseM[find][j], find});
SetQ[j].erase({LoseQ[find][j], find});
LoseM[find][j] = max(LoseM[find][j], Max[j]);
LoseQ[find][j] = min(LoseQ[find][j], QQ[j]);
}
for (int j = 0; j < k; j++) {
SetM[j].insert({LoseM[find][j], find});
SetQ[j].insert({LoseQ[find][j], find});
}
LoseNum[find] += people;
} else {
LoseM.push_back(Max);
LoseQ.push_back(QQ);
LoseNum.push_back(people);
for (int j = 0; j < k; j++)
SetM[j].insert({Max[j], loseId}), SetQ[j].insert({QQ[j], loseId});
loseId++;
}
}
int main() {
int n;
while (scanf("%d%d", &n, &k) == 2) {
init();
for (int i = 0; i < k; i++) val[i].clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++) {
scanf("%d", &d[i][j]);
val[j].push_back(d[i][j]);
}
for (int i = 0; i < k; i++) sort(val[i].begin(), val[i].end());
vector<int> Max, QQV;
int pre = 0;
int ans = 1;
for (int i = 0; i < k; i++) {
int tmp = find(val[i], d[0][i]);
Max.push_back(tmp);
QQV.push_back(tmp);
}
printf("%d\n", ans);
for (int i = 1; i < n; i++) {
vector<int> D;
for (int j = 0; j < k; j++) D.push_back(find(val[j], d[i][j]));
int cnt = 0, cnt2 = 0;
for (int j = 0; j < k; j++) {
if (D[j] > QQV[j]) cnt++;
if (D[j] > Max[j]) cnt2++;
}
if (cnt == 0)
insert(D, D, 1);
else if (cnt2 == k) {
insert(Max, QQV, ans);
ans = 1;
for (int j = 0; j < k; j++) Max[j] = QQV[j] = D[j];
} else {
ans++;
for (int j = 0; j < k; j++) {
QQV[j] = min(QQV[j], D[j]);
Max[j] = max(Max[j], D[j]);
}
for (int j = 0; j < k; j++) {
vector<int> removeId;
for (auto it = SetM[j].rbegin(); it != SetM[j].rend(); it++) {
if (it->first > QQV[j]) {
removeId.push_back(it->second);
QQV[j] = min(QQV[j], LoseQ[it->second][j]);
Max[j] = max(Max[j], LoseM[it->second][j]);
} else
break;
}
for (auto id : removeId) {
ans += LoseNum[id];
for (int j = 0; j < k; j++) {
SetM[j].erase({LoseM[id][j], id});
SetQ[j].erase({LoseQ[id][j], id});
QQV[j] = min(QQV[j], LoseQ[id][j]);
Max[j] = max(Max[j], LoseM[id][j]);
}
}
}
}
printf("%d\n", ans);
}
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, vector<T>& arr) {
for (int64_t i = 0; i < (int64_t)arr.size() - 1; ++i) {
out << arr[i] << " ";
}
if (arr.size()) {
out << arr.back() << '\n';
}
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& arr) {
for (auto& i : arr) in >> i;
return in;
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
int64_t sum[2];
int64_t sum2[2];
signed main() {
int64_t n;
cin >> n;
vector<int64_t> arr(n);
cin >> arr;
for (int64_t i = 0; i < n; ++i) {
sum[arr[i]]++;
}
int64_t ans = 0;
for (int64_t i = 0; i < n; ++i) {
ans = max(ans, sum2[0] + sum[1] - sum2[1]);
sum2[arr[i]]++;
}
ans = max(ans, sum[0]);
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, int> mymap;
mymap["C"] = 0;
mymap["C#"] = 1;
mymap["D"] = 2;
mymap["D#"] = 3;
mymap["E"] = 4;
mymap["F"] = 5;
mymap["F#"] = 6;
mymap["G"] = 7;
mymap["G#"] = 8;
mymap["A"] = 9;
mymap["B"] = 10;
mymap["H"] = 11;
vector<int> v;
v.resize(3);
string str;
for (int i = 0; i < 3; i++) {
cin >> str;
v[i] = mymap[str];
}
sort(v.begin(), v.end());
if ((v[1] - v[0] == 4 && v[2] - v[1] == 3) ||
(v[2] - v[1] == 4 && v[0] + 12 - v[2] == 3) ||
(v[0] + 12 - v[2] == 4 && v[1] - v[0] == 3))
cout << "major";
else if ((v[1] - v[0] == 3 && v[2] - v[1] == 4) ||
(v[2] - v[1] == 3 && v[0] + 12 - v[2] == 4) ||
(v[0] + 12 - v[2] == 3 && v[1] - v[0] == 4))
cout << "minor";
else
cout << "strange";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, a, b, x, y, use[40], grad[40];
vector<int> G[40];
queue<int> frunze;
pair<int, int> ans[40];
int X[] = {1, -1, 0, 0};
int Y[] = {0, 0, 1, -1};
void solve(int nod, int x, int y, int lungime, int poz) {
int k = -1;
use[nod] = 1;
ans[nod].first = x;
ans[nod].second = y;
for (int i = 0; i < G[nod].size(); i++) {
if (!use[G[nod][i]]) {
++k;
if (poz == 0 && k == 1 || poz == 1 && k == 0 || poz == 2 && k == 3 ||
poz == 3 && k == 2)
++k;
solve(G[nod][i], x + X[k] * lungime, y + Y[k] * lungime, lungime / 2 - 4,
k);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (i = 1; i < n; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
grad[x]++;
grad[y]++;
}
for (i = 1; i <= n; i++) {
if (grad[i] == 1) {
frunze.push(i);
grad[i]--;
} else if (grad[i] > 4) {
cout << "NO";
return 0;
}
}
while (frunze.size()) {
x = frunze.front();
frunze.pop();
for (auto it : G[x]) {
grad[it]--;
if (grad[it] == 1) {
grad[it]--;
frunze.push(it);
}
}
}
solve(x, 0, 0, 100000000, -1);
cout << "YES\n";
for (i = 1; i <= n; i++) {
cout << ans[i].first << ' ' << ans[i].second << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
char ans[100000 + 5], str[100000 + 5];
memset(ans, '.', sizeof(ans));
int n, i;
cin >> n;
gets(str);
while (n--) {
gets(str);
for (i = 0; str[i]; i++) {
if (ans[i] == '?') {
continue;
}
if (str[i] != '?') {
if (ans[i] == '.') {
ans[i] = str[i];
} else if (ans[i] != str[i]) {
ans[i] = '?';
}
}
}
ans[i] = '\0';
}
for (i = 0; ans[i]; i++) {
if (ans[i] == '.') {
putchar('a');
} else {
putchar(ans[i]);
}
}
putchar('\n');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000005;
char s[MAX];
int z[MAX];
void zfun(int n) {
int l = 0, r = 0;
for (int i = 1; i < n; ++i) {
if (i <= r) z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> s;
n = strlen(s);
zfun(n);
int tmp = -1;
for (int i = 1; i < n; ++i) {
if (z[i] <= tmp && z[i] == n - i) {
for (int j = i; j < i + z[i]; ++j) cout << s[j];
return 0;
}
tmp = max(tmp, z[i]);
}
cout << "Just a legend" << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[100];
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int min = 0;
for (int i = n - 1; i >= 0; i--) {
if (k % a[i] == 0) {
min = a[i];
break;
}
}
cout << k / min;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename TF>
void debug(ostream &out, TF const &f) {
out << f << std::endl;
}
template <typename TF, typename... TR>
void debug(ostream &out, TF const &f, TR const &...rest) {
out << f << " ";
debug(out, rest...);
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<pii>;
using vll = vector<ll>;
using vs = vector<string>;
const int DR[] = {-1, 0, 1, 0, -1, 1, 1, -1};
const int DC[] = {0, -1, 0, 1, -1, -1, 1, 1};
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int MOD = 1e9 + 7;
const int INF = 1073741823;
const ll INFLL = 4e18;
const int MAX = 2e5;
int N, M, task[MAX + 5];
ll T;
vi vec;
void init() {
vec.clear();
for (int i = 0; i < (int)N; i++) task[i] = 0;
}
void read() {
cin >> N >> M >> T;
for (int i = 0; i < (int)N; i++) {
cin >> task[i];
if (task[i] > T) {
N--;
i--;
continue;
}
vec.push_back(task[i]);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
int coba(int d) {
int ret = 0, cnt = 0;
ll now = 0, sum = 0;
for (int i = 0; i < (int)N; i++) {
if (task[i] > d) continue;
if (now + task[i] > T) break;
now += task[i];
sum += task[i];
cnt++;
ret++;
if (cnt >= M) {
now += sum;
sum = 0;
cnt = 0;
}
}
return ret;
}
void solve() {
ll ans_d = 1;
int ans = coba(1);
int l = 0, r = (int)vec.size() - 1;
while (r - l >= 3) {
int m1 = l + (r - l) / 3;
int m2 = r - (r - l) / 3;
int a1 = coba(vec[m1]);
int a2 = coba(vec[m2]);
if (a1 < a2)
l = m1;
else
r = m2;
}
for (int m = (int)l; m <= (int)r; m++) {
int tmp = coba(vec[m]);
if (tmp > ans) {
ans = tmp;
ans_d = vec[m];
}
}
cout << ans << " " << ans_d << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC = 1;
cin >> TC;
for (int tc = (int)1; tc <= (int)TC; tc++) {
init();
read();
solve();
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long ans = 0, k = 1;
while (1) {
k *= 10;
if ((k - 1) <= b)
ans += a;
else
break;
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
if (m >= n) {
cout << n << " ";
cout << (m - n) / 2;
} else {
cout << m << " ";
cout << (n - m) / 2;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
const int MOD = 1000 * 1000 * 1000 + 7;
long long int dp[MAXN][MAXN];
long long int sum[MAXN][MAXN];
long long int sum2[MAXN][MAXN];
void M(long long int &a) { a = a % MOD; }
int main() {
for (int i = 2; i < MAXN; i++) dp[0][i] = 1;
for (int h = 0; h < MAXN - 1; h++) {
long long int s = 0, s2 = 0;
for (int l = 2; l < MAXN; l++) {
s += s2;
s += dp[h][l];
s2 += dp[h][l];
M(s);
M(s2);
dp[h + 1][l] = s;
}
}
int n, m;
cin >> n >> m;
for (int i = 2; i <= m; i++)
for (int j = 0; j < n; j++) {
if (j) sum[j][i] = sum[j - 1][i];
sum[j][i] += dp[j][i];
M(sum[j][i]);
}
for (int i = 0; i < n; i++) {
long long int s = 0, s2 = 0;
for (int j = 2; j <= m; j++) {
sum2[i + 1][j] = s;
s += sum[i][j];
s2 += sum[i][j];
s += s2;
M(s);
M(s2);
}
}
long long int ans = 0;
for (int i = 2; i <= m; i++)
for (int j = 0; j < n; j++) {
long long int t = sum[j][i] * (m - i + 1);
M(t);
t *= sum2[n - j - 1][i] + 1;
M(t);
ans += t;
M(ans);
}
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 300300;
long long a[N], b[N];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
int p = i - 1;
if (p < 0) p += n;
if (a[i] > b[p]) {
ans += a[i] - b[p];
a[i] = b[p];
}
}
long long mn = a[0];
for (int i = 0; i < n; i++) mn = min(mn, a[i]);
cout << ans + mn << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char ch[101][101];
int main() {
int i, j, n, ans = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> ch[i];
for (i = 0; i < n; i++) {
int cnt = 0, cnt2 = 0;
for (j = 0; j < n; j++) {
if (ch[i][j] == 'C') cnt++;
if (ch[j][i] == 'C') cnt2++;
}
ans += cnt * (cnt - 1) / 2;
ans += cnt2 * (cnt2 - 1) / 2;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
int n;
double a[MAX], sum[MAX];
double cal(double X) {
double hsgs = 0, Mn = 0, Mx = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i] - X;
hsgs = max(max(fabs(sum[i] - Mn), fabs(sum[i] - Mx)), hsgs);
Mn = min(Mn, sum[i]), Mx = max(Mx, sum[i]);
}
return hsgs;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
double l = -1e9 - 9, r = 1e9 + 9;
for (int i = 1; i <= 250; i++)
if (cal((2 * l + r) / 3) < cal((l + 2 * r) / 3))
r = (l + 2 * r) / 3;
else
l = (2 * l + r) / 3;
cout << fixed << setprecision(10) << cal(l);
}
| 12 |
#include <bits/stdc++.h>
const int MOD = 1000000007;
int dp[101][2601];
char str[101];
int main() {
int i, j, k;
for (i = 0; i < 26; i++) dp[1][i] = 1;
for (i = 1; i < 100; i++) {
for (j = 0; j < 2501; j++) {
int v = dp[i][j];
if (!v) continue;
for (k = 0; k < 26; k++) {
dp[i + 1][j + k] = (dp[i + 1][j + k] + v) % MOD;
}
}
}
int t, n, m;
scanf("%d", &t);
while (t--) {
scanf("%s", str);
n = strlen(str);
m = 0;
for (i = 0; i < n; i++) m += str[i] - 'a';
int r = dp[n][m] - 1;
if (r < 0) r += MOD;
printf("%d\n", r);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int rep = (n - 7) / 4;
int sub = (n - 7) % 4;
string s = "ROYGBIV";
string s2 = "GBIV";
for (int i = 0; i < rep; i++) {
s += s2;
}
s += s2.substr(0, sub);
cout << s;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int n;
int main() {
cin >> n;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
int cur = 0, best = 0;
for (int i = 0; i < n; i++) {
cur += a[i];
if (cur < 0) cur = 0;
if (cur > best) best = cur;
}
cout << best - (sum - best) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1.0) * 4;
const long long int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if (a == d || b == e || c == f)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 2e5 + 10;
int n, q;
int st[N], ed[N];
int sum[N << 2], lazy[N << 2];
struct {
int to, next;
} edge[N];
int head[N];
int cnt = 0;
int num = 0;
void addedge(int fr, int to) {
edge[cnt].to = to;
edge[cnt].next = head[fr];
head[fr] = cnt++;
}
void dfs(int u) {
st[u] = ++num;
for (int i = head[u]; ~i; i = edge[i].next) {
dfs(edge[i].to);
}
ed[u] = num;
}
void pushup(int root) { sum[root] = sum[root << 1] + sum[root << 1 | 1]; }
void pushdown(int root, int l, int r) {
int len = (r - l + 1);
int lenl = len - (len >> 1);
int lenr = (len) >> 1;
if (lazy[root] % 2) {
lazy[root << 1] += lazy[root];
lazy[root << 1 | 1] += lazy[root];
sum[root << 1] = lenl - sum[root << 1];
sum[root << 1 | 1] = lenr - sum[root << 1 | 1];
lazy[root] = 0;
}
}
void build(int l, int r, int root) {
lazy[root] = 0;
if (l == r) {
sum[root] = 0;
return;
}
int mid = (l + r) >> 1;
build(l, mid, root << 1);
build(mid + 1, r, root << 1 | 1);
pushup(root);
}
void init(int l, int r, int root, int pos, int val) {
if (l == r) {
sum[root] = val;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
init(l, mid, root << 1, pos, val);
else
init(mid + 1, r, root << 1 | 1, pos, val);
pushup(root);
}
void update(int l, int r, int root, int lf, int rt) {
if (lf <= l && r <= rt) {
sum[root] = (r - l + 1) - sum[root];
lazy[root]++;
return;
}
pushdown(root, l, r);
int mid = (l + r) >> 1;
if (lf <= mid) update(l, mid, root << 1, lf, rt);
if (rt > mid) update(mid + 1, r, root << 1 | 1, lf, rt);
pushup(root);
}
int querry(int l, int r, int root, int lf, int rt) {
if (lf <= l && r <= rt) return sum[root];
pushdown(root, l, r);
int mid = (l + r) >> 1;
int ans = 0;
if (lf <= mid) ans += querry(l, mid, root << 1, lf, rt);
if (rt > mid) ans += querry(mid + 1, r, root << 1 | 1, lf, rt);
return ans;
}
int main() {
memset(head, -1, sizeof(head));
n = read();
int x;
for (int i = 2; i <= n; i++) {
x = read();
addedge(x, i);
}
build(1, n, 1);
dfs(1);
for (int i = 0; i < n; i++) {
x = read();
init(1, n, 1, st[i + 1], x);
}
q = read();
char s[20];
while (q--) {
scanf("%s", s);
if (s[0] == 'g') {
x = read();
cout << querry(1, n, 1, st[x], ed[x]) << endl;
} else {
x = read();
update(1, n, 1, st[x], ed[x]);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, d, vx[20], vy[20];
int memo1[401][401][2][2], memo2[401][401][2][2];
bool solve1(int, int, bool, bool);
bool solve2(int, int, bool, bool);
bool solve1(int x, int y, bool flip1, bool flip2) {
if (x * x + y * y > d * d) return true;
int &res = memo1[x + 200][y + 200][flip1][flip2];
if (~res) return res;
for (int i = 0; i < (n); i++)
if (!solve2(x + vx[i], y + vy[i], flip1, flip2)) return res = true;
if (!flip1 && x != y && !solve2(y, x, true, flip2)) return res = true;
return res = false;
}
bool solve2(int x, int y, bool flip1, bool flip2) {
if (x * x + y * y > d * d) return true;
int &res = memo2[x + 200][y + 200][flip1][flip2];
if (~res) return res;
for (int i = 0; i < (n); i++)
if (!solve1(x + vx[i], y + vy[i], flip1, flip2)) return res = true;
if (!flip2 && x != y && !solve1(y, x, flip1, true)) return res = true;
return res = false;
}
int main() {
int x0, y0;
scanf("%d%d%d%d", &x0, &y0, &n, &d);
for (int i = 0; i < (n); i++) scanf("%d%d", vx + i, vy + i);
memset(memo1, -1, sizeof(memo1));
memset(memo2, -1, sizeof(memo2));
puts(solve1(x0, y0, false, false) ? "Anton" : "Dasha");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long maxn = 1e6 + 10;
int a[4], b[10] = {0, 1, 2, 0, 2, 1, 0}, c[4];
int check(int w) {
int sum = 0;
for (int i = 0; i < 3; i++) c[i] = a[i];
for (int i = w; i < 7; i++) {
if (c[b[i]] == 0) break;
--c[b[i]], ++sum;
}
int weeks = min(c[0] / 3, min(c[1] / 2, c[2] / 2));
c[0] -= weeks * 3, c[1] -= weeks * 2, c[2] -= weeks * 2, sum += weeks * 7;
for (int i = 0; i < 7; i++) {
if (c[b[i]] == 0) break;
--c[b[i]], ++sum;
}
return sum;
}
int main() {
int chong;
for (int i = 0; i < 3; i++) cin >> a[i];
if (a[0] == 1 && a[1] == 1 && a[2] == 2) {
cout << "4" << endl;
return 0;
}
int ans = 0;
for (int i = 0; i < 7; i++) {
ans = max(ans, check(i));
}
cout << ans << endl;
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define cy cout<<"YES"<<endl
#define cn cout<<"NO"<<endl
#define ms(a,b) memset(a, b, sizeof a);
#define scd(n) scanf("%d",&n)
#define scld(n) scanf("%lld",&n)
#define lp(i,a,b) for(i=a; i<b; i++)
const int INF = 0x3f3f3f3f;
#define MOD 1000000009
int main()
{
int t; t=1;
scd(t);
while(t--)
{
int px, py; cin>>px>>py;
string s; cin>>s;
sort(s.begin(), s.end());
int r = 0, l = 0, u = 0, d = 0;
for(int i=0; i<s.size(); i++)
{
if(s[i]=='R')r++;
if(s[i]=='L')l++;
if(s[i]=='U')u++;
if(s[i]=='D')d++;
}
int x, y;
bool f = true;
if(px>0)
{
if(px<=r)f= true;
else f = false;
}
else if(px<0)
{
l*=-1;
if(px>=l)f = true;
else f =false;
}
if(f)
{
if(py>0)
{
if(py<=u)f=true;
else f= false;
}
else if(py<0)
{
d*=-1;
if(py>=d)f=true;
else f=false;
}
}
if(f)cy;
else cn;
}
return 0;
}
/*
map<ll, int>mp;
map<ll, int>::iterator it;
ll a[n+2]; int b[n+2], c=0;
for(it = mp.begin(); it != mp.end(); it++)
{
a[c]=(it->first);
b[c++]=(it->second);
}
*/
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > V;
vector<int> R1, R2, R3;
int main() {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
V.push_back(make_pair(a, i));
}
sort(V.begin(), V.end());
for (i = 0; i < n; i++) R1.push_back(V[i].second);
int flag = 0;
for (i = n - 1; i >= 0; i--) {
if (i > 0 && V[i - 1].first == V[i].first && flag != 1) {
flag++;
R2.push_back(V[i - 1].second);
R2.push_back(V[i].second);
i--;
} else
R2.push_back(V[i].second);
}
flag = 0;
for (i = n - 1; i >= 0; i--) {
if (i > 0 && V[i - 1].first == V[i].first && flag != 2) {
flag++;
if (flag == 2 || ((i - 2) >= 0 && V[i - 2].first != V[i - 1].first)) {
R3.push_back(V[i - 1].second);
R3.push_back(V[i].second);
i--;
} else if ((i - 2) >= 0) {
flag = 2;
R3.push_back(V[i - 2].second);
R3.push_back(V[i - 1].second);
R3.push_back(V[i].second);
i -= 2;
}
} else
R3.push_back(V[i].second);
}
if (flag != 2) {
printf("NO");
return 0;
}
printf("YES\n");
for (i = 0; i < n; i++) printf("%d ", R1[i]);
printf("\n");
for (i = n - 1; i >= 0; i--) printf("%d ", R2[i]);
printf("\n");
for (i = n - 1; i >= 0; i--) printf("%d ", R3[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, a[26][10001];
string s, t;
cin >> s >> t;
for (i = 0; i < 26; i++)
for (j = 0; j <= s.size(); j++) a[i][j] = -1;
for (j = s.size() - 1; j > -1; j--) {
for (i = 0; i < 26; i++) {
if (s[j] - 'a' == i)
a[i][j] = j;
else
a[i][j] = a[i][j + 1];
}
}
for (i = 0; i < t.size(); i++) {
if (a[t[i] - 'a'][0] == -1) {
cout << -1 << endl;
return 0;
}
}
for (j = n = 0; j < t.size();) {
n++;
for (i = 0;;) {
if (a[t[j] - 'a'][i] > -1) {
i = a[t[j] - 'a'][i] + 1;
j++;
if (j == t.size()) break;
} else
break;
}
}
cout << n << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
while (n--) {
long long a, b, sub;
cin >> a >> b;
if (b > a) {
std::swap(a, b);
}
sub = a - b;
if (sub > 1) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long w[1005];
signed main() {
long long t;
scanf("%lld", &t);
while (t--) {
long long n;
scanf("%lld", &n);
long long sum = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
sum += w[i];
}
if (sum % n == 0) {
puts("0");
} else
puts("1");
}
}
| 0 |
#include <bits/stdc++.h>
int diru[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dirv[] = {-1, 0, 1, -1, 1, -1, 0, 1};
using namespace std;
template <class T>
T sq(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
bool inside(T a, T b, T c) {
return a <= b && b <= c;
}
template <class T>
void setmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
vector<int> ans;
int main() {
int n, T, t = 1, m, i, j, k, o, w;
scanf("%d", &n);
scanf("%d", &o);
scanf("%d", &w);
{
bool f = 1;
int cur = 1;
ans.push_back(cur);
if (w == 0) {
if (o) {
int tot = 1;
for (i = 0; i < n - o - 1; i++) {
ans.push_back(1);
tot++;
}
while (o--) {
cur++;
if (cur > tot || cur > 50000) {
f = 0;
goto second;
}
ans.push_back(cur);
tot += cur;
}
goto second;
}
}
n--;
while (w--) {
cur *= 2;
if (cur > 50000) {
f = 0;
goto second;
}
ans.push_back(cur);
n--;
}
cur = ans[((int)ans.size()) - 1] + 1;
while (o--) {
if (cur > 50000) {
f = 0;
goto second;
}
ans.push_back(cur);
cur++;
n--;
}
while (n--) ans.push_back(1);
second:;
if (f) {
for (i = 0; i < ((int)ans.size()); i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
puts("");
} else
puts("-1");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int ioo = 1000000000;
long long loo = 1000000000000000000;
void add_self(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
int add(int x, int y) { return add_self(x, y), x; }
void sub_self(int &x, int y) {
if ((x -= y) < 0) x += mod;
}
int sub(int x, int y) { return sub_self(x, y), x; }
int mul(int x, int y) { return (long long)x * y % mod; }
long long po(long long k, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= k;
k *= k;
n /= 2;
}
return res;
}
long long pom(long long k, long long n) {
long long res = 1;
while (n) {
if (n % 2) res = mul(res, k);
k = mul(k, k);
n /= 2;
}
return res;
}
char a[2005];
vector<long long> v;
long long n, k, x;
int main() {
int tt;
scanf("%d", &tt);
while (tt--) {
v.clear();
scanf("%lld%lld%lld", &n, &k, &x);
scanf("%s", a);
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 'a') {
if (cnt) v.push_back(cnt * k);
cnt = 0;
} else
cnt++;
}
if (cnt) v.push_back(cnt * k);
vector<long long> b = v;
if (!b.empty()) b.back()++;
int idx = b.size();
for (int i = (int)b.size() - 2; i >= 1; i--) {
if (b[i] + 1 <= (loo * 2) / b[i + 1])
b[i] = (b[i] + 1) * b[i + 1];
else {
idx = i;
break;
}
}
if (idx != b.size())
for (int i = idx; i >= 0; i--) b[i] = loo * 2;
deque<long long> ans(v.size(), 0);
for (int i = 0; i < v.size(); i++) {
if (i == (int)v.size() - 1)
ans[i] = x - 1;
else {
long long steps = min((x - 1) / b[i + 1], v[i]);
ans[i] = steps;
x -= steps * b[i + 1];
}
}
for (int i = 0; i < n; i++) {
if (a[i] == 'a')
printf("a");
else {
if (i == 0 || a[i] != a[i - 1]) {
long long cur = ans.front();
while (cur--) printf("b");
ans.pop_front();
}
}
}
printf("\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main() {
int T;
cin >> T;
vector<pair<int, int>> edges;
vector<int> matching;
vector<bool> used;
while (T--) {
int n, m;
scanf("%d %d", &n, &m);
matching.clear();
edges.clear();
edges.resize(m);
used.clear();
used.resize(3 * n + 1);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &edges[i].first, &edges[i].second);
if (not used[edges[i].first] and not used[edges[i].second]) {
matching.push_back(i + 1);
used[edges[i].first] = true;
used[edges[i].second] = true;
}
}
if (matching.size() >= n) {
printf("Matching\n");
for (int i = 0; i < n; ++i) {
if (i) printf(" ");
printf("%d", matching[i]);
}
printf("\n");
} else {
printf("IndSet\n");
int count = 0;
for (int i = 1; i < 3 * n + 1 and count < n; ++i) {
if (not used[i]) {
if (count) printf(" ");
printf("%d", i);
++count;
}
}
printf("\n");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1) {
cout << -1 << "\n";
} else {
cout << 2;
for (int i = 1; i < n; i++) {
cout << 3;
}
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("mmx,avx,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
map<long long, long long> cnt;
map<long long, long long> dif;
for (long long i = 0; i < n; i++) {
if (dif[cnt[a[i]]]) dif[cnt[a[i]]]--;
if (dif[cnt[a[i]]] == 0) dif.erase(cnt[a[i]]);
cnt[a[i]]++;
dif[cnt[a[i]]]++;
if (dif.size() == 1 && (cnt.size() == 1 || (*(dif.begin())).first == 1))
ans = i + 1;
else {
if (dif.size() == 2) {
long long t1 = (*(dif.begin())).first;
long long ch1 = (*(dif.begin())).second;
long long t2 = (*(next(dif.begin()))).first;
long long ch2 = (*(next(dif.begin()))).second;
if (ch1 == 1 && (t1 == 1 || t1 - 1 == t2))
ans = i + 1;
else if (ch2 == 1 && (t2 == 1 || t2 - 1 == t1))
ans = i + 1;
}
}
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[100009];
signed main() {
long long i, n, k = -1, j, ct = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (j = 30; j >= 0; j--) {
ct = 0;
for (i = 0; i < n; i++) {
if ((a[i] >> j) & 1) {
ct++;
k = i;
}
}
if (ct == 1) break;
}
if (ct == 1) swap(a[0], a[k]);
for (i = 0; i < n; i++) cout << a[i] << " ";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
long long a[maxn];
int main() {
long long ans = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n / 2; i++)
ans += (a[i] + a[n - i - 1]) * (a[i] + a[n - i - 1]);
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t[20][20][20], ans[20][20];
struct msp {
int num, dep;
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
string s;
cin >> s;
memset(t, -1, sizeof(t));
for (int i = 0; i <= 9; i += 1)
for (int j = 0; j <= 9; j += 1) {
deque<msp> b;
b.push_back({i, 0});
if (i != j) b.push_back({j, 0});
t[i][j][i] = t[i][j][j] = 0;
while (b.size()) {
msp now = b.front();
b.pop_front();
int h = (now.num + i) % 10;
if (t[i][j][h] == -1) {
t[i][j][h] = now.dep + 1;
b.push_back({h, now.dep + 1});
}
h = (now.num + j) % 10;
if (t[i][j][h] == -1) {
t[i][j][h] = now.dep + 1;
b.push_back({h, now.dep + 1});
}
}
}
for (int i = 0; i <= 9; i += 1) {
for (int j = 0; j <= 9; j += 1) {
int now = 0, num = 0;
for (int k = 1; k < s.length(); k += 1) {
int u = (s[k] - '0' + 10 - now) % 10;
if (~t[i][j][u]) {
num += t[i][j][u];
} else {
num = -1;
break;
}
now = s[k] - '0';
}
ans[i][j] = num;
}
}
for (int i = 0; i <= 9; i += 1) {
for (int j = 0; j <= 9; j += 1) {
cout << ans[i][j] << ' ';
}
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
string s;
cin >> n >> m >> s;
vector<vector<int> > cnt(m, vector<int>(m, 0));
for (int i = 1; i < n; i++) {
cnt[s[i] - 'a'][s[i - 1] - 'a']++;
cnt[s[i - 1] - 'a'][s[i] - 'a']++;
}
vector<int> dp(1 << m, int(1e9));
dp[0] = 0;
for (int i = 1; i < (1 << m); i++) {
int c = 0;
for (int j = 0; j < m; j++) {
for (int k = j + 1; k < m; k++) {
if ((i >> j & 1) ^ (i >> k & 1)) c += cnt[j][k];
}
}
for (int j = 0; j < m; j++) {
if (i >> j & 1) {
dp[i] = min(dp[i], dp[i ^ (1 << j)] + c);
}
}
}
cout << dp[(1 << m) - 1] << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
struct SegTree {
vector<int> tree;
int base;
SegTree(int a) {
base = 1;
while (base < a) base <<= 1;
tree.resize(base * 2 + 2, INF);
base--;
}
void update(int idx, int val) {
idx += base;
tree[idx] = val;
idx >>= 1;
while (idx != 0) {
tree[idx] = min(tree[idx * 2], tree[idx * 2 + 1]);
idx >>= 1;
}
}
int query(int st, int fn, int ns = 1, int nf = -1, int num = 1) {
if (nf == -1) nf = base + 1;
if (nf < st || fn < ns) return INF;
if (st <= ns && nf <= fn) return tree[num];
int mid = (ns + nf) >> 1;
return min(query(st, fn, ns, mid, num * 2),
query(st, fn, mid + 1, nf, num * 2 + 1));
}
};
int t;
int n;
int a[300005], b[300005];
pair<int, int> a2[300005], b2[300005];
int pos[300005];
int main() {
for (scanf("%d", &t); t > 0; t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a2[i] = pair<int, int>(a[i], i);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
b2[i] = pair<int, int>(b[i], i);
}
sort(a2 + 1, a2 + 1 + n);
sort(b2 + 1, b2 + 1 + n);
bool tf = true;
for (int i = 1; i <= n; i++) {
if (a2[i].first != b2[i].first) {
tf = false;
printf("NO\n");
break;
}
pos[b2[i].second] = a2[i].second;
}
if (!tf) continue;
SegTree T(n);
int cur = 0, idx = 1;
for (int i = 1; i <= n; i++) {
cur = max(cur, pos[i]);
while (idx <= cur) {
T.update(idx, a[idx]);
idx++;
}
if (pos[i] > 1 && T.query(1, pos[i] - 1) < b[i]) {
tf = false;
break;
}
T.update(pos[i], INF);
}
if (tf)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T>
vector<T> prefixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = 0; i < (int((v).size())); i++) res[i + 1] = res[i] + v[i];
return res;
}
template <typename C, typename T>
vector<T> suffixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = (int((v).size())) - 1; i >= 0; i--) res[i] = v[i] + res[i + 1];
return res;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
void solve() {
int N, M, K;
re(N, M, K);
vi ht(N);
re(ht);
for (int i = 0; i < (N - 1); i++) {
int targ = max(0, ht[i + 1] - K);
if (targ - ht[i] > M) {
ps("NO");
return;
}
M += ht[i] - targ;
}
ps("YES");
}
int main() {
setIO();
int T;
re(T);
for (int t = 0; t < (T); t++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int rj = 0;
int n, tr = 0, kolko = 0;
vector<pair<int, int> > raz;
set<pair<int, int> > najm;
vector<int> nes;
int main() {
int x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
nes.push_back(x);
raz.push_back(make_pair(i - x, i));
}
sort(raz.begin(), raz.end());
for (int i = 0; i < raz.size(); i++) {
if (tr < raz[i].first) {
najm.insert(make_pair(tr, raz[i - 1].second));
tr = raz[i].first;
}
}
najm.insert(make_pair(tr, raz[raz.size() - 1].second));
for (int i = 0; i < n; i++) {
while (i > (najm.begin()->second)) {
najm.erase(najm.begin());
}
if (kolko < (najm.begin()->first)) kolko++;
rj += i - nes[i] - kolko;
}
printf("%lld", rj);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int el = 0; el < n; ++el) {
int v;
cin >> v;
ans = max(ans, v);
}
cout << max(25, ans) - 25 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<string> name(n + 1);
vector<short> type(n + 1);
int e = 0;
for (int i = 0; i < n; i++) {
cin >> name[i] >> type[i];
if (type[i] == 1) e++;
}
set<string> example, test;
for (int i = 1; i <= n; i++) {
string s = to_string(i);
if (i <= e)
example.insert(to_string(i));
else
test.insert(to_string(i));
}
set<string> testToExample, exampleToTest, ilegalToExample, ilegalToTest;
for (int i = 0; i < n; i++) {
if (example.count(name[i])) {
example.erase(name[i]);
if (type[i] == 0) testToExample.insert(name[i]);
} else if (test.count(name[i])) {
test.erase(name[i]);
if (type[i] == 1) exampleToTest.insert(name[i]);
} else {
if (type[i] == 0)
ilegalToTest.insert(name[i]);
else
ilegalToExample.insert(name[i]);
}
}
vector<pair<string, string> > moves;
while (example.size() || test.size() || testToExample.size() ||
exampleToTest.size()) {
if (example.size() && exampleToTest.size()) {
moves.push_back({*exampleToTest.begin(), *example.begin()});
example.erase(example.begin());
test.insert(*exampleToTest.begin());
exampleToTest.erase(exampleToTest.begin());
continue;
}
if (test.size() && testToExample.size()) {
moves.push_back({*testToExample.begin(), *test.begin()});
test.erase(test.begin());
example.insert(*testToExample.begin());
testToExample.erase(testToExample.begin());
continue;
}
if (example.size() && ilegalToExample.size()) {
moves.push_back({*ilegalToExample.begin(), *example.begin()});
example.erase(example.begin());
ilegalToExample.erase(ilegalToExample.begin());
continue;
}
if (test.size() && ilegalToTest.size()) {
moves.push_back({*ilegalToTest.begin(), *test.begin()});
test.erase(test.begin());
ilegalToTest.erase(ilegalToTest.begin());
continue;
}
assert(testToExample.size() == exampleToTest.size() &&
testToExample.size());
example.insert(*testToExample.begin());
moves.push_back({*testToExample.begin(), "escom"});
testToExample.erase(testToExample.begin());
ilegalToTest.insert("escom");
}
cout << moves.size() << "\n";
for (auto m : moves) {
cout << "move " << m.first << " " << m.second << "\n";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string now = "Aa";
vector<string> ans;
for (int i = 0; i < k - 1; i++) {
ans.push_back(now);
if (now.back() == 'z') {
now += "a";
} else {
now.back()++;
}
}
for (int i = 0; i < n - k + 1; i++) {
string s;
cin >> s;
if (s == "NO") {
ans.push_back(ans[i]);
} else {
ans.push_back(now);
if (now.back() == 'z') {
now += "a";
} else {
now.back()++;
}
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
| 7 |
#include <bits/stdc++.h>
long long getSquareDistance(std::vector<long long> &first,
std::vector<long long> &second) {
long long squareDistance = 0l;
for (int i = 0; i < first.size(); ++i) {
squareDistance += (first[i] - second[i]) * (first[i] - second[i]);
}
return squareDistance;
}
bool isCube(std::vector<std::vector<long long>> &coordinates) {
std::vector<long long> squareDistances;
squareDistances.reserve(28);
for (int i = 0; i < 7; ++i) {
for (int j = i + 1; j < 8; ++j) {
squareDistances.push_back(
getSquareDistance(coordinates[i], coordinates[j]));
}
}
std::map<long long, int> distancesCounts;
for (auto d : squareDistances) {
if (distancesCounts.find(d) == distancesCounts.end()) {
if (distancesCounts.size() == 3) {
return false;
} else {
distancesCounts[d] = 1;
}
} else {
++distancesCounts[d];
}
}
if (distancesCounts.size() != 3) {
return false;
}
for (auto d : distancesCounts) {
if (d.second != 12 && d.second != 4) {
return false;
}
}
return true;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::vector<std::vector<long long>> cubePermutation(
8, std::vector<long long>(3, 0));
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 3; ++j) {
std::cin >> cubePermutation[i][j];
}
}
for (int i = 0; i < 8; ++i) {
std::sort(cubePermutation[i].begin(), cubePermutation[i].end());
}
bool canRestoreCube = false;
for (int i1 = 0; i1 < 6 && !canRestoreCube; ++i1) {
for (int i2 = 0; i2 < 6 && !canRestoreCube; ++i2) {
for (int i3 = 0; i3 < 6 && !canRestoreCube; ++i3) {
for (int i4 = 0; i4 < 6 && !canRestoreCube; ++i4) {
for (int i5 = 0; i5 < 6 && !canRestoreCube; ++i5) {
for (int i6 = 0; i6 < 6 && !canRestoreCube; ++i6) {
for (int i7 = 0; i7 < 6 && !canRestoreCube; ++i7) {
if (isCube(cubePermutation)) {
canRestoreCube = true;
} else {
std::next_permutation(cubePermutation[7].begin(),
cubePermutation[7].end());
}
}
if (!canRestoreCube) {
std::next_permutation(cubePermutation[6].begin(),
cubePermutation[6].end());
}
}
if (!canRestoreCube) {
std::next_permutation(cubePermutation[5].begin(),
cubePermutation[5].end());
}
}
if (!canRestoreCube) {
std::next_permutation(cubePermutation[4].begin(),
cubePermutation[4].end());
}
}
if (!canRestoreCube) {
std::next_permutation(cubePermutation[3].begin(),
cubePermutation[3].end());
}
}
if (!canRestoreCube) {
std::next_permutation(cubePermutation[2].begin(),
cubePermutation[2].end());
}
}
if (!canRestoreCube) {
std::next_permutation(cubePermutation[1].begin(),
cubePermutation[1].end());
}
}
if (canRestoreCube) {
std::cout << "YES\n";
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 3; ++j) {
std::cout << cubePermutation[i][j] << " ";
}
std::cout << "\n";
}
} else {
std::cout << "NO";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
void chmin(T& a, const T& b) noexcept {
if (b < a) a = b;
}
template <class T>
void chmax(T& a, const T& b) noexcept {
if (a < b) a = b;
}
template <class T>
void drop(const T& x) {
std::cout << x << endl;
exit(0);
}
void debug_out() { std::cout << "\n"; }
template <class T, class... Args>
void debug_out(const T& x, const Args&... args) {
std::cout << x << " ";
debug_out(args...);
}
struct InitIO {
InitIO() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
}
} init_io;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
bool operator==(const mint rhs) const { return x == rhs.x; }
bool operator!=(const mint rhs) const { return x != rhs.x; }
bool operator<(const mint& a) const { return x < a.x; };
};
istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
template <typename ModInt>
struct Combination {
vector<ModInt> fact, ifact;
Combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
}
ModInt C(int n, int k) {
if (k < 0 || n < k) return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
ModInt P(int n, int r) {
if (r < 0 || n < r) return 0;
return fact[n] * ifact[n - r];
}
ModInt H(int n, int r) {
if (r < 0 || n < 0) return 0;
return r == 0 ? 1 : C(n + r - 1, r);
}
ModInt operator()(int n, int k) { return C(n, k); }
};
int main() {
int n, m;
cin >> n >> m;
vector<vector<mint> > dp(m + 5, vector<mint>(n + 5, 0));
for (int i = 0; i < (n + 5); ++i) dp[0][i] = 1;
for (int i = 1; i < (m); ++i) {
for (int j = 1; j < (n + 1); ++j) {
for (int k = 1; k <= j; ++k) dp[i][j] += dp[i - 1][k];
}
}
Combination<mint> comb(2000);
mint ans = 0;
for (int i = 1; i < (n + 1); ++i) {
ans += dp[m - 1][i] * comb.H(n - i + 1, m);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int test, n, i;
cin >> test;
while (test--) {
cin >> n;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
if (arr[0] + arr[1] > arr[n - 1])
cout << -1 << endl;
else
cout << 1 << " " << 2 << " " << n << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> G[N];
int fa[N][17], tin[N], tout[N], dep[N], dfs_tag = 0;
void dfs(int u, int father) {
fa[u][0] = father;
for (int i = 1; i < 17; ++i) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
tin[u] = ++dfs_tag;
for (auto v : G[u]) {
if (v == father) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
}
tout[u] = dfs_tag;
}
inline int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 16; i >= 0; --i) {
if (dep[fa[u][i]] >= dep[v]) {
u = fa[u][i];
}
}
if (u == v) return u;
for (int i = 16; i >= 0; --i) {
if (fa[u][i] ^ fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
int a[N], K;
bool imp[N];
inline bool cmp(int x, int y) { return tin[x] < tin[y]; }
inline int getNext(int p) {
int l = 0, r = K - 1, c = K;
while (l <= r) {
int m = (l + r) >> 1;
if (tin[a[m]] > p) {
c = m;
r = m - 1;
} else {
l = m + 1;
}
}
return c;
}
vector<int> g[N];
pair<int, int> st[N];
int cost;
int DFS(int u) {
if (imp[u] && g[u].empty()) return 1;
int c = 0;
for (auto v : g[u]) c += DFS(v);
if (imp[u]) {
cost += c;
return 1;
} else if (c > 1) {
++cost;
return 0;
} else {
return c;
}
}
int cal(vector<int> &a) {
int sz = a.size();
for (int i = 1; i < sz; ++i) {
a.push_back(lca(a[i - 1], a[i]));
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
sort(a.begin(), a.end(), cmp);
int top = 0;
for (auto x : a) {
int t = tin[x];
while (top && st[top - 1].second < t) --top;
if (top) g[st[top - 1].first].push_back(x);
st[top++] = make_pair(x, tout[x]);
}
cost = 0;
DFS(a[0]);
for (auto x : a) g[x].clear();
return cost;
}
int divide(int l, int r) {
if (l >= r) return 0;
int p = l, ret = 0;
vector<int> vx;
if (tout[a[l]] >= tin[a[r]]) {
vx.push_back(a[p++]);
}
while (p <= r) {
vx.push_back(a[p]);
int np = getNext(tout[a[p]]);
ret += divide(p, np - 1);
p = np;
}
return ret + cal(vx);
}
int solve() {
for (int i = 0; i < K; ++i) {
int u = a[i], f = fa[u][0];
if (f != u && imp[f]) return -1;
}
sort(a, a + K, cmp);
return divide(0, K - 1);
}
int main() {
int n;
scanf("%d", &n);
for (int u, v, i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 1);
int q;
scanf("%d", &q);
while (q--) {
scanf("%d", &K);
for (int i = 0; i < K; ++i) {
scanf("%d", a + i);
imp[a[i]] = true;
}
printf("%d\n", solve());
for (int i = 0; i < K; ++i) {
imp[a[i]] = false;
}
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long const INF = 2e18 + 100;
int const MAX = 3 * 1e5 + 10;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, n, i, x;
cin >> t;
while (t--) {
cin >> n;
int arr[n + 1];
map<int, int> mp;
x = n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
if (mp[arr[i]]) {
x = min(x, i - mp[arr[i]]);
}
mp[arr[i]] = i;
}
if (x == n)
x = -1;
else
x++;
cout << x << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INF = 1e9;
const int N = 2e5 + 5;
const ll MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string a, b;
cin >> a >> b;
vector<int> cum;
int n = a.size(), m = b.size();
int sum = 0, i;
for (i = 0; i <= m - n; i++) {
if (b[i] == '1') sum++;
}
cum.push_back(sum);
int k = 0;
for (; i < m; i++) {
if (b[k] == '1') sum--;
if (b[i] == '1') sum++;
cum.push_back(sum);
++k;
}
ll ans = 0;
k = 0;
for (int i = 0; i < n; i++) {
int ex = 0;
if (a[i] == '1') ex = m - n + 1;
ans += (ll)abs(cum[k] - ex), k++;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct EDGE {
int to, next, w;
} e[200010];
int head[100010], top;
const long long mod = 1000000007;
void add(int u, int v, int w) {
e[top].to = v;
e[top].next = head[u];
e[top].w = w;
head[u] = top++;
}
int fa[100010];
struct _ {
long long cfa, c;
_ operator+(_ ob) {
_ rv;
rv.c = c + ob.c;
rv.cfa = cfa + ob.cfa;
return rv;
}
};
long long qpow(long long base, int index) {
long long mul = 1;
while (index) {
if (index & 1) mul = mul * base % mod;
base = base * base % mod;
index >>= 1;
}
return mul;
}
_ dfs(int x, int w) {
int i, cnt = 0;
bool flag = 1;
long long sumw = 0;
_ sum = {0, 0};
for (i = head[x]; ~i; i = e[i].next) {
cnt++;
if (e[i].to == fa[x]) continue;
flag = 0;
fa[e[i].to] = x;
sum = sum + dfs(e[i].to, e[i].w);
sumw += e[i].w;
}
if (flag) return (_){0, 0};
sumw = (sum.c + sumw + w) % mod;
cnt = (cnt - sum.cfa % mod + mod) % mod;
cnt = qpow(cnt, mod - 2);
return (_){cnt, sumw * cnt % mod};
}
int main() {
memset(head, 255, sizeof(head));
memset(fa, 255, sizeof(fa));
int n;
scanf("%d", &n);
int i;
int u, v, w;
for (i = 1; i < n; i++) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
_ ans = dfs(0, 0);
printf("%lld\n", ans.c);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, i, b, c, x;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
if (x < 0) {
c += x;
} else {
b += x;
}
}
cout << b - c;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const char NAMES[8][9] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
int i;
char str[9];
inline bool eq(const char* a, const char* b) {
int i;
for (i = 0; a[i] != '\0' && b[i] != '\0'; i++)
if (a[i] != '.' && a[i] != b[i]) return false;
return a[i] == b[i];
}
int main() {
scanf("%*d");
gets(str);
gets(str);
for (i = 0; i < 8; i++)
if (eq(str, NAMES[i])) puts(NAMES[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int j, i, p = 0, t, m, q = 0, d[1000], k, n, l = 0, r, sum = 0, b,
y, x1, x2, x3, x4;
vector<long> v(4);
vector<pair<int, int> > v1;
pair<int, int> p1[100];
string s;
stack<int> s1, s2;
cin >> n;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == 'B') {
p++;
}
if ((s[i] == 'W' && s[i - 1] == 'B' && i != 0) ||
(s[i] == 'B' && i == n - 1)) {
d[q] = p;
q++;
p = 0;
}
}
if (p == n) {
cout << 1 << endl;
cout << p;
} else {
cout << q;
cout << endl;
for (i = 0; i < q; i++) {
cout << d[i] << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, i;
string a;
cin >> a;
l = a.size();
int kx = 0, ky = 0;
for (i = 0; i < l; i++) {
if (a[i] == 'x') {
kx++;
}
if (a[i] == 'y') {
ky++;
}
}
if (kx > ky) {
for (i = 1; i <= kx - ky; i++) {
cout << 'x';
}
} else {
if (kx < ky) {
for (i = 1; i <= ky - kx; i++) {
cout << 'y';
}
} else {
cout << 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long b, long long e, long long m) {
b %= m;
long long ans = 1;
for (; e; b = b * b % m, e /= 2)
if (e & 1) ans = ans * b % m;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
priority_queue<int, vector<int>, greater<int> > pq;
long long res = 0;
int p;
cin >> p;
pq.push(p);
for (int i = 1; i < (n); ++i) {
cin >> p;
pq.push(p);
if (pq.top() < p) {
res += p - pq.top();
pq.pop();
pq.push(p);
}
}
cout << res << "\n";
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
int n, num[100000 + 10], last = -1, sum = 0;
bool zero = false, boleh[100000 + 10];
int main() {
memset(boleh, true, sizeof boleh);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", num + i);
for (int i = 0; i < n; i++)
if (num[i] == 0) zero = true;
if (!zero) {
puts("-1");
return 0;
}
sort(num, num + n);
for (int i = 0; i < n; i++) sum += num[i];
if (sum % 3 == 0) {
if (sum == 0)
puts("0");
else {
for (int i = n - 1; i >= 0; i--) printf("%d", num[i]);
puts("");
}
} else {
if (sum % 3 == 2) {
bool ada = false;
for (int i = 1; i < n; i++)
if (num[i] % 3 == 2) {
ada = true;
boleh[i] = false;
sum -= num[i];
break;
}
if (!ada) {
for (int i = 1; i < n; i++) {
if (num[i] % 3 == 1) {
boleh[i] = false;
sum -= num[i];
if (sum % 3 == 0) break;
}
}
}
} else {
bool ada = false;
for (int i = 1; i < n; i++)
if (num[i] % 3 == 1) {
ada = true;
boleh[i] = false;
sum -= num[i];
break;
}
if (!ada) {
for (int i = 1; i < n; i++) {
if (num[i] % 3 == 2) {
boleh[i] = false;
sum -= num[i];
if (sum % 3 == 0) break;
}
}
}
}
if (sum % 3 != 0)
puts("-1");
else {
if (sum == 0)
puts("0");
else {
for (int i = n - 1; i >= 0; i--)
if (boleh[i]) printf("%d", num[i]);
puts("");
}
}
}
fprintf(stderr, "%.3lf\n", clock() / (double)CLOCKS_PER_SEC);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
int n;
scanf("%d", &n);
long long G = 0;
for (int i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
if (G == 0)
G = x;
else
G = gcd(G, x);
}
long long ans = 0;
for (long long i = 1; i <= floor(sqrt(G)); i++) {
if (G % i == 0 && i * i != G)
ans += 2;
else if (G % i == 0 && i * i == G)
ans++;
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
int x;
scanf("%d", &x);
if (x == 3)
printf("5\n");
else {
if (x % 2 == 1) x--;
int ans = 1;
while (1) {
int g = (ans * ans - 1) / 2;
if (g < x)
ans += 2;
else
break;
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
struct tree {
int l, r;
long long c1, c2, tag;
} d[maxn << 2];
struct edge {
int to, nex, dis;
} e[maxn << 1];
int n, Q, cnt, cc;
int st[maxn], en[maxn], fa[maxn], dep[maxn], mindis[maxn], dis[maxn], a[maxn],
son[maxn], sz[maxn], head[maxn];
int top[maxn], pp[maxn];
void add(int x, int y, int z) {
e[++cnt].to = y;
e[cnt].dis = z;
e[cnt].nex = head[x];
head[x] = cnt;
}
void dfs1(int x, int father) {
fa[x] = father;
dep[x] = dep[father] + 1;
son[x] = -1;
sz[x] = 1;
for (int i = head[x]; i; i = e[i].nex) {
int v = e[i].to;
if (v == father) continue;
dis[v] = dis[x] + e[i].dis;
dfs1(v, x);
if (son[x] == -1 || sz[v] > sz[son[x]]) son[x] = v;
sz[x] += sz[v];
}
}
void dfs2(int x, int tp) {
top[x] = tp;
st[x] = ++cc;
pp[cc] = x;
if (son[x] != -1) dfs2(son[x], tp);
for (int i = head[x]; i; i = e[i].nex)
if (e[i].to != fa[x] && e[i].to != son[x]) dfs2(e[i].to, e[i].to);
en[x] = cc;
}
void pushdown(int o) {
if (!d[o].tag || d[o].l == d[o].r) return;
d[o << 1].c1 += d[o].tag;
d[o << 1].c2 += d[o].tag;
d[o << 1].tag += d[o].tag;
d[o << 1 | 1].c1 += d[o].tag;
d[o << 1 | 1].c2 += d[o].tag;
d[o << 1 | 1].tag += d[o].tag;
d[o].tag = 0;
}
void update(int o) { d[o].c2 = min(d[o << 1].c2, d[o << 1 | 1].c2); }
void build(int o, int l, int r) {
d[o].l = l;
d[o].r = r;
if (l == r) {
d[o].c1 = dis[pp[l]];
d[o].c2 = dis[pp[l]] + a[pp[l]];
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
update(o);
}
void change1(int o, int l, int r, long long val) {
if (d[o].l == l && d[o].r == r) {
d[o].c1 += val;
d[o].c2 += val;
d[o].tag += val;
return;
}
pushdown(o);
int mid = (d[o].l + d[o].r) >> 1;
if (r <= mid)
change1(o << 1, l, r, val);
else if (l > mid)
change1(o << 1 | 1, l, r, val);
else
change1(o << 1, l, mid, val), change1(o << 1 | 1, mid + 1, r, val);
update(o);
}
void change2(int o, int x, long long val) {
if (d[o].l == d[o].r) {
d[o].c2 += val;
return;
}
pushdown(o);
int mid = (d[o].l + d[o].r) >> 1;
if (x <= mid)
change2(o << 1, x, val);
else
change2(o << 1 | 1, x, val);
update(o);
}
long long query1(int o, int x) {
if (d[o].l == d[o].r) return d[o].c1;
int mid = (d[o].l + d[o].r) >> 1;
pushdown(o);
if (x <= mid)
return query1(o << 1, x);
else
return query1(o << 1 | 1, x);
}
long long query2(int o, int l, int r) {
if (d[o].l == l && d[o].r == r) return d[o].c2;
int mid = (d[o].l + d[o].r) >> 1;
pushdown(o);
if (r <= mid)
return query2(o << 1, l, r);
else if (l > mid)
return query2(o << 1 | 1, l, r);
else
return min(query2(o << 1, l, mid), query2(o << 1 | 1, mid + 1, r));
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[x] < dep[y]) swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
int X[maxn << 1], Y[maxn << 1], Z[maxn << 1];
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &X[i], &Y[i], &Z[i]);
add(X[i], Y[i], Z[i]);
}
for (int i = n; i <= 2 * n - 2; i++) {
scanf("%d%d%d", &X[i], &Y[i], &Z[i]);
a[X[i]] = Z[i];
}
dfs1(1, 0);
dfs2(1, 1);
build(1, 1, n);
while (Q--) {
int opt, x, y;
scanf("%d%d%d", &opt, &x, &y);
if (opt == 1) {
if (x < n)
change1(1, st[Y[x]], en[Y[x]], y - Z[x]), Z[x] = y;
else
change2(1, st[X[x]], y - Z[x]), Z[x] = y;
} else {
int lca = LCA(x, y);
if (x == lca)
printf("%I64d\n", query1(1, st[y]) - query1(1, st[x]));
else {
printf("%I64d\n",
query2(1, st[x], en[x]) - query1(1, st[x]) + query1(1, st[y]));
}
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void out(T A[], int n) {
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
template <class T>
void out(vector<T> A, int n = -1) {
if (n == -1) n = A.size();
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
const int MAXN = 99999;
const int INF = (1 << 30);
const double PI = acos(-1.0);
const double EPS = 1e-11;
long long a[100005], b[100005];
long long dp[100005];
int n;
int input() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (i = 1; i <= n; i++) scanf("%I64d", &b[i]);
return 0;
}
int sgn(double d1, double d2) {
if (d1 - d2 > EPS)
return 1;
else if (d2 - d1 > EPS)
return -1;
else
return 0;
}
int solve() {
int i, j;
long long q[100005], head, tail;
memset(dp, -1, sizeof(dp));
dp[1] = 0;
head = tail = 0;
q[tail++] = 1;
for (i = 2; i <= n; i++) {
while (head < tail - 1 && dp[q[head + 1]] - dp[q[head]] <=
a[i] * (b[q[head]] - b[q[head + 1]]))
head++;
dp[i] = dp[q[head]] + a[i] * b[q[head]];
while (head < tail - 1 && sgn((double)(dp[q[tail - 1]] - dp[q[tail - 2]]) *
(b[i] - b[q[tail - 1]]),
(double)(dp[i] - dp[q[tail - 1]]) *
(b[q[tail - 1]] - b[q[tail - 2]])) <= 0)
tail--;
q[tail++] = i;
}
printf("%I64d", dp[n]);
return 0;
}
int main() {
input();
solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int prime[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
int n;
int a[111];
int f[111][1 << 16], g[111][1 << 16], S[111][1 << 16];
int p[61][1 << 16];
int pd(int x, int s) {
int ret = 0;
for (int i = 0; i < 16; i++) {
while (x % prime[i] == 0) {
ret |= 1 << i;
x /= prime[i];
}
}
if (ret & s) return -1;
return ret | s;
}
int abs(int x) {
if (x > 0) return x;
return -x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= 58; i++) {
for (int j = 0; j < (1 << 16); j++) {
p[i][j] = pd(i, j);
}
}
memset(f, 127 / 3, sizeof(f));
f[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 58; j++) {
for (int s = 0; s < (1 << 16); s++) {
if (p[j][s] != -1) {
if (f[i][s] + abs(j - a[i + 1]) < f[i + 1][p[j][s]]) {
f[i + 1][p[j][s]] = f[i][s] + abs(j - a[i + 1]);
g[i + 1][p[j][s]] = s;
S[i + 1][p[j][s]] = j;
}
}
}
}
}
int ans = 1234567890, k;
for (int i = 0; i < (1 << 16); i++)
if (f[n][i] < ans) {
ans = f[n][i];
k = i;
}
int print[111];
for (int i = n; i >= 1; i--) {
print[i] = S[i][k];
k = g[i][k];
}
for (int i = 1; i <= n; i++) printf("%d ", print[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 99999999;
const double EPS = 1e-9;
int n, prev, now;
vector<int> ary;
int main() {
cin >> n;
ary.resize(n);
for (int i = 0; i < (n); ++i) cin >> ary[i];
sort((ary).begin(), (ary).end());
if (ary[ary.size() - 1] != 1)
ary[ary.size() - 1] = 1;
else
ary[ary.size() - 1] = 2;
sort((ary).begin(), (ary).end());
for (int i = 0; i < (n); ++i) cout << ary[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, k, flag = 0, x, i, j;
string st;
cin >> n >> k >> st;
for (i = 0; i < n; i++) {
if (st[i] == 'G') {
break;
}
}
for (j = i + k; j < n; j = j + k) {
if (st[j] == '#') {
break;
}
if (st[j] == 'T') {
cout << "YES";
return 0;
}
}
for (j = i - k; j >= 0; j = j - k) {
if (st[j] == '#') {
cout << "NO";
return 0;
}
if (st[j] == 'T') {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> num, position;
long long p;
int check(long long x) {
int index = 0;
for (int i = 0; i < num.size(); i++) {
if (abs(num[i] - p) > x) return 0;
int flag = 0;
for (int j = index; j < position.size(); j++) {
if (abs(num[i] - position[j]) + abs(position[j] - p) <= x) {
flag = 1;
index = j + 1;
break;
}
}
if (!flag) return 0;
}
return 1;
}
int main() {
int n, k;
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k >> p;
long long t;
for (int i = 0; i < n; i++) {
cin >> t;
num.push_back(t);
}
sort(num.begin(), num.end());
for (int i = 0; i < k; i++) {
cin >> t;
position.push_back(t);
}
sort(position.begin(), position.end());
long long r = max(max(position[k - 1], num[n - 1]), p) * 2;
long long l = 0;
while (r - l > 3) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
long long ans;
for (long long i = l; i <= r; i++) {
if (check(i)) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
int intcmp(const void *f, const void *s) { return (*(int *)f - *(int *)s); }
int gcd(int a, int b) { return ((b == 0) ? a : gcd(b, a % b)); }
int preprocess() { return 0; }
int main() {
int cases;
int i, j, n;
int a, m;
preprocess();
scanf("%d", &n);
scanf("%d", &m);
int ones = 0, minus = 0;
for (i = 0; i < n; ++i) {
scanf("%d", &a);
if (a == 1)
ones++;
else
minus++;
}
while (m--) {
int l, r, cnt;
scanf("%d%d", &l, &r);
cnt = r - l + 1;
if (cnt & 1) {
printf("0\n");
continue;
}
int left = cnt / 2;
if ((left <= ones) && (left <= minus)) {
printf("1\n");
continue;
} else {
printf("0\n");
continue;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int p[6], n, k, ans, total;
void att(int z) {
if (z == k) {
total++;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ans += p[i] > p[j];
return;
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
reverse(p + i, p + j + 1);
att(z + 1);
reverse(p + i, p + j + 1);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
att(0);
cout << fixed << setprecision(12) << 1. * ans / total << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
cout << (n < 2 ? 0 : n - 2) << endl;
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define prec(n) fixed<<setprecision(n)
#define optimize ios::sync_with_stdio(0); cin.tie(0);
#define PI acos(-1.0)
#define RESET(a, b) memset(a, b, sizeof(a))
#define pb push_back
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vv vector<int>
#define ff first
#define ss second
#define sz(v) v.size()
#define all(v) v.begin(),v.end()
int const MOD=(int) 1e9+7;
inline void normal(ll &a) { a %= MOD; (a < 0) && (a += MOD); }
inline ll modMul(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a*b)%MOD; }
inline ll modAdd(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a+b)%MOD; }
inline ll modSub(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); a -= b; normal(a); return a; }
inline ll modPow(ll b, ll p) { ll r = 1; while(p) { if(p&1) r = modMul(r, b); b = modMul(b, b); p >>= 1; } return r; }
inline ll modInverse(ll a) { return modPow(a, MOD-2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
inline ll mod(ll a, ll m){ if(a<0) return m-(abs(a)%m); else if(a<m) return a; else return (a%m); }
const int N = 300007;
const int MAX=20000000;
const int INF=1e9;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
int main()
{
optimize
int t;
cin>>t;
while(t--){
ll n,x;
cin>>n>>x;
ll a[n+2];
for(int i=0;i<n;i++){
cin>>a[i];
}
ll s1=0,s2=0;
ll tmp=0;
for(int i=0;i<n;i++){
tmp+=a[i];
if(tmp%x==0){
s1+=(tmp/x);
tmp=0;
}
}
if(tmp!=0) s1+=(tmp+x-1)/x;
for(int i=0;i<n;i++){
s2+=(a[i]+x-1)/x;
}
cout<<s1<<" "<<s2<<"\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5 + 10;
vector<bool> seive(mxN + 10, true);
void pre() {
seive[0] = seive[1] = false;
for (int i = 2; i * i <= mxN; i++) {
if (seive[i]) {
for (int j = i * i; j <= mxN; j += i) {
seive[j] = false;
}
}
}
return;
}
void solve() {
int n;
cin >> n;
vector<int> a(n, 1);
int use;
int num = n;
while (true) {
if (seive[num] && !seive[num - (n - 1)]) {
use = num - (n - 1);
break;
}
num++;
}
a[n - 1] = use;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << a[j] << " ";
}
cout << "\n";
int rotR = 1;
rotate(a.begin(), a.begin() + a.size() - rotR, a.end());
}
return;
}
int main() {
pre();
int t;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc;
cin >> tc;
for (int i = 0; i < tc; i++) {
int n;
cin >> n;
string str;
cin >> str;
int flag = 1;
for (int i = 0; i < n; i++) {
if (str[i] == '0') {
flag = 0;
if (i < n / 2) {
cout << i + 2 << " " << n << " " << i + 1 << " " << n << endl;
break;
} else {
cout << 1 << " " << i + 1 << " " << 1 << " " << i << endl;
break;
}
}
}
if (flag) {
cout << 1 << " " << n - 1 << " " << 2 << " " << n << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> st[5 * 100005];
long long arr[100005];
void build(long long p, long long l, long long r) {
if (l == r) {
st[p] = {arr[l], arr[l]};
return;
}
long long mid = (l + r) / 2;
build(2 * p, l, mid);
build(2 * p + 1, mid + 1, r);
st[p] = {min(st[2 * p].first, st[2 * p + 1].first),
max(st[2 * p].second, st[2 * p + 1].second)};
}
pair<long long, long long> check(long long p, long long l, long long r,
long long i, long long j) {
if (i > r || j < l) return {1000000007, 0};
if (i <= l and r <= j) return st[p];
pair<long long, long long> x;
long long mid = (l + r) / 2;
x = check(2 * p, l, mid, i, j);
pair<long long, long long> y = check(2 * p + 1, mid + 1, r, i, j);
x.first = min(x.first, y.first);
x.second = max(x.second, y.second);
return x;
}
void solve() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> arr[i];
for (long long i = 0; i < 5 * 100005; i++) st[i] = {1000000007, 0};
build(1, 0, n - 1);
long long sol = 0;
map<long long, vector<pair<long long, long long> > > mp;
for (long long i = 0; i < n; i++) {
long long start = i, end = n - 1;
while (start <= end) {
long long mid = (start + end) / 2;
pair<long long, long long> r = check(1, 0, n - 1, i, mid);
if (r.second - r.first <= k) {
sol = max(sol, mid - i + 1);
mp[mid - i + 1].push_back({i + 1, mid + 1});
start = mid + 1;
} else
end = mid - 1;
}
}
cout << sol << " " << mp[sol].size() << "\n";
for (long long i = 0; i < mp[sol].size(); i++) {
cout << mp[sol][i].first << " " << mp[sol][i].second << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int main() {
cin >> s;
cin >> t;
s[s.size() - 1]++;
reverse(s.begin(), s.end());
for (int i = 0; i < s.size(); i++) {
if (s[i] > 'z') {
s[i] -= 26;
if (i + 1 < s.size())
s[i + 1]++;
else
s += 'a';
}
}
reverse(s.begin(), s.end());
if (s < t)
cout << s << endl;
else
cout << "No such string" << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long sz = 1e5 + 10, mod = 1e9 + 7;
long long fact[sz], inv[sz], ara[sz];
long long fastPow(long long x, long long n, long long MOD) {
long long ret = 1;
while (n) {
if (n & 1) ret = (ret * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ret % MOD;
}
inline long long nCr(long long n, long long r) {
if (n < r) return 0;
long long den = (inv[r] * inv[n - r]) % mod;
return (fact[n] * den) % mod;
}
inline bool isLucky(long long num) {
while (num) {
if (num % 10 != 4 && num % 10 != 7) return 0;
num /= 10;
}
return 1;
}
unordered_map<int, int> ase;
vector<vector<long long> > dp;
vector<long long> way;
long long solve(long long pos, long long rest) {
if (pos == 0) {
return rest == 0;
}
if (rest < 0) return 0;
long long &ret = dp[pos][rest];
if (ret != -1) return ret;
ret = solve(pos - 1, rest);
ret += (way[pos] * solve(pos - 1, rest - 1)) % mod;
if (ret >= mod) ret -= mod;
return ret;
}
int main() {
fact[0] = 1;
for (long long i = 1; i <= sz - 1; ++i) fact[i] = (fact[i - 1] * i) % mod;
inv[sz - 1] = fastPow(fact[sz - 1], mod - 2, mod);
for (long long i = (sz - 1 - 1); i >= 0; --i)
inv[i] = (inv[i + 1] * (i + 1)) % mod;
long long n, k, unlucky = 0;
scanf("%lld", &n), scanf("%lld", &k);
for (long long i = 1; i <= n; ++i) {
scanf("%lld", &ara[i]);
if (isLucky(ara[i]))
++ase[ara[i]];
else
unlucky++;
}
long long totLucky = ase.size();
dp.resize(totLucky + 1);
way.resize(totLucky + 1);
for (long long i = 0; i <= totLucky; i++) {
dp[i].resize(totLucky + 1);
for (long long &val : dp[i]) val = -1;
}
long long idx = 0;
for (pair<int, int> p : ase) way[++idx] = p.second;
dp[totLucky][0] = 1;
for (long long i = 1; i <= totLucky; ++i) {
dp[totLucky][i] = solve(totLucky, i);
}
long long ans = 0;
for (long long i = 0; i <= min(k, totLucky); i++) {
long long rest = k - i, way = nCr(unlucky, rest);
ans += (dp[totLucky][i] * way) % mod;
if (ans >= mod) ans -= mod;
}
cout << ans << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
vector<int> vec;
vector<int> adj[5005];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
vec.push_back(x);
adj[i + 1].push_back(x);
}
for (int i = 0; i < n; i++) {
if (adj[adj[vec[i]][0]][0] == i + 1) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[6000065];
int n, root, r, c, a[6000065], dp[1000005][21], pw[22], st[1000055], l;
int main() {
pw[0] = 1;
for (int i = 1; i <= 20; i++) pw[i] = pw[i - 1] * 2;
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; i++) {
scanf("%s", s + root);
st[i] = root;
l = strlen(s + root);
for (int j = root; j < root + l; j++) a[j] = i - 1;
a[root + l - 1] = i;
root += l + 1;
a[root - 1] = i;
}
dp[n + 1][0] = n + 1;
for (int i = 1; i <= n; i++) {
if (st[i] + c - 1 >= root)
dp[i][0] = n + 1;
else
dp[i][0] = a[st[i] + c - 1] + 1;
}
int tot = 0;
for (int i = 1; i <= 20; i++) {
bool isok = false;
for (int j = 1; j <= n + 1; j++) {
dp[j][i] = dp[dp[j][i - 1]][i - 1];
if (dp[j][i] != n + 1) isok = true;
}
tot++;
if (!isok) break;
}
int ans = 0, ans1 = 0;
for (int i = 1; i <= n; i++) {
int t = i, p = r;
for (int j = tot; j >= 0; j--)
if (p >= pw[j]) {
t = dp[t][j];
p -= pw[j];
}
if (ans < t - i || !ans1) {
ans = t - i;
ans1 = i;
}
}
for (int i = 1; i <= r; i++) {
if (ans1 > n) break;
int t = a[st[ans1] + c - 1];
if (st[ans1] + c - 1 >= root) t = n;
if (t < ans1) break;
for (int j = ans1; j < t; j++) printf("%s ", s + st[j]);
printf("%s\n", s + st[t]);
ans1 = t + 1;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
const long long mod = (long long)1e9 + 7;
using namespace std;
long long calc(long long i1, long long i2, const vector<string> &vc) {
long long c = (vc[i1][i2] - '0') + (vc[i1 + 1][i2] - '0') +
(vc[i1][i2 + 1] - '0') + (vc[i1 + 1][i2 + 1] - '0');
return c;
}
vector<long long> getfour(long long i1, long long i2, vector<string> &vc) {
vector<long long> arr;
arr.push_back(i1);
arr.push_back(i2);
arr.push_back(i1 + 1);
arr.push_back(i2);
arr.push_back(i1);
arr.push_back(i2 + 1);
vc[i1][i2] = vc[i1 + 1][i2] = vc[i1][i2 + 1] = '0';
return arr;
}
vector<long long> getone(long long i1, long long i2, vector<string> &vc) {
vector<long long> arr1, arr2;
for (long long ii1 = i1; ii1 <= i1 + 1; ii1++) {
for (long long ii2 = i2; ii2 <= i2 + 1; ii2++) {
if (vc[ii1][ii2] == '1') {
arr2.push_back(ii1);
arr2.push_back(ii2);
vc[ii1][ii2] = '0';
} else if ((long long)arr1.size() < 4) {
arr1.push_back(ii1);
arr1.push_back(ii2);
vc[ii1][ii2] = '1';
}
}
}
vector<long long> arr;
for (auto i : arr1) arr.push_back(i);
for (auto i : arr2) arr.push_back(i);
return arr;
}
vector<long long> gettwo(long long i1, long long i2, vector<string> &vc) {
vector<long long> arr1, arr2;
for (long long ii1 = i1; ii1 <= i1 + 1; ii1++) {
for (long long ii2 = i2; ii2 <= i2 + 1; ii2++) {
if (vc[ii1][ii2] == '1' and (long long) arr2.size() == 0) {
arr2.push_back(ii1);
arr2.push_back(ii2);
vc[ii1][ii2] = '0';
} else if (vc[ii1][ii2] == '0' and (long long) arr1.size() < 4) {
arr1.push_back(ii1);
arr1.push_back(ii2);
vc[ii1][ii2] = '1';
}
}
}
vector<long long> arr;
for (auto i : arr1) arr.push_back(i);
for (auto i : arr2) arr.push_back(i);
return arr;
}
vector<long long> getthree(long long i1, long long i2, vector<string> &vc) {
vector<long long> arr;
for (long long ii1 = i1; ii1 <= i1 + 1; ii1++) {
for (long long ii2 = i2; ii2 <= i2 + 1; ii2++) {
if (vc[ii1][ii2] == '1') {
arr.push_back(ii1);
arr.push_back(ii2);
vc[ii1][ii2] = '0';
}
}
}
return arr;
}
vector<vector<long long>> getAns(long long n, long long m, vector<string> &vc) {
vector<vector<long long>> ans;
for (long long i = 0; i < n - 1; i++) {
for (long long j = 0; j < m - 2; j++) {
if (vc[i][j] == '0' and vc[i + 1][j] == '0') continue;
if (vc[i][j] == '1' and vc[i + 1][j] == '1') {
vector<long long> temp;
temp.push_back(i);
temp.push_back(j);
temp.push_back(i + 1);
temp.push_back(j);
temp.push_back(i);
temp.push_back(j + 1);
vc[i][j] = vc[i + 1][j] = '0';
vc[i][j + 1] == '0' ? vc[i][j + 1] = '1' : vc[i][j + 1] = '0';
ans.push_back(temp);
} else if (vc[i][j] == '1' and vc[i + 1][j] == '0') {
vector<long long> temp;
temp.push_back(i);
temp.push_back(j);
temp.push_back(i);
temp.push_back(j + 1);
temp.push_back(i + 1);
temp.push_back(j + 1);
vc[i][j] = '0';
vc[i][j + 1] == '0' ? vc[i][j + 1] = '1' : vc[i][j + 1] = '0';
vc[i + 1][j + 1] == '0' ? vc[i + 1][j + 1] = '1'
: vc[i + 1][j + 1] = '0';
ans.push_back(temp);
} else if (vc[i][j] == '0' and vc[i + 1][j] == '1') {
vector<long long> temp;
temp.push_back(i + 1);
temp.push_back(j);
temp.push_back(i);
temp.push_back(j + 1);
temp.push_back(i + 1);
temp.push_back(j + 1);
vc[i + 1][j] = '0';
vc[i][j + 1] == '0' ? vc[i][j + 1] = '1' : vc[i][j + 1] = '0';
vc[i + 1][j + 1] == '0' ? vc[i + 1][j + 1] = '1'
: vc[i + 1][j + 1] = '0';
ans.push_back(temp);
}
}
}
for (long long i = 0; i < n - 1; i++) {
long long j = m - 2;
while (calc(i, j, vc) != 0) {
long long c = calc(i, j, vc);
if (c == 4) {
ans.push_back(getfour(i, j, vc));
} else if (c == 3) {
ans.push_back(getthree(i, j, vc));
} else if (c == 2) {
ans.push_back(gettwo(i, j, vc));
} else {
ans.push_back(getone(i, j, vc));
}
}
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<string> vc(n);
for (long long i = 0; i < n; i++) {
cin >> vc[i];
}
if (n > m) {
string s;
for (long long i = 0; i < n; i++) s.push_back('0');
vector<string> arr(m, s);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
arr[m - 1 - j][i] = vc[i][j];
}
}
vector<vector<long long>> ans = getAns(m, n, arr);
vector<vector<long long>> ans2((long long)ans.size(),
vector<long long>(6, 0));
for (long long i = 0; i < (long long)ans.size(); i++) {
for (long long j = 0; j < (long long)ans[i].size(); j += 2) {
long long I = ans[i][j], J = ans[i][j + 1];
ans2[i][j] = J;
ans2[i][j + 1] = m - 1 - I;
}
}
cout << ans2.size() << "\n";
for (long long i = 0; i < (long long)ans2.size(); i++) {
for (auto it : ans2[i]) cout << it + 1 << ' ';
cout << "\n";
}
continue;
}
vector<vector<long long>> ans = getAns(n, m, vc);
cout << ans.size() << "\n";
for (long long i = 0; i < (long long)ans.size(); i++) {
for (auto it : ans[i]) {
cout << it + 1 << ' ';
}
cout << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int Max = 1e5 + 10;
using namespace std;
struct edge {
int to;
int next;
};
struct heap {
priority_queue<int, vector<int>, greater<int> > add, del;
int getMin() {
while (!add.empty() && !del.empty() && add.top() == del.top()) {
add.pop();
del.pop();
}
return add.top();
}
void insert(int x) { add.push(x); }
void remove(int x) {
if (add.top() == x) {
add.pop();
} else {
del.push(x);
}
}
bool empty() { return add.size() - del.size() > 0; }
} point[Max << 1];
vector<int> e[Max], g[Max << 1];
int tree[Max << 3], val[Max << 1];
int head[Max], head1[Max << 1], dfn[Max << 1], rDfn[Max << 1], low[Max << 1],
son[Max << 1], hTop[Max << 1], size[Max << 1], fa[Max << 1], dep[Max << 1];
int s[Max];
int cnt = 0, cnt1 = 0, timing = 0, top = -1, all;
int n, m, q;
void dfs(int u) {
son[u] = 0;
size[u] = 1;
for (int v : g[u]) {
if (!dep[v]) {
dep[v] = dep[u] + 1;
fa[v] = u;
dfs(v);
size[u] += size[v];
if (size[v] > size[son[u]]) {
son[u] = v;
}
}
}
}
void linkCut(int u, int top) {
hTop[u] = top;
dfn[u] = ++timing;
rDfn[timing] = u;
if (!son[u]) {
return;
}
linkCut(son[u], top);
for (int v : g[u]) {
if (v != son[u] && v != fa[u]) {
linkCut(v, v);
}
}
}
void tarjan(int u) {
dfn[u] = low[u] = ++timing;
s[++top] = u;
for (int v : e[u]) {
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
if (dfn[u] == low[v]) {
++all;
for (int t = 0; t != v; top--) {
t = s[top];
g[all].push_back(t);
g[t].push_back(all);
}
g[all].push_back(u);
g[u].push_back(all);
}
} else {
low[u] = min(low[u], dfn[v]);
}
}
}
void pushUp(int k) { tree[k] = min(tree[k << 1], tree[k << 1 | 1]); }
void build(int k, int l, int r) {
if (l == r) {
tree[k] = val[rDfn[l]];
return;
}
int mid = (l + r) >> 1;
build(k << 1, l, mid), build(k << 1 | 1, mid + 1, r);
pushUp(k);
}
void update(int k, int l, int r, int u, int x) {
if (l == r) {
tree[k] = x;
return;
}
int mid = (l + r) >> 1;
if (u <= mid)
update(k << 1, l, mid, u, x);
else
update(k << 1 | 1, mid + 1, r, u, x);
pushUp(k);
}
int query(int k, int l, int r, int ql, int qr) {
int ans1 = 0x7fffffff, ans2 = 0x7fffffff;
if (ql <= l && r <= qr) {
return tree[k];
}
int mid = (l + r) >> 1;
if (ql <= mid) {
ans1 = min(ans1, query(k << 1, l, mid, ql, qr));
}
if (qr > mid) {
ans2 = min(ans2, query(k << 1 | 1, mid + 1, r, ql, qr));
}
return min(ans1, ans2);
}
void modify(int u, int x) {
int mn;
update(1, 1, all, dfn[u], x);
if (fa[u]) {
point[fa[u]].remove(val[u]);
point[fa[u]].insert(x);
mn = point[fa[u]].getMin();
if (val[fa[u]] != mn) {
val[fa[u]] = mn;
update(1, 1, all, dfn[fa[u]], val[fa[u]]);
}
}
val[u] = x;
}
int solve(int u, int v) {
int ans = 0x7fffffff;
while (hTop[u] != hTop[v]) {
if (dep[hTop[u]] < dep[hTop[v]]) {
swap(u, v);
}
ans = min(ans, query(1, 1, all, dfn[hTop[u]], dfn[u]));
u = fa[hTop[u]];
}
if (dep[u] > dep[v]) {
swap(u, v);
}
ans = min(ans, query(1, 1, all, dfn[u], dfn[v]));
if (u > n) {
ans = min(ans, val[fa[u]]);
}
return ans;
}
int main() {
int u, v, k, x, y;
char op[2];
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
all = n;
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i);
top = -1;
}
}
timing = 0;
dep[1] = 1;
dfs(1);
linkCut(1, 1);
for (int i = 1; i <= n; i++) {
if (fa[i]) {
point[fa[i]].insert(val[i]);
}
}
for (int i = n + 1; i <= all; i++) {
val[i] = point[i].getMin();
}
build(1, 1, all);
for (int i = 1; i <= q; i++) {
scanf("%s", op);
if (op[0] == 'C') {
scanf("%d%d", &u, &k);
modify(u, k);
} else {
scanf("%d%d", &u, &v);
printf("%d\n", solve(u, v));
}
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<int> a(n), pre(n), mxpsuf(n, 0);
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
(i - 1) > -1 ? pre[i] = pre[i - 1] + a[i] : pre[i] = a[i];
mx = max(mx, pre[i]);
}
if (mx > d) {
cout << -1 << endl;
return 0;
}
for (int i = n - 1; i >= 0; i--) {
mxpsuf[i] = (i + 1 < n) ? max(pre[i], mxpsuf[i + 1]) : pre[i];
}
int ans = 0;
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
if (pre[i] + cnt >= 0) {
continue;
} else {
int inc = d - (mxpsuf[i - 1] + cnt);
if (inc + pre[i] + cnt >= 0) {
cnt += inc;
ans++;
} else {
cout << -1 << endl;
return 0;
}
}
}
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
struct point {
ll x, y;
};
struct segment {
point p1, p2;
};
int sign(ll x) { return x < 0 ? -1 : 1; }
bool intersect(const segment& s1, const segment& s2, pair<ll, ll>* p) {
ll x1 = s1.p1.x, x2 = s1.p2.x, x3 = s2.p1.x, x4 = s2.p2.x;
ll y1 = s1.p1.y, y2 = s1.p2.y, y3 = s2.p1.y, y4 = s2.p2.y;
ll den = (x4 - x3) * (y1 - y2) - (x1 - x2) * (y4 - y3);
if (den == 0) return false;
ll num1 = (y3 - y4) * (x1 - x3) + (x4 - x3) * (y1 - y3);
if ((num1 > 0 && den < 0) || (num1 < 0 && den > 0) || abs(num1) > abs(den))
return false;
ll num2 = (y1 - y2) * (x1 - x3) + (x2 - x1) * (y1 - y3);
if ((num2 > 0 && den < 0) || (num2 < 0 && den > 0) || abs(num2) > abs(den))
return false;
if ((x1 * den + num1 * (x2 - x1)) % den != 0) return false;
if ((y1 * den + num1 * (y2 - y1)) % den != 0) return false;
*p = {(x1 * den + num1 * (x2 - x1)) / den,
(y1 * den + num1 * (y2 - y1)) / den};
return true;
}
int main() {
int n;
cin >> n;
vector<segment> v(n);
for (auto& e : v) cin >> e.p1.x >> e.p1.y >> e.p2.x >> e.p2.y;
ll ans = 0;
set<pair<ll, ll>> intersections;
for (int i = 0; i < n; ++i) {
set<pair<ll, ll>> tmp_intersections;
for (int j = 0; j < n; ++j) {
if (i == j) continue;
pair<ll, ll> intersection;
if (intersect(v[i], v[j], &intersection)) {
intersections.insert(intersection);
tmp_intersections.insert(intersection);
}
}
ll xdiff = abs(v[i].p1.x - v[i].p2.x);
ll ydiff = abs(v[i].p1.y - v[i].p2.y);
ans += gcd(xdiff, ydiff) + 1 - tmp_intersections.size();
}
ans += intersections.size();
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const int mod = 998244353;
const int inf = 1 << 30;
const int maxn = 300000 + 5;
int n, a[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
vector<int> stk = {a[1]};
for (int i = 2; i <= n; i++) {
while (stk.size() > 1 && stk.back() < a[i]) {
stk.pop_back();
}
if (stk.size() == 1) {
if (a[i] < stk.back()) {
stk.push_back(a[i]);
}
} else {
stk.push_back(a[i]);
}
}
puts(stk.size() <= 1 ? "YES" : "NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
map<string, string> res;
int N;
void scan() {
string a;
int pts;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> a >> pts;
mp[a] = max(mp[a], pts);
}
}
void solve() {
N = mp.size();
for (map<string, int>::iterator it = mp.begin(); it != mp.end(); ++it) {
int better = 0, notworse = 0;
for (map<string, int>::iterator jt = mp.begin(); jt != mp.end(); ++jt)
if (jt->second > it->second)
++better;
else
notworse++;
if (better * 100 <= N)
res[it->first] = "pro";
else if (better * 100 <= N * 10)
res[it->first] = "hardcore";
else if (better * 100 <= N * 20)
res[it->first] = "average";
else if (better * 100 <= N * 50)
res[it->first] = "random";
else
res[it->first] = "noob";
}
cout << res.size() << endl;
for (map<string, string>::iterator it = res.begin(); it != res.end(); ++it)
cout << it->first << " " << it->second << endl;
}
int main() {
scan();
solve();
}
| 6 |
Subsets and Splits