solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
map<int, int> mp;
struct node {
int ch[2], pri, mx, mi;
pair<int, int> val;
long long sum, mn;
} t[100005];
int sz = 0;
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int newnode(int T, int S) {
++sz;
t[sz].ch[0] = t[sz].ch[1] = 0;
t[sz].val = make_pair(T, S);
t[sz].pri = rand();
t[sz].mx = t[sz].mi = sz;
t[sz].sum = 0;
return sz;
}
long long calc(int x, int y) {
return 1LL * t[x].val.second * (t[y].val.first - t[x].val.first);
}
void update(int x) {
if (t[x].ch[1])
t[x].mx = t[t[x].ch[1]].mx;
else
t[x].mx = x;
if (t[x].ch[0])
t[x].mi = t[t[x].ch[0]].mi;
else
t[x].mi = x;
t[x].mn = 0;
t[x].mn = min(t[x].mn, t[t[x].ch[0]].mn);
t[x].sum = t[t[x].ch[0]].sum;
if (t[x].ch[0]) t[x].sum += calc(t[t[x].ch[0]].mx, x);
t[x].mn = min(t[x].mn, t[x].sum);
if (t[x].ch[1]) t[x].sum += calc(x, t[t[x].ch[1]].mi);
t[x].mn = min(t[x].mn, t[x].sum + t[t[x].ch[1]].mn);
t[x].sum += t[t[x].ch[1]].sum;
t[x].mn = min(t[x].mn, t[x].sum);
}
int merge(int x, int y) {
if (!x || !y) return x ^ y;
if (t[x].pri > t[y].pri) {
t[x].ch[1] = merge(t[x].ch[1], y);
update(x);
return x;
} else {
t[y].ch[0] = merge(x, t[y].ch[0]);
update(y);
return y;
}
}
void split(int now, pair<int, int> k, int &x, int &y) {
if (!now)
x = y = 0;
else {
if (t[now].val <= k) {
x = now;
split(t[x].ch[1], k, t[x].ch[1], y);
} else {
y = now;
split(t[y].ch[0], k, x, t[y].ch[0]);
}
update(now);
}
}
void insert(int &root, int T, int S) {
int x, y;
split(root, make_pair(T, S), x, y);
root = merge(merge(x, newnode(T, S)), y);
}
void destroy(int &root, int T, int S) {
int x, y, z;
split(root, make_pair(T, S), y, z);
split(y, make_pair(T, S - 1), x, y);
root = merge(x, z);
}
double find(int &root, int l, int r, long long v) {
if (!v) return l;
int x, y, z;
split(root, make_pair(r, inf), y, z);
split(y, make_pair(l - 1, inf), x, y);
if (!y) {
root = merge(merge(x, y), z);
return -1;
}
int now = y;
while (now) {
long long vv = v;
if (vv + t[t[now].ch[0]].mn <= 0 || vv + t[t[now].ch[0]].sum <= 0)
now = t[now].ch[0];
else {
vv += t[t[now].ch[0]].sum;
if (t[now].ch[0]) {
if (vv + calc(t[t[now].ch[0]].mx, now) <= 0)
break;
else
vv += calc(t[t[now].ch[0]].mx, now);
}
if (t[now].ch[1]) {
if (vv + calc(now, t[t[now].ch[1]].mi) <= 0)
break;
else
vv += calc(now, t[t[now].ch[1]].mi);
}
v += t[now].sum - t[t[now].ch[1]].sum;
now = t[now].ch[1];
}
}
if (!now) {
root = merge(merge(x, y), z);
return -1;
}
int p = t[t[now].ch[0]].mx;
if (p) {
v += t[t[now].ch[0]].sum;
long long tmp = calc(p, now);
if (v + tmp <= 0) {
root = merge(merge(x, y), z);
return t[p].val.first - v * 1.0 / t[p].val.second;
}
v += tmp;
}
root = merge(merge(x, y), z);
return t[now].val.first - v * 1.0 / t[now].val.second;
}
int main() {
srand((unsigned)time(NULL));
int q = read(), root = 0, x, y, z;
for (int i = 1; i <= q; i++) {
int opt = read();
if (opt == 1) {
int T = read(), S = read();
insert(root, T, S);
mp[T] = S;
} else if (opt == 2) {
int T = read();
destroy(root, T, mp[T]);
} else {
int l = read(), r = read(), v = read();
insert(root, r, inf);
printf("%.13f\n", find(root, l, r, v));
destroy(root, r, inf);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = int(1e5);
int K, B, N;
int as[MAX_N];
void init() {
scanf("%d%d%d", &K, &B, &N);
for (int i = 0; i < N; ++i) {
scanf("%d", as + i);
}
}
long long solve() {
long long ans = 0;
long long countZero = 0;
for (int i = 0, cnt = 0; i < N; ++i) {
if (as[i]) {
cnt = 0;
} else {
++cnt;
}
countZero += cnt;
}
if (B == 0) {
return countZero;
}
map<long long, int> dict;
++dict[0];
int acc = 0;
for (int i = 0; i < N; ++i) {
acc = (acc + as[i]) % (K - 1);
int s = (acc - B + (K - 1)) % (K - 1);
ans += dict[s];
++dict[acc];
}
if (B == K - 1) {
ans -= countZero;
}
return ans;
}
int main() {
init();
printf("%I64d\n", solve());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double typedef ld;
unsigned int typedef ui;
long long int typedef li;
pair<int, int> typedef pii;
pair<li, li> typedef pli;
vector<vector<int>> typedef graph;
unsigned long long int typedef ull;
const ld PI = 3.14159265359;
const int mod = 1000000007;
const li inf = 1000000000000000001ll;
inline int power(li _a, int _n) {
li _c = 1;
while (_n > 0) {
if (_n % 2) _c = _c * _a % mod;
_a = _a * _a % mod;
_n /= 2;
}
return _c;
}
inline int geom(li _a, int _n) {
if (_a == 1) return _n + 1;
return ((li)power(_a, _n + 1) - 1) * power((_a - 1), mod - 2) % mod;
}
pli _r;
li bigmod(li _a, li _b, li _m) {
if (_a == 0) return 0;
if (_a % 2 == 1) return (_b + 2 * bigmod(_a / 2, _b, _m)) % _m;
return 2 * bigmod(_a / 2, _b, _m) % _m;
}
void euklid(li _a, li _b) {
if (_b == 1) {
_r = make_pair(1, -_a + 1);
return;
}
euklid(_b, _a % _b);
_r = make_pair(_r.second, _r.first - _r.second * (_a / _b));
}
li kinez(li _x, li _a, li _y, li _b) {
if (_x == _y) return _x;
if (_a > _b) {
swap(_a, _b);
swap(_x, _y);
}
euklid(_b, _a);
(_r.first *= (_x - _y)) %= (_a * _b);
return (bigmod(_b, _r.first, _a * _b) + _y) % (_a * _b);
}
inline li sum(int _n) { return ((li)_n * (_n + 1)) / 2; }
inline li kv(int _n) { return ((li)_n * (_n + 1) * (2 * _n + 1)) / 6; }
char s[1000007];
int p[1000007];
void gen_p(int n) {
int poz = 0;
for (int(i) = (1); (i) < (n); (i)++) {
while (s[i] != s[poz]) {
if (poz == 0) goto lolo;
poz = p[poz];
}
poz++;
lolo:
p[i + 1] = poz;
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", &s[0]);
gen_p(n);
for (int(i) = (1); (i) <= n; (i)++) {
int duz = i - p[i];
int ost = i % duz;
int broj = i / duz;
putchar(
((ost == 0 && broj / k >= broj % k) || (ost > 0 && broj / k > broj % k))
? '1'
: '0');
}
}
| 7 |
#include <bits/stdc++.h>
long long pos[200050];
long long t_pos[200050];
long long t_cnt[200050];
long long dis[200050];
long long dis_sum[200050];
long long cnt[200050];
int N, M;
int st, rpcnt;
void input() {
int i, t;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%lld", &t_pos[i]);
scanf("%d", &M);
for (i = 1; i <= M; i++) {
scanf("%d", &t);
t_cnt[t]++;
}
if (t_cnt[1] < t_cnt[N]) {
for (i = 1; i <= N; i++) {
cnt[i] = t_cnt[N + 1 - i];
pos[i] = t_pos[N] + 1 - t_pos[N + 1 - i];
}
} else {
for (i = 1; i <= N; i++) {
cnt[i] = t_cnt[i];
pos[i] = t_pos[i];
}
}
for (i = 1; i <= N - 1; i++) {
dis[i] = pos[i + 1] - pos[i];
dis_sum[i] = dis_sum[i - 1] + dis[i];
}
return;
}
void get_ans1() {
long long ANS = (2 * cnt[N] - 1) * dis_sum[N - 1];
int i, k1 = -1, k2 = -1;
for (i = 2; i <= N - 1; i++) cnt[i] -= (2 * cnt[N] - 1);
for (i = 2; i <= N - 1; i++) {
if (cnt[i] == 0) {
k1 = i - 1;
break;
}
if (cnt[i] == 2) {
k2 = i;
break;
}
}
for (i = N - 1; i >= 2; i--) {
if (cnt[i] == 0) {
k2 = i + 1;
break;
}
if (cnt[i] == 2) {
k1 = i;
break;
}
}
if (k1 == -1 && k2 == -1) {
for (i = 2; i < N; i++)
if (dis[i] != dis[1]) break;
if (i != N)
printf("-1");
else
printf("%lld", ANS + dis_sum[N - 2]);
return;
}
printf("%lld", ANS + dis_sum[k1 - 1] + dis_sum[N - 1] - dis_sum[k2 - 1]);
return;
}
void get_ans2() {
int i, k1 = -1, k2 = -1;
long long ANS = 2 * cnt[N] * dis_sum[N - 1];
for (i = 2; i <= N - 1; i++) cnt[i] -= cnt[N] * 2;
for (i = 2; i <= N - 1; i++) {
if (cnt[i] == 2) continue;
if (cnt[i] == 1 && k1 == -1) k1 = i - 1;
if (cnt[i] == 0) {
if (k1 == -1) k1 = i - 1;
if (k2 == -1) k2 = i - 1;
break;
}
}
if (i == N) {
if (k1 == -1) k1 = N - 1;
if (k2 == -1) k2 = N - 1;
}
ANS += dis_sum[k1 - 1] + dis_sum[k2 - 1];
printf("%lld", ANS);
return;
}
void get_ans3() {
int i, k1 = -1, k2 = -1;
for (i = 2; i <= N - 1; i++) {
if (cnt[i] == 1 && k1 == -1) {
k1 = i;
continue;
}
if (cnt[i] == 0 && k1 != -1) {
k2 = i - 1;
break;
}
}
if (k2 == -1) k2 = N - 1;
printf("%lld", dis_sum[k2 - 1] - dis_sum[k1 - 1]);
return;
}
int main() {
input();
if (cnt[1] == cnt[N] && cnt[1] != 0)
get_ans1();
else if (cnt[1] != cnt[N])
get_ans2();
else
get_ans3();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int maxdep = 20;
int par[maxdep][maxn], dep[maxn], n;
vector<int> ID[maxdep][maxn], cit[maxn];
vector<int> G[maxn];
void init() {
for (int i = 0; i < maxn; i++) {
G[i].clear();
cit[i].clear();
for (int j = 0; j < maxdep; j++) {
ID[j][i].clear();
}
}
memset(par, -1, sizeof(par));
}
void update(vector<int> &v1, vector<int> &v2) {
for (int x : v2) {
v1.push_back(x);
}
sort(v1.begin(), v1.end());
v1.erase(unique(v1.begin(), v1.end()), v1.end());
while (v1.size() > 10) {
v1.pop_back();
}
}
void dfs(int u, int father) {
par[0][u] = father;
dep[u] = dep[father] + 1;
for (int i = u; i <= u; i++) {
update(ID[0][i], cit[par[0][i]]);
update(ID[0][i], cit[i]);
for (int j = 0; j + 1 < maxdep; j++) {
if (~par[j][i]) {
par[j + 1][i] = par[j][par[j][i]];
update(ID[j + 1][i], cit[i]);
update(ID[j + 1][i], ID[j][i]);
update(ID[j + 1][i], ID[j][par[j][i]]);
} else {
par[j + 1][i] = -1;
}
}
}
for (int v : G[u]) {
if (v != father) {
dfs(v, u);
}
}
}
int lca(int u, int v) {
if (dep[u] > dep[v]) {
swap(u, v);
}
for (int k = 0; k < maxdep; k++) {
if ((dep[v] - dep[u]) >> k & 1) {
v = par[k][v];
}
}
if (u == v) {
return u;
}
for (int i = maxdep - 1; i >= 0; i--) {
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
}
return par[0][u];
}
int anc;
vector<int> solve(int u, int v) {
vector<int> res;
if (u == v) {
update(res, cit[u]);
}
for (int i = maxdep - 1; i >= 0; i--) {
if (~par[i][u] && dep[par[i][u]] >= dep[anc]) {
update(res, ID[i][u]);
u = par[i][u];
}
}
for (int i = maxdep - 1; i >= 0; i--) {
if (~par[i][v] && dep[par[i][v]] >= dep[anc]) {
update(res, ID[i][v]);
v = par[i][v];
}
}
vector<int> emp;
update(res, emp);
return res;
}
int main() {
int m, q;
while (~scanf("%d%d%d", &n, &m, &q)) {
init();
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 0; i < m; i++) {
int c;
scanf("%d", &c);
if (cit[c].size() < 10) {
cit[c].push_back(i + 1);
ID[0][c].push_back(i + 1);
}
}
dfs(1, 0);
while (q--) {
int u, v, a;
scanf("%d%d%d", &u, &v, &a);
anc = lca(u, v);
auto res = solve(u, v);
int tot = min((int)res.size(), a);
printf("%d%c", tot, " \n"[!tot]);
for (int i = 0; i < min((int)res.size(), a); i++) {
printf("%d%c", res[i], " \n"[i + 1 == min((int)res.size(), a)]);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, x, y, a[10000], s;
int main() {
cin >> n >> k >> a[0];
for (i = 1; i < n; ++i) {
cin >> a[i];
if (a[i] + a[i - 1] < k) {
s += k - (a[i] + a[i - 1]);
a[i] += k - (a[i] + a[i - 1]);
}
}
cout << s << '\n';
for (i = 0; i < n; ++i) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
string s, t;
int arr[N];
int n;
int helper(int x) {
int cur_sum = 0;
int max_sum = 0;
for (int i = 1; i <= n; i++) {
cur_sum += x * arr[i];
max_sum = max(max_sum, cur_sum);
if (cur_sum < 0) {
cur_sum = 0;
}
}
return max_sum;
}
int main() {
cin >> n >> s >> t;
int sum = 0;
for (int i = 1; i <= n; i++) {
if (s[i - 1] != t[i - 1]) {
if (s[i - 1] == '1') {
arr[i] = -1;
} else {
arr[i] = 1;
}
}
sum += arr[i];
}
if (sum != 0) {
cout << -1;
return 0;
} else {
int res = max(helper(1), helper(-1));
cout << res;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
point(int x = 0, int y = 0) : x(x), y(y) {}
point operator-(const point a) const { return point(x - a.x, y - a.y); }
point operator+(const point a) const { return point(x + a.x, y + a.y); }
int operator*(const point a) const { return x * a.y - y * a.x; }
} a[15], p[15];
bool ins(point d, point e, point f, point g) {
int sgn;
if ((d - f) * (e - f) > 0)
sgn = 1;
else
sgn = -1;
if (sgn * ((f - e) * (g - e)) < 0) return false;
if (sgn * ((e - g) * (d - g)) < 0) return false;
if (sgn * ((g - d) * (f - d)) < 0) return false;
return true;
}
int r, b, pa[15];
bool ans, vis[15];
bool brute(int i) {
if (i == b) return true;
for (int j = 0, k; j < b; j++) {
if (vis[j]) continue;
for (k = 0; k < i; k++) {
if (ins(a[k], p[pa[k]], a[i], p[j])) break;
}
if (k < i) continue;
vis[j] = 1;
pa[i] = j;
if (brute(i + 1)) return true;
vis[j] = 0;
}
return false;
}
int main() {
scanf("%d%d", &r, &b);
for (int i = 0; i < r; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 0; i < b; i++) scanf("%d%d", &p[i].x, &p[i].y);
if (r != b)
ans = 0;
else
ans = brute(0);
if (ans)
puts("YES");
else
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using maxHeap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
using minHeap = priority_queue<T, vector<T>, greater<T>>;
template <typename Iter>
ostream& _out(ostream& s, Iter b, Iter e) {
s << "[";
for (auto it = b; it != e; it++) s << (it == b ? "" : " ") << *it;
s << "]";
return s;
}
template <typename A, typename B>
ostream& operator<<(ostream& s, const pair<A, B>& p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, const vector<T>& c) {
return _out(s, begin(c), end(c));
}
bool debug = 0;
template <typename T>
void DEBUG(const T& x) {
if (debug) cerr << x;
}
template <typename T, typename... Args>
void DEBUG(const T& head, const Args&... tail) {
if (debug) {
cerr << head;
DEBUG(tail...);
}
}
template <typename T>
struct Point {
static constexpr long double EPS = 1e-8;
T x, y;
Point(T _ = 0, T __ = 0) : x(_), y(__) {}
template <typename T2>
Point(const Point<T2>& a) : x(a.x), y(a.y) {}
inline long double theta() const {
return atan2((long double)y, (long double)x);
}
inline long double dis() const {
return hypot((long double)x, (long double)y);
}
inline long double dis(const Point& o) const {
return hypot((long double)(x - o.x), (long double)(y - o.y));
}
Point operator-(const Point& o) const { return Point(x - o.x, y - o.y); }
Point operator-=(const Point& o) {
x -= o.x, y -= o.y;
return *this;
}
Point operator+(const Point& o) const { return Point(x + o.x, y + o.y); }
Point operator+=(const Point& o) {
x += o.x, y += o.y;
return *this;
}
Point operator*(const T& k) const { return Point(x * k, y * k); }
Point operator*=(const T& k) {
x *= k, y *= k;
return *this;
}
Point operator/(const T& k) const { return Point(x / k, y / k); }
Point operator/=(const T& k) {
x /= k, y /= k;
return *this;
}
Point operator-() const { return Point(-x, -y); }
Point rot90() const { return Point(-y, x); }
bool equal(const Point& o, true_type) const {
return fabs(x - o.x) < EPS and fabs(y - o.y) < EPS;
}
bool equal(const Point& o, false_type) const {
return tie(x, y) == tie(o.x, o.y);
}
bool operator==(const Point& o) const {
return equal(o, is_floating_point<T>());
}
bool operator!=(const Point& o) const { return !(*this == o); }
bool operator<(const Point& o) const { return theta() < o.theta(); }
friend inline T cross(const Point& a, const Point& b) {
return a.x * b.y - b.x * a.y;
}
friend inline T dot(const Point& a, const Point& b) {
return a.x * b.x + a.y * b.y;
}
friend ostream& operator<<(ostream& ss, const Point& o) {
ss << "(" << o.x << ", " << o.y << ")";
return ss;
}
};
template <typename T>
class ConvexHull_2D {
private:
vector<Point<T>> dots;
struct myhash {
uint64_t operator()(const Point<T>& a) const {
uint64_t xx = 0, yy = 0;
memcpy(&xx, &a.x, sizeof(a.x));
memcpy(&yy, &a.y, sizeof(a.y));
uint64_t ret = xx * 17 + yy * 31;
ret = (ret ^ (ret >> 16)) * 0x9E3779B1;
ret = (ret ^ (ret >> 13)) * 0xC2B2AE35;
ret = ret ^ xx;
return (ret ^ (ret << 3)) * yy;
}
};
unordered_set<Point<T>, myhash> in_hull;
public:
inline void init() {
in_hull.clear();
dots.clear();
}
void insert(const Point<T>& x) { dots.push_back(x); }
void solve() {
sort(begin(dots), end(dots), [](const Point<T>& a, const Point<T>& b) {
return tie(a.x, a.y) < tie(b.x, b.y);
});
vector<Point<T>> stk((int)((dots).size()) << 1);
int top = 0;
for (auto p : dots) {
while (top >= 2 and
cross(p - stk[top - 2], stk[top - 1] - stk[top - 2]) <= 0)
top--;
stk[top++] = p;
}
for (int i = (int)((dots).size()) - 2, t = top + 1; i >= 0; i--) {
while (top >= t and
cross(dots[i] - stk[top - 2], stk[top - 1] - stk[top - 2]) <= 0)
top--;
stk[top++] = dots[i];
}
stk.resize(top - 1);
swap(stk, dots);
for (auto i : stk) in_hull.insert(i);
}
vector<Point<T>> get() { return dots; }
inline bool in_it(const Point<T>& x) {
return in_hull.find(x) != in_hull.end();
}
};
using PTL = Point<int64_t>;
ConvexHull_2D<int64_t> cv;
template <typename T>
bool check(const vector<T>&, const vector<T>&);
vector<int64_t> mcp(vector<int64_t> s) {
int n = (int)((s).size());
for (int i = 0; i < n; i++) s.push_back(s[i]);
int i = 0, j = 1;
while (i < n && j < n) {
int k = 0;
while (k < n && s[i + k] == s[j + k]) k++;
if (s[i + k] <= s[j + k])
j += k + 1;
else
i += k + 1;
if (i == j) j++;
}
int ans = i < n ? i : j;
return vector<int64_t>(next(s.begin(), ans), next(s.begin(), ans + n));
}
int main(int argc, char* argv[]) {
if (argc > 1 and string(argv[1]) == "-D") debug = 1;
if (!debug) {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
auto kill = []() {
cout << "NO" << '\n';
exit(0);
};
int n, m;
cin >> n >> m;
cv.init();
for (int i = 0; i < n; i++) {
int64_t x, y;
cin >> x >> y;
cv.insert(PTL(x, y));
}
cv.solve();
vector<PTL> one = cv.get();
cv.init();
for (int i = 0; i < m; i++) {
int64_t x, y;
cin >> x >> y;
cv.insert(PTL(x, y));
}
cv.solve();
vector<PTL> two = cv.get();
if (debug)
cerr << __PRETTY_FUNCTION__ << ":" << 221 << " - " << ("one") << "="
<< (one) << '\n';
if (debug)
cerr << __PRETTY_FUNCTION__ << ":" << 222 << " - " << ("two") << "="
<< (two) << '\n';
if ((int)((one).size()) != (int)((two).size())) kill();
vector<int64_t> d1, d2;
for (int i = 1; i < (int)((one).size()); i++)
d1.push_back(dot(one[i] - one[i - 1], one[i] - one[i - 1]));
d1.push_back(dot(one.back() - one[0], one.back() - one[0]));
for (int i = 1; i < (int)((two).size()); i++)
d2.push_back(dot(two[i] - two[i - 1], two[i] - two[i - 1]));
d2.push_back(dot(two.back() - two[0], two.back() - two[0]));
if (debug)
cerr << __PRETTY_FUNCTION__ << ":" << 231 << " - " << ("d1") << "=" << (d1)
<< '\n';
if (debug)
cerr << __PRETTY_FUNCTION__ << ":" << 232 << " - " << ("d2") << "=" << (d2)
<< '\n';
if (!check(d1, d2)) kill();
vector<int64_t> t1, t2;
t1.push_back(
dot(one[0] - one.back(), one[(int)((one).size()) - 2] - one.back()));
t1.push_back(dot(one[1] - one[0], one.back() - one[0]));
for (int i = 2; i < (int)((one).size()); i++)
t1.push_back(dot(one[i] - one[i - 1], one[i - 2] - one[i - 1]));
t2.push_back(
dot(two[0] - two.back(), two[(int)((two).size()) - 2] - two.back()));
t2.push_back(dot(two[1] - two[0], two.back() - two[0]));
for (int i = 2; i < (int)((two).size()); i++)
t2.push_back(dot(two[i] - two[i - 1], two[i - 2] - two[i - 1]));
if (debug)
cerr << __PRETTY_FUNCTION__ << ":" << 243 << " - " << ("t1") << "=" << (t1)
<< '\n';
if (debug)
cerr << __PRETTY_FUNCTION__ << ":" << 244 << " - " << ("t2") << "=" << (t2)
<< '\n';
if (!check(t1, t2)) kill();
cout << "YES" << '\n';
return 0;
}
template <typename T>
bool check(const vector<T>& a, const vector<T>& b) {
return mcp(a) == mcp(b);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
vector<char> print;
bool solve(vector<long long> a, string s1, string s2) {
string ans;
a[3] -= (a[2] - 1);
while (a[2] > 0) ans += s1, a[2]--;
if (a[3] > 0) ans += s2.back(), a[3]--;
while (a[3] > 0) ans += s2, a[3]--;
long long id = -1;
for (long long i = 0; i < ans.size(); i++) {
auto x = ans[i];
a[0] -= x == '4', a[1] -= x == '7';
if (x == '7') id = i;
}
print.clear();
for (long long i = 0; i < ans.size(); i++) {
print.push_back(ans[i]);
if (ans[i] == '4')
while (a[0]-- > 0) print.push_back('4');
if (ans[i] == '7' and id == i)
while (a[1]-- > 0) print.push_back('7');
}
return true;
}
bool check(vector<long long> v) {
for (long long i = 0; i < print.size(); i++) {
v[0] -= print[i] == '4';
v[1] -= print[i] == '7';
if (i + 1 < print.size()) {
string tp;
tp += print[i];
tp += print[i + 1];
v[2] -= tp == "47";
v[3] -= tp == "74";
}
}
return count(v.begin(), v.end(), 0) == 4;
}
void write() {
for (auto x : print) cout << x;
exit(0);
}
void solve() {
vector<long long> a(4);
for (auto &x : a) cin >> x;
vector<long long> v = a;
if (abs(a[2] - a[3]) > 1) {
cout << "-1" << '\n';
return;
}
string s1 = "47", s2 = "74", ans;
if (solve(a, s1, s2) and check(v)) write();
swap(a[2], a[3]);
if (solve(a, s2, s1) and check(v)) write();
cout << -1 << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n >= 0) {
cout << n << endl;
} else {
if (-n % 10 > -(n / 10) % 10) {
cout << n / 10 << endl;
} else {
cout << (n / 100) * 10 + n % 10 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int vis[300005];
void initialize() {
for (long long i = 1; i < 300005; i++) {
vis[i] = 0;
}
}
bool prime[300005 + 1];
void SieveOfEratosthenes(int n) {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, j, l = 0, p = 0, q = 0, w, i, flag = 0, t, k, r = 0, d;
cin >> n;
vector<pair<long long, long long>> v;
long long m1;
SieveOfEratosthenes(2000);
if (prime[n] == true) {
flag = 1;
m1 = n;
} else {
m1 = n;
while (prime[m1] != true) {
m1++;
}
}
for (long long i = 1; i < n; i++) {
v.push_back({i, i + 1});
}
if (flag != 1) {
initialize();
for (long long i = 1; i < n + 1; i++) {
if (!vis[i]) {
v.push_back({i, i + 2});
vis[i] = 1;
vis[i + 2] = 1;
p++;
}
if (m1 - n == p) {
break;
}
}
}
v.push_back({1, n});
cout << m1 << '\n';
for (long long i = 0; i < m1; i++) {
cout << v[i].first << " " << v[i].second << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 0, b = 0, c = 0, d = 0;
int f = 0;
cin >> n;
int s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == 4) d++;
if (s[i] == 3) c++;
if (s[i] == 2) b++;
if (s[i] == 1) a++;
}
int q = c;
int w = b;
f += d;
d = 0;
for (int i = 0; i < q; i++) {
if (c == 0) break;
if (a != 0) {
a--;
f++;
c--;
} else {
f += c;
c = 0;
break;
}
}
f += b * 2 / 4;
if (b * 2 % 4 != 0) {
b = 2;
if (a >= 2) {
b = 0;
f++;
a -= 2;
} else if (a == 1) {
b = 0;
f++;
a--;
} else {
b = 0;
f++;
}
}
f += a / 4;
if (a % 4 != 0) ++f;
cout << f << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303030;
int n, p, q;
int ma[N], mi[N];
pair<int, int> a[N];
struct Seg {
static const int N = ::N << 2;
int mi[N], cnt[N], la[N];
void build(int l, int r, int rt) {
cnt[rt] = r - l + 1;
mi[rt] = la[rt] = 0;
if (l == r) return;
int mid = l + r >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
}
void gao(int rt, int c) {
mi[rt] += c;
la[rt] += c;
}
void down(int rt) {
if (!la[rt]) return;
gao(rt << 1, la[rt]);
gao(rt << 1 | 1, la[rt]);
la[rt] = 0;
}
void up(int rt) {
mi[rt] = min(mi[rt << 1], mi[rt << 1 | 1]);
cnt[rt] = 0;
if (mi[rt] == mi[rt << 1]) cnt[rt] += cnt[rt << 1];
if (mi[rt] == mi[rt << 1 | 1]) cnt[rt] += cnt[rt << 1 | 1];
}
void upd(int L, int R, int c, int l, int r, int rt) {
if (L <= l && r <= R) {
gao(rt, c);
return;
}
int mid = l + r >> 1;
down(rt);
if (L <= mid) upd(L, R, c, l, mid, rt << 1);
if (R > mid) upd(L, R, c, mid + 1, r, rt << 1 | 1);
up(rt);
}
int qry(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return mi[rt] == 0 ? cnt[rt] : 0;
int mid = l + r >> 1, ans = 0;
down(rt);
if (L <= mid) ans += qry(L, R, l, mid, rt << 1);
if (R > mid) ans += qry(L, R, mid + 1, r, rt << 1 | 1);
up(rt);
return ans;
}
} seg;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n;
for (int i = (1); i < (n + 1); i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + 1 + n);
seg.build(1, n, 1);
long long ans = 0;
for (int i = (1); i < (n + 1); i++) {
seg.upd(i, i, i, 1, n, 1);
seg.upd(1, n, -1, 1, n, 1);
while (p && a[ma[p]].second < a[i].second)
seg.upd(ma[p - 1] + 1, ma[p], -a[ma[p]].second, 1, n, 1), --p;
ma[++p] = i;
seg.upd(ma[p - 1] + 1, i, a[i].second, 1, n, 1);
while (q && a[mi[q]].second > a[i].second)
seg.upd(mi[q - 1] + 1, mi[q], a[mi[q]].second, 1, n, 1), --q;
mi[++q] = i;
seg.upd(mi[q - 1] + 1, i, -a[i].second, 1, n, 1);
ans += seg.qry(1, i, 1, n, 1);
}
cout << ans << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct event {
long long x, e;
event(long long X, long long Y) {
x = X;
e = Y;
}
};
bool cmp(event x, event y) {
if (x.x == y.x) return x.e > y.e;
return x.x < y.x;
}
vector<event> sh;
long long cnt[200005];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long i, j, k, l, m, n, x, y, t, d;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
sh.push_back(event(x, 1));
sh.push_back(event(y, -1));
}
sort(sh.begin(), sh.end(), cmp);
k = 0;
y = 0;
for (i = 0; i < sh.size(); i++) {
if (~sh[i].e) {
cnt[k] += sh[i].x - y;
k++;
y = sh[i].x;
} else {
if (sh[i - 1].e != sh[i].e || sh[i - 1].x != sh[i].x) {
cnt[k] += sh[i].x - y + 1;
y = sh[i].x + 1;
}
k--;
}
}
for (i = 1; i <= n; i++) cout << cnt[i] << ' ';
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5 + 5;
vector<int> adj[mxn];
int level[mxn];
int vis[mxn];
int n, m;
int bad[mxn];
int par[mxn];
void dfs(int node) {
vis[node] = 1;
for (auto& u : adj[node]) {
if (!vis[u]) {
par[u] = node;
level[u] = level[node] + 1;
dfs(u);
} else {
int cycle = level[node] - level[u] + 1;
if (cycle * cycle >= n) {
cout << 2 << endl << cycle << endl;
while (cycle--) {
cout << node << " ";
node = par[node];
}
cout << endl;
exit(0);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
level[1] = 1;
dfs(1);
vector<int> v(n + 1), independent_set;
for (int i = 0; i <= n; ++i) {
v[i] = i;
}
sort(v.begin() + 1, v.end(),
[](int a, int b) { return level[a] > level[b]; });
for (int i = 1; i <= n; ++i) {
int x = v[i];
if (bad[x]) {
continue;
}
independent_set.push_back(x);
int sz = independent_set.size();
if (sz * sz >= n) {
break;
}
for (auto& u : adj[x]) {
bad[u] = 1;
}
}
cout << 1 << endl;
for (auto& u : independent_set) {
cout << u << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> acm[200010];
int main() {
long long n;
long long x, w;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x >> w;
acm[i].first = x + w;
acm[i].second = x - w;
}
sort(acm, acm + n);
long long ans = 1;
long long last = acm[0].first;
for (long long i = 1; i < n; i++) {
if (acm[i].second >= last) {
ans++;
last = acm[i].first;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int i = 1;
string s = "";
while (s.size() < 10009) {
s += to_string(i);
i++;
}
cin >> i;
cout << s[i - 1] << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
const int MAX{100010}, MAXK{50};
const ll MOD{1000000007}, oo{1LL << 62};
ll ps[MAX][MAXK], ms[MAX][MAXK], s[MAX][MAXK];
vector<ii> solve(int N, ll K, const vector<ll>& fs, const vector<ll>& cs) {
for (int i = 0; i < N; ++i) {
ps[i][1] = fs[i];
ms[i][1] = s[i][1] = cs[i];
}
for (int k = 2; k < MAXK; ++k) {
for (int i = 0; i < N; ++i) {
auto j = ps[i][k - 1];
ps[i][k] = ps[j][k - 1];
ms[i][k] = min(ms[i][k - 1], ms[j][k - 1]);
s[i][k] = s[i][k - 1] + s[j][k - 1];
}
}
vector<ii> ans(N, ii(0, oo));
vector<int> ns(N);
iota(ns.begin(), ns.end(), 0);
for (int k = 1; k < MAXK; ++k) {
ll mask = 1LL << (k - 1);
if (mask & K) {
for (int i = 0; i < N; ++i) {
auto j = ns[i];
ans[i].first += s[j][k];
ans[i].second = min(ans[i].second, ms[j][k]);
ns[i] = ps[j][k];
}
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<ll> fs(N), cs(N);
for (int i = 0; i < N; ++i) cin >> fs[i];
for (int i = 0; i < N; ++i) cin >> cs[i];
auto ans = solve(N, K, fs, cs);
for (auto [s, m] : ans) cout << s << ' ' << m << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
map<int, long long> mp[MAX];
int n, arr[MAX];
vector<vector<int> > adjlist;
long long ans[MAX];
int Gcd(int a, int b) { return (b ? Gcd(b, a % b) : a); }
void dfs(int pos, int parent) {
mp[pos][arr[pos]] = 1;
ans[arr[pos]] += 1;
for (int v : adjlist[pos]) {
if (v != parent) {
dfs(v, pos);
for (auto x : mp[v]) {
for (auto y : mp[pos]) {
ans[Gcd(x.first, y.first)] += 1ll * x.second * y.second;
}
}
for (auto x : mp[v]) {
mp[pos][Gcd(x.first, arr[pos])] += x.second;
}
mp[v].clear();
}
}
}
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
adjlist.resize(n + 1);
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
adjlist[u].push_back(v);
adjlist[v].push_back(u);
}
dfs(1, -1);
for (int i = 1; i <= 200000; i++) {
if (ans[i]) {
cout << i << " " << ans[i] << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> genre(m, 0);
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
genre[temp - 1]++;
}
long long ans = 0;
for (int i = 0; i < m; i++)
for (int j = i + 1; j < m; j++) ans += genre[i] * genre[j];
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
int co = 1, change = 0;
char i;
scanf("%d", &n);
getchar();
while (n--) {
scanf("%c", &i);
if (i == '0' && co == 0)
;
else if (i == '1' && co == 1) {
co = 1;
change++;
} else if (i == '0' && co == 1) {
co = 0;
change++;
}
}
printf("%d\n", change);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int len, pos;
void insert(int x) {
len++;
if (x <= pos) pos++;
}
void erase(int x) {
if (x >= pos)
len = x;
else
len -= x, pos -= x;
}
int main() {
int m, t;
scanf("%d%d%d%d", &len, &pos, &m, &t);
while (t--) {
int type, x;
scanf("%d%d", &type, &x);
if (type == 1)
insert(x);
else
erase(x);
printf("%d %d\n", len, pos);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[2000];
int n, len, ans;
bool u[320][320][320];
int main() {
scanf("%s%d", s, &n);
len = strlen(s);
u[0][len][n] = 1;
for (int i = 0; i < len; i++)
for (int j = len - i; j <= len + i; j++)
for (int k = 0; k <= n; k++)
if (u[i][j][k]) {
if (s[i] == 'F') {
u[i + 1][j + 1][k] = 1;
if (k != 0) u[i + 1][2 * len - j][k - 1] = 1;
} else {
u[i + 1][2 * len - j][k] = 1;
if (k != 0) u[i + 1][j + 1][k - 1] = 1;
}
}
for (int i = 0; i <= len + len; i++)
for (int j = 0; j <= n; j += 2)
if (u[len][i][j]) ans = max(ans, (i - len < 0 ? -(i - len) : i - len));
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Qu {
int tp, lp, l, r, t, idx;
bool operator<(Qu d) const {
if (tp != d.tp) return tp < d.tp;
if (lp != d.lp) return lp < d.lp;
return r < d.r;
};
} qu[100005];
struct Change {
int idx, px, x;
} change[100005];
int arr[100005], ans[100005], chk[100005], cnt[2 * 100005];
int n, cn, qn;
int L, R, T;
int C;
map<int, int> num;
int uni(int x) { return num.count(x) ? num[x] : num[x] = C++; }
void add(int x) {
chk[cnt[x]]--;
chk[++cnt[x]]++;
}
void del(int x) {
chk[cnt[x]]--;
chk[--cnt[x]]++;
}
void change_arr(int idx, int x) {
if (idx >= L && idx <= R) {
add(x);
del(arr[idx]);
}
arr[idx] = x;
}
int get(int l, int r, int t) {
int i;
while (T < t) {
T++;
change_arr(change[T].idx, change[T].x);
}
while (T > t) {
change_arr(change[T].idx, change[T].px);
T--;
}
for (i = L; i <= R; i++) {
if (i >= l && i <= r) {
i = r;
continue;
}
del(arr[i]);
}
for (i = l; i <= r; i++) {
if (i >= L && i <= R) {
i = R;
continue;
}
add(arr[i]);
}
L = l;
R = r;
for (i = 1; chk[i]; i++)
;
return i;
}
int main() {
int i, p, tp, l, r, q, x;
scanf("%d %d", &n, &q);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
arr[i] = uni(x);
}
p = pow((double)n, 0.666);
while (q--) {
scanf("%d %d %d", &tp, &l, &r);
if (tp == 1)
qu[qn] = {cn / p, l / p, l, r, cn, qn}, qn++;
else
cn++, change[cn] = {l, -1, uni(r)};
}
for (i = 1; i <= cn; i++) {
change[i].px = arr[change[i].idx];
arr[change[i].idx] = change[i].x;
}
L = 0;
R = -1;
sort(qu, qu + qn);
T = cn;
for (i = 0; i < qn; i++) ans[qu[i].idx] = get(qu[i].l, qu[i].r, qu[i].t);
for (i = 0; i < qn; i++) printf("%d\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, K;
string name, pos;
string str;
bool vis[111][111];
int pre[111][111];
bool yes[111];
int chd[111][26], sz;
int fail[111];
int Que[111];
void Ins(string a) {
int p = 0;
for (int i = 0; i < a.length(); i++) {
int c = a[i] - 'a';
if (!chd[p][c]) {
chd[p][c] = sz++;
}
p = chd[p][c];
}
}
void AC() {
int *s = Que, *e = Que;
for (int i = 0; i < K; i++) {
if (chd[0][i]) {
fail[chd[0][i]] = 0;
*e++ = chd[0][i];
}
}
while (s != e) {
int p = *s++;
for (int i = 0; i < K; i++) {
if (chd[p][i]) {
int v = chd[p][i];
*e++ = v;
fail[v] = chd[fail[p]][i];
} else {
chd[p][i] = chd[fail[p]][i];
}
}
}
}
void solve() {
sz = 1;
Ins(name);
AC();
for (int i = 0; i < pos.size(); i++) {
if (pos[i] == '1') {
yes[i + name.length() - 1] = true;
if (str.size() <= i) {
str += name;
} else {
str.erase(str.begin() + i, str.end());
str += name;
}
} else {
if (str.size() <= i) {
str += '*';
}
}
}
while (str.length() < n) str += "*";
for (int i = 0; i < pos.size(); i++) {
if (pos[i] == '1') {
if (str.substr(i, name.length()) != name) {
puts("No solution");
return;
}
}
}
vis[0][0] = true;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '*') {
for (int u = 0; u < sz; u++) {
if (vis[i][u]) {
for (int ch = 0; ch < K; ch++) {
int v = chd[u][ch];
if (v == sz - 1) continue;
vis[i + 1][v] = true;
pre[i + 1][v] = u * 100 + ch;
}
}
}
} else {
for (int u = 0; u < sz; u++) {
if (vis[i][u]) {
int ch = str[i] - 'a';
int v = chd[u][ch];
if (v == sz - 1 && !yes[i]) continue;
vis[i + 1][v] = true;
pre[i + 1][v] = u * 100 + ch;
}
}
}
}
n = str.length();
int idx = -1;
for (int i = 0; i < sz; i++) {
if (vis[n][i]) {
idx = pre[n][i];
}
}
if (idx == -1) {
puts("No solution");
return;
}
for (int i = n - 1; i >= 0; i--) {
int u = idx / 100;
int ch = idx % 100;
str[i] = ch + 'a';
idx = pre[i][u];
}
cout << str << endl;
}
int main() {
cin >> n >> K;
cin >> name >> pos;
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 1e5;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int my_rand(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
struct mnx {
long long int xr, xl, yr, yl;
};
mnx v[1000006];
long long int a, b;
bool ok(long long int i) {
return (v[i].xr - v[i].xl < a) && (v[i].yr - v[i].yl < b);
}
void solve() {
cin >> a >> b;
string s;
cin >> s;
long long int sz = s.size();
long long int x = 0, y = 0;
for (long long int i = 1; i <= sz; i++) {
if (s[i - 1] == 'U')
x--;
else if (s[i - 1] == 'D')
x++;
else if (s[i - 1] == 'R')
y++;
else
y--;
v[i].xl = v[i].xr = x;
v[i].yl = v[i].yr = y;
v[i].xl = min(v[i].xl, v[i - 1].xl);
v[i].yl = min(v[i].yl, v[i - 1].yl);
v[i].xr = max(v[i].xr, v[i - 1].xr);
v[i].yr = max(v[i].yr, v[i - 1].yr);
}
x = y = 1;
for (long long int i = 1; i <= sz; i++) {
if (v[i].xr - v[i].xl < a && v[i].yr - v[i].yl < b)
x = 1 + (-v[i].xl), y = 1 + (-v[i].yl);
}
x = min(x, a);
y = min(y, b);
cout << x << ' ' << y << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int now;
cin >> now;
if (now == 1) {
cout << "HARD";
return 0;
}
}
cout << "EASY";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b = b >> 1;
}
return res;
}
void isKthBitSet(int n, int k) {
if (n & (1 << (k - 1))) cout << k - 1 << "\n";
}
void solve() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
long long ans = 0;
for (int i = n - 1; i >= n - k - 1; i--) ans += a[i];
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char arr[n][n];
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
arr[j][i] = '.';
}
}
int count = 0;
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
if (j > 0 && arr[j - 1][i] == 'C') {
continue;
}
if (i > 0 && arr[j][i - 1] == 'C') {
continue;
}
if (j < n - 1 && arr[j + 1][i] == 'C') {
continue;
}
if (i < n - 1 && arr[j][i + 1] == 'C') {
continue;
}
count++;
arr[j][i] = 'C';
}
}
cout << count << endl;
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
cout << arr[j][i];
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7, INF = 1e18;
template <class T>
inline T Min(const T& a, const T& b) {
return a < b ? a : b;
}
template <class T>
inline T Max(const T& a, const T& b) {
return a < b ? b : a;
}
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long int readl() {
char ch = getchar();
long long int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long int ksm(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
inline long long int ksc(long long int a, long long int b) {
long long int res = 0;
while (b) {
if (b & 1) res = res + a >= MOD ? res + a - MOD : res + a;
a = a + a >= MOD ? a + a - MOD : a + a;
b >>= 1;
}
return res;
}
const int N = 1e6 + 7;
struct node {
long long int p, m;
bool operator<(const node& tmp) const { return p > tmp.p; }
} a[N];
bool cmp(node a, node b) { return a.m < b.m; }
int main() {
int T = read();
while (T--) {
int n = read();
int must = 0;
priority_queue<node> Q;
for (int i = 1; i <= n; i++) {
a[i].m = read(), a[i].p = read();
}
long long int res = 0;
sort(a + 1, a + 1 + n, cmp);
for (int i = n, j; i >= 1; i = j) {
j = i;
while (j >= 1 && a[j].m == a[i].m) Q.push(a[j--]);
while (n - a[i].m < Q.size()) {
res += Q.top().p;
Q.pop();
}
}
printf("%lld\n", res);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
}
typedef long long ll;
int main() {
fast;
string s, t;
ll c = 0, x = 0;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = char(s[i] += 32);
if (t[i] >= 'A' && t[i] <= 'Z') t[i] = char(t[i] += 32);
}
if (s == t)
cout << "0";
else if (s < t)
cout << "-1";
else
cout << "1";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[111111];
int b[111111] = {0};
vector<int> v[111111];
int dfs(int x) {
if (b[x] == -1) return -1;
if (b[x] == 1) return 1;
for (int i = 0; i < v[x].size(); i++) {
if (dfs(v[x][i]) == -1) return b[x] = 1;
}
return b[x] = -1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; i + a[i] * j <= n || i - a[i] * j > 0; j++) {
if (i + a[i] * j <= n && a[i + a[i] * j] > a[i])
v[i].push_back(i + a[i] * j);
if (i - a[i] * j > 0 && a[i - a[i] * j] > a[i])
v[i].push_back(i - a[i] * j);
}
if (v[i].size() == 0) b[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (dfs(i) == 1)
cout << "A";
else
cout << "B";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21);
int n, mx = 20, r, a[N], b[N], t[N], mark[N];
vector<int> ans, tour, adj[N];
vector<pair<int, pair<int, int> > > pairs;
set<pair<int, int> > g[N];
int mat(int x) { return (x % 2 ? x + 1 : x - 1); }
void add_edge(int u, int v, int an) {
g[u].insert(make_pair(v, an)), g[v].insert(make_pair(u, an));
if (u > v) swap(u, v), an = mat(an);
pairs.push_back(make_pair(u, make_pair(v, an)));
}
void dfs(int x) {
mark[x] = 1;
for (int i = 0; i < adj[x].size(); i++)
if (!mark[adj[x][i]]) dfs(adj[x][i]);
}
void eulor(int x) {
pair<int, int> u, p;
while (g[x].size()) {
u = *g[x].begin(), p = u, p.first = x;
g[x].erase(u);
g[u.first].erase(p);
eulor(u.first);
}
tour.push_back(x);
}
bool check(int x) {
fill(mark, mark + (1 << x), 0);
for (int i = 1; i < 2 * n + 1; i++) b[i] = a[i] % (1 << x);
for (int i = 0; i < (1 << x); i++) adj[i].clear();
for (int i = 1; i < n + 1; i++)
adj[b[i * 2 - 1]].push_back(b[i * 2]),
adj[b[i * 2]].push_back(b[i * 2 - 1]);
for (int i = 0; i < (1 << x); i++)
if (adj[i].size() % 2) return 0;
for (int i = 0; i < (1 << x); i++)
if (adj[i].size()) {
dfs(i);
for (int j = i; j < (1 << x); j++)
if (adj[j].size() && !mark[j]) return 0;
break;
}
return 1;
}
int Get(int x, int y) {
int l = -1, r = pairs.size() - 1, mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (pairs[mid].first < x ||
(pairs[mid].first == x && pairs[mid].second.first < y) ||
(pairs[mid].first == x && pairs[mid].second.first == y && t[mid] == 1))
l = mid;
else
r = mid;
}
t[r] = 1;
return pairs[r].second.second;
}
void solve(int x) {
for (int i = 1; i < 2 * n + 1; i++) b[i] = a[i] % (1 << x);
for (int i = 1; i < n + 1; i++) add_edge(b[i * 2 - 1], b[i * 2], i * 2 - 1);
for (int i = 0; i < (1 << x); i++) {
if (g[i].size()) {
eulor(i);
break;
}
}
sort(pairs.begin(), pairs.end());
for (int i = 0; i < tour.size() - 1; i++) {
int u = Get(min(tour[i], tour[i + 1]), max(tour[i], tour[i + 1]));
if (tour[i] > tour[i + 1])
cout << mat(u) << " " << u << " ";
else
cout << u << " " << mat(u) << " ";
}
}
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) scanf("%d%d", &a[i * 2 - 1], &a[i * 2]);
;
for (int q = 20; q >= 0; q--)
if (check(q)) {
mx = q;
break;
}
cout << mx << '\n';
solve(mx);
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100][20][1024];
int b, digtal[100];
long long dfs(int pos, int mask, bool limit, bool first) {
if (pos == -1) return first == 0 && mask == 0;
if (!limit && !first && dp[pos][b][mask] != -1) return dp[pos][b][mask];
int ed = limit ? digtal[pos] : b - 1;
long long ans = 0;
for (int i = 0; i <= ed; ++i) {
if (i == 0 && first)
ans += dfs(pos - 1, mask, limit && i == ed, true);
else
ans += dfs(pos - 1, mask ^ (1 << i), limit && i == ed, false);
}
return limit || first ? ans : dp[pos][b][mask] = ans;
}
long long calc(long long num) {
memset(digtal, 0, sizeof digtal);
int len = 0;
while (num) {
digtal[len++] = num % b;
num /= b;
}
return dfs(len - 1, 0, true, true);
}
int main() {
int n;
long long l, r;
scanf("%d", &n);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i) {
scanf("%d%lld%lld", &b, &l, &r);
printf("%lld\n", calc(r) - calc(l - 1));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long f[1 << 10], M = 1000000;
long long l, r, k;
struct Matrix {
long long a[3][3];
Matrix(int fib = 0) {
memset(a, 0, sizeof(a));
if (fib) a[1][2] = a[2][1] = a[2][2] = 1;
}
Matrix mul(const Matrix &v) {
Matrix ret;
for (int i = 1; i <= 2; ++i)
for (int j = 1; j <= 2; ++j)
for (int k = 1; k <= 2; ++k)
ret.a[i][k] = (ret.a[i][k] + a[i][j] * v.a[j][k]) % M;
return ret;
}
void print() { printf("%I64d\n", (a[1][2] + M) % M); }
};
long long solve(long long l, long long r, long long v) {
l = (l - 1) / v + 1;
r = r / v;
return r - l + 1;
}
Matrix fib(long long u) {
if (u == 1) return Matrix(1);
Matrix t = fib(u / 2);
t = t.mul(t);
if (u % 2) t = t.mul(Matrix(1));
return t;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &M, &l, &r, &k);
long long ans = 1;
if (k >= 1000000) {
ans = (r - l + 1) / (k - 1) + 2;
while (solve(l, r, ans) < k) --ans;
} else {
for (int i = 1; i + k - 1 <= 1000000; ++i) {
long long tl = (l - 1) / i + 1, tr = r / (i + k - 1);
if (tl <= tr) ans = max(ans, tr);
}
}
fib(ans).print();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[9];
int f(vector<int> x) {
int mn = 2e9;
int last = 0;
int out = 0;
for (int i = 0; i < n; i++) {
last = 0;
mn = 2e9;
for (int j = i; j < n; j++) {
mn = min(mn, x[j]);
last += mn;
}
out += last;
}
return out;
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < n; i++) arr[i] = i + 1;
vector<pair<int, vector<int> > > perm;
do {
vector<int> temp;
for (int i = 0; i < n; i++) temp.push_back(arr[i]);
int t = f(temp);
perm.push_back({-t, temp});
} while (next_permutation(arr, arr + n));
sort(perm.begin(), perm.end());
for (int i = 0; i < n; i++) cout << perm[m - 1].second[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> a(5);
vector<long long> b(5);
long long sum = 0;
for (long long i = 0; i < 5; i++) {
a[i] = n / 5;
if (n % 5 >= i && i != 0) a[i]++;
b[i] = (m + i) / 5;
sum += (a[i] * b[i]);
}
cout << sum << "\n";
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int DBG = 0;
using namespace std;
const double eps = 1e-9;
const int oo = 1000000000;
const int N = 0;
int main() {
int n, R, r;
scanf("%d%d%d", &n, &R, &r);
int ans;
if (r > R)
ans = 0;
else if (r * 2 > R)
ans = 1;
else
ans = int(acos(-1) / asin(r * 1.0 / (R - r)) + eps);
puts(n <= ans ? "YES" : "NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void in() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
template <typename T>
T modexp(T a, T b, T c) {
T ans = 1;
while (b != 0) {
if (b % 2) ans = (ans * a) % c;
a = (a * a) % c;
b /= 2;
}
return ans;
}
template <typename T>
T C(T n, T r) {
r = min(r, n - r);
T ans = 1;
for (T i = 1; i <= r; i++) {
ans *= (n - r + i);
ans /= i;
}
return ans;
}
const long long inf = LLONG_MAX / 2;
const long long N = (1e3 + 1);
const long long M = 25e6 + 10;
const long long mod = 1000000007;
const long long shit = 13131313139;
const double eps = 1e-9;
long long a[27];
map<long long, long long> m[27];
int main() {
in();
for (long long i = 1; i <= 26; i++) cin >> a[i];
string s;
cin >> s;
long long n = s.length(), sum = 0, ans = 0;
for (long long i = 1; i <= n; i++) {
long long tp = s[i - 1] - 'a' + 1;
sum += a[tp];
ans += m[tp][sum - a[tp]];
m[tp][sum]++;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i % 2 == 0)
cout << "#";
else if ((i % 4 == 1 && j == m - 1) || (i % 4 == 3 && j == 0))
cout << "#";
else
cout << ".";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, ans, a, b, si[200005], res, cnt = 0;
bool done[200005];
vector<long long> adj[200005];
long long dfs(long long a, long long par) {
long long deg = 2;
for (auto e : adj[a]) {
if (e == par) continue;
if (dfs(e, a) && deg) {
cnt++;
deg--;
}
}
return deg > 0;
}
int main() {
long long i, j, k;
ios::sync_with_stdio(0);
cin >> n >> x >> y;
for (i = 1; i <= n - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
if (x > y) {
ans = y * (n - 1);
for (i = 1; i <= n; i++)
if (adj[i].size() == n - 1) {
ans = ans - y + x;
break;
}
}
if (x <= y) {
dfs(1, -1);
res = (cnt)*x + (n - 1 - cnt) * y;
ans = res;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T Rint(T &r) {
int b = 1, c = getchar();
r = 0;
while (c < '0' || '9' < c) b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9')
r = (r << 1) + (r << 3) + (c ^ '0'), c = getchar();
return r *= b;
}
const int N = 1e5 + 10;
int n, m;
int aryx[N], stk[N], flef[N], frig[N];
long long aryd[N];
int main() {
Rint(n);
for (int i = 0; i <= n + 1; i++) Rint(aryx[i]);
for (int i = 1; i <= n; i++) Rint(aryd[i]);
aryd[0] = aryd[n + 1] = 1e9 + 7;
stk[m = 1] = 0;
for (int i = 1; i <= n + 1; i++) {
while (m > 1 && 2 * aryd[stk[m]] < aryx[i] - aryx[stk[m - 1]]) m--;
flef[i] = aryx[stk[m]];
stk[++m] = i;
}
stk[m = 1] = n + 1;
for (int i = n; ~i; i--) {
while (m > 1 && 2 * aryd[stk[m]] < aryx[stk[m - 1]] - aryx[i]) m--;
frig[i] = aryx[stk[m]];
stk[++m] = i;
}
if (flef[n + 1]) {
printf("%f\n", 0.0);
return 0;
}
stk[m = 1] = 0;
int ans = aryx[n + 1] - aryx[0];
for (int i = 1; i <= n + 1; i++) {
int nL = 1, nR = m;
while (nL + 1 < nR) {
int nM = (nL + nR) >> 1;
if (flef[stk[nM]] + 2 * aryd[stk[nM]] >= frig[i] - 2 * aryd[i])
nL = nM;
else
nR = nM;
}
int it = 0;
if (flef[stk[nR]] + 2 * aryd[stk[nR]] >= frig[i] - 2 * aryd[i])
it = stk[nR];
else if (flef[stk[nL]] + 2 * aryd[stk[nL]] >= frig[i] - 2 * aryd[i])
it = stk[nL];
if (frig[i] - 2 * aryd[i] < aryx[i]) ans = min(ans, aryx[i] - aryx[it]);
if (flef[i] + 2 * aryd[i] > aryx[i]) {
while (m && 2 * aryd[i] + flef[i] >= 2 * aryd[stk[m]] + flef[stk[m]]) m--;
stk[++m] = i;
}
}
printf("%f\n", ans / 2.0);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int M = 1000000;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double Pi = 2 * acos(0.0);
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
inline int bit(int x) { return 1 << x; }
inline double dabs(double x) { return x > 0 ? x : (-x); }
inline int abs(int x) { return x > 0 ? x : (-x); }
inline int lowbit(int x) { return x & (-x); }
int cnt[5];
vector<int> v;
int main() {
int k, t;
ios::sync_with_stdio(0);
cin >> k;
while (k--) {
cin >> t;
if (t == 0)
cnt[0] = 1;
else if (t == 100)
cnt[4] = 1;
else if (t % 10 == 0)
cnt[3] = t;
else if (t > 10)
cnt[2] = t;
else
cnt[1] = t;
}
if (cnt[0]) v.push_back(0);
if (cnt[4]) v.push_back(100);
if (cnt[1] || cnt[3]) {
if (cnt[1]) v.push_back(cnt[1]);
if (cnt[3]) v.push_back(cnt[3]);
} else if (cnt[2])
v.push_back(cnt[2]);
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using std::next_permutation;
using std::sort;
int a[8][3];
long long b[7];
long long dis(int i, int j) {
long long x = a[i][0] - a[j][0];
long long y = a[i][1] - a[j][1];
long long z = a[i][2] - a[j][2];
return x * x + y * y + z * z;
}
bool check() {
int i, j, k;
for (i = 0; i < 8; i++) {
for (j = 0; j < i; j++) b[j] = dis(i, j);
for (j = i + 1; j < 8; j++) b[j - 1] = dis(i, j);
sort(b, b + 7);
long long t1 = b[0], t2 = t1 + t1, t3 = t2 + t1;
if (t1 == 0 || t1 != b[1] || t1 != b[2] || t2 != b[3] || t2 != b[4] ||
t2 != b[5] || t3 != b[6])
return false;
}
return true;
}
bool canGetAns(int i) {
if (i == 8) return check();
sort(a[i], a[i] + 3);
do {
if (canGetAns(i + 1)) return true;
} while (next_permutation(a[i], a[i] + 3));
return false;
}
int main() {
int i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 3; j++) scanf("%d", &a[i][j]);
if (!canGetAns(0))
printf("NO\n");
else {
printf("YES\n");
for (i = 0; i < 8; i++) printf("%d %d %d\n", a[i][0], a[i][1], a[i][2]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int M = 1e9 + 7;
inline int mod(int n) { return (n % M); }
int main() {
int x, y, z;
std::cin >> x >> y >> z;
if (x > y + z) {
printf("+\n");
return 0;
} else if (y > x + z) {
printf("-\n");
return 0;
} else if (x == y && z == 0) {
printf("0\n");
return 0;
} else {
printf("?\n");
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int array[n];
for (int i = 0; i < n; i++) {
cin >> array[i];
}
sort(array, array + n);
int scope = 1, count = 0;
for (int i = 0; i < n; i++) {
scope = max(scope, i + 1);
for (int j = scope; j < n; j++) {
if (array[j] != array[i]) {
if (array[j] <= array[i] + k) {
count++;
}
scope = j;
break;
}
scope++;
}
}
cout << n - count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string S;
map<string, int> h;
map<pair<string, string>, int> maa;
vector<int> E[1100000];
int ti;
int main() {
cin >> S;
int L = S.size();
for (int i = 1; i <= 4; ++i) {
for (int j = 0; j <= L - i; ++j) {
string s = "";
for (int k = 1; k <= i; ++k) s += S[j + k - 1];
int t;
if (h[s])
t = h[s];
else
t = h[s] = ++ti;
E[t].push_back(j);
}
}
int Q;
scanf("%d", &Q);
while (Q--) {
string s1, s2;
cin >> s1 >> s2;
if (maa[make_pair(s1, s2)]) {
printf("%d\n", maa[make_pair(s1, s2)]);
continue;
}
int ans = 1 << 30;
int a = h[s1], b = h[s2], x = 0, y = 0;
if (!a || !b)
ans = -1;
else {
while (x < E[a].size() && y < E[b].size()) {
int tmp, l1 = E[a][x] + s1.size() - 1, l2 = E[b][y] + s2.size() - 1;
tmp = max(l1, l2) - min(E[a][x], E[b][y]) + 1;
ans = min(ans, tmp);
if (E[a][x] < E[b][y])
x++;
else
y++;
}
}
maa[make_pair(s1, s2)] = maa[make_pair(s2, s1)] = ans;
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, m, q, a[maxn], b[maxn], pos[maxn];
int nxt[20][maxn], ans[maxn];
vector<pair<int, int> > qu[maxn];
vector<int> adj[maxn];
void readf() {
scanf("%d%d%d", &n, &m, &q);
for (int i = (1); i <= (n); ++i) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
for (int i = (1); i <= (m); ++i) {
scanf("%d", &a[i]);
a[i] = b[a[i]];
}
}
int rgt(int u) {
int tmp = n;
for (int k = 18; k >= 0; --k)
if ((1 << k) < tmp) {
u = nxt[k][u];
tmp -= (1 << k);
}
return u;
}
void solve() {
for (int i = m; i > 0; --i) {
if (pos[a[i] % n + 1]) nxt[0][i] = pos[a[i] % n + 1];
pos[a[i]] = i;
}
for (int k = 1; (1 << k) <= m; ++k)
for (int i = 1; i + (1 << k) <= m; ++i)
nxt[k][i] = nxt[k - 1][nxt[k - 1][i]];
for (int i = 1; i <= m; ++i) adj[rgt(i)].emplace_back(i);
for (int i = (1); i <= (q); ++i) {
int l, r;
scanf("%d%d", &l, &r);
qu[r].emplace_back(l, i);
}
int mx = 0;
for (int i = 1; i <= m; ++i) {
for (auto u : adj[i]) mx = max(mx, u);
for (auto u : qu[i]) ans[u.second] = (mx >= u.first);
}
for (int i = 1; i <= q; ++i) printf("%d", ans[i]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int map[20 + 1][20 + 1];
int main(void) {
int n, m;
char hor[30];
char ver[30];
scanf("%d %d", &n, &m);
scanf("%s", hor);
scanf("%s", ver);
if ((hor[0] == '>' && ver[0] == 'v') ||
(hor[0] == '<' && ver[m - 1] == 'v') ||
(hor[n - 1] == '>' && ver[0] == '^') ||
(hor[n - 1] == '<' && ver[m - 1] == '^')) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int evenp[n], oddp[n], evens[n], odds[n];
oddp[0] = v[0];
evenp[0] = 0;
for (int i = 1; i < n; i++) {
if (i % 2 == 0) {
oddp[i] = v[i] + oddp[i - 1];
evenp[i] = evenp[i - 1];
} else {
evenp[i] = v[i] + evenp[i - 1];
oddp[i] = oddp[i - 1];
}
}
if ((n - 1) % 2 == 0) {
odds[n - 1] = v[n - 1];
evens[n - 1] = 0;
} else {
odds[n - 1] = 0;
evens[n - 1] = v[n - 1];
}
for (int i = n - 2; i >= 0; i--) {
if (i % 2 == 0) {
odds[i] = v[i] + odds[i + 1];
evens[i] = evens[i + 1];
} else {
evens[i] = v[i] + evens[i + 1];
odds[i] = odds[i + 1];
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
int odd, even;
if (i % 2 == 0) {
if (i > 0) {
odd = oddp[i - 1] + evens[i];
even = evenp[i - 1] + odds[i] - v[i];
} else {
odd = evens[i];
even = odds[i] - v[i];
}
} else {
if (i > 0) {
odd = oddp[i - 1] + evens[i] - v[i];
even = evenp[i - 1] + odds[i];
} else {
odd = evens[i] - v[i];
even = odds[i];
}
}
if (odd == even) {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
template <typename INint>
inline void IN(INint &first) {
first = 0;
int f = 1;
char c;
cin.get(c);
while (c < '0' || c > '9') {
if (c == '-') f = -1;
cin.get(c);
}
while (c >= '0' && c <= '9') {
first = first * 10 + c - '0';
cin.get(c);
}
first *= f;
}
template <typename INint>
inline void OUT(INint first) {
if (first > 9) OUT(first / 10);
cout.put(first % 10 + '0');
}
const int maxn = int(1e5 + 5);
vector<int> G[maxn];
int a[maxn];
long long ans[maxn] = {0};
int n;
int main() {
int T(1), times(0);
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (++times, T--) {
cin >> n;
for (int i = 1; i <= int(n); i++) {
int a;
cin >> a;
G[a].push_back(i);
}
for (int i = 1; i <= int(n); i++) {
ans[i] = ans[i - 1];
map<int, int> ma;
for (auto first : G[i]) {
a[first] = i;
if (a[first - 1]) ++ma[a[first - 1]];
if (a[first + 1]) ++ma[a[first + 1]];
}
if (ma.empty()) {
ans[i] += i * G[i].size();
continue;
}
ma[i] = max(ma[i], 0);
ma[0] = -1;
long long cnt(0);
for (map<int, int>::iterator it = (--ma.end()); it != ma.begin(); --it) {
cnt += it->second;
auto bef = it;
--bef;
ans[i] += (it->first - bef->first) * G[i].size();
ans[i] -= (it->first - bef->first) * cnt;
}
}
cout << accumulate(ans + 1, ans + 1 + n, 0ll) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a[100005];
int main() {
int n, m, k = 0, c = 0, l = -1;
string x;
cin >> n >> m;
while (m--) {
cin >> x;
l = x.find('0');
if (l != -1) {
k++;
c = max(c, k);
} else {
k = 0;
}
}
c = max(c, k);
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, v, s, d, w, t, temp;
while (cin >> a >> v >> s >> d >> w) {
temp = w / a;
temp = temp * temp * a / 2;
if (temp > d) {
temp = 2 * a * s;
if (temp <= v * v) {
t = sqrt(temp) / a;
printf("%llf\n", t);
continue;
} else {
temp = v / a;
t = temp + (s - v * v / (2 * a)) / v;
printf("%llf\n", t);
continue;
}
} else {
if (v > w) {
double vx = sqrt((w * w + 2 * a * d) / 2);
if (vx < v) {
t = (2 * vx - w) / a;
} else {
t = v / a;
t += d / v - v / a + w * w / (2 * a * v);
t += (v - w) / a;
}
if ((2 * a * (s - d) + w * w) <= v * v) {
temp = 2 * a * (s - d) + w * w;
t += (sqrt(temp) - w) / a;
printf("%llf\n", t);
continue;
} else {
temp = (v * v - w * w) / (2 * a);
t += (v - w) / a;
t += (s - d - temp) / v;
printf("%llf\n", t);
continue;
}
} else {
temp = v / a;
t = temp + (s - v * v / (2 * a)) / v;
printf("%llf\n", t);
continue;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = 2e6 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 998244353;
int n, m, S;
pair<long long, long long> a[N];
int ans[N];
struct node {
long long a, b, id;
bool operator<(const node &t) const { return b > t.b; }
} g[N];
bool cmp(node a, node b) { return a.a < b.a; }
bool check(int x) {
long long sum = 0;
priority_queue<node> q;
int i;
int cnt = n;
for (i = m; i >= 1; i--) {
while (cnt && g[cnt].a >= a[i].first) {
q.push(g[cnt--]);
}
if (q.empty()) return false;
int j;
for (j = i; j > max(i - x, 0); j--) {
ans[a[j].second] = q.top().id;
}
i -= x;
i++;
sum += q.top().b;
q.pop();
}
return sum <= S;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> S;
int i;
for (i = 1; i <= m; i++) {
cin >> a[i].first;
a[i].second = i;
}
for (i = 1; i <= n; i++) {
cin >> g[i].a;
g[i].id = i;
}
for (i = 1; i <= n; i++) cin >> g[i].b;
sort(a + 1, a + 1 + m);
sort(g + 1, g + 1 + n, cmp);
int l = 0, r = m + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l == m + 1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
check(l);
for (i = 1; i <= m; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans[100010];
map<int, int> mp;
int main() {
int n, m, a;
mp.clear();
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a;
mp[a] = 1;
}
int sum = 0, i = 0, cnt = 0;
while (1) {
i++;
if (mp[i]) continue;
if (sum + i > m) break;
sum += i;
ans[cnt++] = i;
}
cout << cnt << endl;
for (int j = 0; j < cnt; j++) cout << ans[j] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
int l = 0;
cin >> n;
int a[n], b[n];
int m = 0;
int pos = 0;
int k = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++)
if (a[i] != b[i]) {
pos = i;
k = b[i] - a[i];
break;
}
if (k > 0) {
for (int i = pos; i < n; i++)
if (a[i] != b[i])
a[i] = a[i] + k;
else
break;
}
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) m = 1;
}
if (m == 1)
cout << "NO\n";
else
cout << "yes\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e3 + 10;
long long ans = 0;
bool isIn(long long o, long long l, long long r) { return l <= o && o <= r; }
pair<long long, long long> cross(long long l1, long long r1, long long l2,
long long r2) {
return {max(l1, l2), min(r1, r2)};
}
void refrain(long long o, long long l, long long r,
vector<pair<long long, long long>> &v) {
v.push_back(cross(1, o - 1, l, r));
v.push_back(cross(1, o - 1, l - o, r - o));
}
void check(long long l1, long long r1, long long l2, long long r2,
long long o) {
if (r1 - l1 + 1 <= ans) return;
if (r2 - l2 + 1 <= ans) return;
if (isIn(o, l1, r1) && isIn(o, l2, r2)) {
ans = max(ans, min(r1, r2) - max(l1, l2) + 1);
}
if (o == 1) return;
vector<pair<long long, long long>> v1, v2;
refrain(o, l1, r1, v1);
refrain(o, l2, r2, v2);
for (auto &p1 : v1) {
for (auto &p2 : v2) {
check(p1.first, p1.second, p2.first, p2.second, o >> 1);
}
}
}
int main() {
long long l1, l2, r1, r2;
cin >> l1 >> r1 >> l2 >> r2;
check(l1, r1, l2, r2, 1 << 30);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
using vul = std::vector<ul>;
using vvul = std::vector<vul>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vvvb = std::vector<vvb>;
using vull = std::vector<ull>;
using vvull = std::vector<vull>;
using vli = std::vector<li>;
using vll = std::vector<ll>;
using pulul = std::pair<ul, ul>;
using vpulul = std::vector<pulul>;
const ul mod = 998244353;
const ul base = 1234234;
ul n, m;
class point {
public:
ll x = 0;
ll y = 0;
point() = default;
point(ll a, ll b) : x(a), y(b) {}
};
point operator-(const point& a, const point& b) {
return point(a.x - b.x, a.y - b.y);
}
point operator+(const point& a, const point& b) {
return point(a.x + b.x, a.y + b.y);
}
ll det(const point& a, const point& b) { return a.x * b.y - a.y * b.x; }
bool lesslean(const point& a, const point& b) { return det(a, b) > 0; }
std::vector<point> datas(1e5);
std::vector<point> top;
std::vector<point> but;
std::vector<point> hull;
std::vector<ul> hash1;
std::vector<ul> hash2;
vul hashn1, hashn2, hashm1, hashm2;
void exgcd(li a, li b, li& x, li& y) {
if (b) {
exgcd(b, a % b, y, x);
y -= x * (a / b);
} else {
x = 1;
y = 0;
}
}
ul inverse(ul a) {
li x, y;
exgcd(mod, a, x, y);
return y < 0 ? li(mod) + y : y;
}
ul plus(ul a, ul b) { return a + b < mod ? a + b : a + b - mod; }
ul minus(ul a, ul b) { return a < b ? a + mod - b : a - b; }
ul times(ul a, ul b) { return ull(a) * b % mod; }
void gethull() {
std::sort(datas.begin(), datas.end(), [](const point& a, const point& b) {
return a.x != b.x ? a.x < b.x : a.y > b.y;
});
top.resize(0);
for (const point& p : datas) {
while (top.size() > 1) {
const point& a = *(top.end() - 2);
const point& b = *(top.end() - 1);
if (!lesslean(p - b, b - a)) {
top.pop_back();
} else {
break;
}
}
top.push_back(p);
}
std::reverse(datas.begin(), datas.end());
but.resize(0);
for (const point& p : datas) {
while (but.size() > 1) {
const point& a = *(but.end() - 2);
const point& b = *(but.end() - 1);
if (!lesslean(p - b, b - a)) {
but.pop_back();
} else {
break;
}
}
but.push_back(p);
}
hull.resize(0);
for (ul i = 1; i != top.size(); ++i) {
hull.push_back(top[i]);
}
for (ul i = 1; i != but.size(); ++i) {
hull.push_back(but[i]);
}
ul inv = inverse(hull.size());
point cen;
for (ul i = 0; i != hull.size(); ++i) {
cen.x = plus(cen.x, times(hull[i].x, inv));
cen.y = plus(cen.y, times(hull[i].y, inv));
}
hash1.resize(hull.size());
hash2.resize(hull.size());
hull.push_back(hull.front());
for (ul i = 0; i + 1 != hull.size(); ++i) {
hash1[i] = plus(times(minus(hull[i].x, cen.x), minus(hull[i].x, cen.x)),
times(minus(hull[i].y, cen.y), minus(hull[i].y, cen.y)));
hash2[i] = plus(
times(minus(hull[i].x, hull[i + 1].x), minus(hull[i].x, hull[i + 1].x)),
times(minus(hull[i].y, hull[i + 1].y),
minus(hull[i].y, hull[i + 1].y)));
}
}
vul fhashn;
vul fhashm;
vul basepow(1e5 + 1, 1);
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
for (ul i = 1; i != basepow.size(); ++i) {
basepow[i] = times(basepow[i - 1], base);
}
std::cin >> n >> m;
datas.resize(n);
for (ul i = 0; i != n; ++i) {
std::cin >> datas[i].x >> datas[i].y;
}
gethull();
hashn1 = hash1;
hashn2 = hash2;
datas.resize(m);
for (ul i = 0; i != m; ++i) {
std::cin >> datas[i].x >> datas[i].y;
}
gethull();
hashm1 = hash1;
hashm2 = hash2;
if (hashn1.size() != hashm1.size()) {
std::cout << "NO" << std::endl;
return 0;
}
fhashn.resize(hashn1.size() * 2 + 1);
fhashm.resize(hashm1.size() + 1);
for (ul i = 0; i != hashn1.size(); ++i) {
fhashn[i + 1] =
plus(plus(hashn1[i], times(hashn2[i], 2)), times(fhashn[i], base));
fhashm[i + 1] =
plus(plus(hashm1[i], times(hashm2[i], 2)), times(fhashm[i], base));
}
ul t = hashn1.size();
for (ul i = hashn1.size(); i != 2 * hashn1.size(); ++i) {
fhashn[i + 1] = plus(plus(hashn1[i - t], times(hashn2[i - t], 2)),
times(fhashn[i], base));
}
for (ul i = 0; i != t; ++i) {
if (minus(fhashn[i + t], times(fhashn[i], basepow[t])) ==
minus(fhashm[t], times(fhashm[0], basepow[t]))) {
std::cout << "YES" << std::endl;
return 0;
}
}
std::cout << "NO" << std::endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 342;
const long double E = 1e-12;
struct Max_flow_relabel_to_front {
long long excess[maxN];
int H[maxN], nbr[maxN];
list<int> L;
long long max_flow(vector<int>* G, long long cap[][maxN], int n, int source,
int target) {
for (int i = 1; i < (n + 1); i++) excess[i] = H[i] = nbr[i] = 0;
L.clear();
H[source] = n;
for (int u : G[source]) {
excess[u] = cap[u][source] = cap[source][u];
excess[source] -= cap[source][u];
cap[source][u] = 0;
}
for (int v = 1; v < (n + 1); v++)
if (v != source and v != target) L.push_back(v);
for (auto it = L.begin(); it != L.end(); it++) {
int v = *it, oldH = H[v];
while (excess[v] > 0) {
if (nbr[v] == G[v].size()) {
H[v] = n * 2;
for (int w : G[v])
if (cap[v][w] > 0) H[v] = min(H[v], H[w]);
H[v]++;
nbr[v] = 0;
continue;
}
int u = G[v][nbr[v]];
if (cap[v][u] > 0 and H[u] < H[v]) {
long long d = min(excess[v], cap[v][u]);
excess[v] -= d;
cap[v][u] -= d;
excess[u] += d;
cap[u][v] += d;
} else
nbr[v]++;
}
if (oldH < H[v]) L.erase(it), L.push_front(v), it = L.begin();
}
long long res = 0;
for (int u : G[source]) res += cap[u][source];
return res;
}
} alg;
long long c0[maxN][maxN], cap[maxN][maxN];
vector<int> G[maxN];
int main() {
int n, m, x;
scanf("%d%d%d", &n, &m, &x);
int num = n;
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (c0[b][a] != 0) {
num++;
G[b].push_back(num);
G[a].push_back(num);
G[num].push_back(a);
G[num].push_back(b);
c0[a][num] = c0[num][b] = c;
} else {
G[a].push_back(b);
G[b].push_back(a);
c0[a][b] = c;
}
}
long double bn = 0, ed = 1000042;
while (ed - bn > E) {
long double w = (bn + ed) / 2;
for (int i = 1; i < (num + 1); i++)
for (int j = 1; j < (num + 1); j++) cap[i][j] = c0[i][j] / w;
alg.max_flow(G, cap, num, 1, n) >= x ? bn = w : ed = w;
}
printf("%.18Lf\n", bn * x);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6;
const int MOD = 1e9 + 7;
const string ALPHA = "abcdefghijklmnopqrstuvwxyz";
const double PI = 3.1415926535;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, a, b;
cin >> n >> a >> b;
int dif = (a + b) - n;
cout << ((a - dif + 1 > b - dif + 1) ? a - dif + 1 : b - dif + 1) << '\n';
;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long a, b, c;
cin >> a >> b >> c;
cout << a - (max(b + 1, a - c)) + 1 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
inline long long area(pair<long long, long long> a,
pair<long long, long long> b,
pair<long long, long long> c) {
return (b.first - a.first) * (c.second - a.second) -
(b.second - a.second) * (c.first - a.first);
}
inline bool intersect_1(long long a, long long b, long long c, long long d) {
if (a > b) swap(a, b);
if (c > d) swap(c, d);
return max(a, c) <= min(b, d);
}
bool intersect(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c, pair<long long, long long> d) {
return intersect_1(a.first, b.first, c.first, d.first) &&
intersect_1(a.second, b.second, c.second, d.second) &&
area(a, b, c) * area(a, b, d) <= 0 &&
area(c, d, a) * area(c, d, b) <= 0;
}
int32_t main() {
long long r, b;
scanf("%lld%lld", &r, &b);
if (r != b) return cout << "NO", 0;
vector<pair<long long, long long> > u(r), v(b);
for (long long i = 0; i < r; i++) {
scanf("%lld%lld", &u[i].first, &u[i].second);
}
for (long long i = 0; i < b; i++) {
scanf("%lld%lld", &v[i].first, &v[i].second);
}
vector<long long> p;
for (long long i = 0; i < b; i++) {
p.push_back(i);
}
do {
bool ok = true;
for (long long i = 0; i < r; i++) {
for (long long j = i + 1; j < r; j++) {
if (intersect(u[i], v[p[i]], u[j], v[p[j]])) {
ok = false;
break;
}
}
if (!ok) break;
}
if (ok) return cout << "YES", 0;
} while (next_permutation(p.begin(), p.end()));
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i, j, arr[s.size() / 2 + 1];
for (i = 0, j = 0; i < s.size(); i += 2, j++) arr[j] = s.at(i);
sort(arr, arr + j);
for (i = 0, j = 0; i < s.size(); i += 2, j++) s.at(i) = arr[j];
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[2005];
long long a[2005], s[2005], l[2005], r[2005];
void dfs(long long v) {
long long c = 0;
s[v] = 1;
for (long long u = 1; u; u++) {
c += !l[u];
if (c > a[v]) r[v] = u, l[u] = 1, u = -1;
}
for (auto u : g[v]) {
dfs(u);
s[v] += s[u];
}
if (a[v] >= s[v]) {
cout << "NO\n";
exit(0);
}
}
int32_t main() {
long long t = 1;
while (t--) {
long long n;
cin >> n;
for (long long i = 1; i < n + 1; i++) {
long long x;
cin >> x >> a[i], g[x].push_back(i);
}
dfs(g[0][0]);
cout << "YES\n";
for (long long i = 1; i < n + 1; i++) cout << r[i] << " ";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323;
const double eps = 1e-8;
const int inf = 1 << 29;
int n, m;
double f[1010][1010];
double dfs(int w, int b) {
if (f[w][b] != -1.0) return f[w][b];
if (!w && !b) return f[w][b] = 0.0;
if (!b) return f[w][b] = 1.0;
if (!w) return f[w][b] = 0.0;
f[w][b] = 1.0 * w / (w + b);
double tmp = 1.0 * b / (w + b) * (b - 1) / (w + b - 1);
if (b >= 2) f[w][b] += tmp * w / (w + b - 2) * dfs(w - 1, b - 2);
if (b >= 3) f[w][b] += tmp * (b - 2) / (w + b - 2) * dfs(w, b - 3);
return f[w][b];
}
int main() {
cin >> n >> m;
for (int i(0); i < (n + 1); i++)
for (int j(0); j < (m + 1); j++) f[i][j] = -1.0;
printf("%.10f\n", dfs(n, m));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, vector<int> > g;
unordered_map<int, bool> visited;
void addedge(int u, int v) {
g[u].push_back(v);
g[v].push_back(u);
}
double dfs(int i, int v) {
double opt = g[i].size();
if (v != 0) opt -= 1;
double cnt = 0;
for (auto u : g[i]) {
if (u != v) {
cnt += (double)(dfs(u, i) + 1.0) / (opt);
}
}
return cnt;
}
int main() {
int n;
cin >> n;
int i, j, a, b;
for (i = 1; i <= n - 1; ++i) {
cin >> a >> b;
addedge(a, b);
}
cout << fixed << setprecision(15) << dfs(1, 0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30004;
const int inf = 1e9;
struct node {
int x;
int id;
} w[N], h[N];
bool comp(node a, node b) { return a.x < b.x; }
long long int add[N][4];
int idh[N];
long long int dp[N];
void update(int i) {
add[i][0] = add[i][1] = add[i][2] = -inf;
if (w[i].id != h[i].id) add[i][0] = 1LL * w[i].x * h[i].x;
if (i - 1 >= 1 && w[i].id != h[i - 1].id && w[i - 1].id != h[i].id)
add[i][1] = 1LL * w[i].x * h[i - 1].x + 1LL * w[i - 1].x * h[i].x;
if (i - 2 >= 1 && w[i].id != h[i - 1].id && w[i - 1].id != h[i - 2].id &&
w[i - 2].id != h[i].id)
add[i][2] = 1LL * w[i].x * h[i - 1].x + 1LL * w[i - 1].x * h[i - 2].x +
1LL * w[i - 2].x * h[i].x;
if (i - 2 >= 1 && w[i].id != h[i - 2].id && w[i - 1].id != h[i].id &&
w[i - 2].id != h[i - 1].id)
add[i][2] =
max(add[i][2], 1LL * w[i].x * h[i - 2].x + 1LL * w[i - 1].x * h[i].x +
1LL * w[i - 2].x * h[i - 1].x);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &w[i].x);
w[i].id = i;
}
for (i = 1; i <= n; i++) {
scanf("%d", &h[i].x);
h[i].id = i;
}
sort(w + 1, w + n + 1, comp);
sort(h + 1, h + n + 1, comp);
for (i = 1; i <= n; i++) idh[h[i].id] = i;
for (i = 1; i <= n; i++) update(i);
int a, b;
while (m--) {
scanf("%d %d", &a, &b);
int u = idh[a];
int v = idh[b];
swap(h[u].id, h[v].id);
idh[a] = v;
idh[b] = u;
for (i = u; i <= min(n, u + 2); i++) update(i);
for (i = v; i <= min(n, v + 2); i++) update(i);
for (i = 1; i <= n; i++) {
dp[i] = -inf;
dp[i] = max(dp[i], dp[i - 1] + add[i][0]);
dp[i] = max(dp[i], dp[i - 2] + add[i][1]);
dp[i] = max(dp[i], dp[i - 3] + add[i][2]);
}
printf("%I64d\n", dp[n]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
static inline void setio(void);
int main(void) {
setio();
long long n;
std::cin >> n;
std::vector<long long> vec(n);
std::vector<char> neg(n);
for (long long i = 0; i < n; ++i) {
std::cin >> vec[i];
if (vec[i] < 0) {
neg[i] = true;
vec[i] = -vec[i];
}
}
std::vector<long long> primes;
std::vector<char> sieve(1000000, true);
for (long long i = 2; i < sieve.size(); ++i) {
if (!sieve[i]) continue;
primes.push_back(i * i);
if (primes.back() > 100000001LL) break;
for (long long j = i + i; j < sieve.size(); j += i) sieve[j] = false;
}
for (auto& num : vec) {
for (const auto& p : primes) {
if (p > num) break;
while (num % p == 0) num /= p;
}
}
for (long long i = 0; i < n; ++i)
if (neg[i]) vec[i] = -vec[i];
std::vector<long long> cnts(n + 1, 0);
std::vector<long long> last_time(n);
std::map<long long, long long> bleh;
for (long long i = 0; i < n; ++i) {
last_time[i] = bleh[vec[i]] - 1;
bleh[vec[i]] = i + 1;
}
bool seen_zero;
for (long long i = 0; i < n; ++i) {
long long count = 0;
seen_zero = false;
for (long long j = i; j < n; ++j) {
count += last_time[j] < i;
seen_zero = seen_zero || vec[j] == 0;
if (count == 1 && seen_zero)
cnts[count]++;
else if (count > 0)
cnts[count - (seen_zero)]++;
}
}
for (long long i = 1; i <= n; ++i) std::cout << cnts[i] << " ";
std::cout << "\n";
return 0;
}
static inline void setio(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.precision(10);
std::cout << std::fixed;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> e[10005];
map<string, int> mp;
string x, y, s[10005];
int n, m;
int main() {
int i, j, k;
scanf("%d", &m);
while (m--) {
cin >> x >> y;
if (mp.find(x) == mp.end()) mp[x] = ++n, s[n] = x;
if (mp.find(y) == mp.end()) mp[y] = ++n, s[n] = y;
e[mp[x]].insert(mp[y]);
e[mp[y]].insert(mp[x]);
}
cout << n << endl;
for (i = 1; i <= n; i++) {
int p = 0, t = 0;
for (j = 1; j <= n; j++) {
if (i != j && e[i].find(j) == e[i].end()) {
int x = 0;
for (set<int>::iterator it = e[i].begin(); it != e[i].end(); it++)
if (e[j].find(*it) != e[j].end()) x++;
if (x > p)
p = x, t = 1;
else if (x == p)
t++;
}
}
cout << s[i] << " " << t << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200013];
vector<int> adj[200013];
bool vis[200013];
bool bad[200013];
int can[200013];
int high[200013];
int s[200013];
void setup(int x, int p, int T) {
vis[x] = 1;
bad[x] = 0;
can[x] = 1;
high[x] = 0;
for (int i : adj[x])
if (i != p) {
if (a[i] < T)
bad[x] = 1;
else {
setup(i, x, T);
if (bad[i]) {
bad[x] = 1;
high[x] = max(high[x], can[i] + high[i]);
} else
can[x] += can[i];
}
}
}
bool go(int x, int p, int T, int cana, bool bada) {
if (can[x] + high[x] >= k) return true;
if (can[x] + cana >= k) return true;
if (!bada && can[x] + cana + high[x] >= k) return true;
bool badx = 0;
int cnt = 0;
int canx = 1;
vector<int> highx;
highx.push_back(0);
for (int i : adj[x])
if (i != p) {
if (a[i] < T)
badx = 1;
else {
if (bad[i]) {
badx = 1;
cnt += 1;
highx.push_back(can[i] + high[i]);
} else
canx += can[i];
}
}
if (bada) {
badx = 1;
cnt += 1;
highx.push_back(cana);
} else
canx += cana;
sort(highx.begin(), highx.end(), greater<int>());
for (int i : adj[x])
if (i != p) {
if (a[i] >= T) {
if (bad[i]) {
if (cnt == 1) {
if (go(i, x, T, canx, 0)) return true;
} else {
int ind = 0;
if (highx[ind] == can[i] + high[i]) ind += 1;
if (go(i, x, T, canx + highx[ind], 1)) return true;
}
} else {
if (go(i, x, T, canx + highx[0] - can[i], badx)) return true;
}
}
}
return false;
}
bool solve(int x, int T) {
setup(x, 0, T);
return go(x, 0, T, 0, 0);
}
bool check(int T) {
for (int i = 1; i <= n; i++) {
vis[i] = 0;
bad[i] = 0;
can[i] = 0;
high[i] = 0;
}
for (int i = 1; i <= n; i++)
if (!vis[i] && a[i] >= T) {
if (solve(i, T)) {
return true;
}
}
return false;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int low = 0;
int high = 1000001;
while (high - low > 1) {
if (check((low + high) / 2))
low = (low + high) / 2;
else
high = (low + high) / 2;
}
printf("%d\n", low);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int si = 1e4 + 10;
long long int n, k, a[si], p, c[si];
int mark[si], t = 1;
vector<long long int> node[si];
void process(int s) {
mark[s] = 1;
for (auto pos : node[s]) {
if (mark[pos] == 0) {
mark[pos] = 1;
if (c[pos] != c[s]) {
t++;
}
process(pos);
}
}
}
void dfs(int start) {
memset(mark, 0, sizeof(mark));
process(start);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> p;
node[i].push_back(p);
node[p].push_back(i);
}
for (int i = 1; i <= n; i++) cin >> c[i];
dfs(1);
cout << t << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(INT_MAX - 100);
const int N = (int)(0);
const long long mod = (int)(1e+9 + 7);
map<string, int> P;
string h[7] = {"Anka", "Chapay", "Cleo", "Troll",
"Dracul", "Snowy", "Hexadecimal"};
int x[3];
bool A[7][7];
int main() {
for (int h_ = 0; h_ < 7; h_++) P[h[h_]] = h_;
int pos[7] = {0, 1, 2, 3, 4, 5, 6};
int n;
cin >> n;
string n1, s, n2;
for (int it1 = 0; it1 < n; it1++) {
cin >> n1 >> s >> n2;
A[P[n1]][P[n2]] = 1;
}
for (int m = 0; m < 3; m++) scanf("%d", &x[m]);
sort(x, x + 3);
int mde = INF, Ma = -INF;
do {
for (int k1 = 1; k1 <= 5; k1++) {
for (int k2 = k1 + 1; k2 <= 6; k2++) {
int k[3] = {k1, k2 - k1, 7 - k2};
sort(k, k + 3);
int e[3];
for (int it1 = 0; it1 < 3; it1++) e[it1] = x[it1] / k[it1];
sort(e, e + 3);
int de = e[2] - e[0];
int a1, a2, a3;
a1 = a2 = a3 = 0;
for (int p1 = (0); p1 <= (k1 - 1); p1++)
for (int p2 = (0); p2 <= (k1 - 1); p2++) a1 += A[pos[p1]][pos[p2]];
for (int p1 = (k1); p1 <= (k2 - 1); p1++)
for (int p2 = (k1); p2 <= (k2 - 1); p2++) a2 += A[pos[p1]][pos[p2]];
for (int p1 = (k2); p1 <= (6); p1++)
for (int p2 = (k2); p2 <= (6); p2++) a3 += A[pos[p1]][pos[p2]];
if (mde > de) {
mde = de;
Ma = a1 + a2 + a3;
continue;
}
if (mde == de) {
Ma = max(Ma, a1 + a2 + a3);
continue;
}
}
}
} while (next_permutation(pos, pos + 7));
cout << mde << " " << Ma;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100100;
vector<int> v[MAX];
set<int> s[MAX];
map<int, int> mp;
void turnon(int x) {
for (vector<int>::iterator i = v[x].begin(); i != v[x].end(); ++i)
if (s[*i].size()) {
cout << "Conflict with " << *s[*i].begin() << "\n";
return;
}
mp[x] = 1;
for (vector<int>::iterator i = v[x].begin(); i != v[x].end(); ++i)
s[*i].insert(x);
cout << "Success\n";
return;
}
void turnof(int x) {
mp[x] = 0;
for (vector<int>::iterator i = v[x].begin(); i != v[x].end(); ++i)
s[*i].erase(x);
cout << "Success\n";
return;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 2; i <= n; ++i)
for (int j = i; j <= n; j += i) v[j].push_back(i);
for (int i = 0; i < m; ++i) {
char x;
int y;
cin >> x >> y;
if (x == '+') {
if (mp[y] == 1)
cout << "Already on\n";
else
turnon(y);
} else {
if (mp[y] == 0)
cout << "Already off\n";
else
turnof(y);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> v) {
for (int i = 0; i < (v.size()); ++i) os << v[i] << " ";
os << endl;
return os;
}
void verify(bool condition) {
if (!condition) cerr << "WRONG WRONG" << endl;
}
int p;
int PP(int x, int n) {
if (n == 0)
return 1;
else {
long long z = PP(x, n / 2);
if (n % 2 == 0)
return (z * z) % p;
else
return (z * z) % p * x % p;
}
}
void bfs(int v, vector<int> &res, map<int, int> &before) {
int maxd = 18;
int maxOffset = 1;
vector<int> q;
q.push_back(v);
map<int, int> ma;
ma[v] = 0;
for (int i = 0; i < q.size(); ++i) {
int curv = q[i];
int d = ma[curv];
if (d >= maxd) continue;
int nextv = PP(curv, p - 2);
if (ma.find(nextv) == ma.end()) {
ma[nextv] = d + 1;
before[nextv] = curv;
q.push_back(nextv);
}
for (int x = (-maxOffset); x <= (maxOffset); ++x)
if (x != 0) {
int nextv = (curv + x + p) % p;
if (ma.find(nextv) == ma.end()) {
ma[nextv] = d + 1;
before[nextv] = curv;
q.push_back(nextv);
}
}
}
sort(q.begin(), q.end());
for (int i = 0; i < (q.size()); ++i) res.push_back(q[i]);
}
vector<int> trace(int u, int v, map<int, int> &before) {
vector<int> res;
while (u != v) {
int bu = before[u];
if ((bu + 1) % p == u)
res.push_back(1);
else if ((bu + p - 1) % p == u)
res.push_back(2);
else
res.push_back(3);
u = bu;
}
reverse(res.begin(), res.end());
return res;
}
void check(vector<int> &res, int u, int v) {
for (int i = 0; i < (res.size()); ++i) {
if (res[i] == 1)
u = (u + 1) % p;
else if (res[i] == 2)
u = (u + p - 1) % p;
else
u = PP(u, p - 2);
}
if (u == v) cout << "Correct" << endl;
}
int main() {
int u, v;
cin >> u >> v >> p;
map<int, int> bu, bv;
vector<int> vu;
bfs(u, vu, bu);
vector<int> vv;
bfs(v, vv, bv);
for (int i = 0; i < (vv.size()); ++i) {
int tv = vv[i];
int id = lower_bound(vu.begin(), vu.end(), tv) - vu.begin();
if (id < vu.size() && vu[id] >= tv && vu[id] - tv < 150) {
int tu = vu[id];
vector<int> p1 = trace(tu, u, bu);
vector<int> p2 = trace(tv, v, bv);
reverse(p2.begin(), p2.end());
vector<int> res;
for (int i = 0; i < (p1.size()); ++i) res.push_back(p1[i]);
for (int i = 0; i < (vu[id] - tv); ++i) res.push_back(2);
for (int i = 0; i < (p2.size()); ++i) {
if (p2[i] == 3)
res.push_back(p2[i]);
else
res.push_back(3 - p2[i]);
}
cout << res.size() << endl;
for (int i = 0; i < (res.size()); ++i) cout << res[i] << " ";
cout << endl;
break;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
long long n, m;
long long ele(long long base, long long e) {
long long ans = 1;
while (e) {
if (e & 1) ans = (ans * base) % MOD;
base = (base * base) % MOD;
e >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
long long k = 2;
cin >> n >> m;
long long ans = ele(4, n * m);
long long wtf = (n + m - k);
long long wtf2 = ((n * m) - 1 - wtf);
long long d = ele(2, wtf);
long long q = ele(4, wtf2);
long long b = (d * q) % MOD;
b = ele(b, MOD - 2);
ans = (ans * b) % MOD;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double dp[3000][3000];
int main() {
long long n, t, i, j;
double p;
cin >> n >> p >> t;
dp[1][1] = p;
dp[1][0] = 1 - p;
for (i = 2; i <= t; i++) {
for (j = 0; j <= min(n, i); j++) {
if (j == n)
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] * p;
else
dp[i][j] = dp[i - 1][j] * (1 - p) + dp[i - 1][j - 1] * p;
}
}
double ans = 0;
for (i = 1; i <= min(n, t); i++) ans += i * dp[t][i];
cout << setprecision(18) << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400005];
int l[400005], r[400005];
int aintlz[1600005], lazy[1600005];
int aint[800005];
int h[400005];
void init(int nod, int l, int r) {
if (l == r)
aint[nod] = l;
else {
int mid = (l + r) / 2;
init(2 * nod, l, mid);
init(2 * nod + 1, mid + 1, r);
if (a[aint[2 * nod]] < a[aint[2 * nod + 1]])
aint[nod] = aint[2 * nod];
else
aint[nod] = aint[2 * nod + 1];
}
}
int query(int nod, int l, int r, int x, int y) {
if (l >= x && r <= y)
return aint[nod];
else {
int mid = (l + r) / 2;
int p1, p2;
if (x <= mid)
p1 = query(2 * nod, l, mid, x, y);
else
p1 = -1;
if (y > mid)
p2 = query(2 * nod + 1, mid + 1, r, x, y);
else
p2 = -1;
if (p1 == -1)
return p2;
else if (p2 == -1)
return p1;
else {
if (a[p1] < a[p2])
return p1;
else
return p2;
}
}
}
void tree(int x, int y, int lev) {
if (x == y)
h[x] = lev;
else {
int pmin = query(1, 1, n, x, y);
h[pmin] = lev;
if (pmin > x) tree(x, pmin - 1, lev + 1);
if (pmin < y) tree(pmin + 1, y, lev + 1);
}
}
void initlz(int nod, int l, int r) {
if (l == r)
aintlz[nod] = h[l];
else {
int mid = (l + r) / 2;
initlz(2 * nod, l, mid);
initlz(2 * nod + 1, mid + 1, r);
aintlz[nod] = max(aintlz[2 * nod], aintlz[2 * nod + 1]);
}
}
void updatelz(int nod, int l, int r, int x, int y, int val) {
if (l > r) return;
if (lazy[nod] != 0) {
aintlz[nod] += lazy[nod];
if (l < r) {
lazy[2 * nod] += lazy[nod];
lazy[2 * nod + 1] += lazy[nod];
}
lazy[nod] = 0;
}
if (l > y || r < x) return;
if (l >= x && r <= y) {
aintlz[nod] += val;
if (l < r) {
lazy[2 * nod] += val;
lazy[2 * nod + 1] += val;
}
return;
}
int mid = (l + r) / 2;
updatelz(2 * nod, l, mid, x, y, val);
updatelz(2 * nod + 1, mid + 1, r, x, y, val);
aintlz[nod] = max(aintlz[2 * nod], aintlz[2 * nod + 1]);
}
int querylz(int nod, int l, int r, int x, int y) {
if (x == 0) return 0;
if (lazy[nod] != 0) {
aintlz[nod] += lazy[nod];
if (l < r) {
lazy[2 * nod] += lazy[nod];
lazy[2 * nod + 1] += lazy[nod];
}
lazy[nod] = 0;
}
if (l >= x && r <= y)
return aintlz[nod];
else {
int mid = (l + r) / 2;
int v1 = -1, v2 = -1;
if (x <= mid) v1 = querylz(2 * nod, l, mid, x, y);
if (y > mid) v2 = querylz(2 * nod + 1, mid + 1, r, x, y);
return max(v1, v2);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i + n] = a[i];
}
init(1, 1, n);
tree(1, n, 1);
n *= 2;
initlz(1, 1, n);
l[1] = 0;
for (int i = 2; i <= n; ++i) {
l[i] = i - 1;
while (a[l[i]] >= a[i]) l[i] = l[l[i]];
}
r[n] = n + 1;
for (int i = n - 1; i >= 1; --i) {
r[i] = i + 1;
while (a[r[i]] >= a[i]) r[i] = r[r[i]];
}
int hmin = aintlz[1];
int shl = 0;
for (int i = 1; i < n / 2; ++i) {
if (r[i] < i + n / 2) updatelz(1, 1, n, i + 1, r[i] - 1, -1);
if (l[i + n / 2] > i) updatelz(1, 1, n, l[i + n / 2] + 1, i + n / 2 - 1, 1);
h[i + n / 2] = querylz(1, 1, n, l[i + n / 2], l[i + n / 2]) + 1;
updatelz(1, 1, n, i + n / 2, i + n / 2, h[i + n / 2]);
h[i] = -querylz(1, 1, n, i, i);
updatelz(1, 1, n, i, i, h[i]);
if (aintlz[1] < hmin) {
hmin = aintlz[1];
shl = i;
}
}
cout << hmin << " " << shl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int ddx[8] = {1, 1, 0, -1, -1, -1, 0, 1}, ddy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void mad(long long &a, long long b) {
a = (a + b) % 1000000007;
if (a < 0) a += 1000000007;
}
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (!a) return b;
return gcd(b % a, a);
}
int dp[1 << 22];
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < 1 << 22; i++) dp[i] = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[a[i]] = i;
}
for (int i = 0; i < 1 << 22; i++) {
if (dp[i] == -1) continue;
for (int j = 0; j < 22; j++) {
if (!(i & (1 << j))) dp[i | (1 << j)] = dp[i];
}
}
for (int i = 0; i < n; i++) {
int id = dp[(1 << 22) - 1 - a[i]];
if (id == -1)
cout << -1 << " ";
else
cout << a[id] << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string f(string &s) {
for (int i = 0; i < s.size(); i++)
if (s[i] < 'a') s[i] += 32;
return s;
}
int main() {
int n;
string a, b;
map<string, int> mp;
mp.insert(pair<string, int>("polycarp", 1));
cin >> n;
while (n--) {
cin >> a >> b >> b;
a = f(a);
b = f(b);
auto it = mp.find(b);
mp.insert(pair<string, int>(a, it->second + 1));
}
int m = -1;
for (auto i = mp.begin(); i != mp.end(); ++i) m = max(i->second, m);
cout << m;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<int> a(m, 0);
char c[n][m];
for (int(i) = (0); (i) < (n); (i)++)
for (int(j) = (0); (j) < (m); (j)++) {
cin >> c[i][j];
if (c[i][j] == '1') a[j]++;
}
for (int(i) = (0); (i) < (n); (i)++) {
bool b = 0;
for (int(j) = (0); (j) < (m); (j)++)
if (c[i][j] == '1' && a[j] - 1 == 0) {
b = 1;
break;
}
if (!b) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans;
int gcd(int a, int b) {
for (int t; b; t = a, a = b, b = t % a)
;
return a;
}
void Sol(int k) {
while (k < m) {
ans += m - k;
k = k << 1;
}
}
int main() {
scanf("%d%d", &n, &m);
int t = 0, x;
while (n--) {
scanf("%d", &x);
t = gcd(x - 1, t);
}
while (~t & 1) t = t >> 1;
for (n = 1; n * n < t; n++)
if (t % n == 0) Sol(n), Sol(t / n);
if (n * n == t) Sol(n);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int j, a[111], x, y, s = 0, m = 0, i = 2, n;
cin >> n;
for (j = 1; j <= n; j++) cin >> a[j];
x = a[1];
while (x == a[i]) {
i++;
}
if (i > n) {
cout << "NO";
goto End;
} else {
y = a[i];
}
for (i = 1; i <= n; i++) {
if (x == a[i])
s++;
else {
if (y == a[i]) m++;
}
}
if (s + m == n && s == m)
cout << "YES\n" << x << " " << y;
else {
cout << "NO";
}
End:
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
if (b == 0) return 1;
long long p = power(a, b / 2);
if (b & 1)
return p * p * a;
else
return p * p;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
vector<long long int> v(n);
long long int max = LLONG_MIN;
for (long long int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] > max) {
max = v[i];
}
}
if (k % 2 != 0) {
for (long long int i = 0; i < n; i++) {
v[i] = max - v[i];
cout << v[i] << " ";
}
cout << "\n";
}
if (k % 2 == 0) {
long long int max1 = LLONG_MIN;
for (long long int i = 0; i < n; i++) {
v[i] = max - v[i];
if (v[i] > max1) {
max1 = v[i];
}
}
for (long long int i = 0; i < n; i++) {
v[i] = max1 - v[i];
cout << v[i] << " ";
}
cout << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
char line[101];
char newLine[101];
int flag = 0;
int t = 0;
int lengthOfString = 0;
fgets(line, 101, stdin);
if (strlen(line) - 1 == 1) {
newLine[t] = line[0];
newLine[t + 1] = '\0';
} else {
if (line[strlen(line) - 1] != '\n') {
lengthOfString = strlen(line) - 1;
} else {
lengthOfString = strlen(line) - 2;
}
for (int i = 0; i <= strlen(line) - 1; i++) {
if (i == lengthOfString) {
if (line[i] != '/' && flag == 1) {
newLine[t] = line[i];
newLine[t + 1] = '\0';
} else if (flag == 0) {
newLine[t] = line[i];
newLine[t + 1] = '\0';
} else {
newLine[t] = '\0';
}
break;
}
if (line[i] == '/' && line[i + 1] == '/') {
newLine[t] = line[i];
} else {
newLine[t] = line[i];
t++;
flag = 1;
}
}
}
printf("%s", newLine);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = (int)(s).size();
vector<vector<long long> > dp(n, vector<long long>(10));
for (int i = 0; i < 10; ++i) {
dp[0][i] = 1;
}
for (int i = 1; i < n; ++i) {
for (int d = 0; d < 10; ++d) {
int x = (s[i] - '0') + d;
dp[i][x / 2] += dp[i - 1][d];
if (x % 2 == 1 && (x / 2 + 1) < 10) {
dp[i][x / 2 + 1] += dp[i - 1][d];
}
}
}
long long ans = 0;
for (int d = 0; d < 10; ++d) {
ans += dp[n - 1][d];
}
bool ok = true;
for (int i = 1; i < n; ++i) {
int x = (s[i] - '0') + (s[i - 1] - '0');
if (x / 2 != s[i] - '0' && (x + 1) / 2 != s[i] - '0') {
ok = false;
}
}
if (ok) {
--ans;
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
int n;
int ans[N];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == a[i + 1]) {
ans[++cnt] = a[i] + 1;
while (ans[cnt] == ans[cnt - 1] && cnt - 1) ans[cnt - 1]++, cnt--;
a[i + 1] = ans[cnt];
cnt--;
} else
ans[++cnt] = a[i];
}
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p1 = -1000000001;
int p2 = -1000000001;
int n;
int q1, h, q2, a, b, c1, c2;
int main() {
cin >> n;
for (; n; n--) {
cin >> q1 >> h;
q2 = q1 + h;
a = -1;
if (q1 - h > p1) a = max(a, c1 + 1);
if (q1 > p1) a = max(a, c1);
if (q1 - h > p2) a = max(a, c2 + 1);
if (q1 > p2) a = max(a, c2);
b = -1;
if (q1 > p1) b = max(b, c1 + 1);
if (q1 > p2) b = max(b, c2 + 1);
p1 = q1;
c1 = a;
p2 = q2;
c2 = b;
}
cout << max(c1, c2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[17], num, hold;
int main(int argc, char const *argv[]) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
num = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &hold);
if (hold) num = num | (1 << j);
}
a[num] = 1;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if ((!(i & j)) && a[i] && a[j]) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000004;
int l, r, p;
int prime[111], js;
int n, a[N], f[N];
int b[N], ans;
bool cn[111];
void get_prime(int n) {
for (int i = 2; i <= n; ++i) {
if (!cn[i]) prime[++js] = i;
for (int j = 1; j <= js && prime[j] * i <= n; ++j) {
cn[prime[j] * i] = 1;
if (i % prime[j] == 0) break;
}
}
}
void dfs(int u, int v) {
a[++n] = u;
for (int i = v; i <= js; ++i)
if (u > r / prime[i])
return;
else
dfs(u * prime[i], i);
}
int main() {
scanf("%d%d%d", &l, &r, &p);
get_prime(p - 1);
dfs(1, 1);
sort(a + 1, a + n + 1);
memset(f, 55, sizeof(f));
f[1] = 0;
for (int i = 2; i <= p - 1; ++i)
for (int j = 1, down = 1; j <= n; ++j)
if (a[j] % i == 0) {
while (a[down] * i < a[j]) down++;
f[j] = min(f[j], f[down] + 1);
if (f[j] + i <= p) b[j] = 1;
}
for (int i = 1; i <= n; ++i)
if (b[i] && a[i] >= l) ans++;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 3e5 + 100;
int a[2][maxn];
int n;
long long ans = 0;
long long sum[2][maxn];
long long f[2][2][maxn];
long long calc1(int x) {
if (x > n) return -0x3f3f3f3f3f3f3f3fLL;
return f[0][0][x] + f[1][1][x];
}
long long calc2(int x) {
if (x > n) return -0x3f3f3f3f3f3f3f3fLL;
return f[1][0][x] + f[0][1][x];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[0][i];
}
for (int i = 1; i <= n; i++) {
cin >> a[1][i];
}
for (int i = 1; i <= n; i++) {
sum[0][i] = sum[0][i - 1] + a[0][i];
sum[1][i] = sum[1][i - 1] + a[1][i];
}
for (int i = n; i >= 1; i--) {
f[0][0][i] = f[0][0][i + 1] + sum[0][n] - sum[0][i - 1];
f[0][1][i] = f[0][1][i + 1] + sum[1][n] - sum[1][i - 1];
f[1][1][i] = f[1][1][i + 1] + 1LL * (n - i + 1) * a[1][i];
f[1][0][i] = f[1][0][i + 1] + 1LL * (n - i + 1) * a[0][i];
}
for (int i = 1; i <= n; i++) {
}
long long cnt = 0;
long long temp_sum = 0;
for (int i = 1; i <= n; i++) {
if (i % 2) {
ans =
max(ans, temp_sum + calc1(i) +
(sum[0][n] - sum[0][i - 1] + sum[1][n] - sum[1][i - 1]) *
(cnt - 1) +
(sum[1][n] - sum[1][i - 1]) * (n - i + 1));
temp_sum += cnt * a[0][i];
cnt++;
temp_sum += cnt * a[1][i];
cnt++;
} else {
ans =
max(ans, temp_sum + calc2(i) +
(sum[0][n] - sum[0][i - 1] + sum[1][n] - sum[1][i - 1]) *
(cnt - 1) +
(sum[0][n] - sum[0][i - 1]) * (n - i + 1));
temp_sum += cnt * a[1][i];
cnt++;
temp_sum += cnt * a[0][i];
cnt++;
}
}
cout << max(ans, temp_sum) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long Ha[300005], Tar, Po = 1, ans;
int be[300005], ed[300005], fa[300005], a[300005];
vector<int> tre[300005];
string str[300005], tar;
int size[300005], hson[300005];
void init(int u) {
size[u] = 1;
for (int i = 0; i < tre[u].size(); i++) {
int v = tre[u][i];
Ha[v] = Ha[u] * 233 + a[v];
init(v);
size[u] += size[v];
if (size[hson[u]] < size[v]) hson[u] = v;
}
}
int HS;
map<unsigned long long, int> cnt;
void add(int u, int k) {
cnt[Ha[u]] += k;
for (int i = 0; i < tre[u].size(); i++) {
int v = tre[u][i];
if (v == HS) continue;
add(v, k);
}
}
void dfs(int u, bool kep) {
for (int i = 0; i < tre[u].size(); i++) {
int v = tre[u][i];
if (hson[u] == v) continue;
dfs(v, false);
}
if (hson[u]) {
dfs(hson[u], true);
HS = hson[u];
}
add(u, 1);
HS = 0;
unsigned long long tmp = Ha[u] * Po + Tar;
ans += cnt[tmp];
if (!kep) add(u, -1);
}
int main() {
int n, tot = 1;
ios::sync_with_stdio(false);
cin >> n;
ed[1] = tot;
for (int i = 2; i <= n; i++) {
cin >> fa[i] >> str[i];
a[++tot] = str[i][0];
be[i] = tot;
for (int j = 1; j < str[i].size(); j++) {
a[++tot] = str[i][j];
tre[tot - 1].push_back(tot);
}
ed[i] = tot;
}
for (int i = 2; i <= n; i++) tre[ed[fa[i]]].push_back(be[i]);
cin >> tar;
for (int i = 0; i < tar.size(); i++) Tar = tar[i] + Tar * 233;
for (int i = 0; i < tar.size(); i++) Po *= 233;
init(1);
dfs(1, 1);
printf("%I64d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dp[410][410];
bool solve(string s, string t) {
long long s_size = s.size();
long long t_size = t.size();
s += '#';
t += '$';
for (long long i = 0; i <= t_size; i++) {
memset(dp, 255, sizeof(dp));
dp[0][0] = i;
for (long long j = 0; j <= s_size; j++)
for (long long k = 0; k <= i; k++) {
if (dp[j][k] == -1) continue;
dp[j + 1][k] = max(dp[j + 1][k], dp[j][k]);
if (s[j] == t[k]) dp[j + 1][k + 1] = max(dp[j + 1][k + 1], dp[j][k]);
if (s[j] == t[dp[j][k]]) dp[j + 1][k] = max(dp[j + 1][k], dp[j][k] + 1);
}
if (dp[s_size][i] == t_size) return true;
}
return false;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
string s, t;
cin >> s >> t;
cout << (solve(s, t) ? "YES\n" : "NO\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int n, days, low, mid, high, i;
cin >> n >> days;
long long int a[2 * n + 1];
long long int pre1[2 * n + 1], pre2[2 * n + 1], ma = 0, ans, temp, sum;
a[0] = 0;
pre1[0] = pre2[0] = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
a[n + i] = a[i];
}
for (i = 1; i <= 2 * n; i++) {
pre1[i] = pre1[i - 1] + ((a[i] * (a[i] + 1)) / 2);
}
for (i = 1; i <= 2 * n; i++) {
pre2[i] = pre2[i - 1] + a[i];
}
for (i = 2 * n; i > n; i--) {
ans = lower_bound(pre2, pre2 + 2 * n + 1, pre2[i] - days) - pre2;
temp = pre2[i] - pre2[ans - 1] - days;
sum = pre1[i] - pre1[ans - 1];
sum -= (temp * (temp + 1)) / 2;
ma = max(ma, sum);
}
cout << ma;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vpll = vector<pair<ll, ll>>;
using pi = pair<int, int>;
using pll = pair<ll, ll>;
const int maxn = 2e5 + 10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, ans = 0;
cin >> n;
pi a[maxn];
for (int i = 1; i <= n; ++i) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n + 1);
vector<int> tv1, tv2;
for (int i = 1; i <= n; ++i) {
if (tv1.empty() || a[tv1.back()].second < a[i].first) {
tv1.push_back(i);
continue;
}
if (tv2.empty() || a[tv2.back()].second < a[i].first) tv2.push_back(i);
}
if (tv1.size() + tv2.size() == n)
cout << "YES";
else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long power(long long base, long long n) {
if (n == 0) return 1;
if (n == 1) return base;
long long halfn = power(base, n / 2);
if (n % 2 == 0)
return (halfn * halfn) % M;
else
return (((halfn * halfn) % M) * base) % M;
}
void solve() {
long long p, q;
cin >> p >> q;
if (p % q != 0) {
cout << p << '\n';
return;
}
vector<long long> v;
long long z = sqrt(q), i;
for (i = 2; i <= z; i++) {
if (q % i == 0) {
v.push_back(i);
if (i != (q / i)) v.push_back(q / i);
}
}
sort(v.begin(), v.end());
v.push_back(q);
long long x = p / q;
long long ans = 1;
for (long long i = v.size() - 1; i >= 0; i--) {
long long an = 1, xx = x;
while (xx % v[i] == 0) xx /= v[i];
an = xx * (q / v[i]);
if (an % q) ans = max(ans, an);
}
cout << ans << '\n';
}
int main() {
fast();
long long tt;
cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long base = 1e9 + 7;
const int N = 1000000;
const double bs = 1e-7;
const double pi = 3.1415926535897;
long long a[N], cnt, sum, n, b[N];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
sum = 0;
for (int i = 2; i <= n; ++i)
if (a[i] == a[i - 1]) ++sum;
if (sum == n - 1) {
cout << "YES";
return 0;
}
sort(a + 1, a + n + 1);
int top = a[1], bot = a[n], check = 0, mid;
for (int i = 1; i <= n; ++i)
if (a[i] != top && a[i] != bot) {
check = 1;
break;
}
if (!check) {
cout << "YES";
return 0;
}
top = a[1], bot = a[n], check = 0, mid;
for (int i = 1; i <= n; ++i)
if (a[i] != top && a[i] != bot) {
mid = a[i];
break;
}
for (int i = 1; i <= n; ++i)
if (a[i] != top && a[i] != bot && a[i] != mid) {
check = 1;
break;
}
if (!check && mid - top == bot - mid) {
cout << "YES";
return 0;
}
sum = 0;
for (int i = 1; i <= n; ++i) sum = sum + a[i];
if (sum % n != 0) {
cout << "NO";
} else {
sum = sum / n;
cnt = 0;
for (int i = 1; i <= n; ++i)
if (a[i] != sum) b[++cnt] = a[i];
for (int i = 1; i <= cnt; ++i)
if (b[i] > sum)
b[i] = b[i] - sum;
else
b[i] = sum - b[i];
for (int i = 2; i <= cnt; ++i)
if (b[i] != b[i - 1]) {
cout << "NO";
return 0;
}
cout << "YES";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int Main() {
int a, b, c;
cin >> a >> b >> c;
c -= c % 4;
cout << c + c / 2 + c / 4;
return 0;
}
int main(int numb, char** modul) {
vector<int> digits;
while (numb > 0) {
int k = numb % 10;
digits.push_back(k);
numb /= 10;
}
for (int i = 0; i < digits.size() / 2; i++) {
int first = digits[i];
int last = digits[digits.size() - i + 1];
digits[i] = last;
digits[digits.size() - i + 1] = first;
}
int a, b, c;
cin >> a >> b >> c;
c -= c % 4;
b -= b % 2;
b = min(b, a * 2);
c = min(c, a * 4);
a = min(a, b / 2);
c = min(c, b * 2);
a = min(a, c / 4);
b = min(b, c / 2);
cout << a + b + c;
int numb_result = 0;
for (int i = 0; i < digits.size(); i++) {
int power = 1;
for (int j = 0; j < i; j++) {
power *= 10;
}
numb_result += digits[i] * power;
power = 0;
numb_result = power;
}
return numb_result;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, x, y, k;
cin >> n >> m;
cin >> x;
map<int, string> boy;
while (x--) {
cin >> k;
boy[k] = "happy";
}
cin >> y;
map<int, string> girl;
while (y--) {
cin >> k;
girl[k] = "happy";
}
int mx = n * m * 1000;
for (int i = 0; i <= mx; i++) {
int bb, gg;
bb = i % n;
gg = i % m;
if (boy[bb] == "happy")
girl[gg] = "happy";
else if (girl[gg] == "happy")
boy[bb] = "happy";
}
map<int, string>::iterator itb;
map<int, string>::iterator itg;
itb = boy.begin();
itg = girl.begin();
while (itb != boy.end()) {
if (itb->second != "happy") {
cout << "No";
return 0;
}
itb++;
}
while (itg != girl.end()) {
if (itg->second != "happy") {
cout << "No";
return 0;
}
itg++;
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long int n, x, f, j, count = 0;
scanf("%I64d", &n);
long int c[n];
for (j = 0; j < n; j++) {
scanf("%I64d", &c[j]);
}
scanf("%I64d %I64d", &x, &f);
for (j = 0; j < n; j++) {
if (c[j] > x) {
count += c[j] / (x + f);
if (c[j] % (x + f) > x) count += 1;
}
}
long long int price = count * f;
printf("%I64d", price);
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.