solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d %d", &n, &k);
int tmp = 0;
for (int j = 0; j < n; j++) {
printf("%c", tmp++ % k + 'a');
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, f;
scanf("%d", &n);
int ar[n];
for (int i = 0; i < n; i++) {
scanf("%d", &ar[i]);
}
scanf("%d %d", &s, &f);
int maxppl = 0;
for (int i = s; i < f; i++) {
maxppl += ar[i - 1];
}
int time = 1;
int k = time;
int ppl = maxppl;
for (int i = s - 1; k < n; i--) {
k++;
if (i == 0) i = n;
ppl += ar[i - 1];
int last = (i + f - s) % n;
if (last == 0) last = n;
ppl -= ar[last - 1];
if (ppl > maxppl) {
maxppl = ppl;
time = k;
}
}
printf("%d", time);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[(100010)], r[(100010)];
unsigned long long m, n, cifang;
unsigned long long f[111][111], ans, t;
bool cmp(unsigned long long L, unsigned long long R) {
char g[(100010)];
for (unsigned long long i = L; i <= R; i++) g[i - L + 1] = r[i];
if (R - L + 1 > m) return 1;
if (R - L + 1 < m) return 0;
for (unsigned long long i = 1; i <= m; i++) {
if (g[i] < s[i]) return 0;
if (g[i] > s[i]) return 1;
}
return 1;
}
void work(unsigned long long L, unsigned long long R) {
if (L > R) return;
unsigned long long x = 0;
for (unsigned long long i = L; i <= R; i++) x = x * 10 + r[i] - '0';
for (unsigned long long i = 1; i <= cifang; i++) x *= t;
ans += x;
}
bool judge(unsigned long long L, unsigned long long R) {
for (unsigned long long i = L; i <= R; i++)
if (r[i] != '0') return 1;
return 0;
}
signed main() {
scanf("%s", s + 1);
scanf("%s", r + 1);
m = strlen(s + 1), n = strlen(r + 1);
for (unsigned long long i = 1; i <= m; i++) t = t * 10 + s[i] - '0';
if (r[1] == '0') {
puts("0");
return 0;
}
unsigned long long p = n, i = n;
while (i > 0) {
if (i <= 0) break;
if (r[i] == '0') {
unsigned long long zz;
for (unsigned long long j = i; r[j] == '0'; j--) zz = j;
if (r[zz] == '0') zz--;
if (cmp(zz, p)) {
if (judge(i, p)) work(i + 1, p), cifang++, p = i;
unsigned long long numofz = 0, k = p;
while (cmp(zz, k)) numofz++, k--;
cifang += numofz;
while (zz && !cmp(zz, k)) zz--;
zz++;
while (r[zz] == '0') zz++;
work(zz, k), p = i = zz - 1, cifang++;
} else {
while (zz && !cmp(zz, p)) zz--;
zz++;
while (r[zz] == '0') zz++;
work(zz, p), cifang++, p = i = zz - 1;
}
} else {
if (cmp(i, p)) work(i + 1, p), cifang++, p = i;
i--;
}
}
work(1, p);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
long long n, k, cost;
pair<int, int> sa, sb;
void solve() {
cost = 0;
cin >> n >> k >> sa.first >> sa.second >> sb.first >> sb.second;
long long maxprofit, i, diff;
cost = LLONG_MAX;
if (max(sa.first, sb.first) <= min(sa.second, sb.second)) {
long long rem =
max(0LL, k - n * (min(sa.second, sb.second) - max(sa.first, sb.first)));
maxprofit = (abs(sa.first - sb.first) + abs(sa.second - sb.second)) * n;
cost = min(rem, maxprofit) + max(0LL, rem - maxprofit) * 2LL;
} else {
diff = max(sa.first, sb.first) - min(sa.second, sb.second);
for (i = 1; i <= n; ++i) {
long long cur = diff * i;
maxprofit = (max(sb.second, sa.second) - min(sa.first, sb.first)) * i;
cur += min(k, maxprofit) + max(0LL, k - maxprofit) * 2LL;
42;
cost = min(cost, cur);
}
}
cout << cost << endl;
}
int main() {
{
int tc;
cin >> tc;
while (tc--) solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;
using pii = pair<int, int>;
using pci = pair<char, int>;
using pcc = pair<char, char>;
using V = vector<long long>;
const long long N = 2e5 + 10;
const long long MOD = 1e9 + 7;
long long i, j, a[N], b[N], sum[N];
unordered_map<long long, long long> mp;
set<long long> S;
string s = "";
stack<long long> p;
queue<long long> q;
V v;
long long test;
long long n, k;
bool check(long long x, long long state) {
long long ans = 0;
for (int i = 0; i < n; i++) {
if (!state) {
ans++;
state ^= 1;
} else {
if (a[i] <= x) {
ans++;
state ^= 1;
}
}
}
return ans >= k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
long long lo = 0;
long long hi = 1e9 + 10;
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
if (check(mid, 0) || check(mid, 1)) {
hi = mid;
} else
lo = mid;
}
if (check(lo, 0) || check(lo, 1)) hi--;
cout << hi << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gene(233);
inline char GET_CHAR() {
const int maxn = 131072;
static char buf[maxn], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, maxn, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int getInt() {
int res(0);
char c = getchar();
while (c < '0') c = getchar();
while (c >= '0') {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
inline int fastpo(int x, int n, int mod) {
int res(1);
while (n) {
if (n & 1) {
res = res * (long long)x % mod;
}
x = x * (long long)x % mod;
n /= 2;
}
return res;
}
inline string itoa(int x, int width = 0) {
string res;
if (x == 0) res.push_back('0');
while (x) {
res.push_back('0' + x % 10);
x /= 10;
}
while ((int)res.size() < width) res.push_back('0');
reverse(res.begin(), res.end());
return res;
}
const int N = 300033;
const int LOG = 20;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct P {
long long x, y;
P operator-(const P& b) const { return P{x - b.x, y - b.y}; }
long long operator*(const P& b) const { return x * b.y - y * b.x; }
};
int main() {
scanf("%d", &n);
long long cur = 0;
vector<P> a, c;
for (int i(1); i <= n; i++) {
int x;
scanf("%d", &x);
cur += x;
a.push_back(P{i, cur});
}
c.push_back(P{0, 0});
for (P p : a) {
while (c.size() >= 2u &&
(p - c.back()) * (c.back() - c[(int)c.size() - 2]) >= 0) {
c.pop_back();
}
c.push_back(p);
}
P prv{0, 0};
int _ = 0;
for (P p : c) {
if (p.x == 0 && p.y == 0) continue;
for (int i = prv.x; i < p.x; i++) {
_++;
printf("%.12f\n", (double)(p.y - prv.y) / (p.x - prv.x));
}
prv = p;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932384;
double ctg(double x) { return cos(x) / sin(x); }
int main() {
double answer = 0;
for (int i = 3; i <= 5; ++i) {
double l;
cin >> l;
double R = l / (2 * sin(PI / i));
double h = sqrt(l * l - R * R);
answer += h * ctg(PI / i) * i * l * l / 4;
}
printf("%.10lf", answer / 3);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> ans;
for (int i = 0; i <= sqrt(n); i++) ans.push_back(i);
for (int i = 1; i <= sqrt(n); i++) ans.push_back(n / i);
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
cout << ans.size() << endl;
for (auto x : ans) cout << x << " ";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int ans = 0, arr[5005] = {0};
for (int i = 0; i + 3 < n; ++i) {
if (s[i] == 'b' && s[i + 1] == 'e' && s[i + 2] == 'a' && s[i + 3] == 'r') {
arr[i + 3] = 1;
}
}
for (int i = 0; i < n; ++i) {
int f = 0;
for (int j = i + 3; j < n; ++j) {
if (arr[j] == 1) f = 1;
ans += f;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7, MAX = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, i;
string second, r;
cin >> n >> second >> r;
vector<long long> a, b, c(n + 1, 0);
a.push_back(0), b.push_back(0);
for (auto i : second) a.push_back(i - 'a');
for (auto i : r) b.push_back(i - 'a');
for (i = n; i >= 0; i--) {
c[i] = c[i] + a[i] + b[i];
if (i && c[i] > 25) c[i] -= 26, c[i - 1]++;
}
string ans;
for (i = 0; i <= n; i++) {
if (i < n && (c[i] % 2)) c[i + 1] += 26;
c[i] /= 2;
if (i) ans.push_back('a' + c[i]);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const int INF = 2139062143;
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 100 + 5;
int n, m, nxt, a[N];
double ans, f[2][N][N];
inline int C2(int x) { return x * (x - 1) / 2; }
int main() {
read(n);
read(m);
m = min(m, 900);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
f[0][i][j] = a[i] > a[j];
}
}
nxt = 1;
for (int Turn = 1; Turn <= m; Turn++) {
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
f[nxt][i][j] =
f[nxt ^ 1][i][j] * (C2(i) + C2(n - j + 1) + C2(j - i)) / C2(n + 1);
for (int K = 1 - i; K < j - i; K++) {
f[nxt][i][j] += 1.0 * f[nxt ^ 1][i + K][j] *
min(min(i, i + K), j - max(i, i + K)) / C2(n + 1);
}
for (int K = i - j + 1; K <= n - j; K++) {
f[nxt][i][j] += 1.0 * f[nxt ^ 1][i][j + K] *
min(min(j, j + K) - i, n - max(j, j + K) + 1) /
C2(n + 1);
}
for (int K = 1 - i; K <= n - j; K++) {
f[nxt][i][j] += 1.0 * (1.0 - f[nxt ^ 1][i + K][j + K]) *
min(min(i, i + K), n - max(j, j + K) + 1) / C2(n + 1);
}
}
}
nxt ^= 1;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans += f[nxt ^ 1][i][j];
}
}
printf("%.10lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
inline int mrand(int k) { return abs((int)mt()) % k; }
struct node_t {
node_t *p, *l, *r;
int size, rev;
int s, w;
int key;
int max;
node_t(int key = 0)
: p(0), l(0), r(0), size(1), rev(0), s(0), w(1), key(key), max(key) {}
};
int isrt(node_t* x) { return !(x->p) || (x->p->l != x && x->p->r != x); }
int left(node_t* x) { return x->p->l == x; }
void setchild(node_t* x, node_t* p, int l) {
(l ? p->l : p->r) = x;
if (x) x->p = p;
}
void push(node_t* x) {
node_t* u = x->l;
node_t* v = x->r;
if (x->rev) {
if (u) swap(u->l, u->r), u->rev ^= 1;
if (v) swap(v->l, v->r), v->rev ^= 1;
x->rev = 0;
}
}
int size(node_t* x) { return x ? x->size : 0; }
int sum(node_t* x) { return x ? x->s : 0; }
int mx(node_t* x) { return x ? x->max : 0; }
void pull(node_t* x) {
x->size = size(x->l) + 1 + size(x->r);
x->s = sum(x->l) + x->w + sum(x->r);
x->max = max(mx(x->l), max(x->key, mx(x->r)));
}
void rotate(node_t* x) {
node_t *p = x->p, *g = p->p;
int l = left(x);
setchild(l ? x->r : x->l, p, l);
if (!isrt(p))
setchild(x, g, left(p));
else
x->p = g;
setchild(p, x, !l);
pull(p);
}
node_t* splay(node_t* x) {
push(x);
while (!isrt(x)) {
node_t *p = x->p, *g = p->p;
if (g) push(g);
push(p), push(x);
if (!isrt(p)) rotate(left(x) != left(p) ? x : p);
rotate(x);
}
pull(x);
return x;
}
node_t* access(node_t* x) {
node_t* z = 0;
for (node_t* y = x; y; y = y->p) {
splay(y);
y->w += sum(y->r);
y->r = z;
y->w -= sum(y->r);
pull(z = y);
}
splay(x);
return z;
}
void link(node_t* x, node_t* p) {
access(x), access(p);
x->p = p;
p->w += sum(x);
chkmax(p->max, x->max);
}
void cut(node_t* x) {
access(x);
x->l->p = 0, x->l = 0;
pull(x);
}
void makeroot(node_t* x) {
access(x);
x->rev ^= 1;
swap(x->l, x->r);
}
node_t* findroot(node_t* x) {
access(x);
while (x->l) push(x), x = x->l;
push(x);
return splay(x);
}
node_t* lca(node_t* x, node_t* y) {
if (findroot(x) != findroot(y)) return 0;
access(x);
return access(y);
}
int connect(node_t* x, node_t* y) {
if (x == y) return 1;
access(x), access(y);
return x->p != 0;
}
int treequery(node_t* x) {
access(x);
return x->w;
}
const int maxn = 2e6 + 5;
node_t pool[maxn];
void makeroot(int u) { makeroot(pool + u); }
void link(int u, int v) { link(pool + u, pool + v); }
void cut(int u) { cut(pool + u); }
int findroot(int u) { return findroot(pool + u) - pool; }
int lca(int u, int v) {
node_t* a = lca(pool + u, pool + v);
if (!a) return -1;
return a - pool;
}
int connect(int u, int v) { return connect(pool + u, pool + v); }
int treequery(int u) { return treequery(pool + u); }
int pathquery(int x, int y) {
makeroot(pool + x);
access(pool + y);
pull(pool + y);
return pool[y].max;
}
void chemthan() {
int n, m, q;
cin >> n >> m >> q;
vector<pair<int, int> > edges;
for (int i = (0); i < (m); ++i) {
int u, v;
cin >> u >> v;
u--, v--;
edges.push_back({u, v});
}
for (int i = (0); i < (2 * n + 2 * m); ++i) pool[i].key = pool[i].max = i;
vector<int> f(m);
vector<int> used(2 * m);
for (int i = (0); i < (m); ++i) {
int u, v;
tie(u, v) = edges[i];
if (findroot(2 * u) == findroot(2 * v)) {
break;
}
f[i] = 1;
for (int it = (0); it < (2); ++it) {
if (findroot(2 * u + 1) != findroot(2 * v)) {
makeroot(2 * u + 1);
makeroot(2 * v);
link(2 * u + 1, 2 * n + 2 * i + it);
link(2 * v, 2 * n + 2 * i + it);
used[2 * i + it] = 1;
}
swap(u, v);
}
}
int ptr = m - 1;
for (int i = (m)-1; i >= (0); --i) {
if (f[i]) {
while (i < ptr) {
int u, v;
tie(u, v) = edges[ptr];
if (findroot(2 * u) == findroot(2 * v)) {
break;
}
for (int it = (0); it < (2); ++it) {
if (findroot(2 * u + 1) != findroot(2 * v)) {
makeroot(2 * u + 1);
makeroot(2 * v);
pool[2 * n + 2 * ptr + it].key = pool[2 * n + 2 * ptr + it].max = 0;
link(2 * u + 1, 2 * n + 2 * ptr + it);
link(2 * v, 2 * n + 2 * ptr + it);
} else {
int d = pathquery(2 * u + 1, 2 * v);
if (2 * n <= d && d < 2 * n + 2 * ptr) {
int x = d - 2 * n >> 1;
int r = d - 2 * n & 1;
int uu, vv;
tie(uu, vv) = edges[x];
if (r) {
swap(uu, vv);
}
makeroot(d);
cut(2 * uu + 1);
cut(2 * vv);
used[d - 2 * n] = 0;
makeroot(2 * u + 1);
makeroot(2 * v);
pool[2 * n + 2 * ptr + it].key = pool[2 * n + 2 * ptr + it].max =
0;
link(2 * u + 1, 2 * n + 2 * ptr + it);
link(2 * v, 2 * n + 2 * ptr + it);
}
}
swap(u, v);
}
ptr--;
}
f[i] = ptr;
int u, v;
tie(u, v) = edges[i];
for (int it = (0); it < (2); ++it) {
if (used[2 * i + it]) {
makeroot(2 * n + 2 * i + it);
cut(2 * u + 1);
cut(2 * v);
}
swap(u, v);
}
} else {
f[i] = m;
}
}
while (0 <= ptr) {
int u, v;
tie(u, v) = edges[ptr];
if (findroot(2 * u) == findroot(2 * v)) {
break;
}
for (int it = (0); it < (2); ++it) {
if (findroot(2 * u + 1) != findroot(2 * v)) {
makeroot(2 * u + 1);
makeroot(2 * v);
link(2 * u + 1, 2 * n + 2 * ptr + it);
link(2 * v, 2 * n + 2 * ptr + it);
} else {
int d = pathquery(2 * u + 1, 2 * v);
if (2 * n <= d && d < 2 * n + 2 * ptr) {
int x = d - 2 * n >> 1;
int r = d - 2 * n & 1;
int uu, vv;
tie(uu, vv) = edges[x];
if (r) {
swap(uu, vv);
}
makeroot(d);
cut(2 * uu + 1);
cut(2 * vv);
used[d - 2 * n] = 0;
makeroot(2 * u + 1);
makeroot(2 * v);
pool[2 * n + 2 * ptr + it].key = pool[2 * n + 2 * ptr + it].max = 0;
link(2 * u + 1, 2 * n + 2 * ptr + it);
link(2 * v, 2 * n + 2 * ptr + it);
}
}
swap(u, v);
}
ptr--;
}
while (q--) {
int l, r;
cin >> l >> r;
l--, r--;
if (r < (l ? f[l - 1] : ptr)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int c, d, n, m, k;
int main() {
cin >> c >> d >> n >> m >> k;
int t = 0;
int cur = k;
int best = 1000000000;
for (int i = 0; i <= m; i++) {
int tmp = (n * m - k - n * i);
if (tmp < 0)
best = min(best, c * i);
else
best = min(best, c * i + tmp * d);
}
cout << best << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const long long EPS = 1e-7;
struct PT {
long long x, y;
PT() {}
PT(long long x, long long y) : x(x), y(y) {}
bool operator<(const PT &rhs) const {
return make_pair(y, x) < make_pair(rhs.y, rhs.x);
}
bool operator==(const PT &rhs) const {
return make_pair(y, x) == make_pair(rhs.y, rhs.x);
}
};
long long cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
long long area2(PT a, PT b, PT c) {
return cross(a, b) + cross(b, c) + cross(c, a);
}
bool between(const PT &a, const PT &b, const PT &c) {
return (fabs(area2(a, b, c)) < EPS && (a.x - b.x) * (c.x - b.x) <= 0 &&
(a.y - b.y) * (c.y - b.y) <= 0);
}
void ConvexHull(vector<PT> &pts) {
sort(pts.begin(), pts.end());
pts.erase(unique(pts.begin(), pts.end()), pts.end());
vector<PT> up, dn;
for (int i = 0; i < pts.size(); i++) {
while (up.size() > 1 && area2(up[up.size() - 2], up.back(), pts[i]) >= 0)
up.pop_back();
while (dn.size() > 1 && area2(dn[dn.size() - 2], dn.back(), pts[i]) <= 0)
dn.pop_back();
up.push_back(pts[i]);
dn.push_back(pts[i]);
}
pts = dn;
for (int i = (int)up.size() - 2; i >= 1; i--) pts.push_back(up[i]);
if (pts.size() <= 2) return;
dn.clear();
dn.push_back(pts[0]);
dn.push_back(pts[1]);
for (int i = 2; i < pts.size(); i++) {
if (between(dn[dn.size() - 2], dn[dn.size() - 1], pts[i])) dn.pop_back();
dn.push_back(pts[i]);
}
if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
dn[0] = dn.back();
dn.pop_back();
}
pts = dn;
}
bool PointInPolygon(vector<PT> &l, PT p) {
int a = 1, b = l.size() - 1, c;
if (((l[a].x - l[0].x) * (l[b].y - l[0].y) -
(l[a].y - l[0].y) * (l[b].x - l[0].x)) > 0)
swap(a, b);
if (((l[a].x - l[0].x) * (p.y - l[0].y) -
(l[a].y - l[0].y) * (p.x - l[0].x)) >= 0 ||
((l[b].x - l[0].x) * (p.y - l[0].y) -
(l[b].y - l[0].y) * (p.x - l[0].x)) <= 0)
return false;
while (abs(a - b) > 1) {
c = (a + b) / 2;
if (((l[c].x - l[0].x) * (p.y - l[0].y) -
(l[c].y - l[0].y) * (p.x - l[0].x)) > 0)
b = c;
else
a = c;
}
return ((l[b].x - l[a].x) * (p.y - l[a].y) -
(l[b].y - l[a].y) * (p.x - l[a].x)) < 0;
}
vector<PT> pts, tmp;
const int maxn = 100010;
int n, m;
int x, y;
int a[maxn];
int b[maxn];
int c[maxn];
int d[maxn];
void solve() {
scanf("%d%d", &n, &m);
scanf("%d%d", &x, &y);
for (int i = 0; i < n; i++) scanf("%d%d", a + i, b + i);
for (int i = 0; i < m; i++) {
scanf("%d%d", c + i, d + i);
pts.push_back(PT(c[i], d[i]));
}
ConvexHull(pts);
int u = 0, v = 0;
for (int i = 0; i < int((pts).size()); i++) {
if (pts[i].x > pts[u].x) u = i;
if (pts[i].y > pts[v].y) v = i;
}
tmp.push_back(PT(0, 0));
tmp.push_back(PT(pts[u].x, 0));
for (int i = u; i < v + 1; i++) tmp.push_back(pts[i]);
tmp.push_back(PT(0, pts[v].y));
for (int i = 0; i < n; i++)
if (!PointInPolygon(tmp, PT(a[i], b[i]))) {
printf("Max");
return;
}
printf("Min");
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
class SegTree {
private:
int N;
std::vector<int>& A;
int tree[5 * MAX], lazy[5 * MAX];
void build(int node, int start, int end);
void lazy_updateRange(int node, int start, int end, int l, int r, int val);
int lazy_queryRange(int node, int start, int end, int l, int r);
void push_lazy(int node, int start, int end);
void update(int node, int start, int end, int val);
public:
SegTree(std::vector<int>& a) : A(a) {
N = A.size();
build(1, 0, N - 1);
}
void update_range(int l, int r, int val) {
lazy_updateRange(1, 0, N - 1, l, r, val);
}
int query(int l, int r) { return lazy_queryRange(1, 0, N - 1, l, r); }
};
void SegTree::build(int node, int start, int end) {
if (start == end) {
tree[node] = A[start];
return;
}
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = tree[2 * node] + tree[2 * node + 1];
}
void SegTree::push_lazy(int node, int start, int end) {
if (lazy[node]) {
if (lazy[node] == -1)
tree[node] = 0;
else
tree[node] = (end - start + 1);
if (start != end) {
lazy[node * 2 + 1] = lazy[node];
lazy[node * 2] = lazy[node];
}
lazy[node] = 0;
}
}
void SegTree::update(int node, int start, int end, int val) {
if (val == -1)
tree[node] = 0;
else
tree[node] = (end - start + 1) * val;
if (start != end) {
lazy[node * 2] = val;
lazy[node * 2 + 1] = val;
}
}
void SegTree::lazy_updateRange(int node, int start, int end, int l, int r,
int val) {
push_lazy(node, start, end);
if (start > end || start > r || end < l) return;
if (start >= l && end <= r) {
update(node, start, end, val);
return;
}
int mid = (start + end) / 2;
lazy_updateRange(node * 2, start, mid, l, r, val);
lazy_updateRange(node * 2 + 1, mid + 1, end, l, r, val);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
int SegTree::lazy_queryRange(int node, int start, int end, int l, int r) {
if (start > end || start > r || end < l) return 0;
push_lazy(node, start, end);
if (start >= l && end <= r) return tree[node];
int mid = (start + end) / 2;
int p1 = lazy_queryRange(2 * node, start, mid, l, r);
int p2 = lazy_queryRange(2 * node + 1, mid + 1, end, l, r);
return p1 + p2;
}
int main() {
int N, Q;
cin >> N >> Q;
string s;
cin >> s;
vector<int> v[26];
vector<SegTree> seg;
for (int i = 0; i < 26; i++) {
vector<int> v(N);
for (int k = 0; k < N; k++) {
if (s[k] == i + 'a') v[k] = 1;
}
seg.push_back(SegTree(v));
}
while (Q--) {
int a, b, t;
cin >> a >> b >> t;
a--, b--;
if (t == 1) {
vector<int> amnt(26);
for (int i = 0; i < 26; i++) {
amnt[i] = seg[i].query(a, b);
}
int total = a;
for (int i = 0; i < 26; i++) {
if (total != a) seg[i].update_range(a, total - 1, -1);
if (total + amnt[i] <= b) seg[i].update_range(total + amnt[i], b, -1);
if (amnt[i] != 0) {
seg[i].update_range(total, total + amnt[i] - 1, 1);
}
total += amnt[i];
}
} else {
vector<int> amnt(26);
for (int i = 0; i < 26; i++) {
amnt[i] = seg[i].query(a, b);
}
int total = a;
for (int i = 25; i >= 0; i--) {
if (total != a) {
seg[i].update_range(a, total - 1, -1);
}
if (total + amnt[i] <= b) {
seg[i].update_range(total + amnt[i], b, -1);
}
if (amnt[i] != 0) {
seg[i].update_range(total, total + amnt[i] - 1, 1);
}
total += amnt[i];
}
}
}
for (int i = 0; i < N; i++) {
for (int k = 0; k < 26; k++) {
if (seg[k].query(i, i)) {
cout << char(k + 'a');
}
}
}
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string a[30010];
int num = 0, k = 0;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < a[1].size(); i++) {
k = 0;
for (int j = 1; j < n; j++)
if (a[j][i] != a[j + 1][i]) k++;
if (k == 0)
num++;
else {
cout << num << endl;
return 0;
}
}
cout << num << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long M = 1e7;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const long long inf = -1e18;
bool isprime(long long x) {
long long y = sqrt(x);
for (int i = 2; i <= y; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
long long a, b, c, mn = INF, ans = INF;
int main() {
cin >> a >> b;
c = a + b;
for (long long i = 1; i * i <= c; i++) {
if (a % i == 0) {
mn = min(mn, a / i);
}
if (b % i == 0) {
mn = min(mn, b / i);
}
if (c % i == 0 && c / i >= mn) {
ans = min(ans, (i + (c / i)) * 2);
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int MAXN = 1e6 + 5, inf = 1e9;
const ll INF = 1e18;
const ld PI = 3.1415926535897932384626433832795;
int cnt[MAXN], par[MAXN];
ll dp[MAXN], tab[MAXN], n, sz[MAXN];
bool vis[MAXN], used[MAXN];
vector<int> G[MAXN];
vector<ll> V;
set<ll> S;
map<ll, int> M;
stack<ll> St;
queue<ll> Q;
void dfs(int v, int p) {
par[v] = p;
sz[v] = 1;
for (int u : G[v]) {
if (u == p) continue;
dfs(u, v);
sz[v] += sz[u];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(13) << fixed;
int x, y;
cin >> n >> x >> y;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1, 0);
bool ok1 = 0, ok2 = 0;
int v = x;
int prev = v;
ll a = 0, b = 0, c = 0;
while (true) {
if (v == y) {
ok1 = 1;
a = sz[x];
b = sz[v] - sz[prev];
c = sz[1] - sz[y];
break;
}
if (!par[v]) break;
prev = v;
v = par[v];
}
v = y;
while (true) {
if (v == x) {
ok2 = 1;
a = sz[v] - sz[prev];
b = sz[y];
c = sz[1] - sz[x];
break;
}
if (!par[v]) break;
prev = v;
v = par[v];
}
if (ok1) {
cout << n * n - n - a * (b + c) << "\n";
} else if (ok2) {
cout << n * n - n - b * (a + c) << "\n";
} else {
cout << n * n - n - sz[x] * sz[y] << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 50005;
vector<long long> adjList[MAX];
long long visited[MAX] = {};
long long dp[MAX][505];
long long n, k, ans = 0;
void dfs1(long long x) {
visited[x] = 1;
dp[x][0] += 1;
for (auto v : adjList[x]) {
if (!visited[v]) {
dfs1(v);
for (long long i = 1; i <= k; i++) dp[x][i] += dp[v][i - 1];
}
}
}
void dfs2(long long x) {
visited[x] = 1;
ans += dp[x][k];
long long q = 0;
for (auto v : adjList[x]) {
if (!visited[v]) {
for (long long i = 1; i <= k - 1; i++) {
q += dp[v][i - 1] * dp[x][k - i];
q -= dp[v][i - 1] * dp[v][k - i - 1];
}
}
}
ans += (q / 2);
for (auto v : adjList[x]) {
if (!visited[v]) dfs2(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
u--;
v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
dfs1(0);
memset(visited, 0, sizeof visited);
dfs2(0);
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7, M = 998244353, g = 3;
long long bin_pow(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x % M;
if (n % 2 == 0) {
long long mem = bin_pow(x, n / 2);
return (mem * mem) % M;
}
return (bin_pow(x, n - 1) * x) % M;
}
long long rev(long long x) { return bin_pow(x, M - 2); }
void dft(vector<long long> &p) {
long long n = p.size(), lg = 30 - __builtin_clz(n);
long long rev[n];
rev[0] = 0;
for (long long i = 0; i < n; i++) {
rev[i] = ((i & 1) << lg) + rev[i / 2] / 2;
}
for (long long i = 0; i < n; i++) {
if (i < rev[i]) {
swap(p[i], p[rev[i]]);
}
}
for (long long step = 2; step <= n; step *= 2) {
long long curw = bin_pow(g, (M - 1) / step);
for (long long i = 0; i < n; i += step) {
long long cur = 1;
long long cur2 = bin_pow(curw, step / 2);
for (long long j = i; j < i + step / 2; j++) {
long long a, b;
a = p[j] + cur * p[j + step / 2];
b = p[j] + cur2 * p[j + step / 2];
p[j] = a % M;
p[j + step / 2] = b % M;
cur = (cur * curw) % M;
cur2 = (cur2 * curw) % M;
}
}
}
}
vector<long long> mul(vector<long long> a, vector<long long> b) {
long long n = a.size();
long long sz = max(a.size(), b.size()) * 2;
n = 1 << (32 - __builtin_clz(sz));
a.resize(n);
b.resize(n);
vector<long long> res(n);
dft(a);
dft(b);
for (long long i = 0; i < n; i++) {
res[i] = (a[i] * b[i]) % M;
}
dft(res);
reverse(res.begin() + 1, res.end());
vector<long long> ans;
long long nn = rev(n);
for (long long i = 0; i < n; i++) {
ans.push_back((res[i] * nn) % M);
}
return ans;
}
long long fact[N], obr[N], pref0[N];
long long a[N];
vector<long long> summ;
void init(long long k) {
fact[0] = 1;
obr[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * i) % M;
obr[i] = rev(fact[i]);
}
pref0[0] = 1;
for (long long i = 1; i < N; i++) {
pref0[i] = (pref0[i - 1] * (k - 2)) % M;
}
vector<long long> a(N), b(N);
for (long long i = 0; i < N; i++) {
a[i] = b[i] = obr[i];
}
summ = mul(a, b);
}
long long cnk(long long n, long long k) {
return (((fact[n] * obr[k]) % M) * obr[n - k]) % M;
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
init(k);
for (long long i = 0; i < n; i++) cin >> a[i];
long long ca = 0, cb = 0;
long long ans = 0, mull = 1;
for (long long i = 0; i < n; i++) {
long long nxt = (i + 1) % n;
if (a[i] == a[nxt])
cb++;
else
ca++;
}
for (long long i = 0; i < cb; i++) mull = (mull * k) % M;
for (long long s = 1; s <= ca; s++) {
long long sm = summ[s];
if (s % 2 == 0) {
sm = (sm - obr[s / 2] * obr[s / 2]) % M;
if (sm < 0) sm += M;
}
sm = (sm * obr[2]) % M;
sm = (sm * fact[ca]) % M;
sm = (sm * obr[ca - s]) % M;
sm = (sm * pref0[ca - s]);
ans = (ans + sm) % M;
}
ans = (ans * mull) % M;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
char b;
cin >> a;
b = a[0];
int count = 1, counter = 0;
for (int i = 1; i < a.size(); i++) {
counter++;
if (a[i] != b) {
b = a[i];
count++;
counter = 0;
}
if (counter >= 5) {
count++;
counter = 0;
}
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, rH = 1, rW = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
if (s == "UL" or s == "DR") {
++rH;
} else if (s == "UR" or s == "DL") {
++rW;
} else {
++rW, ++rH;
}
}
cout << rW * rH;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
const long long mod = 998244353;
int n, k;
int a[MAXN];
long long dp[MAXN][MAXN];
set<int> diffs;
long long cal(int lb) {
dp[0][1] = 1;
for (int j = 2; j <= k; j++) dp[0][j] = 0;
int pre = -1;
for (int i = 1; i < n; i++) {
while (a[pre + 1] <= a[i] - lb && pre + 1 < i) pre++;
dp[i][1] = i + 1;
for (int j = 2; j <= k; j++) {
dp[i][j] = dp[i - 1][j];
if (pre >= 0) dp[i][j] += dp[pre][j - 1];
dp[i][j] %= mod;
}
}
return dp[n - 1][k];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[i] != a[j]) diffs.insert(a[j] - a[i]);
}
}
long long res = 0;
int pre = 0;
for (int diff : diffs) {
if (diff * (k - 1) > a[n - 1] - a[0]) break;
res += (diff - pre) * cal(diff) % mod;
res %= mod;
pre = diff;
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int n, k, a[N], cnt;
struct trie {
int son[2], de;
} sh[N];
struct node {
int l, r, ans;
};
vector<node> p[N];
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
void insert(int num) {
int x = 0;
for (int i = k - 1; i >= 0; i--) {
int now = ((num >> i) & 1), p = sh[x].son[now];
if (!p) p = ++cnt;
sh[x].son[now] = p;
sh[p].de = sh[x].de + 1;
x = p;
}
p[x].push_back((node){num, num, 0x3f3f3f3f});
}
void upd(int x, int s) {
int now = (int)p[s].size();
p[x] = p[s];
p[x].resize(now << 1);
for (int i = now; i < (int)p[x].size(); i++) p[x][i] = p[x][i - now];
}
inline void pushup(int x) {
int ls = sh[x].son[0], rs = sh[x].son[1];
if (!ls) {
upd(x, rs);
return;
}
if (!rs) {
upd(x, ls);
return;
}
int now = (int)p[ls].size();
p[x].resize(now << 1);
for (int i = 0; i < now; i++) {
p[x][i].l = p[ls][i].l;
p[x][i].r = p[rs][i].r;
p[x][i].ans = min(p[ls][i].ans, p[rs][i].ans);
p[x][i].ans = min(p[x][i].ans, (p[rs][i].l ^ i) - (p[ls][i].r ^ i));
}
for (int i = now; i < (int)p[x].size(); i++) {
p[x][i].l = p[rs][i - now].l;
p[x][i].r = p[ls][i - now].r;
p[x][i].ans = min(p[ls][i - now].ans, p[rs][i - now].ans);
p[x][i].ans =
min(p[x][i].ans, (p[ls][i - now].l ^ i) - (p[rs][i - now].r ^ i));
}
}
void dfs(int x) {
if (sh[x].de == k) return;
if (sh[x].son[0]) dfs(sh[x].son[0]);
if (sh[x].son[1]) dfs(sh[x].son[1]);
pushup(x);
}
signed main() {
n = read();
k = read();
for (int i = 1; i <= n; i++) insert(read());
dfs(0);
assert((int)p[0].size() == (1 << k));
for (int i = 0; i < (int)p[0].size(); i++) printf("%d ", p[0][i].ans);
printf("\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void setIO() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long double PI = 4 * atan((long double)1);
const int INF = 1e9 + 7;
const long long _INF = 1e18;
int main() {
setIO();
int t;
cin >> t;
while (t--) {
int x, k = 0;
cin >> x;
int y = x;
while (y) {
y /= 10;
k++;
}
cout << 10 * (x % 10 - 1) + k * (k + 1) / 2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
class SegmentTree {
struct node {
int add, cap;
bool empty;
node(int v = -1) {
if (v == -1) {
add = cap = 0;
empty = true;
} else {
add = v - 1;
cap = 0;
empty = !v;
}
}
node(int add_, int cap_, bool empty_) {
add = add_;
cap = cap_;
empty = empty_;
}
node operator+(node arg) {
if (arg.empty) return node(add + arg.add, cap, empty);
return node(std::max(add - arg.cap, 0) + arg.add,
cap + std::max(arg.cap - add, 0), false);
}
int get() { return add; }
};
std::vector<node> t;
public:
SegmentTree(int size) { t.resize((1 << 33 - __builtin_clz(size - 1)) - 1); }
void build(int v, int tl, int tr, int init);
void update(int v, int tl, int tr, int i, int x);
node query(int v, int tl, int tr, int l, int r);
int get();
};
void SegmentTree::build(int v, int tl, int tr, int init) {
if (tr - tl == 1)
t[v] = node(init);
else {
int m = (tl + tr) >> 1;
build((v << 1) + 1, tl, m, init);
build((v << 1) + 2, m, tr, init);
t[v] = t[(v << 1) + 1] + t[(v << 1) + 2];
}
}
void SegmentTree::update(int v, int tl, int tr, int i, int x) {
if (tr - tl == 1)
t[v] = node(x);
else {
int m = (tl + tr) >> 1;
if (i < m)
update((v << 1) + 1, tl, m, i, x);
else
update((v << 1) + 2, m, tr, i, x);
t[v] = t[(v << 1) + 1] + t[(v << 1) + 2];
}
}
int SegmentTree::get() { return t[0].get(); }
const int N = 200000;
int n, m, k, a[2 * N];
int main() {
scanf("%d%d%d", &n, &k, &m);
SegmentTree t(2 * n);
t.build(0, 0, 2 * n, 0);
std::set<std::pair<int, int> > s;
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
int pos = y - 1 + abs(x - k);
if (s.count(std::make_pair(x, y))) {
s.erase(std::make_pair(x, y));
--a[pos];
t.update(0, 0, 2 * n, pos, a[pos]);
} else {
s.insert(std::make_pair(x, y));
++a[pos];
t.update(0, 0, 2 * n, pos, a[pos]);
}
printf("%d\n", std::max(0, n + t.get()));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
using ll = long long;
const int maxn = 1 << 18;
ll n, m, T = 0, sum = 0, a[maxn];
vector<ll> f[maxn];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i];
}
for (int i = 2; i <= m; i++) {
if (a[i] == a[i - 1]) continue;
f[a[i]].push_back(a[i - 1]);
f[a[i - 1]].push_back(a[i]);
sum += abs(a[i] - a[i - 1]);
}
for (int i = 1; i <= n; i++) {
if (f[i].empty()) continue;
sort(begin(f[i]), end(f[i]));
ll x = 0, med = f[i][f[i].size() / 2];
for (auto j : f[i]) {
x -= abs(j - i);
x += abs(j - med);
}
T = min(T, x);
}
cout << sum + T << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e3;
long long A, B, N;
int main() {
scanf("%I64d %I64d %I64d", &A, &B, &N);
long long ans = 0;
bool check = false;
for (int i = -P; i <= P; i++) {
long long x = 1, tot = i;
int cnt = 0;
while (cnt < N) {
x *= tot;
if (abs(A * x) > abs(B)) break;
cnt++;
}
if (cnt == N && A * x == B) ans = tot, check = true;
}
if (!check)
printf("No solution\n");
else
printf("%I64d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<int> pref((int)1e7 + 1, 0);
vector<int> v((int)1e7 + 2, 0);
int a, b, m;
vector<bool> es((int)1e7, 1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
v[x]++;
}
for (int i = 2; i < (int)1e7; i++) {
if (es[i] == false) continue;
for (int l = i; l <= (int)1e7; l += i) {
es[l] = false;
pref[i] += v[l];
}
}
for (int i = 1; i <= (int)1e7; i++) {
pref[i] += pref[i - 1];
}
cin >> m;
while (m--) {
cin >> a >> b;
a = min(a, (int)1e7);
b = min(b, (int)1e7);
cout << pref[b] - pref[a - 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, k, s[50010][10];
struct item {
int id, ty;
bool operator<(const item& it) const {
if (s[id][ty] != s[it.id][ty]) return s[id][ty] < s[it.id][ty];
return id < it.id;
}
};
std::set<item> st[10], S;
int fa[50010], siz[50010];
int find(int i) { return fa[i] == i ? i : fa[i] = find(fa[i]); }
void merge(int i, int j) {
fa[i = find(i)] = j = find(j);
siz[j] += siz[i];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) fa[i] = i, siz[i] = 1;
for (int i = 0; i < n; i++) {
int x = -1, y = -1;
for (int j = 0; j < k; j++) {
scanf("%d", s[i] + j);
std::set<item>::iterator it = st[j].insert((item){i, j}).first;
if (it != st[j].begin()) {
it--;
if (x < 0 || *s[it->id] > *s[x]) x = it->id;
it++;
}
it++;
if (it != st[j].end() && (y < 0 || *s[y] > *s[it->id])) y = it->id;
}
if (x > -1 && y > -1) {
std::set<item>::iterator ix = S.find((item){find(x), 0}),
iy = S.find((item){find(y), 0}), it;
for (ix++; iy != ix; it = iy++, S.erase(it)) merge(iy->id, i);
}
S.insert((item){i, 0});
printf("%d\n", siz[find(S.rbegin()->id)]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == "Cube") {
x = x + 6;
} else if (s[i] == "Tetrahedron") {
x = x + 4;
} else if (s[i] == "Octahedron") {
x = x + 8;
} else if (s[i] == "Dodecahedron") {
x = x + 12;
} else if (s[i] == "Icosahedron") {
x = x + 20;
}
}
cout << x << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long arr1[26], arr2[26][26];
int main() {
string S;
cin >> S;
for (int i = 0; i < S.length(); i++) {
int c = S[i] - 'a';
for (int j = 0; j < 26; j++) arr2[j][c] += arr1[j];
arr1[c]++;
}
long long ans = 0;
for (int i = 0; i < 26; i++) ans = max(ans, arr1[i]);
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++) ans = max(ans, arr2[i][j]);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct IO {
static const int Siz = 1 << 13;
char ibuf[Siz], *ips = ibuf + Siz - 1;
char obuf[Siz], *ops = obuf;
~IO() { o(); }
void i() {
fread(ibuf, 1, Siz, stdin);
ips = ibuf;
}
void o() {
fwrite(obuf, 1, ops - obuf, stdout);
ops = obuf;
}
void flush() {
o();
fflush(stdout);
}
int getchar() {
if (ips == ibuf + Siz - 1) i();
return *ips++;
}
void putchar(int x) {
if (ops == obuf + Siz) o();
*ops++ = x;
}
void gets(char* s) {
for (; !isspace(*s++ = getchar());)
;
}
void puts(char* s) {
for (; *s; putchar(*s++))
;
}
} io;
int read() {
int x = 0, f = 1, c = io.getchar();
for (; !isdigit(c); c = io.getchar())
if (c == 45) f ^= 1;
for (; isdigit(c); c = io.getchar()) x = x * 10 + c - 48;
return f ? x : -x;
}
void write(int x) {
int stk[20], tp = 0;
if (x < 0) io.putchar(45), x = -x;
if (!x) io.putchar(48);
for (; x; stk[tp++] = x % 10, x /= 10)
;
for (; tp; io.putchar(48 + stk[--tp]))
;
}
int a[1 << 20];
int cnt[1 << 20];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int lb = 0, rb = 1e9;
int ans = 0;
auto chk = [&](int md) {
bool ok = 0;
vector<int> v;
for (int i = 0; i < n; ++i) {
v.push_back(a[i] - md);
v.push_back(a[i] + md + 1);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
int m = v.size();
for (int i = 0; i < m; ++i) cnt[i] = 0;
for (int i = 0; i < n; ++i) {
cnt[lower_bound(v.begin(), v.end(), a[i] - md) - v.begin()]++;
cnt[lower_bound(v.begin(), v.end(), a[i] + md + 1) - v.begin()]--;
}
for (int i = 1; i < m; ++i) cnt[i] += cnt[i - 1];
for (int i = 0; i < m; ++i)
if (cnt[i] > k) {
ok = 1, ans = v[i];
break;
}
return ok;
};
for (; lb < rb;) {
int md = lb + rb >> 1;
if (chk(md))
rb = md;
else
lb = md + 1;
}
chk(lb);
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
T abst(const T &n) {
return (n < 0 ? -n : n);
}
template <class T>
T max3(const T &a, const T &b, const T &c) {
return max2(a, max2(b, c));
}
template <class T>
T min3(const T &a, const T &b, const T &c) {
return min2(a, min2(b, c));
}
template <class T>
T gcd(const T a, const T b) {
return (b ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(const T a, const T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
T sq(const T &x) {
return x * x;
}
using namespace std;
int main() {
int n, k = 1, i;
scanf("%d", &n);
if (n <= 3) {
if (n <= 2)
puts("-1");
else
puts("210");
} else {
for (i = 1; i < n; i++) {
k *= 10;
k %= 210;
}
int lastdigit = 210 - k;
printf("1");
for (i = 1; i < n - 3; i++) printf("0");
printf("%03d\n", lastdigit);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int q_pow(int x, int n) {
int ret = 1;
for (; n; n >>= 1, x = (long long)x * x % 998244353)
if (n & 1) ret = (long long)ret * x % 998244353;
return ret;
}
long long ans[1 << 17];
int A[1 << 17], B[1 << 17], C[1 << 17], n, K, x, y, z;
void FWT(int *a, int len) {
for (int k = 2, t = 1; k <= len; k <<= 1, t <<= 1)
for (int i = 0; i < len; i += k)
for (int j = i, tmp; j < i + t; j++)
tmp = a[j] - a[j + t], a[j] += a[j + t], a[j + t] = tmp;
}
void IFWT(long long *a, int len) {
long long tmp;
for (int k = 2, t = 1; k <= len; k <<= 1, t <<= 1)
for (int i = 0; i < len; i += k)
for (int j = i; j < i + t; j++)
tmp = a[j] - a[j + t], a[j] += a[j + t], a[j + t] = tmp;
tmp = q_pow(len, 998244353 - 2);
for (int i = 0; i < len; i++) a[i] = a[i] % 998244353 * tmp % 998244353;
}
int main() {
scanf("%d%d%d%d%d", &n, &K, &x, &y, &z);
int now = 0;
for (int i = 1, a, b, c; i <= n; i++)
scanf("%d%d%d", &a, &b, &c), now ^= a, A[b ^ a]++, B[c ^ a]++, C[b ^ c]++;
FWT(A, 1 << K), FWT(B, 1 << K), FWT(C, 1 << K);
int v1 = ((long long)x + y + z) % 998244353, v2 = (x - y + z) % 998244353,
v3 = (x + y - z) % 998244353, v4 = (x - y - z) % 998244353;
for (int i = 0; i < 1 << K; i++)
ans[i] = (long long)q_pow(v1, (n + A[i] + B[i] + C[i]) >> 2) *
q_pow(v2, (n + B[i] - C[i] - A[i]) >> 2) % 998244353 *
q_pow(v3, (n + A[i] - B[i] - C[i]) >> 2) % 998244353 *
q_pow(v4, (n + C[i] - A[i] - B[i]) >> 2) % 998244353;
IFWT(ans, 1 << K);
for (int i = 0; i < 1 << K; i++)
printf("%lld ", (ans[i ^ now] + 998244353) % 998244353);
puts("");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long dp[25][25][2];
vector<int> digits;
long long calc(int pos, int cnt, int f) {
if (cnt > 3) return 0;
if (pos == digits.size()) return 1;
if (dp[pos][cnt][f] != -1) return dp[pos][cnt][f];
int add;
if (f)
add = 9;
else
add = digits[pos];
long long res = 0;
for (int currdigit = 0; currdigit <= add; currdigit++) {
int newf = f;
int newcnt = cnt;
if (currdigit) newcnt++;
if (!f && currdigit < add) newf = 1;
if (newcnt <= 3) res += calc(pos + 1, newcnt, newf);
}
return dp[pos][cnt][f] = res;
}
long long solve(long long num) {
digits.clear();
while (num) {
digits.push_back(num % 10);
num /= 10;
}
reverse(digits.begin(), digits.end());
memset(dp, -1, sizeof(dp));
long long res = calc(0, 0, 0);
return res;
}
int main() {
int q;
cin >> q;
while (q--) {
long long l, r;
cin >> l >> r;
cout << solve(r) - solve(l - 1) << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, arr[100003], d[100003], m[100003];
memset(d, 0, sizeof d);
memset(m, 0, sizeof m);
cin >> n;
for (int i = 0; i < n; ++i) cin >> arr[i];
int maxNum = *(max_element(arr, arr + n));
int maxBit = 0;
while ((maxNum >>= 1) > 0) ++maxBit;
int maxBitMask = 1 << maxBit;
int aggMask = (1 << (maxBit + 1)) - 1;
for (int i = 0; i < n; ++i) {
while (!(maxBitMask & arr[i])) arr[i] <<= 1, ++m[i];
aggMask &= arr[i];
}
for (int x = maxBit; x >= 0; --x) {
if (aggMask & (1 << x)) continue;
for (int i = 0; i < n; ++i) {
if (!(arr[i] & (1 << x))) continue;
arr[i] = (arr[i] >> (x + 1)) << (x + 1);
d[i] = (x + 1 - m[i]), m[i] += d[i];
aggMask &= arr[i];
}
}
int res = (accumulate(d, d + n, 0) + accumulate(m, m + n, 0));
for (int x = maxBit; x >= 0; --x) {
for (int i = 0; i < n; ++i) (m[i] > 0) ? (--m[i]) : (++d[i]);
int tmpRes = (accumulate(d, d + n, 0) + accumulate(m, m + n, 0));
if (tmpRes > res) break;
res = tmpRes;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int n, k, a[1005];
long long f[1005][1005], res[100005], ans, s[1005][1005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
a[0] = -1000000000;
for (int v = 1; v * (k - 1) <= a[n]; v++) {
f[0][0] = 1;
int now = 0;
s[0][0] = 1;
for (int i = 1; i <= n; i++) {
while (a[now] <= a[i] - v) now++;
s[i][1] = i;
f[i][1] = 1;
for (int j = 2; j <= k; j++) {
if (j) f[i][j] = s[now - 1][j - 1];
s[i][j] = (s[i - 1][j] + f[i][j]) % MOD;
}
res[v] += f[i][k];
}
ans += res[v] % MOD;
}
printf("%I64d\n", ans % MOD);
getchar();
getchar();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1e6 + 5, LG = 26, SM = 800, inf = 1e18 + 1;
long long int mod = 1e9 + 7;
long long int a[M];
long long int n;
long long int ps[M];
int main() {
ios::sync_with_stdio(0);
cin >> n;
long long int su = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
su += a[i];
}
if (su % 3) {
cout << 0;
return 0;
}
long long int su2 = 0, cnt = 0;
for (int i = 0; i < n; i++) {
su2 += a[i];
ps[i] = ps[i - 1];
ps[i] += (su2 == su / 3);
}
long long int s2 = 0;
for (int i = n - 1; i >= 2; i--) {
s2 += a[i];
if (s2 == su / 3) cnt += ps[i - 2];
}
cout << cnt << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10;
static vector<int> V[MAXN], q[MAXN];
static vector<pair<int, int> > c[MAXN];
static pair<int, int> w[MAXN];
static int n, m, N, a[MAXN], b[MAXN], p[MAXN], Tohka[MAXN], sum[MAXN], id[MAXN];
inline int lowbit(int first) { return first & -first; }
inline void Add(int first, pair<int, int> d) {
for (; first <= N; c[first].push_back(d), first += lowbit(first))
;
}
inline void Gets(int first, int d) {
for (; first; q[first].push_back(d), first -= lowbit(first))
;
}
inline double calc1(const pair<int, int> &w, const double &first) {
return first * w.first + w.second;
}
inline int calc2(const pair<int, int> &w, const int &first) {
return first * w.first + w.second;
}
inline double Inter(const pair<int, int> &a, const pair<int, int> &b) {
return (double)(b.second - a.second) / (a.first - b.first);
}
int T, T1, cnt;
inline void Calc(vector<pair<int, int> > &W, vector<int> &q) {
static int s[MAXN], top, n;
static double first[MAXN];
static pair<int, int> w[MAXN];
s[top = 1] = 0;
n = (int)W.size();
for (int i = 0; i < n; ++i) w[i] = W[i];
for (int i = 1; i < n; ++i) {
pair<int, int> wi = w[i];
for (; top > 1 && first[top - 1] * (w[s[top]].first - wi.first) >=
wi.second - w[s[top]].second;
--top, ++cnt)
;
s[++top] = i;
if (top > 1) first[top - 1] = Inter(w[s[top - 1]], wi), ++cnt;
}
for (int t = 1, i = 0; i < (int)q.size(); ++i) {
for (; t < top && calc2(w[s[t]], b[q[i]] - p[q[i]]) >=
calc2(w[s[t + 1]], b[q[i]] - p[q[i]]);
++t)
;
Tohka[q[i]] =
min(Tohka[q[i]], (int)calc2(w[s[t]], b[q[i]] - p[q[i]]) + sum[p[q[i]]]);
}
W.clear();
q.clear();
}
inline bool cmp(int a, int b) { return w[a] > w[b]; }
inline bool cmp1(int first, int second) {
return b[first] - p[first] < b[second] - p[second];
}
void solve(int dep, int l, int r) {
if (l == r) {
vector<int> &v = V[l];
for (int i = 0; i < (int)v.size(); ++i)
Tohka[v[i]] = min(Tohka[v[i]], a[l] * b[v[i]]);
return;
}
int mid = (l + r) >> 1;
solve(dep + 1, l, mid);
solve(dep + 1, mid + 1, r);
N = mid - l + 1;
for (int i = l; i <= mid; ++i)
w[i - l + 1] = make_pair(a[i], a[i] * i - sum[i]),
id[i - l + 1] = i - l + 1;
sort(id + 1, id + N + 1, cmp);
for (int i = 1; i <= N; ++i) Add(N - id[i] + 1, w[id[i]]);
vector<int> s;
for (int i = mid + 1; i <= r; ++i) {
vector<int> &v = V[i];
for (int j = 0; j < (int)v.size(); ++j) s.push_back(v[j]);
}
sort(s.begin(), s.end(), cmp1);
for (int i = 0; i < (int)s.size(); ++i) {
int h = max(p[s[i]] - b[s[i]] + 1, l);
if (h > mid) continue;
Gets(mid - h + 1, s[i]);
}
for (int i = 1; i <= N; ++i) Calc(c[i], q[i]);
}
int main() {
memset(Tohka, 0x3f, sizeof(Tohka));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i];
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int first;
scanf("%d%d", &b[i], &first);
V[first].push_back(i);
p[i] = first;
}
solve(1, 1, n);
for (int i = 1; i <= m; ++i) printf("%d\n", Tohka[i]);
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
vector<int> g[N];
int n, m, cnt = 0;
int low[N], dfn[N];
int vis[N], SCC[N];
int mark = 0;
stack<int> st;
double TIME() { return 1.0 * clock() / CLOCKS_PER_SEC; }
void verify() {
printf("-1");
exit(0);
}
void tarjan(int u) {
dfn[u] = low[u] = ++cnt;
st.push(u);
vis[u] = 1;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
if (st.top() != u) {
if (mark) verify();
mark = u;
}
int v;
do {
v = st.top();
st.pop();
SCC[v] = u;
vis[v] = 0;
} while (v != u);
}
}
int vic[N], flag, num;
void dfs(int u) {
if (flag) return;
for (int i = 0; i < g[u].size(); ++i) {
if (flag) return;
int v = g[u][i];
if (vis[v] == num) {
if (vic[v])
flag = -1;
else
flag = v, vic[v] = 1;
}
if (vis[v] < num) {
vis[v] = num;
dfs(v);
}
}
vis[u] = num + 1;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
int x = mark;
num = 1;
while (TIME() < 0.95) {
vis[x] = num + 1;
dfs(x);
if (flag == 0) return 0 * printf("%d", x);
if (flag == -1) verify();
x = flag;
num += 2;
flag = 0;
}
verify();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
bool isprime[N];
void sieve() {
memset(isprime, 1, sizeof(isprime));
isprime[0] = isprime[1] = 0;
for (int i = 2; i <= sqrt(N); i++) {
if (isprime[i]) {
for (int j = i * i; j <= N; j += i) {
isprime[j] = 0;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
sieve();
int ans[N];
ans[1] = 1;
for (int i = 2; i < N; i++) {
ans[i] = ans[i - 1] + isprime[i];
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int x = sqrt(n);
cout << ans[n] - ans[x] + 1 << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
double arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int i = 0;
int j = i + k - 1;
double max = 0;
int dp[n];
dp[0] = arr[0];
for (int i = 1; i < n; i++) {
dp[i] = dp[i - 1] + arr[i];
}
while (i <= j && j < n && i < n) {
double sum = 0;
sum = sum + dp[j] - dp[i] + arr[i];
sum = sum / (j - i + 1);
if (sum - max > 0.000000001) max = sum;
if (j == n - 1) {
i++;
j = i + k - 1;
} else
j++;
}
printf("%.15f", max);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
char a[101][101];
bool isvalid(int i, int j) { return i >= 0 && j >= 0 && i < n && j < n; }
bool check(int i, int j) {
int c = 0;
if (isvalid(i + 1, j))
if (a[i + 1][j] == 'o') c++;
if (isvalid(i - 1, j))
if (a[i - 1][j] == 'o') c++;
if (isvalid(i, j + 1))
if (a[i][j + 1] == 'o') c++;
if (isvalid(i, j - 1))
if (a[i][j - 1] == 'o') c++;
return c % 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (check(i, j)) {
cout << "NO";
return 0;
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n / 2; i += 2) {
swap(a[i], a[n - i - 1]);
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcdExtended(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long int modInverse(int a, int m) {
int x, y;
int g = gcdExtended(a, m, &x, &y);
long long int res = ((long long int)x % m + (long long int)m) % m;
return res;
}
long long int poww(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return poww(x * x, n / 2);
else
return x * poww(x * x, (n - 1) / 2);
}
long long int modularExponentiation(long long int x, long long int n,
long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
inline long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
inline long long int min(long long int a, long long int b) {
if (a > b)
return b;
else
return a;
}
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b) return a;
if (a > b)
return gcd(a - b, b);
else
return gcd(a, b - a);
}
long long int ncr(int n, int r) {
long long int ans = 1;
r = min(r, n - r);
for (int i = 0; i < r; i++) {
ans = (ans * (n - i) / (i + 1)) % 1000000007;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
long long int n, m, k;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
;
long long int ans = -1, ind = -1;
k = 1 << 30;
while (k > 0) {
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] & k) count++;
}
if (count == 1) {
for (int i = 0; i < n; i++) {
if (a[i] & k) {
ind = i;
break;
}
}
break;
}
k = k >> 1;
}
if (ind != -1) {
cout << a[ind] << " ";
for (int i = 0; i < n; i++) {
if (i != ind) cout << a[i] << " ";
}
} else {
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <class T>
std::vector<T> vec(int len, T elem) {
return std::vector<T>(len, elem);
}
constexpr int INF = 1 << 30;
int main() {
int n;
std::cin >> n;
int evens = n / 2;
int odds = n - evens;
std::vector<int> xs(n);
for (auto& x : xs) {
std::cin >> x;
if (x == 0) {
x = -1;
continue;
}
x %= 2;
--(x == 0 ? evens : odds);
}
auto dp = vec(n + 1, vec(n + 1, vec(2, INF)));
if (xs[0] < 0) {
if (odds > 0) {
dp[odds - 1][evens][1] = 0;
}
if (evens > 0) {
dp[odds][evens - 1][0] = 0;
}
} else {
dp[odds][evens][xs[0]] = 0;
}
for (int i = 1; i < n; ++i) {
auto ndp = vec(n + 1, vec(n + 1, vec(2, INF)));
int x = xs[i];
for (int odd = 0; odd <= n; ++odd) {
for (int even = 0; even <= n; ++even) {
if (x < 0) {
if (odd > 0) {
ndp[odd - 1][even][1] =
std::min(dp[odd][even][1], dp[odd][even][0] + 1);
}
if (even > 0) {
ndp[odd][even - 1][0] =
std::min(dp[odd][even][1] + 1, dp[odd][even][0]);
}
} else {
ndp[odd][even][x] = std::min(dp[odd][even][0] + (x != 0),
dp[odd][even][1] + (x != 1));
}
}
}
dp = ndp;
}
std::cout << std::min(dp[0][0][0], dp[0][0][1]) << std::endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool f[200005];
int main() {
int n, i, m, k, l = 0, r = 0, c = 0, cur = 0;
cin >> n >> m >> k;
int arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
if (k == 1)
cout << n << "\n";
else {
cur = 1;
while (r < n) {
while ((arr[r] - arr[l] > m - 1 || f[l] == 1) && l < r) {
if (f[l] == 0) cur--;
l++;
}
if (cur == k && arr[r] - arr[l] <= m - 1) {
f[r] = 1;
c++;
cur--;
}
r++;
cur++;
}
cout << c << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
const int N = 1101;
int n, k;
char s[N];
bool dp[N][28][28][2];
vector<char> ans;
bool write_answer(int i, int j, int z, int l) {
if (!dp[i][j][z][l]) return false;
if (i == n && l) return true;
for (int x = l ? 0 : s[i]; x < k; x++) {
if (j == x || z == x) continue;
int ni = i + 1, nj = z, nz = x, nl = l || x > s[i];
ans.push_back(x + 'a');
if (write_answer(ni, nj, nz, nl)) return true;
ans.pop_back();
}
return false;
}
int main() {
cin >> n >> k >> s;
for (int i = 0; i < n; i++) s[i] -= 'a';
if (n == 1) {
if (s[0] == k - 1)
puts("NO");
else {
s[0] += 'a' + 1;
printf("%s\n", s);
}
return 0;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j < k; j++)
for (int z = 0; z < k; z++)
for (int l = 0; l < 2; l++) dp[i][j][z][l] = 0;
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) dp[n][i][j][1] = 1;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < k; j++)
for (int z = 0; z < k; z++)
for (int l = 0; l < 2; l++) {
for (int x = 0; x < k; x++) {
if (x < s[i] && !l) continue;
if (j == x || z == x) continue;
int ni = i + 1, nj = z, nk = x, nl = x > s[i] || l;
dp[i][j][z][l] = dp[i][j][z][l] || dp[ni][nj][nk][nl];
}
}
for (int i = s[0]; i < k; i++)
for (int j = i > s[0] ? 0 : s[1]; j < k; j++)
if (i != j && write_answer(2, i, j, i != s[0] || j != s[1])) {
printf("%c%c", (char)(i + 'a'), (char)(j + 'a'));
for (int z = 0; z < ((int)(ans).size()); z++) printf("%c", ans[z]);
puts("");
return 0;
}
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, M = 505, OO = 0x3f3f3f3f;
string s, r;
int main() {
cin >> s;
bool f = 1;
for (int i = 0; i < s.size(); ++i) {
if (f && s[i] == '0') {
f = 0;
} else {
r.push_back(s[i]);
}
}
if (r.size() == s.size()) r.pop_back();
cout << r << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 3e5 + 10;
const long long kInf = (1LL << 60);
long long t[5], p[5], a[5];
long long GetMin(long long T, long long F, long long a, long long t,
long long p, long long t0) {
if (T < 0) return kInf;
if (t0 <= t) {
if (T / t0 < F) {
return kInf;
}
return 0;
}
if (T / t < F) {
return kInf;
}
long long maxAns = (F / a + (F % a ? 1 : 0)) * p;
long long top = F * t0 - T;
long long bot = a * (t0 - t);
long long bestAns = max(0LL, (top / bot + (top % bot ? 1 : 0))) * p;
return min(bestAns, maxAns);
}
void Solve() {
long long F, T;
scanf("%lld %lld %lld", &F, &T, &t[0]);
for (int i = 1; i <= 2; ++i) {
scanf("%lld %lld %lld", &a[i], &t[i], &p[i]);
}
long long ans = kInf;
for (int wh = 1; wh <= 2; ++wh) {
for (int i = 0; i <= F / a[wh]; ++i) {
ans = min(ans, GetMin(T - i * t[wh] * a[wh], F - i * a[wh], a[3 - wh],
t[3 - wh], p[3 - wh], t[0]) +
i * p[wh]);
}
}
if (ans == kInf)
cout << -1 << "\n";
else
cout << ans << "\n";
}
int main() {
int tests = 1;
for (; tests; --tests) {
Solve();
}
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
struct PT {
int x, y, z;
PT() {}
PT(int x, int y, int z) : x(x), y(y), z(z) {}
PT(const PT &p) : x(p.x), y(p.y), z(p.z) {}
};
PT operator +(PT a,PT b){
return PT(a.x+b.x,a.y+b.y, a.z+b.z);
}
PT operator -(PT a,PT b){
return PT(a.x-b.x,a.y-b.y, a.z-b.z);
}
PT operator *(PT a,int b){
return PT(a.x*b,a.y*b, a.z*b);
}
PT operator /(PT a,int b){
return PT(a.x/b,a.y/b, a.z/b);
}
PT operator %(PT a,int b){
return PT(a.x%b,a.y%b, a.z%b);
}
ostream& operator << (ostream &os, PT P) {
return os<<P.x<<" "<<P.y<<" "<<P.z;
}
const int N = 1005;
int ans[N][N], a[N][N];
const PT DX(1, 0, 0), DY(0, 1, 0), DZ(0, 0, 1);
vector<PT> vv;
int n, q;
PT O, OX, OY, OZ;
void print() {
// cout<<O<<" -- "<<OX<<" --"<<OY<<" -- "<<OZ<<endl;
for (PT P: vv) {
PT Q = (O + OX*P.x + OY*P.y + OZ*P.z)%n;
ans[Q.x][Q.y] = Q.z;
}
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
cout<<ans[i][j]+1<<" ";
}
cout<<endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin>>t;
while (t--) {
cin>>n>>q;
O = PT(0, 0, 0);
OX = DX, OY = DY, OZ = DZ;
PT N(n, n, n);
vv.clear();
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
cin>>a[i][j];
a[i][j]--;
vv.push_back({i, j, a[i][j]});
}
}
string s;
cin>>s;
for (char c: s){
if (c == 'D') O = O + DX;
else if (c == 'U') O = O - DX;
else if (c == 'L') O = O - DY;
else if (c == 'R') O = O + DY;
else if (c == 'I') {
swap(O.y, O.z);
swap(OX.y, OX.z);
swap(OY.y, OY.z);
swap(OZ.y, OZ.z);
}
else if (c == 'C') {
swap(O.x, O.z);
swap(OX.x, OX.z);
swap(OY.x, OY.z);
swap(OZ.x, OZ.z);
}
else print();
O = (O+N)%n;
}
print();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5;
const long long mod = 1e9 + 6;
const long long mmod = 1e9 + 7;
typedef struct {
long long m[MAX][MAX];
} Matrix;
Matrix P = {1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0};
Matrix I = {1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0};
Matrix matrixmul(Matrix a, Matrix b) {
int i, j, k;
Matrix c;
for (i = 0; i < MAX; i++)
for (j = 0; j < MAX; j++) {
c.m[i][j] = 0;
for (k = 0; k < MAX; k++)
c.m[i][j] = (c.m[i][j] + (a.m[i][k] * b.m[k][j]) % mod + mod) % mod;
}
return c;
}
Matrix quickpow(long long n) {
Matrix m = P, b = I;
while (n) {
if (n & 1) b = matrixmul(m, b);
n = n / 2;
m = matrixmul(m, m);
}
return b;
}
long long qmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mmod;
b >>= 1;
a = a * a % mmod;
}
return ans;
}
int main() {
long long n, f1, f2, f3, c;
cin >> n >> f1 >> f2 >> f3 >> c;
Matrix t = quickpow(n - 3);
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
P.m[i][j] = 0;
I.m[i][j] = 0;
}
}
P.m[0][0] = 1, P.m[0][1] = P.m[0][2] = P.m[0][4] = P.m[0][3] = P.m[1][0] =
P.m[2][1] = P.m[3][3] = P.m[3][4] = P.m[4][4] = 1;
I.m[4][0] = 2;
long long cc = quickpow(n - 3).m[0][0];
long long ans = qmod(c, cc) * qmod(f3, t.m[0][0]) % mmod;
ans = ans * qmod(f2, t.m[0][1]) % mmod;
ans = ans * qmod(f1, t.m[0][2]) % mmod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void init_code() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sum *= 2;
if (sum % n) {
cout << 0 << '\n';
} else {
sum /= n;
map<long long int, long long int> mp;
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += mp[sum - a[i]];
mp[a[i]]++;
}
cout << ans << '\n';
}
}
signed main() {
init_code();
long long int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
const int mo = 998244353;
int n, m, i, j, k, l, ans, f[4005][2005][2], inv[4005];
int main() {
scanf("%d%d%d", &n, &m, &l);
f[0][0][0] = 1;
for (i = 0; i <= n * 2; i++)
for (j = 0; j <= n; j++)
for (k = 0; k <= 1; k++)
if (f[i][j][k]) {
f[i + 1][j + 1][k] = (f[i + 1][j + 1][k] + f[i][j][k]) % mo;
if (j)
f[i + 1][j - 1][k] =
(f[i + 1][j - 1][k] + 1ll * f[i][j][k] * j) % mo;
if (!k && j >= m) f[i + 1][j][1] = (f[i + 1][j][1] + f[i][j][0]) % mo;
}
ans = f[2 * n + 1][0][1], inv[1] = 1;
for (i = 2; i <= 2 * n + 1; i++)
inv[i] = 1ll * (mo - mo / i) * inv[mo % i] % mo,
ans = 1ll * ans * inv[i] % mo;
for (i = 1; i <= n; i++) ans = 1ll * ans * 2 % mo * i % mo;
printf("%d\n", 1ll * ans * l % mo);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, n, var;
cin >> t;
while (t--) {
cin >> n;
string s;
cin >> s;
var = (((2 * n) - 1) / n) + 1;
for (i = 0; i < (2 * n - 1); i += var) {
cout << s[i];
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, k;
vector<long long> p;
vector<long long> ans, res;
map<long long, int> mp;
vector<long long> a[101010];
int main() {
cin >> x >> k;
if (x == 1LL) {
printf("1\n");
return 0;
}
if (k >= 100000LL) {
for (int i = 0; i < 100000; i++) {
printf("1%c", " \n"[i == 99999]);
}
return 0;
}
if (x == 1LL) {
for (int i = 0; i <= k; i++) {
printf("1%c", " \n"[i == k]);
}
return 0;
}
for (long long i = 1; i * i <= x; i++) {
if (i * i == x) {
p.push_back(i);
} else if (x % i == 0) {
p.push_back(i);
p.push_back(x / i);
}
}
sort(p.begin(), p.end());
if (2 == (int)p.size()) {
for (int i = 0; i < (int)k; i++) {
printf("1 ");
}
printf(
"%I64d"
"\n",
x);
return 0;
}
for (int i = 0; i < (int)p.size(); i++) {
mp[p[i]] = i;
for (int j = 0; j <= i; j++) {
if (p[i] % p[j] == 0) {
a[i].push_back(p[j]);
}
}
}
ans.clear();
ans.push_back(x);
if (k <= 600LL) {
for (int j = 0; j < (int)k; j++) {
res.clear();
int now = 0;
for (int i = 0; i < (int)ans.size(); i++) {
int w = mp[ans[i]];
for (int o = 0; o < (int)a[w].size(); o++) {
res.push_back(a[w][o]);
now++;
if (now == 100000) break;
}
if (now == 100000) break;
}
ans.clear();
for (int i = 0; i < (int)res.size(); i++) {
ans.push_back(res[i]);
}
}
for (int i = 0; i < (int)ans.size(); i++) {
printf(
"%I64d"
"%c",
ans[i], " \n"[i == (int)ans.size() - 1]);
}
return 0;
}
for (int j = 0; j < 600; j++) {
res.clear();
int now = 0;
for (int i = 0; i < (int)ans.size(); i++) {
int w = mp[ans[i]];
for (int o = 0; o < (int)a[w].size(); o++) {
res.push_back(a[w][o]);
now++;
if (now == 100000) break;
}
if (now == 100000) break;
}
ans.clear();
for (int i = 0; i < (int)res.size(); i++) {
ans.push_back(res[i]);
}
}
k -= 600;
int now = 0;
res.clear();
int v = 0;
for (int i = 0; i < (int)ans.size(); i++) {
if (ans[i] == 1LL) {
res.push_back(1LL);
now++;
if (now == 100000) break;
} else {
for (int o = 0; o < k; o++) {
res.push_back(1LL);
if (++now == 100000) break;
}
if (now == 100000) break;
res.push_back(ans[i]);
now++;
}
if (now == 100000) break;
}
for (int i = 0; i < (int)res.size(); i++) {
printf(
"%I64d"
"%c",
res[i], " \n"[i == (int)res.size() - 1]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e5 + 9;
struct nod {
int x, y, p, w;
} que[inf];
vector<pair<int, int> > adj[inf];
int subtree[inf];
int sel_nod[inf];
int sel_list[inf];
queue<pair<int, int> > lists[inf];
int cnt = 0;
long long dfs(int x, int p, int ss) {
sel_nod[x] = ss;
long long sz = 0;
int mx = -1;
for (int i = 0; i < adj[x].size(); ++i) {
int to = adj[x][i].first;
if (to == p) continue;
sz += dfs(to, x, adj[x][i].second);
subtree[x] += subtree[to];
if (mx == -1 || lists[sel_list[to]].size() > lists[mx].size())
mx = sel_list[to];
}
sel_list[x] = mx == -1 ? cnt++ : mx;
int select = sel_list[x];
for (int i = 0; i < adj[x].size(); ++i) {
int to = adj[x][i].first;
if (to == p) continue;
int tmp = sel_list[to];
if (tmp == select) continue;
while (!lists[tmp].empty()) {
lists[select].push(lists[tmp].front());
lists[tmp].pop();
}
}
if (x != 1) {
int power = que[sel_nod[x]].p;
while (sz > power && !lists[select].empty()) {
int tmp = lists[select].front().first;
int e = lists[select].front().second;
long long k =
min(sz - power, (long long)min(que[tmp].p - e, que[tmp].w - 1));
if (k > 0) {
sz -= k;
que[tmp].p -= k;
que[tmp].w -= k;
}
if (que[tmp].w <= 1 || que[tmp].p <= e) lists[select].pop();
}
if (sz > power) {
printf("-1\n");
exit(0);
}
}
lists[select].push(pair<int, int>(sel_nod[x], subtree[x]));
subtree[x] += max(que[sel_nod[x]].w - que[sel_nod[x]].p + subtree[x], 1);
return sz + que[sel_nod[x]].w;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%d%d", &que[i].x, &que[i].y, &que[i].w, &que[i].p);
adj[que[i].x].push_back(pair<int, int>(que[i].y, i));
adj[que[i].y].push_back(pair<int, int>(que[i].x, i));
}
dfs(1, -1, 0);
printf("%d\n", n);
for (int i = 0; i < n - 1; ++i)
printf("%d %d %d %d\n", que[i].x, que[i].y, que[i].w, que[i].p);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool status[3000];
int main() {
vector<int> prime;
int p = 1000, m, i, j, sq;
status[1] = 1;
sq = sqrt(p);
for (i = 4; i <= p; i += 2) status[i] = 1;
for (i = 3; i <= sq; i += 2) {
if (status[i] == 0) {
for (j = i * i; j <= p; j += i) status[j] = 1;
}
}
for (i = 2; i <= p; i++) {
if (status[i] == 0) {
prime.push_back(i);
}
}
int n, k;
cin >> n >> k;
int sum = 0;
bool flag = false;
int ct = 0;
for (i = 0; prime[i] <= n; i++) {
sum = 0;
for (j = i / 2; j <= i; j++) {
if (prime[j] + prime[j + 1] + 1 == prime[i]) {
ct++;
}
}
}
if (ct >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int x[maxn];
int vis[maxn];
int main() {
int n, k;
memset(vis, 0, sizeof(vis));
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &x[i]);
vis[x[i]] = 1;
}
for (int i = 1; i <= k; i++) {
printf("%d ", x[i]);
int num = 1;
for (int j = 1; j <= n * k; j++) {
if (!vis[j]) {
num++;
printf("%d ", j);
vis[j] = 1;
}
if (num == n) break;
}
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
ll mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
unordered_map<int, int> m;
int flag = 0;
for (int i = 0; i < 4 * n; i++) {
int x;
cin >> x;
m[x]++;
}
for (auto it : m) {
if (it.second % 2 != 0) {
flag = 1;
break;
}
}
if (flag) {
cout << "NO" << endl;
continue;
}
unordered_map<int, int> mp;
for (auto it : m) {
for (auto itr : m) {
mp[it.first * itr.first] += min(it.second / 2, itr.second / 2);
}
}
for (auto it : mp) {
if (it.second == 2 * n) {
flag = 1;
break;
}
}
if (flag)
cout << "YES" << endl;
else {
cout << "NO" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
getline(cin, s1);
getline(cin, s2);
int n = s1.size(), c = 0;
int ss1 = 0, ss2 = 0;
while (n--) {
if (tolower(s1[c]) == tolower(s2[c])) {
c++;
continue;
}
ss1 += int(tolower(s1[c]));
ss2 += int(tolower(s2[c]));
}
if (ss1 == ss2) cout << 0 << endl;
if (ss1 < ss2) cout << -1 << endl;
if (ss1 > ss2) cout << 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
double d[110000];
double d2[110000];
double pref[110000];
pair<int, int> get(int l, int r) {
if (l < 1) l = 1;
if (r < 1) r = 1;
return make_pair(l, r);
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
int n, m;
int sum = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 0; i <= n * m; i++) {
d[i] = 0;
if (i >= 1 && i <= m && i != a[0]) d[i] = 1.0 / (m - 1);
}
for (int i = 2; i <= n; i++) {
pref[0] = d[0];
for (int j = 0; j <= n * m; j++) {
d2[j] = 0;
pref[j] = pref[j - 1] + d[j];
}
for (int j = i; j <= i * m; j++) {
pair<int, int> loop = get(j - m, j - 1);
d2[j] += (pref[loop.second] - pref[loop.first - 1]) / (m - 1);
if (j - a[i - 1] > 0) d2[j] -= d[j - a[i - 1]] / (m - 1);
}
for (int j = 0; j <= n * m; j++) d[j] = d2[j];
}
double ans = 0;
for (int i = 1; i < sum; i++) ans += 1.0 * d[i];
cout << 1 + ans * (m - 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char sir[200];
int cost[200], ans[200], dp[200][200], best[200][200][200];
int n, sol;
int solve(int i, int j, int k, int p);
bool pal(int p1, int p2);
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> cost[i];
if (cost[i] == -1) {
cost[i] = -100000000;
}
}
cin >> sir + 1;
for (int i = 0; i < 200; ++i) {
for (int j = 0; j < 200; ++j) {
for (int k = 0; k < 200; ++k) {
best[i][j][k] = -100000000;
}
if (i > j) {
best[i][j][0] = 0;
}
dp[i][j] = -100000000;
}
}
for (int lg = 1; lg <= n; ++lg) {
for (int i = 1; i <= n - lg + 1; ++i) {
int j = i + lg - 1;
for (int p = i; p < j; ++p) {
for (int k = 0; k < lg; ++k) {
best[i][j][k] = max(best[i][j][k], solve(i, j, k, p));
}
}
if (sir[i] == sir[j]) {
if (i != j) {
for (int k = 2; k <= lg; ++k) {
best[i][j][k] = max(best[i][j][k], best[i + 1][j - 1][k - 2]);
}
} else {
for (int k = 1; k <= lg; ++k) {
if (i == n) {
best[i][j][k] = max(best[i][j][k], 0);
} else
best[i][j][k] = max(best[i][j][k], best[i + 1][j - 1][k - 1]);
}
}
}
for (int p = i; p < j; ++p) {
dp[i][j] = max(dp[i][j], dp[i][p] + dp[p + 1][j]);
}
for (int k = 1; k <= lg; ++k) {
dp[i][j] = max(dp[i][j], best[i][j][k] + cost[k]);
}
best[i][j][0] = dp[i][j];
}
}
for (int i = 1; i <= n; ++i) {
ans[i] = ans[i - 1];
for (int j = 0; j < i; ++j) {
ans[i] = max(ans[i], ans[j] + dp[j + 1][i]);
}
}
cout << ans[n];
return 0;
}
int solve(int i, int j, int k, int p) {
return max(best[i][p][k] + dp[p + 1][j], dp[i][p] + best[p + 1][j][k]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 500 + 10;
int n, m, q, cnt, mark[maxN];
vector<pair<int, int> > adj[maxN];
void dfs(int v, int l, int r) {
mark[v] = true;
for (int i = 0; i < adj[v].size(); i++) {
int p = adj[v][i].second;
int x = adj[v][i].first;
if (p > r || p < l) {
if (!mark[x]) dfs(x, l, r);
}
}
}
void dfsA(int l, int r) {
cnt = 0;
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
dfs(i, l, r);
cnt++;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
adj[x].push_back(make_pair(y, i));
adj[y].push_back(make_pair(x, i));
}
cin >> q;
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
fill(mark + 1, mark + n + 1, 0);
dfsA(x - 1, y - 1);
printf("%d \n", cnt);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fileio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
}
string s;
int a[200005], res = 0;
int main() {
fileio();
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++) a[i] = (s[i] - 48) % 3;
for (int i = 0; i < n; i++) {
if (a[i] % 3 == 0)
res++;
else if ((a[i] + a[i + 1]) % 3 == 0 && a[i + 1] % 3 != 0 && i + 1 < n)
res++, i++;
else if ((a[i] + a[i + 1] + a[i + 2]) % 3 == 0 && a[i + 1] % 3 != 0 &&
a[i + 2] % 3 != 0 && i + 2 < n)
res++, i += 2;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const long long linf = 1e18 + 7;
const long long hh = 523;
int n, m;
char p[2];
bool visited[17];
bool hve[17][7];
bool init[27][27];
int dxw[2];
pair<int, int> w[2];
map<char, int> sz, hs;
pair<int, int> pp[27][27];
char hysz[17], hyhs[7];
pair<int, int> ans[54];
bool check2(int x, int y) {
memset(visited, false, sizeof(visited));
int ths = 0;
bool f1 = false, f2 = false;
for (int i = x; i < x + 3; i++) {
for (int j = y; j < y + 3; j++) {
if (ths == 0) {
ths = pp[i][j].second;
} else if (ths != pp[i][j].second) {
f1 = true;
}
if (visited[pp[i][j].first]) {
f2 = true;
}
visited[pp[i][j].first] = true;
}
}
if (!f1 || !f2) {
return true;
}
return false;
}
bool check() {
memset(init, false, sizeof(init));
int cnt = 0;
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < m - 2; j++) {
if (!init[i][j] && check2(i, j)) {
ans[cnt++] = make_pair(i + 1, j + 1);
if (cnt >= 2) {
for (int ii = 0; ii < cnt - 1; ii++) {
if (!(abs(ans[ii].first - 1 - i) < 3 &&
abs(ans[ii].second - 1 - j) < 3)) {
ans[0] = ans[ii];
ans[1] = ans[cnt - 1];
return true;
}
}
}
}
}
}
return false;
}
int main() {
sz['A'] = 1;
hysz[1] = 'A';
for (int i = 2; i <= 9; i++) {
sz[char(i + '0')] = i;
hysz[i] = char(i + '0');
}
sz['T'] = 10;
sz['J'] = 11;
sz['Q'] = 12;
sz['K'] = 13;
hysz[10] = 'T';
hysz[11] = 'J';
hysz[12] = 'Q';
hysz[13] = 'K';
hs['C'] = 1;
hs['D'] = 2;
hs['H'] = 3;
hs['S'] = 4;
hyhs[1] = 'C';
hyhs[2] = 'D';
hyhs[3] = 'H';
hyhs[4] = 'S';
scanf("%d%d", &n, &m);
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%s", p);
if (p[1] == '1') {
w[cnt] = make_pair(i, j);
dxw[cnt++] = 1;
} else if (p[1] == '2') {
w[cnt] = make_pair(i, j);
dxw[cnt++] = 2;
} else {
pp[i][j].first = sz[p[0]];
pp[i][j].second = hs[p[1]];
hve[sz[p[0]]][hs[p[1]]] = true;
}
}
}
if (cnt == 0) {
if (check()) {
puts("Solution exists.");
puts("There are no jokers.");
printf("Put the first square to (%d, %d).\n", ans[0].first,
ans[0].second);
printf("Put the second square to (%d, %d).\n", ans[1].first,
ans[1].second);
return 0;
}
} else if (cnt == 1) {
for (int sz = 1; sz <= 13; sz++) {
for (int hs = 1; hs <= 4; hs++) {
if (hve[sz][hs]) {
continue;
}
pp[w[0].first][w[0].second] = make_pair(sz, hs);
if (check()) {
puts("Solution exists.");
printf("Replace J%d with %c%c.\n", dxw[0], hysz[sz], hyhs[hs]);
printf("Put the first square to (%d, %d).\n", ans[0].first,
ans[0].second);
printf("Put the second square to (%d, %d).\n", ans[1].first,
ans[1].second);
return 0;
}
}
}
} else {
for (int sz1 = 1; sz1 <= 13; sz1++) {
for (int hs1 = 1; hs1 <= 4; hs1++) {
if (hve[sz1][hs1]) {
continue;
}
pp[w[0].first][w[0].second] = make_pair(sz1, hs1);
hve[sz1][hs1] = true;
for (int sz = 1; sz <= 13; sz++) {
for (int hs = 1; hs <= 4; hs++) {
if (hve[sz][hs]) {
continue;
}
pp[w[1].first][w[1].second] = make_pair(sz, hs);
if (check()) {
puts("Solution exists.");
if (dxw[0] == 1) {
printf("Replace J1 with %c%c and J2 with %c%c.\n", hysz[sz1],
hyhs[hs1], hysz[sz], hyhs[hs]);
} else {
printf("Replace J1 with %c%c and J2 with %c%c.\n", hysz[sz],
hyhs[hs], hysz[sz1], hyhs[hs1]);
}
printf("Put the first square to (%d, %d).\n", ans[0].first,
ans[0].second);
printf("Put the second square to (%d, %d).\n", ans[1].first,
ans[1].second);
return 0;
}
}
}
hve[sz1][hs1] = false;
}
}
}
puts("No solution.");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
vector<int> v;
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i < n + 1; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long int ans = 0;
for (int i = 0; i < v.size(); i++) {
if (i < m) {
ans += k;
} else
ans += v[i];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
template <typename T>
inline bool MIN(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool MAX(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
using namespace std;
long long n, c0, c1;
long long C[20000][40];
long long calc(long long j, long long i) {
if (i == 0) return j + 1;
if (j > 15000) return n;
return C[i + j + 1][i + 1];
}
int ok(long long cost) {
if (!c0) return 1;
long long res = 0;
for (long long i = 0; i < 40 && cost - i * c1 >= 0; ++i) {
long long j = (cost - i * c1) / c0;
res += calc(j, i);
if (res >= n) return 1;
}
return 0;
}
int main() {
scanf("%I64d%I64d%I64d", &n, &c0, &c1);
--n;
if (c0 > c1) swap(c0, c1);
C[0][0] = 1;
for (int i = 1; i < 20000; ++i) {
C[i][0] = 1;
for (int j = 1; j < 40; ++j)
C[i][j] = min(n, C[i - 1][j - 1] + C[i - 1][j]);
}
long long l = 0, r = 0x3f3f3f3f3f3f3f3fll;
while (l < r) {
long long mid = l + r >> 1;
if (ok(mid))
r = mid;
else
l = mid + 1;
}
long long cnt = 0, sum = 0;
for (long long i = 0; i < 40 && (l - 1) - i * c1 >= 0; ++i) {
long long j = ((l - 1) - i * c1) / c0;
if (i == 0) {
cnt += j + 1;
sum += (j + 1) * j / 2 * c0;
} else {
for (; j >= 0; --j) {
cnt += C[i + j][i];
sum += C[i + j][i] * (c1 * i + c0 * j);
}
}
}
printf("%I64d\n", sum + l * (n - cnt) + n * (c0 + c1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
vector<char*> tokenizer(const char* args) {
char* token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char*> v({token});
while (token = strtok(NULL, ", ")) v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
void debugg(vector<char*> args) { cerr << "\b\b "; }
template <typename Head, typename... Tail>
void debugg(vector<char*> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
long long mod = 1e9 + 7;
const int MX = 0x3f3f3f3f;
int N = 2e5 + 2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k, n;
cin >> n >> k;
int i;
vector<pair<int, int> > vp(n);
vector<int> a(N);
vector<vector<int> > en(N);
for (i = 0; i <= n - 1; i++) {
cin >> vp[i].first >> vp[i].second;
en[vp[i].first].emplace_back(i + 1);
en[vp[i].second + 1].emplace_back(-i - 1);
a[vp[i].first]++;
a[vp[i].second + 1]--;
}
for (i = 1; i <= N - 1; i++) a[i] += a[i - 1];
vector<int> r(N);
int temp = 0;
vector<int> ans;
set<pair<int, int> > s;
for (i = 1; i <= N - 1; i++) {
temp += r[i];
for (auto u : en[i]) {
if (u > 0) {
s.insert(make_pair(vp[u - 1].second, u - 1));
} else {
if (s.find(make_pair(vp[-u - 1].second, -u - 1)) != s.end())
s.erase(make_pair(vp[-u - 1].second, -u - 1));
}
}
while (a[i] - temp > k) {
auto it = s.rbegin();
int pos = it->second;
ans.emplace_back(it->second + 1);
r[vp[pos].second + 1]--;
s.erase(prev(s.end()));
temp++;
}
}
cout << ans.size() << "\n";
for (auto u : ans) cout << u << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct widget {
string name;
long long x, y;
};
struct box {
string name;
bool type;
long long border, spacing, x, y;
vector<pair<int, bool> > pack;
};
vector<widget> vw;
vector<box> vb;
pair<long long, long long> go(int n) {
pair<long long, long long> xy;
long long xx = 0, yy = 0;
for (int j = 0; j < vb[n].pack.size(); j++) {
if (vb[n].pack[j].second == 1) {
if (vb[vb[n].pack[j].first].x == -1)
xy = go(vb[n].pack[j].first);
else {
xy.first = vb[vb[n].pack[j].first].x;
xy.second = vb[vb[n].pack[j].first].y;
}
} else
xy = make_pair(vw[vb[n].pack[j].first].x, vw[vb[n].pack[j].first].y);
if (vb[n].type == 0) {
if (xy.second > yy) yy = xy.second;
xx += xy.first;
} else {
if (xy.first > xx) xx = xy.first;
yy += xy.second;
}
}
if (vb[n].pack.size() > 0) {
xx = xx + vb[n].border * 2;
yy = yy + vb[n].border * 2;
if (vb[n].pack.size() > 0 && vb[n].type == 0) {
xx += (vb[n].pack.size() - 1) * vb[n].spacing;
} else {
yy += (vb[n].pack.size() - 1) * vb[n].spacing;
}
}
vb[n].x = xx;
vb[n].y = yy;
return make_pair(xx, yy);
}
int main() {
int n;
pair<long long, long long> xy;
string com, name, x, y;
widget vwv;
box vbv;
long long a, b, xx, yy;
cin >> n;
getline(cin, com);
for (int i = 0; i < n; i++) {
getline(cin, com);
if (com.find("Widget") == 0) {
a = com.find("(");
b = com.find(",");
vwv.name = com.substr(7, a - 7);
x = com.substr(a + 1, b - (a + 1));
y = com.substr(b + 1, com.size() - 1 - (b + 1));
xx = 0;
for (int j = 0; j < x.size(); j++) {
xx = xx * 10 + (x[j] - '0');
}
yy = 0;
for (int j = 0; j < y.size(); j++) {
yy = yy * 10 + (y[j] - '0');
}
vwv.x = xx;
vwv.y = yy;
vw.push_back(vwv);
}
if (com.find("HBox") == 0) {
vbv.name = com.substr(5, com.size() - 5);
vbv.type = 0;
vbv.border = 0;
vbv.spacing = 0;
vbv.x = -1;
vb.push_back(vbv);
}
if (com.find("VBox") == 0) {
vbv.name = com.substr(5, com.size() - 5);
vbv.type = 1;
vbv.border = 0;
vbv.spacing = 0;
vbv.x = -1;
vb.push_back(vbv);
}
if (com.find(".pack") < com.size()) {
name = com.substr(0, com.find("."));
for (a = 0; a < vb.size(); a++) {
if (name == vb[a].name) break;
}
name = com.substr(com.find(".pack(") + 6,
com.size() - 1 - (com.find(".pack(") + 6));
for (b = 0; b < vw.size(); b++) {
if (name == vw[b].name) break;
}
if (b < vw.size() && name == vw[b].name)
vb[a].pack.push_back(make_pair(b, 0));
else {
for (b = 0; b < vb.size(); b++) {
if (name == vb[b].name) break;
}
vb[a].pack.push_back(make_pair(b, 1));
}
}
if (com.find(".set_border") < com.size()) {
name = com.substr(0, com.find("."));
for (a = 0; a < vb.size(); a++) {
if (name == vb[a].name) break;
}
y = com.substr(com.find(".set_border") + 12,
com.size() - 1 - (com.find(".set_border") + 12));
yy = 0;
for (int j = 0; j < y.size(); j++) {
yy = yy * 10 + (y[j] - '0');
}
vb[a].border = yy;
}
if (com.find(".set_spacing") < com.size()) {
name = com.substr(0, com.find("."));
for (a = 0; a < vb.size(); a++) {
if (name == vb[a].name) break;
}
y = com.substr(com.find(".set_spacing") + 13,
com.size() - 1 - (com.find(".set_spacing") + 13));
yy = 0;
for (int j = 0; j < y.size(); j++) {
yy = yy * 10 + (y[j] - '0');
}
vb[a].spacing = yy;
}
}
set<pair<string, pair<long long, long long> > > s;
for (int i = 0; i < vw.size(); i++) {
com = vw[i].name;
s.insert(make_pair(com, make_pair(vw[i].x, vw[i].y)));
}
for (int i = 0; i < vb.size(); i++) {
xy = go(i);
com = vb[i].name;
s.insert(make_pair(com, make_pair(xy.first, xy.second)));
}
for (set<pair<string, pair<long long, long long> > >::iterator it = s.begin();
it != s.end(); ++it) {
cout << (*it).first << ' ' << (*it).second.first << ' '
<< (*it).second.second << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t,n;
cin>>t;
while(t--){
int o=1,e=2,l,i=0;
cin>>n;
l=n*n;
if(n==1) cout<<'1'<<endl;
else if(n==2)cout<<"-1"<<endl;
else{
while(o<=l){
cout<<o<<' ';
i++;
if(i==n) {
cout<<endl;
i=0;
}
o=o+2;
}
while(e<=l){
cout<<e<<' ';
i++;
if(i==n) {
cout<<endl;
i=0;
}
e=e+2;
}
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int k_max_n = 1e5 + 11, k_max_s = 1e5 + 11;
int n;
int ss[k_max_n], cnt[k_max_s];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &ss[i]);
}
for (int i = 0; i < n; ++i) {
int sqrtn = sqrt(ss[i]);
for (int j = 1; j <= sqrtn; ++j) {
if (ss[i] % j == 0) {
cnt[j]++;
if (j != ss[i] / j) cnt[ss[i] / j]++;
}
}
}
int ans = 1;
for (int i = 2; i < k_max_s; ++i) ans = max(ans, cnt[i]);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double pi = 2 * acos(0.0);
long long a1, a2, a3, a4, b1, b2, b3, c, c1, c2, c3, c4, d, d1, d2, d3, d4, d5,
e1, e2, e3, f, h, k, l, m, n, m1, m2, n1, n2, o, p, p1, p2, p3, p4, q, q1,
q2, q3, q4, r, s, t, u, v, x, y, z, sum, mx = -1e15, mn = 1e15, flg, flg1,
flg2, id1, id2, id3, id4, lim;
long long A[101][101], vis[101][101];
map<pair<long long, long long>, long long> Mp;
void solve() {
c = 0;
mn = 0;
memset(vis, 0, sizeof(vis));
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (vis[i][j]) continue;
c1 = i;
d1 = j;
c2 = i;
d2 = (m - j) + 1;
c3 = (n - i) + 1;
d3 = j;
c4 = c3;
d4 = d2;
a1 = (A[c1][d1] + A[c2][d2] + A[c3][d3] + A[c4][d4]);
a2 = (a1 / 4);
d = (a1 % 4);
c = 1e15;
for (long long k = 0; k <= d; k++) {
a3 = (a2 + k);
a4 = abs(A[c1][d1] - a3);
Mp[make_pair(c1, d1)] = 1;
if (!Mp[make_pair(c2, d2)]) {
a4 += abs(A[c2][d2] - a3);
Mp[make_pair(c2, d2)] = 1;
}
if (!Mp[make_pair(c3, d3)]) {
a4 += abs(A[c3][d3] - a3);
Mp[make_pair(c3, d3)] = 1;
}
if (!Mp[make_pair(c4, d4)]) {
a4 += abs(A[c4][d4] - a3);
}
Mp.clear();
c = min(c, a4);
}
a4 = abs(A[c1][d1] - A[c2][d2]) + abs(A[c1][d1] - A[c3][d3]) +
abs(A[c1][d1] - A[c4][d4]);
c = min(c, a4);
a4 = abs(A[c1][d1] - A[c2][d2]) + abs(A[c2][d2] - A[c3][d3]) +
abs(A[c2][d2] - A[c4][d4]);
c = min(c, a4);
a4 = abs(A[c1][d1] - A[c3][d3]) + abs(A[c2][d2] - A[c3][d3]) +
abs(A[c3][d3] - A[c4][d4]);
c = min(c, a4);
a4 = abs(A[c1][d1] - A[c4][d4]) + abs(A[c4][d4] - A[c2][d2]) +
abs(A[c3][d3] - A[c4][d4]);
c = min(c, a4);
mn = mn + c;
vis[c1][d1] = vis[c2][d2] = vis[c3][d3] = vis[c4][d4] = 1;
}
}
printf("%lld\n", mn);
}
int main() {
t = 1;
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
scanf("%lld", &A[i][j]);
}
}
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool bit(int x, int b) { return (x >> b) & 1; }
string s[60];
int n, m;
double prob[1 << 21];
long long not_can[1 << 21];
int main() {
scanf("%d\n", &n);
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
m = s[0].size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (j == i) {
continue;
}
int mask = 0;
for (int k = 0; k < m; ++k) {
if (s[i][k] == s[j][k]) {
mask |= 1 << k;
}
}
not_can[mask] |= 1ll << i;
}
}
for (int len = m; len >= 0; --len) {
for (int mask = 0; mask < (1 << m); ++mask) {
if (__builtin_popcount(mask) == len) {
for (int k = 0; k < m; ++k) {
if (bit(mask, k)) {
not_can[mask ^ (1 << k)] |= not_can[mask];
}
}
}
}
}
double ans = 0.0;
memset(prob, 0, sizeof prob);
prob[0] = 1.0;
for (int len = 0; len <= m; ++len) {
for (int mask = 0; mask < (1 << m); ++mask) {
if (__builtin_popcount(mask) == len) {
for (int k = 0; k < m; ++k) {
if (!bit(mask, k)) {
double nprob = prob[mask] / (m - len);
long long nmask = mask | (1 << k);
int cnt_end = __builtin_popcountll(not_can[mask] ^ not_can[nmask]);
ans += ((double)cnt_end / n) * nprob * (len + 1);
prob[mask | (1 << k)] += nprob;
}
}
}
}
}
printf("%.10f\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[2][100005];
int main() {
ios::sync_with_stdio(false);
int n;
string a, b;
cin >> n;
cin >> a >> b;
long long int q = 1;
long long int eq = 0;
if (a[0] != '?' && b[0] != '?') {
dp[0][0] = (a[0] >= b[0]) ? 1 : 0;
dp[1][0] = (a[0] <= b[0]) ? 1 : 0;
} else if (a[0] == '?' && b[0] != '?') {
dp[0][0] = 10 - (b[0] - '0');
dp[1][0] = (b[0] - '0') + 1;
q *= 10;
++eq;
} else if (a[0] != '?' && b[0] == '?') {
dp[0][0] = (a[0] - '0') + 1;
dp[1][0] = 10 - (a[0] - '0');
q *= 10;
++eq;
} else {
dp[0][0] = dp[1][0] = 55;
q *= 100;
eq += 10;
}
for (int i = 1; i < n; ++i) {
if (a[i] != '?' && b[i] != '?') {
dp[0][i] = dp[0][i - 1];
dp[1][i] = dp[1][i - 1];
if (a[i] < b[i])
dp[0][i] = 0;
else if (a[i] > b[i])
dp[1][i] = 0;
if (dp[0][i] == 0 || dp[1][i] == 0) eq = 0;
} else {
if (a[i] == '?' && b[i] != '?') {
dp[0][i] = dp[0][i - 1] * (10 - (b[i] - '0'));
dp[1][i] = dp[1][i - 1] * ((b[i] - '0') + 1);
dp[0][i] = (dp[0][i] % 1000000007);
dp[1][i] = (dp[1][i] % 1000000007);
q *= 10;
} else if (a[i] != '?' && b[i] == '?') {
dp[0][i] = dp[0][i - 1] * ((a[i] - '0') + 1);
dp[1][i] = dp[1][i - 1] * (10 - (a[i] - '0'));
dp[0][i] = (dp[0][i] % 1000000007);
dp[1][i] = (dp[1][i] % 1000000007);
q *= 10;
} else {
dp[0][i] = 55 * dp[0][i - 1];
dp[1][i] = 55 * dp[1][i - 1];
dp[0][i] = (dp[0][i] % 1000000007);
dp[1][i] = (dp[1][i] % 1000000007);
q *= 100;
if (dp[0][i] != 0 && dp[1][i] != 0) eq *= 10;
}
if (dp[0][i] == 0 || dp[1][i] == 0) eq = 0;
q = (q % 1000000007);
eq = (eq % 1000000007);
}
}
if (q + eq < (dp[0][n - 1] + dp[1][n - 1]))
cout << 1000000007 + q - (dp[0][n - 1] + dp[1][n - 1]) + eq << endl;
else
cout << q - (dp[0][n - 1] + dp[1][n - 1]) + eq << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const double EPS = 10e-9;
int main() {
long long n;
cin >> n;
long long pot = 1;
for (int i = 0; i < (18); ++i) pot *= 10;
long long r = pot % n;
for (int i = 0; i < (4); ++i) {
r *= 3;
r %= n;
}
n -= r;
cout << n << " " << pot + n - 1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize "03"
using namespace std;
const char E = '\n';
const int N = 100005;
vector<long long> g[N];
long long ans, kilk;
bool used[N];
void dfs(int v, int p) {
kilk++;
used[v] = 1;
for (int i = 0; i < g[v].size(); i++)
if (used[g[v][i]] == 0) dfs(g[v][i], v);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, x, y, z;
cin >> n >> k;
ans = n;
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y >> z;
if (z == 0) {
g[x].push_back(y);
g[y].push_back(x);
}
}
long long mod = 1e9 + 7;
for (int i = 2; i <= k; i++) ans *= n, ans %= mod;
for (int i = 1; i <= n; i++) {
kilk = 0;
if (used[i] == 0) {
dfs(i, -1);
long long cnt = kilk;
for (int j = 2; j <= k; j++) cnt *= kilk, cnt %= mod;
ans -= cnt;
ans %= mod;
ans += mod;
ans %= mod;
ans += mod;
ans %= mod;
}
}
cout << ans << E;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> fa, R;
int q, op, l, r, lt, x;
int fin(int u) {
if (fa.find(u) == fa.end()) return u;
int v = fin(fa[u]);
R[u] ^= R[fa[u]];
return fa[u] = v;
}
void un(int u, int v, int tp) {
int x = fin(u), y = fin(v);
if (x == y) return;
fa[x] = y;
R[x] = R[u] ^ R[v] ^ tp;
}
int main() {
cin >> q;
while (q--) {
scanf("%d%d%d", &op, &l, &r);
l ^= lt;
r ^= lt;
if (l > r) swap(l, r);
r++;
if (op == 1) {
scanf("%d", &x);
x ^= lt;
un(l, r, x);
} else {
if (fin(l) == fin(r))
lt = R[l] ^ R[r];
else
lt = -1;
printf("%d\n", lt);
if (lt == -1) lt = 1;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i, j;
int freq[101] = {0};
for (j = 0; j < n; j++) {
int a, x;
cin >> a;
for (i = 0; i < a; i++) {
cin >> x;
freq[x]++;
}
}
for (j = 1; j <= 100; j++) {
if (freq[j] == n) cout << j << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
long long ans = a[0];
long long s = 0;
for (long long i = 1; i < n; ++i) {
if (a[i])
s++;
else {
ans += (s / 3);
s = 0;
}
}
ans += (s / 3);
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int main() {
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
if ((n - i) % i == 0) {
ans++;
}
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(string a, string b) { return a.size() < b.size(); }
int main() {
ios_base::sync_with_stdio(false);
std::ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int arr[51][51];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
int ans[51];
set<int> st;
for (int i = 0; i < n; i++) {
int mx = 0;
for (int j = 0; j < n; j++) {
mx = max(mx, arr[i][j]);
}
if (!st.count(mx)) {
ans[i] = mx;
st.insert(mx);
} else {
ans[i] = n;
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, head[400005], tot, rk[400005], m, chan[400005], lca;
struct node {
int to, next, id;
node(int to = 0, int next = 0, int id = 0) : to(to), next(next), id(id) {}
} e[400005];
struct node1 {
int fa, top, id, d, son, size, w;
} s[400005];
struct node2 {
int l, r;
bool col;
} t[400005 << 1];
int read() {
int w = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
w = (w << 3) + (w << 1) + (c ^ 48);
c = getchar();
}
return w * f;
}
void adde(int u, int v, int i) {
e[++tot] = node(v, head[u], i);
head[u] = tot;
}
void dfs1(int u) {
s[u].d = s[s[u].fa].d + 1, s[u].size = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v != s[u].fa) {
s[v].fa = u;
dfs1(v);
s[u].size += s[v].size;
chan[e[i].id] = v;
if (s[s[u].son].size < s[v].size) s[u].son = v;
}
}
}
void dfs2(int u, int tp) {
s[u].top = tp, s[u].id = ++tot, rk[tot] = u;
if (s[u].son) dfs2(s[u].son, tp);
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v != s[u].fa && v != s[u].son) dfs2(v, v);
}
}
void build(int i, int l, int r) {
t[i].l = l, t[i].r = r;
if (l == r) return;
int mid = l + r >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
}
void update(int i) { t[i].col = t[i << 1].col | t[i << 1 | 1].col; }
void ch(int i, int dis, int k) {
if (t[i].l == t[i].r) {
t[i].col = k;
return;
}
if (t[i << 1].r >= dis)
ch(i << 1, dis, k);
else
ch(i << 1 | 1, dis, k);
update(i);
}
bool search(int i, int l, int r) {
if (t[i].l >= l && t[i].r <= r) return t[i].col;
bool ans = 0;
if (t[i << 1].r >= l) ans |= search(i << 1, l, r);
if (t[i << 1 | 1].l <= r) ans |= search(i << 1 | 1, l, r);
return ans;
}
bool judge(int u, int v) {
bool ans = 0;
while (s[u].top != s[v].top) {
if (s[s[u].top].d < s[s[v].top].d) swap(u, v);
ans |= search(1, s[s[u].top].id, s[u].id);
u = s[s[u].top].fa;
}
if (s[u].id > s[v].id) swap(u, v);
lca = u;
if (s[u].id < s[v].id) ans |= search(1, s[u].id + 1, s[v].id);
return ans;
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
adde(u, v, i), adde(v, u, i);
}
dfs1(1);
tot = 0;
dfs2(1, 1);
build(1, 1, n);
m = read();
for (int i = 1; i <= m; i++) {
int op = read();
if (op == 1)
ch(1, s[chan[read()]].id, 0);
else if (op == 2)
ch(1, s[chan[read()]].id, 1);
else {
int u = read(), v = read();
if (judge(u, v))
puts("-1");
else
printf("%d\n", s[u].d + s[v].d - s[lca].d * 2);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, A[1500005], B[1500005], I[25], E[25], D[25];
long long f(long long n) { return (n * (n - 1)) / 2; }
void MergeSort(long long bas, long long son, long long lvl) {
if (bas == son) return;
long long ort = (bas + son) / 2;
MergeSort(bas, ort, lvl - 1);
MergeSort(ort + 1, son, lvl - 1);
long long j = ort + 1;
for (long long i = bas; i <= ort; i++) {
while (j <= son && A[i] > A[j]) j++;
I[lvl] += j - ort - 1;
}
long long i = bas, l = bas;
j = ort + 1;
while (i <= ort && j <= son) {
if (A[i] < A[j])
B[l++] = A[i++];
else
B[l++] = A[j++];
}
while (i <= ort) B[l++] = A[i++];
while (j <= son) B[l++] = A[j++];
i = bas;
while (i <= son) {
j = i + 1;
while (B[i] == B[j]) j++;
E[lvl] += (j - i) * (j - i - 1) / 2;
i = j;
}
for (long long i = bas; i <= son; i++) A[i] = B[i];
}
int main() {
long long x;
scanf("%lld", &n);
k = 1 << n;
for (long long i = 1; i <= k; i++) scanf("%lld", A + i);
MergeSort(1, k, n);
for (long long i = 1; i <= n; i++) D[i] = I[i];
for (long long i = 1; i <= n; i++) I[i] += I[i - 1];
scanf("%lld", &m);
for (long long i = 1; i <= m; i++) {
scanf("%lld", &x);
long long t = I[x];
for (long long i = 1; i <= x; i++)
I[i] = ((1 << (n - i)) * f(1 << i) - E[i]) - I[i];
for (long long i = x + 1; i <= n; i++) I[i] += I[x] - t;
printf("%lld\n", I[n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double one = 1.0;
const double PI = 3.14159265;
const long long maxn = 1e4 + 10;
const long double eps = 1e-14;
const long long max_len = 1e6 + 1;
long long x[maxn], r[maxn], id[maxn], n, ans[maxn], k;
bool cmp(long long a, long long b) { return (x[a] < x[b]); }
long long pw(long long n) { return n * n; }
void search(long long lw, long long hi, long long u, long long v,
long long ind) {
if (lw > hi) return;
long long mid = (lw + hi) >> 1;
if (ans[id[mid]] == -1 && pw(x[id[mid]] - u) + pw(v) <= pw(r[id[mid]])) {
ans[id[mid]] = ind;
++k;
}
if (u < x[id[mid]]) search(lw, mid - 1, u, v, ind);
if (u > x[id[mid]]) search(mid + 1, hi, u, v, ind);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x[i] >> r[i];
id[i] = i;
}
sort(id, id + n, cmp);
fill(ans, ans + n, -1);
long long m;
cin >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
search(0, n - 1, u, v, i + 1);
}
cout << k << endl;
for (long long i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
int k = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9') k = k * 10 + c - '0', c = getchar();
return k;
}
const int N = 100001;
struct E {
int v, w, nxt;
} e[N << 1];
int n, q, head[N], cnt, u, v, w, d[N], f[N], son[N], top[N], size[N], id[N];
long long sum, dis[N];
char c;
struct Cmp {
bool operator()(int a, int b) { return id[a] < id[b]; }
};
set<int, Cmp> S;
set<int, Cmp>::iterator it, IT;
void add(int u, int v, int w) { e[++cnt] = (E){v, w, head[u]}, head[u] = cnt; }
void dfs1(int u, int fa) {
d[u] = d[f[u] = fa] + 1, size[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dis[v] = dis[u] + e[i].w, dfs1(v, u), size[u] += size[v];
if (size[son[u]] < size[v]) son[u] = v;
}
}
void dfs2(int u, int t) {
top[u] = t, id[u] = ++cnt;
if (!son[u]) return;
dfs2(son[u], t);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != f[u] && v != son[u]) dfs2(v, v);
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (d[top[x]] > d[top[y]])
x = f[top[x]];
else
y = f[top[y]];
}
return d[x] < d[y] ? x : y;
}
long long D(int x, int y) { return dis[x] + dis[y] - 2 * dis[LCA(x, y)]; }
void Insert(int x) {
if (S.empty()) {
S.insert(x);
return;
}
S.insert(x), it = S.find(x);
if (it == S.begin())
++it, sum += D(x, *--S.end()) + D(x, *it) - D(*it, *--S.end());
else if (it == --S.end())
--it, sum += D(x, *S.begin()) + D(x, *it) - D(*it, *S.begin());
else
IT = it, ++IT, --it, sum += D(*it, x) + D(*IT, x) - D(*it, *IT);
}
void Delete(int x) {
if (S.size() == 1) {
S.clear();
return;
}
it = S.find(x);
if (it == S.begin())
++it, sum -= D(x, *--S.end()) + D(x, *it) - D(*it, *--S.end());
else if (it == --S.end())
--it, sum -= D(x, *S.begin()) + D(x, *it) - D(*it, *S.begin());
else
IT = it, ++IT, --it, sum -= D(x, *it) + D(x, *IT) - D(*it, *IT);
S.erase(x);
}
int main() {
n = rd();
for (int i = 1; i < n; ++i)
u = rd(), v = rd(), w = rd(), add(u, v, w), add(v, u, w);
cnt = 0, dfs1(1, 0), dfs2(1, 1), q = rd();
while (q--) {
scanf("%c", &c);
if (c == '+') Insert(rd());
if (c == '-') Delete(rd());
if (c == '?') printf("%lld\n", sum >> 1), getchar();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int c, a, i, k, j, n, d, m, z, jx, z0, b, a0, b0;
int cas, i1, i2, i3;
vector<pair<int, int> > vp;
vector<vector<pair<int, int> > > vz;
pair<int, int> p1, p2;
vector<string> ve;
string wya, wyb, we;
vector<string> vsl, vt;
vector<int> vk, vk1, vk2, vk0;
int ta[100010], tb[100010], tc[100010];
int k1, k2, k3;
int main() {
cin >> we;
cin >> m;
memset(ta, 0, sizeof(ta));
memset(tb, 0, sizeof(tb));
memset(tc, 0, sizeof(tc));
k = we.size();
for (i = 1; i <= k; i++) {
if (we[i - 1] == 'x') {
ta[i] = ta[i - 1] + 1;
tb[i] = tb[i - 1];
tc[i] = tc[i - 1];
} else if (we[i - 1] == 'y') {
ta[i] = ta[i - 1];
tb[i] = tb[i - 1] + 1;
tc[i] = tc[i - 1];
} else if (we[i - 1] == 'z') {
ta[i] = ta[i - 1];
tb[i] = tb[i - 1];
tc[i] = tc[i - 1] + 1;
}
}
for (i = 0; i < m; i++) {
cin >> a >> b;
k1 = ta[b] - ta[a - 1];
k2 = tb[b] - tb[a - 1];
k3 = tc[b] - tc[a - 1];
if (b - a < 2)
cout << "YES" << endl;
else if (k1 == k2 || k2 == k3 || k1 == k3) {
if (abs(k1 - k2) == 1 || abs(k2 - k3) == 1 || abs(k1 - k3) == 1)
cout << "YES" << endl;
else if (k1 == k2 && k2 == k3 && k1 == k3)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct p {
double x, y;
};
int main() {
int n;
p P;
double pi = 3.14159265358979323846;
cin >> n >> P.x >> P.y;
vector<p> ps(n);
for (int i = 0; i < n; i++) cin >> ps[i].x >> ps[i].y;
double max_d = -1, min_d;
double dist;
p p1, p2, p3;
double d1, d2, d3, c12, c13, c23;
for (int i = 0; i < n; i++) {
p1 = ps[i % n];
p2 = ps[(i + 1) % n];
p3 = ps[(i + 2) % n];
d1 = sqrt((p1.x - P.x) * (p1.x - P.x) + (p1.y - P.y) * (p1.y - P.y));
d2 = sqrt((p2.x - P.x) * (p2.x - P.x) + (p2.y - P.y) * (p2.y - P.y));
d3 = sqrt((p3.x - P.x) * (p3.x - P.x) + (p3.y - P.y) * (p3.y - P.y));
min_d = min(d1, min(d2, d3));
c12 = ((p2.x - p1.x) * (P.x - p1.x) + (p2.y - p1.y) * (P.y - p1.y)) /
((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
c13 = ((p3.x - p1.x) * (P.x - p1.x) + (p3.y - p1.y) * (P.y - p1.y)) /
((p3.x - p1.x) * (p3.x - p1.x) + (p3.y - p1.y) * (p3.y - p1.y));
c23 = ((p3.x - p2.x) * (P.x - p2.x) + (p3.y - p2.y) * (P.y - p2.y)) /
((p3.x - p2.x) * (p3.x - p2.x) + (p3.y - p2.y) * (p3.y - p2.y));
if (c12 < 1.0 && c12 > 0.0)
min_d = min(min_d, sqrt(d1 * d1 - c12 * c12 *
((p2.x - p1.x) * (p2.x - p1.x) +
(p2.y - p1.y) * (p2.y - p1.y))));
if (c13 < 1.0 && c13 > 0.0)
min_d = min(min_d, sqrt(d1 * d1 - c13 * c13 *
((p3.x - p1.x) * (p3.x - p1.x) +
(p3.y - p1.y) * (p3.y - p1.y))));
if (c23 < 1.0 && c23 > 0.0)
min_d = min(min_d, sqrt(d2 * d2 - c23 * c23 *
((p3.x - p2.x) * (p3.x - p2.x) +
(p3.y - p2.y) * (p3.y - p2.y))));
max_d = max(
max_d, sqrt((p1.x - P.x) * (p1.x - P.x) + (p1.y - P.y) * (p1.y - P.y)));
}
double area = pi * max_d * max_d - pi * min_d * min_d;
cout.precision(8);
cout << fixed << area;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const int maxn = 2e5 + 10;
const int maxx = 2e6 + 10;
const double EPS = 1e-8;
const double eps = 1e-8;
const int mod = 1e9 + 7;
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline bool scan_d(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) {
return 0;
}
while (c != '-' && (c < '0' || c > '9')) {
c = getchar();
}
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') {
ret = ret * 10 + (c - '0');
}
ret *= sgn;
return 1;
}
inline bool scan_lf(double &num) {
char in;
double Dec = 0.1;
bool IsN = false, IsD = false;
in = getchar();
if (in == EOF) return false;
while (in != '-' && in != '.' && (in < '0' || in > '9')) in = getchar();
if (in == '-') {
IsN = true;
num = 0;
} else if (in == '.') {
IsD = true;
num = 0;
} else
num = in - '0';
if (!IsD) {
while (in = getchar(), in >= '0' && in <= '9') {
num *= 10;
num += in - '0';
}
}
if (in != '.') {
if (IsN) num = -num;
return true;
} else {
while (in = getchar(), in >= '0' && in <= '9') {
num += Dec * (in - '0');
Dec *= 0.1;
}
}
if (IsN) num = -num;
return true;
}
void Out(long long a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) Out(a / 10);
putchar(a % 10 + '0');
}
void print(long long a) { Out(a), puts(""); }
int n;
int a[maxn];
int pos[maxn];
int l[maxn], r[maxn];
map<int, int> mmp;
void solve() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
l[i] = mmp[a[i]];
for (int j = 0; j <= 31; j++) {
if ((a[i] & (1 << j)) == 0) {
l[i] = max(l[i], pos[j]);
}
}
for (int j = 0; j <= 31; j++) {
if ((a[i] & (1 << j)) > 0) {
pos[j] = i;
}
}
mmp[a[i]] = i;
}
for (int i = 0; i <= 31; i++) pos[i] = n + 1;
for (int i = n; i >= 1; i--) {
r[i] = n + 1;
for (int j = 0; j <= 31; j++) {
if ((a[i] & (1 << j)) == 0) {
r[i] = min(r[i], pos[j]);
}
}
for (int j = 0; j <= 31; j++) {
if ((a[i] & (1 << j)) > 0) {
pos[j] = i;
}
}
}
long long ans = 1ll * n * (n + 1) / 2;
for (int i = 1; i <= n; i++) ans -= (1ll * i - l[i]) * (1ll * r[i] - i);
print(ans);
}
}
int main() {
int t = 1;
for (int cas = 1; cas <= t; cas++) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int D = 10010;
const int N = 3010;
const int M = 1e9 + 7;
int n, td, f[D][N];
vector<int> g[N];
int fac[D + 10], invfac[D + 10], pre[D + 10], suf[D + 10];
int fp(int x, int y) {
int ret = 1;
for (; y; y >>= 1, x = (long long)x * x % M)
if (y & 1) ret = (long long)ret * x % M;
return ret;
}
int L(int x) { return x >= M ? x - M : x; }
void dfs(int x) {
for (auto i : g[x]) dfs(i);
for (int j = 1; j <= td && j < D; ++j) {
int tmp = 1;
for (auto i : g[x]) tmp = (long long)tmp * f[j][i] % M;
f[j][x] = L(f[j - 1][x] + tmp);
}
}
int main() {
scanf("%d%d", &n, &td);
for (int i = 2, f; i <= n; ++i) {
scanf("%d", &f);
g[f].push_back(i);
}
dfs(1);
if (td < D) {
cout << f[td][1];
return 0;
}
fac[0] = 1;
for (int i = 1; i < D; ++i) fac[i] = (long long)fac[i - 1] * i % M;
invfac[D - 1] = fp(fac[D - 1], M - 2);
for (int i = D - 2; i >= 0; --i)
invfac[i] = (long long)invfac[i + 1] * (i + 1) % M;
pre[0] = 1;
for (int i = 1; i < D; ++i) pre[i] = (long long)pre[i - 1] * (td - i) % M;
suf[D] = 1;
for (int i = D - 1; i >= 0; --i)
suf[i] = (long long)suf[i + 1] * (td - i) % M;
int ans = 0;
for (int i = 1; i < D; ++i) {
int fz = (long long)pre[i - 1] * suf[i + 1] % M;
int fm = (long long)invfac[i - 1] * invfac[D - 1 - i] % M;
if ((D - 1 - i) & 1) fm = L(M - fm);
ans = (ans + (long long)fz * fm % M * f[i][1]) % M;
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int IINF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const int MOD = 1000000007;
const double EPS = 1e-9;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long sqr(long long x) { return x * x; }
long long sqr(int x) { return (long long)x * x; }
double sqr(double x) { return x * x; }
long double sqr(long double x) { return x * x; }
mt19937 mmtw(960172);
long long rnd(long long x, long long y) {
static uniform_int_distribution<long long> d;
return d(mmtw) % (y - x + 1) + x;
}
const int N = 100111;
int n;
int s2i(string const& s) {
if (s[0] == '0') return -1;
int x = 0;
for (char c : s) {
if (c < '0' || c > '9') return -1;
x *= 10;
x += c - '0';
}
if (x <= 0 || x > n) return -1;
return x;
}
struct File {
string name;
bool st;
};
vector<File> files;
int e;
set<int> free1, free2;
set<int> f12, f21, f01, f02;
vector<pair<string, string> > ans;
void fmove(int v, string const& nf) {
File& file = files[v];
ans.emplace_back(file.name, nf);
int x = s2i(file.name);
if (x == -1) {
(file.st ? f01 : f02).erase(v);
} else {
if (x <= e) {
free1.insert(x);
if (!file.st) f12.erase(v);
} else {
free2.insert(x);
if (file.st) f21.erase(v);
}
}
file.name = nf;
x = s2i(nf);
if (x == -1) {
(file.st ? f01 : f02).insert(v);
} else {
if (x <= e) {
free1.erase(x);
if (!file.st) f12.insert(v);
} else {
free2.erase(x);
if (file.st) f21.insert(v);
}
}
}
int main() {
ios::sync_with_stdio(false);
scanf("%d", &n);
files.resize(n);
for (int i = 0; i < n; ++i) {
char ss[10];
int x;
scanf("%s%d", ss, &x);
files[i].name = ss;
files[i].st = x;
e += x;
}
for (int i = 1; i <= e; ++i) free1.insert(i);
for (int i = e + 1; i <= n; ++i) free2.insert(i);
for (int i = 0; i < n; ++i) {
int x = s2i(files[i].name);
if (x == -1) {
(files[i].st ? f01 : f02).insert(i);
} else {
(x <= e ? free1 : free2).erase(x);
if (x <= e && !files[i].st)
f12.insert(i);
else if (x > e && files[i].st)
f21.insert(i);
}
}
if (((int)((f01).size())) + ((int)((f02).size())) == 0 &&
((int)((f12).size())) != 0) {
int v = *f12.begin();
fmove(v, "qwe");
}
while (true) {
if (((int)((f12).size())) > 0 && ((int)((free2).size())) > 0) {
int v = *f12.begin();
int p = *free2.begin();
fmove(v, to_string(p));
} else if (((int)((f21).size())) > 0 && ((int)((free1).size())) > 0) {
int v = *f21.begin();
int p = *free1.begin();
fmove(v, to_string(p));
} else
break;
}
while (((int)((f01).size())) > 0) {
int v = *f01.begin();
int p = *free1.begin();
fmove(v, to_string(p));
}
while (((int)((f02).size())) > 0) {
int v = *f02.begin();
int p = *free2.begin();
fmove(v, to_string(p));
}
cout << ((int)((ans).size())) << "\n";
for (auto const& x : ans)
cout << "move " << x.first << " " << x.second << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int maxk = 10;
const int mod = 19260817;
int n, m, k, u, v, w, ans;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq[maxn];
long long hsh[maxn], all_hash, single_hash[maxk][maxk];
void dfs(int pos, long long now) {
if (pos > k) {
if (now == all_hash) ++ans;
return;
}
for (int i = 1; i <= pos; ++i) {
dfs(pos + 1, now + single_hash[pos][i]);
}
}
int main() {
cin >> n >> m >> k;
while (m--) {
cin >> u >> v >> w;
pq[u].push(pair<int, int>(w, v));
}
srand(time(NULL));
for (int i = 1; i <= n; ++i) {
hsh[i] = rand() % mod;
all_hash += hsh[i];
}
for (int i = 1; i <= n; ++i) {
int deg = pq[i].size();
for (int j = 1; j <= deg; ++j) {
single_hash[deg][j] += hsh[pq[i].top().second];
pq[i].pop();
}
}
dfs(1, 0);
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int calculateCombinations(int n) {
int up[n - 2];
int down[n - 2];
for (int i = n; i >= 2 + 1; i--) up[n - i] = i;
for (int i = n - 2; i >= 1; i--) down[n - 2 - i] = i;
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < n - 2; j++) {
int divide = gcd(up[i], down[j]);
up[i] /= divide;
down[j] /= divide;
}
}
int sumUp = 1, sumDown = 1;
for (int i = 0; i < n - 2; i++) {
sumUp *= up[i];
sumDown *= down[i];
}
return sumUp / sumDown;
}
long long int sum(long long int m, long long int k) {
return (k + m) * (k - m + 1) / 2;
}
int main() {
int n, m, k, t;
cin >> n >> m >> k >> t;
int wastes[k][2];
for (int i = 0; i < k; i++) cin >> wastes[i][0] >> wastes[i][1];
int crops[t][2];
for (int i = 0; i < t; i++) {
int waste = false;
cin >> crops[i][0] >> crops[i][1];
int d = m * (crops[i][0] - 1) + (crops[i][1] - 1);
int num = d;
for (int j = 0; j < k; j++) {
int d2 = m * (wastes[j][0] - 1) + (wastes[j][1] - 1);
if (wastes[j][0] - 1 == crops[i][0] - 1 &&
wastes[j][1] - 1 == crops[i][1] - 1) {
waste = true;
break;
}
if (d2 < d) {
num--;
}
}
if (waste)
cout << "Waste" << endl;
else if (num % 3 == 0)
cout << "Carrots" << endl;
else if (num % 3 == 1)
cout << "Kiwis" << endl;
else if (num % 3 == 2)
cout << "Grapes" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, a[2], b[2], c[2], x, y, z;
cin >> n;
cin >> a[0] >> a[1];
x = a[0];
cin >> b[0] >> b[1];
y = b[0];
cin >> c[0] >> c[1];
z = c[0];
n -= (x + y + z);
while (n && a[1] != a[0]) {
a[0]++;
n--;
x++;
}
while (n && b[1] != b[0]) {
b[0]++;
n--;
y++;
}
while (n && c[1] != c[0]) {
c[0]++;
n--;
z++;
}
cout << x << " " << y << " " << z;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int a[maxn];
int num[maxn];
vector<int> pos[maxn];
struct Query {
int l, r, id;
Query(int a = 0, int b = 0, int c = 0) { l = a, r = b, id = c; }
bool operator<(const Query &a) const { return r < a.r; }
};
struct node {
int l, r, sum;
int mid() { return (l + r) >> 1; }
};
struct segtree {
node ns[maxn << 2];
void pushup(int rt) {
if (ns[rt].sum != 0) {
ns[rt << 1].sum += ns[rt].sum;
ns[rt << 1 | 1].sum += ns[rt].sum;
ns[rt].sum = 0;
}
}
void build(int rt, int l, int r) {
ns[rt].l = l;
ns[rt].r = r;
ns[rt].sum = 0;
if (l == r) return;
build(rt << 1, l, ns[rt].mid());
build(rt << 1 | 1, ns[rt].mid() + 1, r);
}
void update(int rt, int L, int R, int val) {
int l = ns[rt].l, r = ns[rt].r;
if (L <= l && r <= R) {
ns[rt].sum += val;
} else {
pushup(rt);
int mid = ns[rt].mid();
if (L <= mid) update(rt << 1, L, R, val);
if (mid < R) update(rt << 1 | 1, L, R, val);
}
}
int query(int rt, int pos) {
int l = ns[rt].l, r = ns[rt].r, mid = ns[rt].mid();
if (l == r)
return ns[rt].sum;
else {
pushup(rt);
if (pos <= mid)
return query(rt << 1, pos);
else
return query(rt << 1 | 1, pos);
}
}
} seg;
pair<int, int> len[maxn];
vector<Query> qu;
int ans[maxn];
int main() {
int n, m;
while (cin >> n >> m) {
memset(num, 0, sizeof num);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
int t1, t2;
cin >> t1 >> t2;
qu.push_back(Query(t1, t2, i));
}
sort(qu.begin(), qu.end());
seg.build(1, 1, n);
int now = 0;
for (int i = 1; i <= n; i++)
if (a[i] <= n) {
int val = a[i];
num[val]++;
pos[val].push_back(i);
if (num[val] == val) {
len[val] = make_pair(1, pos[val][0]);
seg.update(1, 1, pos[val][0], 1);
} else if (num[val] > val) {
seg.update(1, len[val].first, len[val].second, -1);
len[val] = make_pair(len[val].second + 1, pos[val][num[val] - val]);
seg.update(1, len[val].first, len[val].second, 1);
}
while (qu[now].r == i && now < m) {
ans[qu[now].id] = seg.query(1, qu[now].l);
now++;
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0xFFFFFFFFFFFFFFFL;
const long long mod = 1000000007L;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (k % 3 == 0) {
long long mx = n / (k + 1);
long long mn;
if (n + 3 >= k) {
mn = ((n + 3 - k) % (k + 1) == 0) ? ((n + 3 - k) / (k + 1))
: ((n + 3 - k) / (k + 1) + 1);
} else {
mn = 0;
}
if (mn < 0) {
mn = 0;
}
if (mn > mx) {
cout << "Alice" << endl;
} else {
long long ans = false;
for (long long i = mn; i <= mx; i++) {
if ((n - (k + 1) * i) % 3 == 0) {
ans = true;
break;
}
}
if (ans) {
cout << "Bob" << endl;
} else {
cout << "Alice" << endl;
}
}
} else {
if (n % 3 == 0) {
cout << "Bob" << endl;
} else {
cout << "Alice" << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int bitx[200020], bitp[200020], bitq[200020];
int p[200020], q[200020];
int ordo[200020], ordo_p[200020], ordo_q[200020];
int ans[200020];
int n;
void updatep(int pos, int val) {
while (pos <= n) {
bitp[pos] += val;
pos += (pos & -pos);
}
}
void updateq(int pos, int val) {
while (pos <= n) {
bitq[pos] += val;
pos += (pos & -pos);
}
}
void updatex(int pos, int val) {
while (pos <= n) {
bitx[pos] += val;
pos += (pos & -pos);
}
}
int queryp(int pos) {
int ret = 0;
while (pos > 0) {
ret += bitp[pos];
pos -= (pos & -pos);
}
return ret;
}
int queryq(int pos) {
int ret = 0;
while (pos > 0) {
ret += bitq[pos];
pos -= (pos & -pos);
}
return ret;
}
int queryx(int pos) {
int ret = 0;
while (pos > 0) {
ret += bitx[pos];
pos -= (pos & -pos);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
updatep(i, 1);
updateq(i, 1);
}
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &q[i]);
}
for (int i = 0; i < n; i++) {
ordo_p[i] = queryp(p[i]);
ordo_q[i] = queryq(q[i]);
updatep(p[i] + 1, -1);
updateq(q[i] + 1, -1);
ordo[i] = ordo_p[i] + ordo_q[i];
}
for (int i = n - 1; i >= 0; i--) {
if (ordo[i] >= (n - i)) {
ordo[i] -= (n - i);
if (i > 0) {
ordo[i - 1]++;
}
}
}
for (int i = 1; i <= n; i++) {
updatex(i, 1);
}
for (int i = 0; i < n; i++) {
int l = 1;
int r = n;
while (l < r) {
int mid = (l + r) >> 1;
int check = queryx(mid - 1);
if (check < ordo[i]) {
l = mid + 1;
} else if (check > ordo[i]) {
r = mid - 1;
} else {
if (queryx(mid) == ordo[i]) {
l = mid + 1;
} else {
l = mid;
r = mid;
}
}
}
ans[i] = l - 1;
updatex(l, -1);
}
for (int i = 0; i < n; i++) {
printf("%d", ans[i]);
if (i < n - 1) printf(" ");
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 41;
int q;
int par[500005];
double a[500005][MX + 1] = {};
int n = 1;
void solve(int v) {
int u = par[v];
double old[MX + 1], nold[MX + 1];
for (int i = 0; i < (int)(MX + 1); ++i) old[i] = a[u][i];
a[u][1] *= 0.5;
v = u;
for (int i = 2; i < MX + 1; ++i) {
if (v == 0) break;
u = par[v];
for (int j = 0; j < (int)(MX + 1); ++j) nold[j] = a[u][j];
for (int j = MX; j > 0; --j) {
a[u][j] *= (0.5 + 0.5 * a[v][j - 1]) / (0.5 + 0.5 * old[j - 1]);
}
memcpy(old, nold, sizeof old);
v = u;
}
}
int main() {
scanf("%d", &q);
a[0][0] = 0;
for (int i = 1; i <= MX; ++i) a[0][i] = 1;
for (int times = 0; times < (int)(q); ++times) {
int qt, v;
scanf("%d%d", &qt, &v), --v;
if (qt == 1) {
par[n] = v;
solve(n);
a[n][0] = 0;
for (int i = 1; i <= MX; ++i) a[n][i] = 1;
++n;
} else {
double ans = 0;
double pre = 0;
for (int i = MX; i >= 1; --i) {
ans += (1 - a[v][i] - pre) * i;
pre = 1 - a[v][i];
}
printf("%.12f\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f[3010][3010];
struct ma {
int x, y;
} a[3010];
bool operator<(ma p, ma q) { return p.x > q.x; }
void get(int k) {
sort(a + k, a + n + 1);
int w = a[k].x;
for (int i = n; i > k; i--) {
if (w > 1)
w -= 2, f[a[k].y][a[i].y] = 1;
else if (!w)
a[i].x -= 2, f[a[i].y][a[k].y] = 1;
else
w--, a[i].x--, f[a[k].y][a[i].y] = f[a[i].y][a[k].y] = 2;
}
a[k].x = 0;
}
int main() {
cin >> n >> m;
int x = 0, sum = 0;
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i].x);
a[i].y = i;
x += 2 * (n - i);
sum += a[i].x;
if (sum > x) return puts("no"), 0;
}
for (int i = m + 1; i <= n; i++) {
a[i].y = i;
x += 2 * (n - i);
a[i].x = min(a[i - 1].x, x - sum);
sum += a[i].x;
}
if (sum != x) return puts("no"), 0;
for (int i = 1; i < n; i++) get(i);
puts("yes");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
putchar('X');
else if (!f[i][j])
putchar('L');
else if (f[i][j] == 1)
putchar('W');
else
putchar('D');
}
puts("");
}
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.