solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct bam {
long long id, d;
bam(int __id, int _d) { id = __id, d = _d; }
bool operator<(const bam &b) const { return d > b.d; }
};
priority_queue<bam> t;
long long num[100010], h[100010], a[100010], n, m, p, k;
bool pan(long long x) {
while (t.size()) t.pop();
for (int i = 1; i <= n; i++) num[i] = 0;
for (int i = 1; i <= n; i++)
if (x - a[i] * m < h[i]) t.push(bam(i, x / a[i]));
for (int i = 1; i <= m; i++)
for (int j = 1; j <= k; j++) {
if (!t.size()) break;
bam tmp = t.top();
t.pop();
if (tmp.d < i) return 0;
num[tmp.id]++;
if (x + num[tmp.id] * p - a[tmp.id] * m < h[tmp.id])
t.push(bam(tmp.id, (x + num[tmp.id] * p) / a[tmp.id]));
}
return !t.size();
}
int main() {
cin >> n >> m >> k >> p;
long long l = 0, r = 0, ans;
for (int i = 1; i <= n; i++)
cin >> h[i] >> a[i], l = max(l, a[i]), r = max(r, h[i] + m * a[i]);
while (l <= r) {
long long mid = (l + r) / 2;
if (pan(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200500;
int n, m;
struct field {
set<pair<int, int>> by_ymx[N];
pair<set<pair<int, int>>*, set<pair<int, int>>::iterator> pos[N];
const int sy, sx;
field(int _sy, int _sx) : sy(_sy), sx(_sx) {}
set<pair<int, int>>& get(int diff) {
assert(diff < n && diff > -m);
return by_ymx[diff + m];
}
inline void add(int y, int x, int i) {
int ymx = y - x + m;
pos[i] = make_pair(&by_ymx[ymx],
by_ymx[ymx].insert(make_pair(min(x, y), i)).first);
}
inline void init() {}
void erase(int i) { pos[i].first->erase(pos[i].second); }
} F[2][2] = {{field(0, 0), field(0, 1)}, {field(1, 0), field(1, 1)}};
long long ans[N];
int main() {
int k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d %d", &y, &x);
F[0][0].add(y, x, i);
F[1][0].add(n - y, x, i);
F[0][1].add(y, m - x, i);
F[1][1].add(n - y, m - x, i);
ans[i] = -1;
}
for (int sy = 0; sy < 2; sy++) {
for (int sx = 0; sx < 2; sx++) {
F[sy][sx].init();
}
}
int sy = 0, sx = 0;
long long py = 0, px = 0;
while (true) {
long long ymx = px - py;
assert(-m <= ymx && ymx <= n);
vector<pair<int, int>> todel;
for (const auto& pr : F[sy][sx].get(ymx)) {
int id = pr.second;
int dt = pr.first;
ans[id] = max(py, px) + dt;
todel.push_back(pr);
}
for (const auto& pr : todel) {
int id = pr.second;
for (int sy = 0; sy < 2; sy++) {
for (int sx = 0; sx < 2; sx++) {
F[sy][sx].erase(id);
}
}
}
if (py + n < px + m) {
py += n;
sy ^= 1;
} else if (py + n > px + m) {
px += m;
sx ^= 1;
} else {
break;
}
}
for (int i = 0; i < k; i++) {
printf("%lld\n", ans[i]);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int dcmp(double a, double b) {
return ((fabs(a - b) < (1e-9)) ? 0 : (a < b) ? -1 : +1);
}
double crossP(const complex<double> &v1, const complex<double> &v2) {
return (conj(v1) * v2).imag();
}
double dotP(const complex<double> &v1, const complex<double> &v2) {
return (conj(v1) * v2).real();
}
double lengthSqr(const complex<double> &p) { return dotP(p, p); }
double length(const complex<double> &p) { return hypot(p.real(), p.imag()); }
double fixAngle(double a) { return ((a > 1) ? 1 : (a < -1) ? -1 : a); }
bool same(const complex<double> &p1, const complex<double> &p2) {
return ((dcmp(p1.real(), p2.real()) == 0 && dcmp(p1.imag(), p2.imag()) == 0)
? 1
: 0);
}
double getAngle_A_abc(double a, double b, double c) {
return acos(fixAngle((b * b + c * c - a * a) / (2 * b * c)));
}
const int N = 3000 + 9;
map<int, vector<int>> v;
priority_queue<int, deque<int>, greater<int>> q;
long long calc(int mx, int n, int d) {
q = priority_queue<int, deque<int>, greater<int>>();
long long cost = 0;
for (const auto &a : v) {
const vector<int> &x = a.second;
int s = ((int)((x).size()));
int i = 0;
while (s > mx) d++, cost += x[i], s--, i++;
while (i < ((int)((x).size())) && d <= mx) q.emplace(x[i++]);
}
while (d <= mx) d++, cost += q.top(), q.pop();
return cost;
}
int main() {
int t, n;
scanf("%d %d", &t, &n);
long long d = 0;
for (__typeof(t) i = 0; i < t; ++i) {
int p, c;
scanf("%d %d", &p, &c);
--p;
if (p)
v[p].emplace_back(c);
else
d++;
}
int max_v = 0;
for (auto &a : v)
max_v = max(max_v, ((int)((a.second).size()))),
sort(a.second.begin(), a.second.end());
long long ans = (~(1LL << 63));
for (__typeof(max_v + 1) i = 0; i < max_v + 1; ++i)
ans = min(ans, calc(i, n, d));
printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
void comp(vector<long long> &x) {
vector<long long> ord = x;
sort(ord.begin(), ord.end());
auto last = unique(ord.begin(), ord.end());
ord.erase(last, ord.end());
for (auto &v : x) v = lower_bound(ord.begin(), ord.end(), v) - ord.begin();
}
int main() {
int n, a, b, c, d;
scanf("%d\n", &n);
scanf("%d/%d %d/%d\n", &a, &b, &c, &d);
vector<long long> x(n), y(n);
for (int i = 0; i < n; i++) {
int xx, yy;
scanf("%d %d\n", &xx, &yy);
x[i] = (long long)-a * xx + (long long)b * yy;
y[i] = (long long)c * xx - (long long)d * yy;
}
for (int i = 0; i < (int)x.size(); i++) {
if (x[i] <= 0 || y[i] <= 0) {
swap(x[i], x[x.size() - 1]);
x.pop_back();
swap(y[i], y[y.size() - 1]);
y.pop_back();
--i;
}
}
x.push_back(0);
y.push_back(0);
comp(x);
comp(y);
n = x.size();
vector<int> prior(n);
iota(prior.begin(), prior.end(), 0);
sort(prior.begin(), prior.end(), [&](int i, int j) {
if (x[i] != x[j]) return x[i] < x[j];
return y[i] > y[j];
});
vector<int> bit(2 * (n + 2), -INF);
vector<int> dp(n);
int ans = 0;
for (auto ind : prior) {
int xi = x[ind], yi = y[ind];
int &res = dp[ind];
if (xi == 0 && yi == 0)
res = 0;
else {
res = 0;
for (int i = yi; i > 0; i -= i & (-i)) res = max(res, bit[i]);
res++;
}
for (int i = yi + 1; i < (int)bit.size(); i += i & (-i))
bit[i] = max(bit[i], res);
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1000010];
scanf("%s", ch);
return ch;
}
const int MAX_LG = 21;
const int maxn = 1e5 + 10;
const int base = 29;
const int mod = 1e9 + 7;
const int INF = 1e9 + 100;
int n, m;
string s;
int segtree[4 * maxn][26];
int cnt[26];
int lazy[4 * maxn];
inline void build(int p, int l, int r) {
if (l == r) {
segtree[p][s[l] - 'a'] = 1;
return;
}
int mid = (l + r) >> 1;
build(2 * p + 1, l, mid);
build(2 * p + 2, mid + 1, r);
for (int i = 0; i < 26; i++)
segtree[p][i] = segtree[2 * p + 1][i] + segtree[2 * p + 2][i];
}
inline void push(int p, int l, int r) {
if (lazy[p] == -1) return;
lazy[2 * p + 1] = lazy[2 * p + 2] = lazy[p];
int mid = (l + r) >> 1;
for (int i = 0; i < 26; i++) {
segtree[2 * p + 1][i] = (i == lazy[p] ? mid - l + 1 : 0);
segtree[2 * p + 2][i] = (i == lazy[p] ? r - mid : 0);
}
lazy[p] = -1;
}
inline void doJob(int p, int l, int r, int ql, int qr) {
if (l > qr || r < ql) return;
if (l >= ql && r <= qr) {
for (int i = 0; i < 26; i++) cnt[i] += segtree[p][i];
return;
}
push(p, l, r);
int mid = (l + r) >> 1;
doJob(2 * p + 1, l, mid, ql, qr);
doJob(2 * p + 2, mid + 1, r, ql, qr);
}
inline void update(int p, int l, int r, int ql, int qr, int what) {
if (l > qr || r < ql) return;
if (l >= ql && r <= qr) {
lazy[p] = what;
for (int i = 0; i < 26; i++) segtree[p][i] = (i == what ? r - l + 1 : 0);
return;
}
push(p, l, r);
int mid = (l + r) >> 1;
update(2 * p + 1, l, mid, ql, qr, what);
update(2 * p + 2, mid + 1, r, ql, qr, what);
for (int i = 0; i < 26; i++)
segtree[p][i] = segtree[2 * p + 1][i] + segtree[2 * p + 2][i];
}
inline void dfs(int p, int l, int r) {
if (l == r) {
for (int i = 0; i < 26; i++)
if (segtree[p][i]) s[l] = char(i + 'a');
return;
}
int mid = (l + r) >> 1;
push(p, l, r);
dfs(2 * p + 1, l, mid);
dfs(2 * p + 2, mid + 1, r);
}
int32_t main() {
n = in(), m = in();
s = get();
build(0, 0, n - 1);
for (int i = 0; i < 4 * maxn; i++) lazy[i] = -1;
while (m--) {
int l = in() - 1, r = in() - 1, k = in();
for (int i = 0; i < 26; i++) cnt[i] = 0;
doJob(0, 0, n - 1, l, r);
int cur = l;
int now = (k == 1 ? 0 : 25);
while (now >= 0 && now <= 25) {
if (cnt[now]) update(0, 0, n - 1, cur, cur + cnt[now] - 1, now);
cur += cnt[now];
now += (k == 1 ? 1 : -1);
}
}
dfs(0, 0, n - 1);
cout << s << "\n";
}
| 15 |
#include <bits/stdc++.h>
const int MAXN = 1e6;
const int inf = 1e9 + 69;
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
int nQuery, l, r, x;
cin >> n >> m;
vector<vector<int> > v, res;
vector<int> tmp = vector<int>(m + 1);
vector<int> tmp2 = tmp;
v.push_back(tmp);
res.push_back(tmp2);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cin >> tmp[j];
v.emplace_back(tmp);
res.emplace_back(tmp2);
}
v.emplace_back(tmp2);
res.emplace_back(tmp2);
for (int i = 1; i <= m; i++) {
int deep = 0;
for (int j = 1; j <= n; j++) {
if (j > deep) {
deep = j;
while (v[deep][i] <= v[deep + 1][i]) deep++;
}
res[j][i] = deep;
}
}
vector<int> arr_max;
arr_max.emplace_back(0);
for (int i = 1; i <= n; i++) {
int maxx = res[i][1];
for (int j = 2; j <= m; j++)
if (maxx < res[i][j]) maxx = res[i][j];
arr_max.emplace_back(maxx);
}
cin >> nQuery;
for (int query = 1; query <= nQuery; query++) {
cin >> l >> r;
cout << (arr_max[l] >= r ? "Yes" : "No") << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, check = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
if (s[i] == '0') check = 1;
if (!check)
cout << 1 << " " << n - 1 << " " << 2 << " " << n << endl;
else {
for (int i = 0; i < n; i++) {
if (s[i] == '1') continue;
if (i < n / 2)
cout << i + 1 << " " << n << " " << i + 2 << " " << n << endl;
else
cout << 1 << " " << i + 1 << " " << 1 << " " << i << endl;
break;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.14159265358979323846264338327950288419716939937510582097494459230;
const long long MOD = 1e6 + 3;
const long long INF = 1e14;
long long mpow(long long a, long long b) {
a = a % MOD;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b = b >> 1;
}
return res % MOD;
}
long long sum(long long x) {
if (x == -1) return 0;
return (x * (x + 1)) / 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long l, r, a;
cin >> l >> r >> a;
long long ans = 0;
if (l < r) {
if (a > r - l) {
a -= r - l;
ans += r + r + a / 2 + a / 2;
} else {
l = l + a;
ans += 2 * min(l, r);
}
} else if (r < l) {
swap(l, r);
if (a > r - l) {
a -= r - l;
ans += r + r + a / 2 + a / 2;
} else {
l = l + a;
ans += 2 * min(l, r);
}
} else {
ans += l + l + a / 2 + a / 2;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::map;
using std::queue;
using std::set;
using std::string;
using std::vector;
const double kEps = 10e-8;
const int kMax = 1000;
const int kInf = 1 << 30;
int main() {
int n;
std::cin >> n;
vector<int> A(n);
for (int& a : A) {
std::cin >> a;
}
if (n == 1) {
std::cout << A[0] << std::endl;
return EXIT_SUCCESS;
}
map<int, int> index;
for (int i = 0; i < n; i++) {
index[A[i]] = i;
}
std::sort(A.begin(), A.end());
vector<int> B(n);
for (int i = 0; i + 1 < n; i++) {
B[index[A[i]]] = A[i + 1];
}
B[index[A[n - 1]]] = A[0];
for (int b : B) {
std::cout << b << " ";
}
std::cout << std::endl;
return EXIT_SUCCESS;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 998244353;
const ll root = 62;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = atan(1);
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 100001;
ll ans;
ll arr[mxN];
ll barr[mxN];
string s, t;
int e, o;
int n;
vector<pair<int, int> > res;
void complete() {
cout << ans << "\n";
for (auto k : res) {
cout << (k.first + 1) << " " << k.second << "\n";
}
exit(0);
}
void go(int idx, int val) {
if (arr[idx + 1] == 0 && val == -1) {
go(idx + 1, 1);
}
if (arr[idx + 1] == 9 && val == 1) {
go(idx + 1, -1);
}
res.push_back({idx, val});
if (res.size() == mxN - 1) complete();
arr[idx] += val;
arr[idx + 1] += val;
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n >> s >> t;
for (auto i = (0); i < (n); ++i) {
arr[i] = (s[i] - '0');
barr[i] = (t[i] - '0');
if (i & 1) {
o += arr[i] - barr[i];
} else {
e += arr[i] - barr[i];
}
}
if (o ^ e) {
cout << "-1\n";
exit(0);
}
for (auto i = (0); i < (n - 1); ++i) {
if (arr[i] > barr[i]) {
ans += arr[i] - barr[i];
arr[i + 1] -= arr[i] - barr[i];
} else if (arr[i] < barr[i]) {
ans += barr[i] - arr[i];
;
arr[i + 1] += barr[i] - arr[i];
}
}
for (auto i = (0); i < (n); ++i) {
arr[i] = (s[i] - '0');
barr[i] = (t[i] - '0');
}
for (auto i = (0); i < (n - 1); ++i) {
while (arr[i] ^ barr[i]) {
if (arr[i] > barr[i]) {
go(i, -1);
} else if (arr[i] < barr[i]) {
go(i, 1);
}
}
}
complete();
return 0;
}
| 19 |
#include <bits/stdc++.h>
int main() {
int Mishka, mishkaWin = 0;
int Chris, chrisWin = 0;
int numberOfPlay;
int i;
scanf("%d", &numberOfPlay);
for (i = 1; i <= numberOfPlay; i++) {
scanf("%d %d", &Mishka, &Chris);
if (Mishka > Chris) {
mishkaWin++;
}
if (Chris > Mishka) {
chrisWin++;
}
}
if (mishkaWin > chrisWin) {
printf("Mishka");
} else if (chrisWin > mishkaWin) {
printf("Chris");
} else {
printf("Friendship is magic!^^");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
const long long inf = 2e9;
char buf[1 << 12], *pp1 = buf, *pp2 = buf, nc;
int ny;
inline char gc() {
return pp1 == pp2 &&
(pp2 = (pp1 = buf) + fread(buf, 1, 1 << 12, stdin), pp1 == pp2)
? EOF
: *pp1++;
}
inline int read() {
int x = 0;
for (ny = 1; nc = gc(), (nc < 48 || nc > 57) && nc != EOF;)
if (nc == 45) ny = -1;
if (nc < 0) return nc;
for (x = nc - 48; nc = gc(), 47 < nc && nc < 58 && nc != EOF;
x = (x << 3) + (x << 1) + (nc ^ 48))
;
return x * ny;
}
int n, K, a[MAXN], b[MAXN];
long long Ans;
inline int check(long long k) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
int cnt = 0;
Ans = 0;
for (int i = (1); i <= (n); i++) {
if (a[i] + k < 0) q.push(make_pair(a[i], 1));
if (!q.empty()) {
pair<long long, int> t = q.top();
int w = t.second;
long long val = t.first;
if (b[i] + val + k < 0)
Ans += b[i] + val + k, cnt += w, q.pop(),
q.push(make_pair(-k - b[i], 0));
}
if (cnt > K) return K + 1;
}
return cnt;
}
inline void Solve() {
long long l = -inf, r = 0, ans = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid) <= K)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
check(ans), cout << Ans - 1ll * ans * K << "\n";
}
int main() {
n = read(), K = read();
for (int i = (1); i <= (n); i++) a[i] = read();
for (int i = (1); i <= (n); i++) b[i] = read();
Solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
vector<int> V[maxn];
set<int> S;
int LL[maxn], RR[maxn];
void gao(int n) {
int cnt = 0;
set<int>::iterator it = S.begin();
V[n].clear();
while (it != S.end()) {
V[n].push_back(*it);
if (++cnt > 4) break;
it++;
}
}
map<int, int> M[maxn];
int N, f;
int dfs(int dep, int n) {
if (dep == 0) return 1;
S.erase(n);
gao(n);
for (int i = 0; i < V[n].size(); i++)
if (M[n][V[n][i]])
;
else {
LL[dep] = n, RR[dep] = V[n][i];
if (dfs(dep - 1, V[n][i])) return 1;
}
if (N > 2 && dep == 1 && M[n][f] == 0) {
LL[dep] = n, RR[dep] = f;
return 1;
}
S.insert(n);
return 0;
}
int main() {
int n, m, i, j, k, u, v;
scanf("%d%d", &n, &m);
N = m;
for (i = 1; i <= m; i++) scanf("%d%d", &u, &v), M[u][v] = M[v][u] = 1;
for (i = 1; i <= n; i++) S.insert(i);
int ii = 0;
for (i = 1; i <= min(n, 4); i++) {
f = i;
if (dfs(m, i)) {
for (i = 1; i <= m; i++) printf("%d %d\n", LL[i], RR[i]);
return 0;
}
}
puts("-1");
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int n;
int a[maxn];
int t;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
t ^= a[i];
}
if (n % 2 == 0) {
if (t == 0) {
printf("YES\n");
n--;
printf("%d\n", n / 2 * 2 - 1);
for (int i = 0; i < n / 2; i++) {
printf("%d %d %d\n", (2 * i + 1), 2 * i + 2, 2 * i + 3);
}
for (int i = 0; i < n / 2 - 1; i++) {
int g = n / 2 - 2 - i;
printf("%d %d %d\n", 2 * g + 1, 2 * g + 2, 2 * g + 3);
}
} else {
printf("NO\n");
}
} else {
printf("YES\n");
printf("%d\n", n / 2 * 2 - 1);
for (int i = 0; i < n / 2; i++) {
printf("%d %d %d\n", (2 * i + 1), 2 * i + 2, 2 * i + 3);
}
for (int i = 0; i < n / 2 - 1; i++) {
int g = n / 2 - 2 - i;
printf("%d %d %d\n", 2 * g + 1, 2 * g + 2, 2 * g + 3);
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n;
int d[10][10][3];
int dp[10][10];
int a, b, c, dd, e;
int ee;
int p[30][2];
int mi = -1, mx = -1;
void dfs(int cnt, int u);
void solve();
int ru[10], chu[10];
int main() {
scanf("%d", &n);
int k = n * (n - 1) / 2;
for (int i = 0; i < k; i++) {
scanf("%d%d%d%d%d", &a, &b, &c, &dd, &e);
d[a][b][0] = c;
d[a][b][1] = dd;
d[a][b][2] = e;
}
ee = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
p[ee][0] = i;
p[ee][1] = j;
ee++;
}
}
memset(ru, 0, sizeof(ru));
memset(chu, 0, sizeof(chu));
dfs(0, 0);
cout << mi << " " << mx << endl;
return 0;
}
void solve() {
int liu = 0;
for (int i = 1; i < n; i++) liu += dp[i][n];
for (int i = 2; i < n; i++) {
if (ru[i] != chu[i]) return;
}
int cost = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (dp[i][j] == 0) continue;
cost += d[i][j][2] + dp[i][j] * dp[i][j];
}
}
if (mi == -1) {
mi = liu;
mx = cost;
} else {
if (liu < mi) {
mi = liu;
mx = cost;
} else if (liu == mi) {
mx = max(mx, cost);
}
}
}
void dfs(int cnt, int u) {
if (cnt == ee) {
solve();
return;
}
if (u > mi && mi != -1) {
return;
}
if (n == 6 && chu[3] != 0 && ru[2] != chu[2]) return;
if (n == 6 && chu[4] != 0 && ru[3] != chu[3]) return;
if (n == 6 && chu[5] != 0 && ru[4] != chu[4]) return;
int i = p[cnt][0], j = p[cnt][1];
for (int k = d[i][j][0]; k <= d[i][j][1]; k++) {
dp[i][j] = k;
chu[i] += k;
ru[j] += k;
if (cnt < n - 1)
dfs(cnt + 1, u + k);
else
dfs(cnt + 1, u);
chu[i] -= k;
ru[j] -= k;
}
}
| 14 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma warning(disable : 4996)
#pragma hdrstop
template <typename T, size_t N>
struct MakeVector {};
template <typename T>
struct MakeVector<T, 1> {
template <typename R = std::vector<T>>
static R make_vector(std::size_t size, const T& value) {
return R(size, value);
}
};
using namespace std;
void solve(std::istream& in, std::ostream& out) {
int n;
long long k;
in >> n >> k;
long long cnt = (1LL << n) - 1;
int step = n;
while (k >= 1) {
long long half_cnt = cnt / 2;
if (k == half_cnt + 1) {
out << step << endl;
return;
}
if (k > half_cnt) {
k -= half_cnt + 1;
}
cnt /= 2;
--step;
}
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
out << fixed << setprecision(16);
solve(in, out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int alph = 256;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
while (q--) {
string second, t;
cin >> second >> t;
vector<vector<int> > idxes(alph);
for (int i = 0; i < second.size(); i++) {
idxes[second[i]].push_back(i);
}
int ans = 0;
for (int i = 0; i < t.size(); i++) {
int j = i;
int mxidx = -1;
for (j; j < t.size(); j++) {
int pos =
upper_bound((idxes[t[j]]).begin(), (idxes[t[j]]).end(), mxidx) -
idxes[t[j]].begin();
if (pos == idxes[t[j]].size() || idxes[t[j]].size() == 0) {
break;
}
mxidx = idxes[t[j]][pos];
}
if (j != t.size() && idxes[t[j]].size() == 0) {
ans = -1;
break;
}
i = j - 1;
ans++;
}
cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double a[101];
double sum1, sum2;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
sum1 += a[i];
}
sum2 = n * 100;
printf("%.12lf\n", sum1 * 1.0 / sum2 * 100);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e8 + 5;
const long long mod = 1e9 + 7;
long long n, x;
char s[N];
long long getans(long long ans) { return (ans % mod + mod) % mod; }
void solve() {
scanf("%lld%s", &x, s + 1);
long long now = 0, len = strlen(s + 1);
n = len;
while (len < x) {
++now;
long long x = s[now] - '0', tot = (x - 1) * (len - now);
long long l = now + 1, r = len;
for (int i = len + 1; i <= len + tot; i++) {
if (l > r) l = now + 1;
s[i] = s[l];
++l;
}
len += tot;
}
long long ans = 0;
for (int i = now + 1; i <= x; i++) {
ans = i + 1ll * (s[i] - '0') * (len - i) % mod;
len += 1ll * (s[i] - '0' - 1ll) * (len - i) % mod;
len = (len % mod + mod) % mod;
}
printf("%lld\n", (ans % mod + mod) % mod);
}
int main() {
int cs;
scanf("%d", &cs);
while (cs--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = 1e6 + 10;
const int inf = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long llinf = (long long)1e18 + 5;
const double pi = acos(-1.0);
int n, m;
int a[maxn];
long long pref[maxn];
long long suff[maxn];
int fw[maxn];
long long fw2[maxn];
void upd(int v, int x) {
for (; v < maxn; v |= v + 1) fw[v]++, fw2[v] += x;
}
int get(int v) {
int ret = 0;
for (; v >= 0; v = (v & (v + 1)) - 1) ret += fw[v];
return ret;
}
long long get2(int v) {
long long ret = 0;
for (; v >= 0; v = (v & (v + 1)) - 1) ret += fw2[v];
return ret;
}
int main() {
int n;
cin >> n;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
long double ans = 0.0;
long long ways = n * 1LL * (n + 1) / 2;
for (int i = (1); i < (n + 1); i++) {
long long cnt = get(n) - get(a[i]);
long long sum = get2(n) - get2(a[i]);
ans += cnt;
ans -= (sum * 1LL * (n - i + 1)) * 1.0 / ways;
upd(a[i], i);
}
for (int len = (1); len < (n + 1); len++) {
ans += (n - len + 1) * 1LL * len * (len - 1) / (4.0 * ways);
}
cout.precision(16);
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long power(long long x, long long y) {
long long t = 1;
while (y > 0) {
if (y % 2)
y -= 1, t = t * x % mod;
else
y /= 2, x = x * x % mod;
}
return t;
}
char s[N];
bool vowel(int c) {
if (c == 'a' || c == 'e' || c == 'o' || c == 'i' || c == 'u') return true;
return false;
}
int main() {
scanf("%s", s);
int n = strlen(s);
int prv = 'a', pprv = 'a';
for (int i = 0; i < n; ++i) {
int cur = s[i];
if (cur != prv || cur != pprv || prv != pprv) {
if (!vowel(cur) && !vowel(pprv) && !vowel(prv)) {
printf(" ");
printf("%c", cur);
pprv = 'a';
prv = cur;
} else {
printf("%c", cur);
pprv = prv;
prv = cur;
}
} else {
printf("%c", cur);
pprv = prv;
prv = cur;
}
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, MAXN = 1e5 + 10, MAXM = 2e5 + 10;
int head[MAXN], sz, to[MAXM], nxt[MAXM];
inline void add(int x, int y) {
nxt[++sz] = head[x], head[x] = sz, to[sz] = y;
nxt[++sz] = head[y], head[y] = sz, to[sz] = x;
}
int N;
double in[MAXN], out[MAXN], sumin, sumout, ans;
int siz[MAXN], fa[MAXN];
inline void dfs(int x) {
siz[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
if (to[i] == fa[x]) continue;
fa[to[i]] = x;
dfs(to[i]);
siz[x] += siz[to[i]];
in[x] += in[to[i]];
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int ii, jj;
scanf("%d%d", &ii, &jj);
add(ii, jj);
}
for (int i = 1; i <= N; i++) {
scanf("%lf%lf", in + i, out + i);
sumin += in[i];
sumout += out[i];
}
for (int i = 1; i <= N; i++) {
in[i] /= sumin;
out[i] /= sumout;
}
dfs(1);
for (int i = 1; i <= N; i++) {
for (int j = head[i]; j; j = nxt[j]) {
if (to[j] == fa[i])
ans += (1 - in[i]) * (N - siz[i]) * out[i];
else
ans += in[to[j]] * siz[to[j]] * out[i];
}
}
printf("%.9lf", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
int main() {
long long n;
scanf("%I64d", &n);
printf("25");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
long long rng(long long l) {
uniform_int_distribution<long long> uid(0, l - 1);
return uid(rang);
}
long long c(long long a) {
long long i = 0;
while (!(a & 1)) {
i++;
a >>= 1;
}
return i;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long n;
cin >> n;
long long a[n];
long long b[n];
long long cn[65] = {};
for (long long i = 0; i < n; ++i) {
cin >> a[i];
b[i] = c(a[i]);
cn[b[i]]++;
}
long long ii = 0;
for (long long i = 0; i < 65; ++i) {
if (cn[ii] < cn[i]) {
ii = i;
}
}
cout << n - cn[ii] << "\n";
for (long long i = 0; i < n; ++i) {
if (b[i] != ii) {
cout << a[i] << " ";
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using LD = long double;
using PLL = pair<long long, long long>;
using VII = vector<pair<int, int> >;
template <class T>
bool power_2(T v) {
static_assert(std::is_integral<T>::value, "type should be integral");
return v && !(v & (v - 1));
}
template <class T>
istream& operator>>(istream& st, vector<T>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T>
ostream& operator<<(ostream& st, const vector<T>& container) {
for (auto& u : container) st << u << '\n';
return st;
}
template <class T, size_t N>
istream& operator>>(istream& st, array<T, N>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T, size_t N>
ostream& operator<<(ostream& st, const array<T, N>& container) {
for (auto u : container) st << u << ' ';
return st;
}
template <class T, class U>
istream& operator>>(istream& st, pair<T, U>& p) {
st >> p.first >> p.second;
return st;
}
template <class T, class U>
ostream& operator<<(ostream& st, pair<T, U> p) {
st << p.first << ' ' << p.second;
return st;
}
template <class T, class U, class V>
pair<T, U> operator*(pair<T, U> p, V val) {
return {p.first * val, p.second * val};
}
template <class T, class U, class V>
pair<T, U> operator/(pair<T, U> p, V val) {
return {p.first / val, p.second / val};
}
template <class T, class U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <class T, class U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <class T>
T dotProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.first + a.second * b.second;
}
template <class T>
T crossProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.second - a.second * b.first;
}
template <class T>
T lengthPow(pair<T, T> a) {
return a.first * a.first + a.second * a.second;
}
template <class T>
LD length(pair<T, T> a) {
return sqrt(lengthPow(a));
}
int const inf = 1e9 + 7;
int const N = 1e5 + 7;
int const M = 1 << 18;
struct Node {
priority_queue<int> rectangles;
int max, min;
Node() : max(-1), min(0) {}
};
bitset<N> seen, erased;
Node segTree[2 * M];
void update(int v) {
auto& que = segTree[v].rectangles;
int& minVal = segTree[v].min;
int& maxVal = segTree[v].max;
while (!que.empty() && erased[que.top()]) {
que.pop();
}
int maxInChildren = -1;
if (v < M) maxInChildren = max(segTree[v + v].max, segTree[v + v + 1].max);
int minInChildren = 0;
if (v < M) minInChildren = min(segTree[v + v].min, segTree[v + v + 1].min);
int maxInNode = -1;
if (!que.empty()) maxInNode = que.top();
if (maxInNode > maxInChildren) {
if (seen[maxInNode] || maxInNode < minInChildren)
maxVal = -1;
else
maxVal = maxInNode;
} else {
maxVal = maxInChildren;
}
minVal = max(maxInNode, minInChildren);
}
void addSegment(int col, int a, int b, bool add, int v = 1, int l = 0,
int p = M) {
if (b <= l || p <= a) return;
if (a <= l && p <= b) {
if (add) {
segTree[v].rectangles.push(col);
}
update(v);
return;
}
int mid = (l + p) / 2;
addSegment(col, a, b, add, 2 * v, l, mid);
addSegment(col, a, b, add, 2 * v + 1, mid, p);
update(v);
}
int x1[N], x2[N], Y1[N], Y2[N];
map<int, int> newCoordsX, newCoordsY;
vector<pair<int, int> > events[2 * N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x1[i] >> Y1[i] >> x2[i] >> Y2[i];
newCoordsX[x1[i]] = 0;
newCoordsX[x2[i]] = 0;
newCoordsY[Y1[i]] = 0;
newCoordsY[Y2[i]] = 0;
}
int j = 0;
for (auto& u : newCoordsY) u.second = j++;
j = 0;
for (auto& u : newCoordsX) u.second = j++;
for (int i = 0; i < n; ++i) {
x1[i] = newCoordsX[x1[i]];
x2[i] = newCoordsX[x2[i]];
Y1[i] = newCoordsY[Y1[i]];
Y2[i] = newCoordsY[Y2[i]];
events[x1[i]].push_back({i, 1});
events[x2[i]].push_back({i, 0});
}
for (int i = 0; i < 2 * n; ++i) {
for (auto u : events[i]) {
int c = u.first;
int t = u.second;
if (t == 0) erased[c] = 1;
addSegment(c, Y1[c], Y2[c], t);
}
while (segTree[1].max >= segTree[1].min) {
int id = segTree[1].max;
seen[id] = 1;
addSegment(id, Y1[id], Y2[id], 0);
}
}
int res = 1;
for (int i = 0; i < n; ++i) {
if (seen[i]) ++res;
}
cout << res << '\n';
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100, M = 1010;
int n, m;
long long int c[N], g[N], a1[M], b1[M], a2[M], b2[M];
inline long long int read() {
long long int x = 0, t = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * t;
}
inline void init() {
freopen("graph.in", "r", stdin);
freopen("graph.out", "w", stdout);
}
void work(long long int x, int n, long long int *d1, long long int *d2) {
if (n == 0) {
d1[n] = d2[n] = 0;
return;
}
if (n == 1) {
d1[n] = (x == 2);
d2[n] = (x == 1);
return;
}
if (x <= c[n - 1]) {
work(x, n - 1, d1, d2);
d1[n] = min(d1[n - 1], d2[n - 1] + 2);
d2[n] = min(d1[n - 1], d2[n - 1]) + 1 + g[n - 2];
} else {
work(x - c[n - 1], n - 2, d1, d2);
d1[n] = d1[n - 2] + 1;
d2[n] = d2[n - 2];
}
}
long long int dis(long long int u, long long int v, int n) {
if (n <= 1) return (u != v);
if (u <= c[n - 1]) {
if (v > c[n - 1]) return min(a1[n - 1], a2[n - 1]) + b1[n - 2] + 1;
return min(dis(u, v, n - 1),
min(a1[n - 1] + b2[n - 1], a2[n - 1] + b1[n - 1]) + 2);
} else
return dis(u - c[n - 1], v - c[n - 1], n - 2);
}
int main() {
m = read();
n = read();
n = min(n, 80);
c[0] = 1;
c[1] = 2;
for (register int i = 2; i <= n; i++) c[i] = c[i - 1] + c[i - 2];
g[0] = 0;
g[1] = g[2] = 1;
for (register int i = 3; i <= n; i++) g[i] = g[i - 2] + 1;
while (m--) {
long long int u = read(), v = read();
if (u > v) swap(u, v);
work(u, n, a1, a2);
work(v, n, b1, b2);
cout << dis(u, v, n) << endl;
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
int f = 1;
x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
x *= f;
}
const int N = 2e5 + 10;
const long long INF = 1e18;
struct edge {
int u, v;
long long w;
} e[N << 1];
int n, m, q, dist, in[N], l[N], r[N], to[N << 1], nxt[N << 1], id[N << 1];
int head[N], cnt;
long long val[N << 1];
int vis[N];
long long disS[N], disT[N];
bool road[N];
void add(int ID, int x, int y, long long w) {
nxt[++cnt] = head[x];
head[x] = cnt;
val[cnt] = w;
to[cnt] = y;
id[cnt] = ID;
}
struct node {
int pos;
long long dis;
bool operator<(const node &x) const { return x.dis < dis; }
};
priority_queue<node> Q;
void dij(int s, long long dis[], int f = 0) {
for (int i = 1; i <= n; i++) dis[i] = INF;
dis[s] = 0;
Q.push(node{s, 0});
while (!Q.empty()) {
node x = Q.top();
Q.pop();
int u = x.pos;
if (x.dis > dis[u]) continue;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (dis[v] > x.dis + val[i]) {
vis[v] = id[i];
dis[v] = x.dis + val[i];
if (f == 1 && !road[v]) l[v] = l[u];
if (f == 2 && !road[v]) r[v] = r[u];
Q.push(node{v, dis[v]});
}
}
}
}
void init() {
int now = 1;
road[now] = 1;
l[now] = r[now] = 0;
for (int i = 1; now != n; i++) {
int now_id = vis[now];
in[now_id] = i;
++dist;
now = e[now_id].u ^ e[now_id].v ^ now;
road[now] = 1;
l[now] = r[now] = i;
}
}
long long min_dis[N << 4];
void build(int p, int l, int r) {
min_dis[p] = INF;
if (l == r) return;
int mid = (l + r) >> 1;
build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
}
void update(int p, int l, int r, int L, int R, long long k) {
if (L > R) return;
if (L <= l && r <= R) {
min_dis[p] = min(min_dis[p], k);
return;
}
int mid = (l + r) >> 1;
if (L <= mid) update(p << 1, l, mid, L, R, k);
if (R > mid) update(p << 1 | 1, mid + 1, r, L, R, k);
}
long long query(int p, int l, int r, int x) {
if (l == r) return min_dis[p];
int mid = (l + r) >> 1;
long long res = min_dis[p];
if (x <= mid)
res = min(res, query(p << 1, l, mid, x));
else
res = min(res, query(p << 1 | 1, mid + 1, r, x));
return res;
}
int main() {
read(n), read(m), read(q);
for (int i = 1; i <= m; i++) {
read(e[i].u), read(e[i].v), read(e[i].w);
add(i, e[i].u, e[i].v, e[i].w);
add(i, e[i].v, e[i].u, e[i].w);
in[i] = -1;
}
dij(n, disT);
init();
dij(1, disS, 1);
dij(n, disT, 2);
build(1, 1, dist);
for (int i = 1; i <= m; i++)
if (in[i] == -1) {
update(1, 1, dist, l[e[i].u] + 1, r[e[i].v],
disS[e[i].u] + e[i].w + disT[e[i].v]);
update(1, 1, dist, l[e[i].v] + 1, r[e[i].u],
disS[e[i].v] + e[i].w + disT[e[i].u]);
}
for (int i = 1, id, x; i <= q; i++) {
read(id), read(x);
long long ans = disS[n];
if (in[id] == -1) {
if (x < e[id].w) {
ans = min(ans, disS[e[id].u] + x + disT[e[id].v]);
ans = min(ans, disS[e[id].v] + x + disT[e[id].u]);
}
} else {
ans = ans - e[id].w + x;
if (x > e[id].w) ans = min(ans, query(1, 1, dist, in[id]));
}
printf("%lld\n", ans);
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, st, dr, m, t;
string ans;
inline bool ask(long long st, long long dr) {
cout << st << ' ' << dr << '\n';
cout.flush();
cin >> ans;
if (ans == "Yes") return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
srand(time(NULL));
cin >> n >> k;
st = 1;
dr = n;
while (true) {
while (dr - st > 50) {
m = (st + dr) / 2;
if (ask(st, m)) {
st = max(1ll, st - k);
dr = min(n, m + k);
} else {
st = max(m - k, 1ll);
dr = min(n, dr + k);
}
}
t = rand() % (dr - st + 1) + st;
if (ask(t, t)) return 0;
st = max(1ll, st - k);
dr = min(n, dr + k);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
bool ismagic(int n, int *a) {
int S = 0;
for (int i = 0; i < n * n; ++i) S += a[i];
if (S % n != 0) return false;
S /= n;
for (int i = 0; i < n; ++i) {
int s = 0;
for (int j = 0; j < n; ++j) s += a[i * n + j];
if (s != S) return false;
s = 0;
for (int j = 0; j < n; ++j) s += a[j * n + i];
if (s != S) return false;
}
int s = 0;
for (int i = 0; i < n; ++i) s += a[i * n + i];
if (s != S) return false;
s = 0;
for (int i = 0; i < n; ++i) s += a[i * n + n - i - 1];
if (s != S) return false;
return true;
}
struct part {
int t[4];
int idx;
};
int SS, use[16];
int sum[6];
vector<part> P;
int n, a[16];
void dfs(int p, int u) {
if (p == 16) {
if (ismagic(n, use)) {
printf("%d\n", SS);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
printf("%d%c", use[i * n + j], j == n - 1 ? '\n' : ' ');
exit(0);
}
return;
}
if (p % 4 == 3) {
int s = use[p - 1] + use[p - 2] + use[p - 3];
for (int i = 0; i < 16; ++i) {
if ((u & (1 << i)) == 0) {
if (s + a[i] == SS) {
bool cond = true;
if (p == 15) {
int t = use[0] + use[5] + use[10] + a[i];
cond &= t == SS;
int x = use[3] + use[7] + use[11] + a[i];
cond &= x == SS;
}
use[p] = a[i];
if (cond) dfs(p + 1, u | (1 << i));
}
}
}
return;
}
if (p / 4 == 3) {
int s = use[p - 4] + use[p - 8] + use[p - 12];
for (int i = 0; i < 16; ++i) {
if ((u & (1 << i)) == 0) {
if (s + a[i] == SS) {
bool cond = true;
if (p == 12) {
int t = use[3] + use[6] + use[9] + a[i];
cond &= t == SS;
}
use[p] = a[i];
if (cond) dfs(p + 1, u | (1 << i));
}
}
}
return;
}
for (int i = 0; i < 16; ++i) {
if ((u & (1 << i)) == 0) {
use[p] = a[i];
dfs(p + 1, u | (1 << i));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n * n; ++i) scanf("%d", &a[i]);
if (n <= 3) {
sort(a, a + n * n);
do {
if (ismagic(n, a)) {
int S = 0;
for (int i = 0; i < n * n; ++i) S += a[i];
printf("%d\n", S / n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
printf("%d%c", a[i * n + j], j == n - 1 ? '\n' : ' ');
return 0;
}
} while (next_permutation(a, a + n * n));
} else {
SS = 0;
for (int i = 0; i < n * n; ++i) SS += a[i];
SS /= n;
dfs(0, 0);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, string> > res;
map<string, int> m;
map<string, int> m1;
int n;
string mn;
bool cmp(pair<int, string> x, pair<int, string> y) {
if (x.first == y.first) return x.second > y.second;
return x.first < y.first;
}
int main() {
cin >> mn >> n;
m["posted"] = 15;
m["commented"] = 10;
m["likes"] = 5;
for (int i = 0; i < n; i++) {
string x, y, a, f, l;
cin >> x >> a;
if (a == "posted" || a == "commented") cin >> f;
cin >> y >> f;
l = y.substr(0, (int)y.size() - 2);
if (x != mn && l != mn) m1[x] += 0, m1[l] += 0;
if (x == mn) m1[l] += m[a];
if (l == mn) m1[x] += m[a];
}
for (map<string, int>::iterator it = m1.begin(); it != m1.end(); it++)
res.push_back(make_pair(it->second, it->first));
sort(res.begin(), res.end(), cmp);
for (int i = (int)res.size() - 1; i >= 0; i--) cout << res[i].second << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int maxn = 100;
long ds[maxn];
long hs[maxn];
long solu[maxn];
long soluNum;
long min;
int n, k, m;
int main() {
using std::cin;
using std::cout;
cin >> n >> k >> m;
int i, j;
for (i = 0; i < k; i++) cin >> ds[i];
for (i = 0; i < m; i++) cin >> hs[i];
min = m + 1;
soluNum = 1;
for (i = 0; i < k; i++) {
long sum = 0;
for (j = 0; j < m; j++) {
if (hs[j] % ds[i] == 0) sum++;
}
if (sum < min) {
soluNum = 1;
solu[0] = i;
min = sum;
} else if (sum == min) {
solu[soluNum++] = i;
}
}
cout << soluNum << '\n';
for (i = 0; i < soluNum; i++) cout << solu[i] + 1 << ' ';
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
long long poww(long long base, long long p) {
if (p == 0) return 1;
if (p % 2 == 0) {
long long temp = poww(base, p / 2) % mod;
return (temp * temp) % mod;
} else {
long long temp = poww(base, p / 2) % mod;
return (((temp * temp) % mod) * base) % mod;
}
}
long long POW(long long bs, long long ex) {
long long res = 1;
while (ex) {
if (ex % 2) res = (res * bs) % mod;
bs = (bs * bs) % mod;
ex /= 2LL;
}
return res % mod;
}
long long GS(long long r, long long n) {
if (r == 1) return n % mod;
return (1 - poww(r, n)) * poww(1 - r, mod - 2) % mod;
}
int main() {
long long a, b, n, x;
cin >> a >> b >> n >> x;
cout << (poww(a, n) * x + b * GS(a, n)) % mod;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
inline bool Equal(const double& a, const double& b) {
return a + eps >= b && b + eps >= a;
}
inline bool Below(const double& a, const double& b) { return b + eps >= a; }
inline int Abs(const int& a) { return a > 0 ? a : -a; }
void Read(int& x) {
char ch;
while (ch = getchar(), ch < '0' || ch > '9')
;
x = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') x = x * 10 + ch - '0';
}
int n, m;
struct EDGE {
int to, next;
} edge[200010];
int head[100010], tot = 0;
inline void AddEdge(int a, int b) {
edge[++tot].to = b;
edge[tot].next = head[a];
head[a] = tot;
}
int size[100010], prt[100010], son[100010], deep[100010];
int dfn[100010], ufn[100010], ti = 0, top[100010], Id[100010];
void Dfs1(int rt) {
size[rt] = 1;
for (int x = head[rt]; x; x = edge[x].next) {
if (size[(edge[x].to)]) continue;
deep[(edge[x].to)] = deep[rt] + 1;
prt[(edge[x].to)] = rt;
Dfs1((edge[x].to));
size[rt] += size[(edge[x].to)];
if (size[(edge[x].to)] > size[son[rt]]) son[rt] = (edge[x].to);
}
}
void Dfs2(int rt, int tp, int k) {
dfn[rt] = ++ti;
ufn[ti] = rt;
top[rt] = tp;
Id[rt] = k;
if (son[rt]) Dfs2(son[rt], tp, k + 1);
for (int x = head[rt]; x; x = edge[x].next)
if (prt[(edge[x].to)] == rt && son[rt] != (edge[x].to))
Dfs2((edge[x].to), (edge[x].to), 1);
}
int Lca(int a, int b) {
while (top[a] != top[b]) {
if (deep[top[a]] > deep[top[b]])
a = prt[top[a]];
else
b = prt[top[b]];
}
if (deep[a] < deep[b]) return a;
return b;
}
int Dis(int a, int b) {
int c = Lca(a, b);
return deep[a] + deep[b] - 2 * deep[c];
}
double TIM;
int ppp = 0;
struct Node {
double tim;
int fr, to, spd, id;
bool Dir;
Node() {}
Node(double a, int b, int c, int d, int e) {
tim = a, fr = b, to = c, spd = d, id = e;
if (fr <= to)
Dir = 1;
else
Dir = 0;
}
bool operator<(const Node& a) const {
ppp++;
if (ppp > 50000000) {
puts("mdzz");
exit(0);
}
double x1 = (TIM - tim) * spd;
double x2 = (TIM - a.tim) * a.spd;
if (Dir == 0)
x1 = fr - x1;
else
x1 = fr + x1;
if (a.Dir == 0)
x2 = a.fr - x2;
else
x2 = a.fr + x2;
if (Equal(x1, x2))
return id < a.id;
else
return Below(x1, x2);
}
};
vector<Node> sta[100010];
double Query(Node a, Node b) {
int u1 = a.fr, v1 = a.to, u2 = b.fr, v2 = b.to;
if (u1 > v1) swap(u1, v1);
if (u2 > v2) swap(u2, v2);
u1 = max(u1, u2), v1 = min(v1, v2);
double t1, t2, x;
if (u1 <= v1) {
if (a.Dir == b.Dir) {
if (a.Dir == 1 && b.Dir == 1)
t1 = a.tim + (double)Abs(u1 - a.fr) / a.spd,
t2 = b.tim + (double)Abs(u1 - b.fr) / b.spd;
else
t1 = a.tim + (double)Abs(a.fr - v1) / a.spd,
t2 = b.tim + (double)Abs(b.fr - v1) / b.spd;
if (a.spd == b.spd) {
if (!Equal(t1, t2))
return 1e100;
else
return t1;
} else {
x = (t1 - t2) * b.spd * a.spd / (a.spd - b.spd);
if (Below(0, x) && Below(x, v1 - u1))
return t1 + x / a.spd;
else
return 1e100;
}
} else {
if (a.Dir == 0 && b.Dir == 1)
t1 = a.tim + (double)Abs(a.fr - v1) / a.spd,
t2 = b.tim + (double)Abs(u1 - b.fr) / b.spd;
else
t1 = a.tim + (double)Abs(u1 - a.fr) / a.spd,
t2 = b.tim + (double)Abs(b.fr - v1) / b.spd;
x = a.spd * (v1 - u1 - b.spd * t1 + b.spd * t2) / (a.spd + b.spd);
if (Below(0, x) && Below(x, v1 - u1))
return t1 + x / a.spd;
else
return 1e100;
}
} else
return 1e100;
}
struct Things {
double tim;
bool Ty;
int id;
Things(double a = 0, bool b = false, int d = 0) { tim = a, Ty = b, id = d; }
bool operator<(const Things& a) const {
return Equal(tim, a.tim) ? (Ty != a.Ty ? Ty < a.Ty : id < a.id)
: tim < a.tim;
}
} B[200010];
int cnt = 0;
double Work(vector<Node>& p) {
vector<Node>::iterator it;
cnt = 0;
int i, x;
for (it = p.begin(), i = 0; it != p.end(); ++it, ++i) {
B[++cnt] = Things(it->tim, 0, i);
B[++cnt] = Things(it->tim + (double)Abs(it->to - it->fr) / it->spd, 1, i);
}
set<Node> S;
TIM = 0;
sort(B + 1, B + 1 + cnt);
Node q;
double ans = 1e100;
for (int i = 1; i <= cnt; ++i) {
TIM = B[i].tim;
if (Below(ans, TIM)) {
return ans;
}
if (B[i].Ty == 0) {
q = p[B[i].id];
set<Node>::iterator iter = S.lower_bound(q);
if (iter != S.end()) ans = min(ans, Query(*iter, q));
if (Below(ans, TIM)) return ans;
if (iter != S.begin()) --iter, ans = min(ans, Query(*iter, q));
if (Below(ans, TIM)) return ans;
S.insert(q);
} else {
q = p[B[i].id];
S.erase(q);
set<Node>::iterator iter = S.lower_bound(q);
if (iter != S.end() && iter != S.begin()) {
set<Node>::iterator iter2 = iter;
iter2--;
ans = min(ans, Query(*iter, *iter2));
if (Below(ans, TIM)) return ans;
}
}
}
return ans;
}
signed main() {
scanf("%d%d", &n, &m);
int a, b;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
AddEdge(a, b);
AddEdge(b, a);
}
Dfs1(1);
Dfs2(1, 1, 1);
double t1, t2;
int t, c, u, v;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &t, &c, &u, &v);
a = u, b = v;
t2 = t + (double)Dis(a, b) / c;
while (top[a] != top[b]) {
if (deep[top[a]] > deep[top[b]]) {
sta[top[a]].push_back(
Node(t + (double)(deep[u] - deep[a]) / c, Id[a], 0, c, i));
a = prt[top[a]];
} else {
sta[top[b]].push_back(Node(
t2 - (double)(deep[v] - deep[prt[top[b]]]) / c, 0, Id[b], c, i));
b = prt[top[b]];
}
}
sta[top[a]].push_back(
Node(t + (double)(deep[u] - deep[a]) / c, Id[a], Id[b], c, i));
}
double ans = (double)1e100;
for (int i = 1; i <= n; ++i) {
if (sta[i].empty()) continue;
ans = min(ans, Work(sta[i]));
}
if (Equal(ans, 1e100))
puts("-1");
else
printf("%.10f\n", (double)ans);
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ia[n], m = 0;
for (int i = 0; i < n; i++) {
cin >> ia[i];
if (ia[i] % 2 == 0) m++;
}
if (m == 1) {
for (int i = 0; i < n; i++) {
if (ia[i] % 2 == 0) {
cout << i + 1;
break;
}
}
} else {
for (int i = 0; i < n; i++) {
if (ia[i] % 2 != 0) {
cout << i + 1;
break;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long mod = 998244353;
const int phash = 3;
const long long modhash = 1000000000000000003;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<string> dates(n);
for (int i = 0; i < n; i++) cin >> dates[i];
for (int i = 0; i < n; i++) {
string best = "2012";
for (int j = 0; j < 4; j++)
for (char x = '0'; x <= '9'; x++) {
string cur = dates[i];
cur[j] = x;
if (cur[0] != '0' && (!i || cur >= dates[i - 1]) && cur < best)
best = cur;
}
if (best == "2012") {
cout << "No solution";
return 0;
}
dates[i] = best;
}
for (string i : dates) cout << i << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, m, s;
void go(long long u, long long v, long long k1, long long k2) {
s = (u - x) / k1;
if (s > m) {
x += m * k1;
y += m * k2;
printf("%I64d %I64d", x, y);
exit(0);
}
m -= s;
x = u;
y = v;
}
int main() {
cin >> m;
if (!m) {
printf("0 0");
return 0;
}
n = floor(sqrt(m / 3)) + 1;
for (; n * (n - 1) * 3 >= m; n--)
;
m -= n * (n - 1) * 3 + 1;
x = (n - 1) * 2 + 1;
y = 2;
go(n, n * 2, -1, 2);
go(-n, n * 2, -2, 0);
go(-2 * n, 0, -1, -2);
go(-n, -n * 2, 1, -2);
go(n, -n * 2, 2, 0);
go(2 * n, 0, 1, 2);
printf("%I64d %I64d", x, y);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int qq, n, m, k, l, r;
string s, s1, s2, s3;
int INF = (int)1e9 + 7;
struct st {
long long mi, ma, mir, mar, mir2, mar2;
};
vector<st> v;
multimap<int, st> ma;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int ans = 0;
int t, x = 1, y = n, k1 = 0, k2, k3, k4, x1, x2;
k = 0;
cin >> n >> k;
vector<int> a, b(k), c, dp;
for (int i = 0; i < n; i++) {
cin >> m;
m -= i;
a.push_back(m);
}
for (int i = 0; i < k; i++) {
cin >> b[i];
}
for (int i = 1; i < k; i++)
if (a[b[i] - 1] < a[b[i - 1] - 1]) {
cout << -1;
return 0;
}
k1 = 0;
if (b.size() && b[0] == 1) {
k3 = a[0];
k1 = 0;
} else {
k1 = -1;
k3 = -INF;
}
for (int j : b) {
for (int i = k1 + 1; i < j; i++) {
if (a[i] > a[j - 1] || a[i] < k3)
ans++;
else
c.push_back(a[i]);
}
if (c.size()) {
dp.clear();
dp.push_back(c[0]);
for (int i = 1; i < c.size(); i++) {
k2 = upper_bound(dp.begin(), dp.end(), c[i]) - dp.begin();
if (k2 == dp.size())
dp.push_back(c[i]);
else
dp[k2] = c[i];
}
ans += c.size() - dp.size();
}
k1 = j - 1;
k3 = a[j - 1];
c.clear();
}
k1 = -1;
k3 = -INF;
if (b.size()) {
k1 = b[k - 1] - 1;
k3 = a[b[k - 1] - 1];
}
for (int i = k1 + 1; i < n; i++) {
if (a[i] < k3)
ans++;
else
c.push_back(a[i]);
}
if (c.size()) {
dp.clear();
dp.push_back(c[0]);
for (int i = 1; i < c.size(); i++) {
k2 = upper_bound(dp.begin(), dp.end(), c[i]) - dp.begin();
if (k2 == dp.size())
dp.push_back(c[i]);
else
dp[k2] = c[i];
}
ans += c.size() - dp.size();
}
cout << ans << endl;
cin >> k;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, k, v[100010], t, i;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> v[i];
while (t < k) {
t++;
k -= t;
}
if (k)
cout << v[k];
else
cout << v[t];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool chk[100010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int N;
cin >> N;
fill(chk + 1, chk + N + 1, 0);
string A, B;
cin >> A >> B;
A = '*' + A, B = '*' + B;
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (A[i] == '0' && B[i] == '0') {
if (A[i - 1] == '1' && B[i - 1] == '1' && !chk[i - 1]) {
cnt += 2;
chk[i] = true;
} else
cnt++;
} else if (A[i] == '1' && B[i] == '1') {
if (A[i - 1] == '0' && B[i - 1] == '0' && !chk[i - 1]) {
cnt++;
chk[i] = true;
}
} else
cnt += 2;
}
cout << cnt << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b, long long int mod) {
long long int ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
b = b / 2;
}
return ans;
}
vector<long long int> fact(100);
void pre_fact(long long int m) {
fact[0] = 1;
for (long long int i = 1; i < 100; i++) fact[i] = (fact[i - 1] * i) % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
return (fact[n] * (power((fact[n - r] * fact[r]) % m, m - 2, m))) % m;
}
void print(long long int n) {
for (long long int i = 1; i <= n; i++) {
cout << '(';
}
for (long long int i = 1; i <= n; i++) {
cout << ")";
}
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) {
print(i);
print(n - i);
cout << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, same;
char c1, c2;
signed main() {
scanf("%d%d", &n, &m);
while (!isalpha(c1)) c1 = getchar();
long long ans = n * (m - 1);
for (int i = 1; i < n; ++i) {
char c = getchar();
same = (c == c2) ? same + 1 : 0;
if (c != c1) ans += n * (m - 1) - same - 1;
c2 = c1;
c1 = c;
}
return !printf("%lld", ans);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[1000005];
long long ans;
int inline read() {
int res = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); res *= 10, res += c ^ 48, c = getchar())
;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
n = read();
m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
++d[u];
++d[v];
}
for (int u = 1; u <= n; ++u) {
int d = ::d[u];
ans += (long long)d * (n - d - 1);
}
ans /= 2;
ans = (long long)n * (n - 1) * (n - 2) / 6 - ans;
cout << ans << '\n';
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> v) {
for (auto& i : v) os << i << ' ';
return os;
}
template <typename T, typename U>
istream& operator>>(istream& is, pair<T, U>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, pair<T, U> p) {
os << p.first << ' ' << p.second;
return os;
}
template <typename T, typename U>
void cmin(T& a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
void cmax(T& a, U b) {
if (a < b) a = b;
}
const int N = 2e5 + 2, M = 1e9 + 7;
int tt = 1, n, k;
void solve() {
cin >> n;
map<int, int> m;
for (auto i = 0; i < n; i++) {
int x;
cin >> x;
m[x]++;
}
long long ans = m[1];
for (auto i = 0; i < m[0]; i++) ans *= 2;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> tt;
while (tt--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int A[100005];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) scanf("%d", &A[i]);
for (int i = (0); i < (n); i++) {
while (A[i] % 2 == 0) A[i] /= 2;
while (A[i] % 3 == 0) A[i] /= 3;
}
for (int i = (1); i < (n); i++)
if (A[i] != A[i - 1]) {
printf("No\n");
return 0;
}
printf("Yes\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1001][1001];
int b[1001][1001][4];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if ((a[i][j - 1] == 1 || b[i][j - 1][0] == 1) && a[i][j] == 0) {
b[i][j][0] = 1;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = m - 1; j >= 0; j--) {
if ((a[i][j + 1] == 1 || b[i][j + 1][1] == 1) && a[i][j] == 0) {
b[i][j][1] = 1;
}
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
if ((a[i - 1][j] == 1 || b[i - 1][j][2] == 1) && a[i][j] == 0) {
b[i][j][2] = 1;
}
}
}
for (int j = 0; j < m; j++) {
for (int i = n - 1; i >= 0; i--) {
if ((a[i + 1][j] == 1 || b[i + 1][j][3] == 1) && a[i][j] == 0) {
b[i][j][3] = 1;
}
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
if (b[i][j][k] == 1) {
sum++;
}
}
}
}
printf("%d", sum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void debug() {
fflush(stdin);
printf("Press any key to continue");
getc(stdin);
fflush(stdin);
}
long long n, m;
long long pp(long long a, long long b) {
if (b == 0) return 1;
long long tmp = pp(a, b / 2);
tmp = (tmp * tmp) % m;
if (b % 2) tmp = (tmp * a) % m;
return tmp;
}
int main() {
scanf("%I64d %I64d", &n, &m);
long long ans = pp(3, n);
ans = (ans - 1 + m) % m;
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
const int S = 448;
const int K = 86;
const int N = 1e5 + 5;
template <const int &MOD>
struct _m_int {
int val;
_m_int(int64_t v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static int mod_inv(int a, int m = MOD) {
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
explicit operator int64_t() const { return val; }
_m_int &operator+=(const _m_int &other) {
val -= MOD - other.val;
if (val < 0) val += MOD;
return *this;
}
_m_int &operator-=(const _m_int &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
return x % m;
unsigned x_high = x >> 32, x_low = (unsigned)x;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
_m_int &operator*=(const _m_int &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
_m_int &operator/=(const _m_int &other) { return *this *= other.inv(); }
friend _m_int operator+(const _m_int &a, const _m_int &b) {
return _m_int(a) += b;
}
friend _m_int operator-(const _m_int &a, const _m_int &b) {
return _m_int(a) -= b;
}
friend _m_int operator*(const _m_int &a, const _m_int &b) {
return _m_int(a) *= b;
}
friend _m_int operator/(const _m_int &a, const _m_int &b) {
return _m_int(a) /= b;
}
_m_int &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
_m_int &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
_m_int operator++(int) {
_m_int before = *this;
++*this;
return before;
}
_m_int operator--(int) {
_m_int before = *this;
--*this;
return before;
}
_m_int operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const _m_int &other) const { return val == other.val; }
bool operator!=(const _m_int &other) const { return val != other.val; }
bool operator<(const _m_int &other) const { return val < other.val; }
bool operator<=(const _m_int &other) const { return val <= other.val; }
bool operator>(const _m_int &other) const { return val > other.val; }
bool operator>=(const _m_int &other) const { return val >= other.val; }
_m_int inv() const { return mod_inv(val); }
_m_int pow(int64_t p) const {
if (p < 0) return inv().pow(-p);
_m_int a = *this, result = 1;
while (p > 0) {
if (p & 1) {
result *= a;
}
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &os, const _m_int &m) {
return os << m.val;
}
};
extern const int MOD = 1e9 + 7;
using mod_int = _m_int<MOD>;
template <typename T>
class persistent_segtree {
public:
int n, m;
vector<int> root, lc, rc;
vector<T> st;
int FREE_ID = 0;
persistent_segtree() {}
persistent_segtree(int n_, int m_, T val = T()) {
n = n_;
m = m_;
FREE_ID = 0;
root.resize(n + 2);
st.resize(m + 2, val);
lc.resize(m + 2);
rc.resize(m + 2);
}
T merge(T a, T b) {
T res = a * b;
return res;
}
int build(int l, int r) {
int node = ++FREE_ID;
if (l == r) {
return node;
}
int mid = (l + r) >> 1;
lc[node] = build(l, mid);
rc[node] = build(mid + 1, r);
return node;
}
int update(int prev, int ss, int se, int pos, int val) {
int node = ++FREE_ID;
if (ss == se) {
st[node] = val;
return node;
}
lc[node] = lc[prev];
rc[node] = rc[prev];
int mid = (ss + se) >> 1;
if (pos <= mid) {
lc[node] = update(lc[prev], ss, mid, pos, val);
} else {
rc[node] = update(rc[prev], mid + 1, se, pos, val);
}
st[node] = merge(st[lc[node]], st[rc[node]]);
return node;
}
T query(int node, int ss, int se, int qs, int qe) {
if (qs > se || qe < ss) {
return 1;
}
if (qs <= ss && se <= qe) {
return st[node];
}
int mid = (ss + se) >> 1;
T res = merge(query(lc[node], ss, mid, qs, qe),
query(rc[node], mid + 1, se, qs, qe));
return res;
}
};
template <typename T>
class segment {
public:
vector<T> st;
int n;
segment() {}
segment(int _n) {
n = _n;
st.resize(2 * n, (T)0);
}
T merge(T &a, T &b) { return max(a, b); }
void create() {
for (int i = n - 1; i > 0; i--) {
st[i] = merge(st[i << 1], st[(i << 1) | 1]);
}
}
void update(int idx, T val) {
for (st[idx += n - 1] = val; idx > 1; idx >>= 1) {
st[idx >> 1] = merge(st[min(idx, idx ^ 1)], st[max(idx, idx ^ 1)]);
}
}
T query(int l, int r) {
T ans{};
T ansl{};
T ansr{};
for (l += n - 1, r += n - 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
ansl = merge(ansl, st[l++]);
}
if (r & 1) {
ansr = merge(st[--r], ansr);
}
}
ans = merge(ansl, ansr);
return ans;
}
};
vector<segment<int>> obj(K);
persistent_segtree<mod_int> obj_ps;
int p[N], val[N], a[N], spf[M], pv[M];
mod_int prime[K];
int n, q;
void pre() {
for (int i = 1; i < M; i++) {
spf[i] = i;
}
for (int i = 2; i < M; i++) {
if (spf[i] == i) {
for (int j = 2 * i; j < M; j += i) {
spf[j] = min(spf[j], i);
}
}
}
int id = 0;
for (int i = 2; i < S; i++) {
if (spf[i] == i) {
prime[id++] = i;
}
}
for (int i = 0; i < K; i++) {
obj[i] = segment<int>(n);
obj[i].create();
}
for (int i = 1; i < M; i++) {
pv[i] = -1;
}
for (int i = 1; i <= n; i++) {
int x = a[i];
for (int j = 0; j < K; j++) {
int pw = 0;
while (x % (int)prime[j] == 0) {
x /= (int)prime[j];
pw++;
}
if (pw) {
obj[j].update(i, pw);
}
}
p[i] = x;
val[i] = pv[p[i]];
pv[p[i]] = i;
}
int sz1 = n << 1;
int sz2 = (log2(n) + 1) * (sz1 + 1);
sz2 <<= 1;
obj_ps = persistent_segtree<mod_int>(sz1, sz2, 1);
obj_ps.root[0] = obj_ps.build(1, n);
for (int i = 1; i <= n; i++) {
obj_ps.root[i] = obj_ps.update(obj_ps.root[i - 1], 1, n, i, p[i]);
if (val[i] != -1) {
obj_ps.root[i] = obj_ps.update(obj_ps.root[i], 1, n, val[i], 1);
}
}
}
mod_int lcm(int l, int r) {
mod_int ans = 1;
for (int i = 0; i < K; i++) {
ans = (ans * prime[i].pow(obj[i].query(l, r + 1)));
}
ans = (ans * obj_ps.query(obj_ps.root[r], 1, n, l, r));
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
pre();
cin >> q;
mod_int last = 0;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
int l = (x + (int)last) % n + 1;
int r = (y + (int)last) % n + 1;
if (l > r) {
swap(l, r);
}
last = lcm(l, r);
cout << last << '\n';
}
}
| 19 |
#include <bits/stdc++.h>
int m, n, ans, h;
bool in[100];
struct ele {
int a, b, c;
} num[100050];
int cmp(struct ele c, struct ele d) { return c.a < d.a; }
int cmpc(struct ele c, struct ele d) { return c.b < d.b; }
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
int i, j, k, x, y, z;
scanf("%d%d", &n, &h);
for (i = 1; i <= n; i++) {
scanf("%d", &num[i].a);
num[i].b = i;
}
std::sort(num + 1, num + 1 + n, cmp);
x = max(num[n].a + num[n - 1].a, num[n].a + num[1].a + h) -
min(num[1].a + num[2].a + h, num[2].a + num[3].a);
y = num[n].a + num[n - 1].a - num[1].a - num[2].a;
if (x < y) {
for (i = 2; i <= n; i++) num[i].c = 2;
num[1].c = 1;
printf("%d\n", x);
} else {
for (i = 1; i <= n; i++) num[i].c = 1;
printf("%d\n", y);
}
std::sort(num + 1, num + 1 + n, cmpc);
for (i = 1; i <= n; i++) {
if (num[1].c == 2) {
if (num[i].c == 2)
printf("1 ");
else
printf("2 ");
} else
printf("%d ", num[i].c);
}
getchar();
getchar();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int test = 0;
const int MAXN = 200009;
const long long MOD = 119 << 23 | 1;
class {
public:
int a[4444], b[4444];
int n, m, k;
void solve() {
int _;
cin >> _;
while (_--) {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
k = min(m - 1, k);
int N = n - (m - 1 - k);
int R = 1 + N - 1, L = 1;
while (R <= n) {
cal(L, R);
L++;
R++;
}
int Max = -1;
for (int i = 0; i <= k; ++i) {
Max = max(b[i], Max);
}
cout << Max << '\n';
}
}
void cal(int L, int R) {
if (L == 1) {
for (int i = 0; i <= k; ++i) {
b[i] = max(a[L + i], a[R - (k - i)]);
}
} else {
for (int i = 0; i <= k; ++i) {
b[i] = min(b[i], max(a[L + i], a[R - (k - i)]));
}
}
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int a[N], x[N], y[N], v[N], f[N], n, d;
queue<int> Q;
int main() {
scanf("%d%d", &n, &d);
for (int i = 2; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
Q.push(n);
memset(f, 0x7f, sizeof(f));
f[n] = 0;
v[n] = 1;
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = 1; i <= n; i++)
if (i != now && f[i] > f[now] +
(abs(x[i] - x[now]) + abs(y[i] - y[now])) * d -
a[i]) {
f[i] = f[now] + (abs(x[i] - x[now]) + abs(y[i] - y[now])) * d - a[i];
if (!v[i]) {
v[i] = 1;
Q.push(i);
}
}
v[now] = 0;
}
printf("%d\n", f[1]);
}
| 13 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tt = 1;
while (tt--) {
long long int n;
cin >> n;
string s;
cin >> s;
long long int sl = 0, ql = 0, sr = 0, qr = 0;
for (long long int i = 0; i < n / 2; i++) {
if (s[i] == '?')
ql++;
else
sl += (s[i] - '0') * 2;
}
for (long long int i = n / 2; i < n; i++) {
if (s[i] == '?')
qr++;
else
sr += (s[i] - '0') * 2;
}
long long int x = sl + ql * 9 - (sr + qr * 9);
if (x == 0)
cout << "Bicarp\n";
else
cout << "Monocarp\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int time, root, initial[100], repeat[100], store[100], i, min, st;
scanf("%d %d", &root, &time);
for (i = 0; i < root; i++) scanf("%d %d", &initial[i], &repeat[i]);
for (i = 0; i < root; i++) {
while (time > initial[i]) {
initial[i] = initial[i] + repeat[i];
}
store[i] = initial[i] - time;
}
for (i = 0, min = 100000, st = 0; i < root; i++) {
if (min > store[i]) {
st = i;
min = store[i];
}
}
printf("%d\n", st + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:336777216")
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using ui = unsigned int;
ll const mod = 1e9 + 7;
auto mt = mt19937(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n, t;
cin >> n >> t;
string s;
cin >> s;
int point = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '.') {
point = i;
break;
}
}
int first5 = -1;
for (int i = point + 1; i < n; i++) {
if (s[i] >= '5') {
first5 = i;
break;
}
}
if (first5 == -1) return cout << s << '\n', 0;
while (s.size() > first5 + 1) s.pop_back();
t--;
n = s.size();
reverse(s.begin(), s.end());
first5 = n - first5 - 1;
point = n - point - 1;
int i;
if (first5 + 1 == point)
i = point + 1;
else
i = first5 + 1;
s[i]++;
s[first5] = '0';
s += "00000";
n = s.size();
while (s[i] == '9' + 1) {
s[i] = '0';
s[++i]++;
}
while (t--) {
while (first5 < point && s[first5] < '5') first5++;
if (s[first5] >= '5') {
int i;
if (first5 + 1 == point)
i = point + 1;
else
i = first5 + 1;
s[first5] = '0';
s[i]++;
while (s[i] == '9' + 1) {
s[i] = '0';
s[++i]++;
}
} else
break;
}
while (s.back() == '0') s.pop_back();
reverse(s.begin(), s.end());
while (s.back() == '0') s.pop_back();
if (s.back() == '.') s.pop_back();
cout << s << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
set<int> s;
cin >> n;
for (int i = 1; i <= n; i++) {
int f = 0;
for (int j = 1; j <= n; j++) {
cin >> x;
if (x == 1 || x == 3) f = 1;
}
if (!f) s.insert(i);
}
cout << s.size() << endl;
for (int ans : s) cout << ans << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, x, y;
char c, d;
int main() {
scanf("%c%c", &c, &d);
if (c == 'a' || c == 'h') {
if (d == '1' || d == '8')
printf("3\n");
else
printf("5\n");
} else {
if (d == '1' || d == '8')
printf("5\n");
else
printf("8\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, Max = 50, inf = 1e8;
int dp[maxn][Max], a[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < Max; i++) {
dp[0][i] = inf;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
int x1 = x / 100, x2 = x1 / 10;
for (int j = 0; j < Max; j++) {
int A = inf, B = inf;
if (j >= x2) A = dp[i - 1][j - x2] + x1;
if (j + x1 < Max) B = dp[i - 1][j + x1];
dp[i][j] = min(A, B);
}
for (int j = 1; j < x1; j++) {
dp[i][0] = min(dp[i][0], dp[i - 1][j] + x1 - j);
}
}
int ans = inf;
for (int i = 0; i < Max; i++) {
ans = min(ans, dp[n][i]);
}
return cout << ans * 100 << endl, 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
vector<int> g[N];
int dis[N][N];
vector<pair<int, int>> in[N], out[N];
int n, m;
int ans = 0;
vector<int> moves(4, 0);
void bfs(int x) {
dis[x][x] = 0;
queue<int> q;
q.push(x);
while (!q.empty()) {
int cur = q.front();
q.pop();
int curDistance = dis[x][cur];
for (auto k : g[cur]) {
if (curDistance + 1 < dis[x][k]) {
dis[x][k] = curDistance + 1;
q.push(k);
}
}
}
for (int i = 1; i <= n; i++) {
if (dis[x][i] < INT_MAX) {
in[i].push_back(make_pair(dis[x][i], x));
out[x].push_back(make_pair(dis[x][i], i));
}
}
}
void f(int b, int c) {
if (b == c) return;
for (int i = 0; i < min(6, (int)in[b].size()); i++) {
int a = in[b][i].second;
if (a == b || a == c) continue;
for (int j = 0; j < min(6, (int)out[c].size()); ++j) {
int d = out[c][j].second;
if (d == a || d == b || d == c) continue;
int total = dis[a][b] + dis[b][c] + dis[c][d];
if (total > ans) {
ans = total;
moves[0] = a;
moves[1] = b;
moves[2] = c;
moves[3] = d;
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
dis[i][j] = INT_MAX;
}
}
while (m--) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
}
for (int i = 1; i <= n; i++) bfs(i);
for (int i = 1; i <= n; i++) {
sort(in[i].begin(), in[i].end());
reverse(in[i].begin(), in[i].end());
sort(out[i].begin(), out[i].end());
reverse(out[i].begin(), out[i].end());
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dis[i][j] < INT_MAX) {
f(i, j);
}
}
}
for (auto x : moves) cout << x << " ";
}
| 12 |
#include <bits/stdc++.h>
const long long MAX_N = 2e5 + 5;
const long long MOD = 1e9 + 7;
using namespace std;
int a[MAX_N];
int n;
long long mx = 1e6;
bool seen[1000005];
long long fnd(long long x, int l) {
int r = n - 1;
if (a[0] > x) return -1;
if (a[n - 1] < x) return a[n - 1];
while (r - l > 1) {
int mid = (l + r) / 2;
if (a[mid] < x)
l = mid;
else
r = mid;
}
return a[l];
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == 1 or seen[a[i]]) continue;
for (int j = 1; j <= (a[n - 1] / a[i] + 1); ++j) {
long long x = fnd(a[i] * j, i);
if (x == -1) continue;
ans = max(ans, x % a[i]);
}
seen[a[i]] = true;
}
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<long long> v;
int n;
long long x, y, sum = 0;
cin >> n >> x >> y;
for (int i = 0; i < n - 1; i++) {
v.push_back(1);
}
v.push_back(y - n + 1);
for (int i = 0; i < n; i++) {
sum += v[i] * v[i];
}
if (sum < x || v[n - 1] <= 0) {
cout << -1;
} else {
for (int i = 0; i < n; i++) {
cout << v[i] << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int nbr_of_a = 0;
string a;
int taille;
cin >> a;
taille = a.size();
for (int k = 0; k < taille; k++) {
if (a[k] == 'a') {
nbr_of_a++;
}
}
int result;
if (nbr_of_a > taille / 2) {
cout << a.size();
} else {
result = (2 * nbr_of_a - 1);
cout << result;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int mod = 998244353;
int f[N][N], g[N][N];
int mn[N][N], ind[N];
bool bz[N][N];
int a[N];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]), ind[a[i]] = i;
for (int i = 1; i <= m; i++) {
mn[i][i] = a[i];
for (int j = i + 1; j <= m; j++) mn[i][j] = min(mn[i][j - 1], a[j]);
}
for (int i = 1; i <= m + 1; i++) f[i][i - 1] = g[i][i - 1] = 1;
for (int i = 1; i <= m; i++)
for (int l = 1; l + i - 1 <= m; l++) {
int r = i + l - 1;
int x = mn[l][r], id = ind[x];
for (int mid = id; mid <= r; mid++)
g[l][r] = (g[l][r] + (long long)f[l][id - 1] * f[mid + 1][r] % mod *
f[id + 1][mid] % mod) %
mod;
for (int ll = l; ll <= id; ll++)
f[l][r] = (f[l][r] + (long long)g[ll][r] * f[l][ll - 1]) % mod;
}
printf("%d\n", f[1][n]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int main() {
int n, i, j, k, l, f;
scanf("%d%d", &n, &k);
scanf("%s", &str);
f = 0;
i = 0;
l = 0;
while (f == 0) {
if (l == k) break;
if (i < n - 1 && str[i] == '4' && str[i + 1] == '7') {
if (i % 2 == 0) {
str[i + 1] = '4';
l++;
} else {
str[i] = '7';
l++;
if (i != 0 && str[i - 1] == '4') {
f = 1;
break;
}
}
if (l == k) break;
} else if (i == n - 1)
break;
i++;
}
if (l == 0) l = k;
if (l == k)
printf("%s\n", str);
else if (f == 1) {
k = k - l;
if (k % 2 != 0) str[i] = '4';
printf("%s\n", str);
} else {
l = k % l;
i = 0;
while (l) {
if (i < n - 1 && str[i] == '4' && str[i + 1] == '7') {
if (i % 2 == 0) {
str[i + 1] = '4';
l--;
} else {
str[i] = '7';
l--;
}
}
i++;
if (i == n - 1) break;
}
printf("%s\n", str);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<int> seg[4 * N];
int arr[N], n;
void build(int s, int e, int idx) {
if (s == e) {
seg[idx].push_back(arr[s]);
return;
}
build(s, (s + e) / 2, idx * 2);
build((s + e) / 2 + 1, e, idx * 2 + 1);
seg[idx] = seg[idx * 2];
for (int i = 0; i < seg[idx * 2 + 1].size(); i++)
seg[idx].push_back(seg[idx * 2 + 1][i]);
sort(seg[idx].begin(), seg[idx].end());
}
int get(int s, int e, int idx, int l, int r, int val) {
if (s > r || e < l) return 0;
if (s >= l && e <= r)
return seg[idx].end() - lower_bound(seg[idx].begin(), seg[idx].end(), val);
return get(s, (s + e) / 2, idx * 2, l, r, val) +
get((s + e) / 2 + 1, e, idx * 2 + 1, l, r, val);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
build(1, n, 1);
long long ans = 0;
for (int i = 2; i <= n; i++) {
ans += get(1, n, 1, 1, min(i - 1, arr[i]), i);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
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));
}
long long int Bigmod(long long int base, long long int power,
long long int mod) {
if (power == 0) return 1 % mod;
if (power == 1) return base % mod;
long long int x = Bigmod(base, power / 2, mod);
x = (x * x) % mod;
if (power % 2) {
x = (x * (base % mod)) % mod;
}
return x;
}
long long int Mulmod(long long int base, long long int power,
long long int mod) {
if (power == 0) return 0;
if (power == 1) return base % mod;
long long int x = Mulmod(base, power / 2, mod);
x = (x + x) % mod;
if (power % 2) {
x = (x + (base % mod)) % mod;
}
return x;
}
long long int BigMulmod(long long int base, long long int power,
long long int mod) {
if (power == 0) return 1 % mod;
if (power == 1) return base % mod;
long long int x = BigMulmod(base, power / 2, mod);
x = Mulmod(x, x, mod);
if (power % 2) {
x = Mulmod(x, (base % mod), mod);
}
return x;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
long long int ModInverse(long long int number, long long int mod) {
return Bigmod(number, mod - 2, mod);
}
bool isConso(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
bool isPrime(long long int val) {
if (val == 2) return true;
if (val % 2 == 0 || val == 1) return false;
long long int sqrt_N = (long long int)((double)sqrt(val));
for (long long int i = 3; i <= sqrt_N; i += 2) {
if (val % i == 0) return false;
}
return true;
}
template <class T>
string convert(T _input) {
stringstream blah;
blah << _input;
return blah.str();
}
int distchar(char a, char b) {
int x = ((a - b) + 26) % 26;
int y = ((b - a) + 26) % 26;
return min(x, y);
}
bool cmp(long long int a, long long int b) { return a > b; }
int main() {
int t, T;
scanf("%d", &(T));
for (__typeof(t) t = 1; t <= T; t++) {
string str;
cin >> str;
reverse(str.begin(), str.end());
if (str[0] == 'o')
printf("FILIPINO\n");
else if (str[0] == 'u')
printf("JAPANESE\n");
else
printf("KOREAN\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, kt[100001];
vector<pair<int, int> > a[100001];
long long bfs(int u) {
long long res = 0;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
if (kt[v] == 0) {
kt[v] = 1;
res += bfs(v) + 2 * a[u][i].second;
}
}
return res;
}
long long bfs2(int u) {
long long res = 0;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
if (kt[v] == 0) {
kt[v] = 1;
res = max(res, bfs2(v) + a[u][i].second);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
a[u].push_back(pair<int, int>(v, w));
a[v].push_back(pair<int, int>(u, w));
}
kt[1] = 1;
long long ans = bfs(1);
memset(kt, 0, sizeof(kt));
kt[1] = 1;
cout << ans - bfs2(1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
set<int> ans;
for (int i = 0; i < n; i++) {
if (a[i] % k)
ans.insert(a[i]);
else if (ans.count(a[i] / k) == 0)
ans.insert(a[i]);
}
cout << ans.size() << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string query(string x, int l, int r, int k) {
string a, b;
a = x.substr(r - k, k);
b = x.substr(l - 1, r - l + 1 - k);
x.erase(r - k, k);
x.erase(l - 1, r - l + 1 - k);
x.insert(l - 1, b);
x.insert(l - 1, a);
return x;
}
int main() {
string x;
long long int m, l, r, k;
cin >> x;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r >> k;
k %= (r - l + 1);
if (k > 0) x = query(x, l, r, k);
}
cout << x << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int main(int argc, char const *argv[]) {
scanf("%d %d %d", &n, &a, &b);
int ans = (a - 1 + b) % n + 1;
printf("%d\n", ans < 1 ? ans + n : ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r1 = -1, p1 = -1, p2 = 6000, temp, n, a, b, r2 = -1;
cin >> n;
while (n--) {
cin >> temp;
r1 = max(r1, temp);
}
cin >> n;
while (n--) {
cin >> temp;
p1 = max(p1, temp);
}
cin >> n;
while (n--) {
cin >> temp;
p2 = min(p2, temp);
}
cin >> a >> b;
r2 = max(r2, r1 * sqrt((b * p1) / (b * p1 + a * p2)));
printf("%.7lf", r2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, w[10001], k;
double v, al[10001], x[100001], y[100001], t, d, g, p[10001], q[10001];
void sort1(int l, int r) {
int i, j;
double xx, yy;
i = l;
j = r;
xx = x[(i + j) / 2];
while (i <= j) {
while (x[i] < xx) i++;
while (xx < x[j]) j--;
if (i <= j) {
yy = x[i];
x[i] = x[j];
x[j] = yy;
yy = y[i];
y[i] = y[j];
y[j] = yy;
i++;
j--;
}
}
if (i < r) sort1(i, r);
if (l < j) sort1(l, j);
}
void sort2(int l, int r) {
int i, j, zz;
double xx, yy;
i = l;
j = r;
xx = al[(i + j) / 2];
while (i <= j) {
while (al[i] < xx) i++;
while (xx < al[j]) j--;
if (i <= j) {
yy = al[i];
al[i] = al[j];
al[j] = yy;
zz = w[i];
w[i] = w[j];
w[j] = zz;
i++;
j--;
}
}
if (i < r) sort2(i, r);
if (l < j) sort2(l, j);
}
int main() {
cin >> n >> v;
for (i = 0; i < n; i++) cin >> al[i];
cin >> m;
for (i = 1; i <= m; i++) cin >> x[i] >> y[i];
for (i = 0; i < n; i++) w[i] = i;
sort2(0, n - 1);
sort1(1, m);
g = 9.8;
i = 0;
for (j = 1; j <= m; j++) {
while (i < n) {
t = (2 * v * sin(al[i])) / g;
d = v * cos(al[i]) * t;
if (d <= x[j]) {
p[w[i]] = d;
q[w[i]] = 0;
i++;
} else {
t = x[j] / (v * cos(al[i]));
d = v * sin(al[i]) * t - 0.5 * g * t * t;
if (d <= y[j]) {
p[w[i]] = x[j];
q[w[i]] = d;
i++;
} else
goto end;
}
}
end:;
}
k = i;
for (i = k; i < n; i++) {
t = (2 * v * sin(al[i])) / g;
d = v * cos(al[i]) * t;
p[w[i]] = d;
q[w[i]] = 0;
}
for (i = 0; i < n; i++) printf("%.4f %.4f\n", p[i], q[i]);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void ff() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void in_out_txt() {
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
}
long long fp(long x, long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long res = fp(x, y / 2) % 1000000007;
res = (res * res) % 1000000007;
if (y % 2 != 0) res = res * x;
res %= 1000000007;
return res;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool fun1(int a, int r1, int r2, int c1, int c2, int d1, int d2) {
if (a == r1 || a == r2 || a == c1 || a == c2 || a == d1 || a == d2)
return false;
if (a > 9) return false;
return true;
}
bool fun2(int a1, int a2, int a3, int a4) {
if (a1 == a2 || a1 == a3 || a1 == a4 || a2 == a3 || a2 == a4 || a3 == a4)
return false;
return true;
}
int main() {
short n;
set<short> s;
set<short>::iterator v;
cin >> n;
short *x = new short[n];
for (short i = 0; i < n; i++) {
cin >> x[i];
s.insert(x[i]);
}
v = s.begin();
short *y = new short[s.size()];
for (short i = 0; i < s.size(); i++) {
y[i] = *v;
y[i] = count(x, x + n, y[i]);
v++;
}
short *c;
c = max_element(y, y + s.size());
if (n % 2 == 0) {
if (*c <= n / 2)
cout << "YES";
else
cout << "NO";
} else {
if (*c <= (n / 2) + 1)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int n, m;
string c[250];
bool was[250][250];
int cnt;
vector<pair<int, int> > q;
void analyze() {
int mix = 5000, maX = -5000;
int miy = 5000, may = -5000;
for (int i = 0; i < (int)(((int)((q).size()))); ++i) {
pair<int, int> a = q[i];
mix = min(mix, a.first);
maX = max(maX, a.first);
miy = min(miy, a.second);
may = max(may, a.second);
}
int len = maX - mix + 1;
if (len != may - miy + 1 || len == 1) return;
{
if (((int)((q).size())) == (len - 1) * 4) {
bool isGood = true;
for (int i = 0; i < (int)(((int)((q).size()))); ++i) {
pair<int, int> a = q[i];
bool cur = false;
if (a.first == mix || a.first == maX) {
if (a.second >= miy && a.second <= may) cur = true;
}
if (a.second == miy || a.second == may) {
if (a.first >= mix && a.first <= maX) cur = true;
}
if (!cur) isGood = false;
}
if (isGood) {
cnt++;
return;
}
}
}
{
if (len > 2) {
len = (len + 1) / 2;
if (((int)((q).size())) == (len - 1) * 4) {
bool isGood = true;
int d11 = mix - (miy + len - 1);
int d12 = maX - (miy + len - 1);
int d21 = mix + (miy + len - 1);
int d22 = maX + (miy + len - 1);
for (int i = 0; i < (int)(((int)((q).size()))); ++i) {
pair<int, int> a = q[i];
int diff1 = a.first - a.second, diff2 = a.first + a.second;
bool cur = false;
if (diff1 == d11 || diff1 == d12) {
if (diff2 >= d21 && diff2 <= d22) cur = true;
}
if (diff2 == d21 || diff2 == d22) {
if (diff1 >= d11 && diff1 <= d12) cur = true;
}
if (!cur) {
isGood = false;
}
}
if (isGood) {
cnt++;
}
}
}
}
}
void dfs(int x, int y) {
was[x][y] = true;
q.push_back(make_pair(x, y));
for (int nx = x - 1; nx <= x + 1; ++nx)
for (int ny = y - 1; ny <= y + 1; ++ny) {
if (nx >= 0 && ny >= 0 && nx < n && ny < m && !was[nx][ny] &&
c[nx][ny] == '1')
dfs(nx, ny);
}
}
int main() {
int tc;
cin >> tc;
for (int it = 0; it < tc; ++it) {
scanf("%d%d", &n, &m);
getline(cin, c[0]);
for (int i = 0; i < n; ++i) getline(cin, c[i]);
memset(&was, false, sizeof(was));
cnt = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (c[i][j] == '1' && !was[i][j]) {
q.clear();
dfs(i, j);
analyze();
}
printf("%d\n", cnt);
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = 10;
string s[N];
bool ok(ll x, ll y) {
initializer_list<pll> ds = {{1, 0}, {0, 1}, {1, 1}, {1, -1}};
for (auto const &d : ds) {
ll nx = 0, nd = 0;
for (ll k = 0; k < (ll)(5); ++k) {
ll xx = x + k * d.first, yy = y + k * d.second;
if (xx < 0 || xx >= N || yy < 0 || yy >= N) continue;
if (s[xx][yy] == 'X')
++nx;
else if (s[xx][yy] == '.')
++nd;
}
if (nx == 4 && nd == 1) return true;
}
return false;
}
void init() {
for (ll i = 0; i < (ll)(N); ++i) cin >> s[i];
}
void solve() {
for (ll x = 0; x < (ll)(N); ++x)
for (ll y = 0; y < (ll)(N); ++y)
if (ok(x, y)) {
cout << "YES";
return;
}
cout << "NO";
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool possible(long long w, long long m) {
if (m == 1) return true;
if (m % w == 0)
return possible(w, m / w);
else if ((m - 1) % w == 0)
return possible(w, (m - 1) / w);
else if ((m + 1) % w == 0)
return possible(w, (m + 1) / w);
else
return false;
}
int main() {
long long w, m;
cin >> w >> m;
if (w == 2)
cout << "YES\n";
else if (possible(w, m))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, r1, x2, y2, r2;
int main() {
ios_base::sync_with_stdio(0);
cout << (fixed) << setprecision(12);
cin >> x >> y >> r1;
cin >> x2 >> y2 >> r2;
long double dis = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
if (dis >= abs(r1 + r2)) {
cout << 0;
return 0;
} else if (dis <= abs(r1 - r2)) {
cout << min(r1, r2) * min(r1, r2) * acosl(-1);
return 0;
}
long double a = 2 * acosl((dis * dis + r1 * r1 - r2 * r2) / (2 * dis * r1));
long double b = 2 * acosl((dis * dis + r2 * r2 - r1 * r1) / (2 * dis * r2));
cout << (a * r1 * r1 - r1 * r1 * sin(a) + b * r2 * r2 - r2 * r2 * sin(b)) / 2;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000009;
const double eps = 1e-6;
const int mod = 1000000007;
const int mx = 300005;
int f[mx], s[mx], n, w;
int play[mx];
int main() {
scanf("%d%d", &n, &w);
for (int i = 0; i < (n); ++i) scanf("%d %d", f + i, s + i);
set<pair<int, pair<int, int> > > s1, s2;
for (int i = 0; i < (n); ++i) {
s1.insert(make_pair(f[i], make_pair(s[i] - f[i], i)));
s2.insert(make_pair(s[i], make_pair(-1 * f[i], i)));
}
long long ans = 0;
while (w > 0) {
if ((w & 1) || (int)(s1.size()) == 1) {
assert((int)(s1.size()) >= 1);
pair<int, pair<int, int> > cur = *s1.begin();
ans += cur.first;
s1.erase(s1.begin());
int i = cur.second.second;
if (++play[i] == 1) {
s2.erase(make_pair(s[i], make_pair(-1 * f[i], i)));
s1.insert(make_pair(s[i] - f[i], make_pair(oo, i)));
}
--w;
continue;
}
int from = 0;
if ((int)(s1.size()) >= 2 && (int)(s2.size()) > 0) {
pair<int, pair<int, int> > cur1 = *s1.begin();
s1.erase(s1.begin());
pair<int, pair<int, int> > cur2 = *s1.begin();
s1.insert(cur1);
pair<int, pair<int, int> > cur = *s2.begin();
if (cur.first <= cur1.first + cur2.first) {
from = 1;
} else {
from = 0;
};
} else if ((int)(s2.size()) == 0 && (int)(s1.size()) >= 2) {
from = 0;
} else {
from = 1;
}
if (from == 0) {
assert((int)(s1.size()) >= 2);
pair<int, pair<int, int> > cur1 = *s1.begin();
s1.erase(s1.begin());
pair<int, pair<int, int> > cur2 = *s1.begin();
s1.erase(s1.begin());
ans += cur1.first;
ans += cur2.first;
int i = cur1.second.second;
if (++play[i] == 1) {
s2.erase(s2.find(make_pair(s[i], make_pair(-1 * f[i], i))));
s1.insert(make_pair(s[i] - f[i], make_pair(oo, i)));
}
i = cur2.second.second;
if (++play[i] == 1) {
s2.erase(s2.find(make_pair(s[i], make_pair(-1 * f[i], i))));
s1.insert(make_pair(s[i] - f[i], make_pair(oo, i)));
}
} else {
assert((int)(s2.size()) >= 1);
pair<int, pair<int, int> > cur = *s2.begin();
ans += cur.first;
int i = cur.second.second;
play[i] = 2;
s2.erase(s2.begin());
s1.erase(s1.find(make_pair(f[i], make_pair(s[i] - f[i], i))));
}
w -= 2;
}
cout << ans << endl;
for (int i = 0; i < (n); ++i) printf("%d", play[i]);
printf("\n");
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n;
pair<int, int> a[N];
char s[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i].first, a[i].second = i;
sort(a, a + n);
for (int i = 0; i < n; ++i)
for (int j = 0; j <= n; ++j)
s[(i - j + n + 1) % (n + 1)][a[i].second] = '0' + (j < a[i].first);
cout << n + 1 << '\n';
for (int i = 0; i <= n; ++i) cout << s[i] << '\n';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << (2ll << n) - 2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
pair<int, int> a[300010];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + 1 + n, [](pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
});
priority_queue<int, vector<int>, greater<int> > pq;
long long len = 0;
long long res = 0;
for (int i = 1; i <= n; ++i) {
len += a[i].first;
pq.push(a[i].first);
if ((int)pq.size() > k) {
len -= pq.top();
pq.pop();
}
res = max(res, len * a[i].second);
}
printf("%lld\n", res);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int* decimal(int res[], int base, int inputNum) {
int index = 0;
while (inputNum > 0) {
res[index++] = inputNum % base;
inputNum /= base;
}
res[index] = -1;
return res;
}
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);
return gcd(a, b - a);
}
int main() {
int inputNum, base, sum = 0, deno, hcf, i, j;
cin >> inputNum;
deno = inputNum - 2;
int res[100];
for (i = 2; i < inputNum; i++) {
decimal(res, i, inputNum);
j = 0;
while (res[j] != -1) {
sum += res[j];
j++;
}
}
hcf = gcd(sum, deno);
sum /= hcf;
deno /= hcf;
cout << sum << "/" << deno << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<vector<char> > > ans;
int main() {
vector<string> v(7);
for (int i = 1; i <= 6; i++) cin >> v[i];
sort(v.begin(), v.end());
do {
if (v[1].size() < 3 || v[6].size() < 3 || v[2].size() < 3 ||
v[5].size() < 3 || v[4].size() < 5 || v[3].size() < 5)
continue;
if (v[2][0] != v[1][0] || v[2][v[2].size() - 1] != v[4][0] ||
v[1][v[1].size() - 1] != v[3][0] || v[4][v[4].size() - 1] != v[5][0] ||
v[5][v[5].size() - 1] != v[6][v[6].size() - 1] ||
v[3][v[3].size() - 1] != v[6][0] ||
v[3][v[2].size() - 1] != v[4][v[1].size() - 1])
continue;
if (v[1].size() + v[6].size() - 1 != v[4].size() ||
v[2].size() + v[5].size() - 1 != v[3].size())
continue;
char arr[v[3].size()][v[4].size()];
for (int i = 0; i < v[3].size(); i++)
for (int j = 0; j < v[4].size(); j++) arr[i][j] = '.';
for (int i = 0; i < v[1].size(); i++) arr[0][i] = v[1][i];
for (int i = 0; i < v[2].size(); i++) arr[i][0] = v[2][i];
for (int i = 0; i < v[3].size(); i++) arr[i][v[1].size() - 1] = v[3][i];
for (int i = 0; i < v[4].size(); i++) arr[v[2].size() - 1][i] = v[4][i];
for (int i = 0; i < v[5].size(); i++)
arr[i + v[2].size() - 1][v[4].size() - 1] = v[5][i];
for (int i = 0; i < v[6].size(); i++)
arr[v[3].size() - 1][i + v[1].size() - 1] = v[6][i];
vector<vector<char> > temp(v[3].size());
for (int i = 0; i < v[3].size(); i++) {
for (int j = 0; j < v[4].size(); j++) {
temp[i].push_back(arr[i][j]);
}
}
ans.push_back(temp);
} while (next_permutation(v.begin(), v.end()));
sort(ans.begin(), ans.end());
if (!ans.size()) return cout << "Impossible", 0;
for (int i = 0; i < ans[0].size(); i++) {
{
for (int j = 0; j < ans[0][i].size(); j++) cout << ans[0][i][j];
cout << '\n';
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
int in[110][110], re[110][110], ou[110][110];
cin >> m >> n;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> in[i][j];
re[i][j] = 1;
ou[i][j] = 0;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (in[i][j] == 0) {
for (int k = 1; k <= m; k++) re[k][j] = 0;
for (int k = 1; k <= n; k++) re[i][k] = 0;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (re[i][j] == 1) {
for (int k = 1; k <= m; k++) ou[k][j] = 1;
for (int k = 1; k <= n; k++) ou[i][k] = 1;
}
}
}
int flag = 1;
for (int i = 1; i <= m && flag; i++) {
for (int j = 1; j <= n; j++) {
if (in[i][j] != ou[i][j]) {
flag = 0;
break;
}
}
}
if (flag == 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cout << re[i][j] << ' ';
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2018;
int arr[N], f1[N], f2[N];
int dp[N][N];
int tmp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
f1[i] = f1[i - 1] + (arr[i] == 1);
f2[i] = f2[i - 1] + (arr[i] == 2);
}
for (int l = 1; l <= n; l++) {
int p1 = 0, p2 = 0;
for (int r = l; r <= n; r++) {
if (arr[r] == 1) {
p1++;
} else {
if (p1 == p2) p1++;
p2++;
}
dp[l][r] = max(p1, p2);
}
}
int ans = dp[1][n];
for (int l = 1; l <= n; l++) {
ans = max(ans, f1[l] + (f2[n] - f2[l - 1]));
for (int r = l; r <= n; r++) {
ans = max(ans, f1[l - 1] + (f2[n] - f2[r]) + dp[l][r]);
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
template <class T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_heap = priority_queue<T>;
const int mod = 998244353;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct PairHash {
template <typename T1, typename T2>
std::size_t operator()(const pair<T1, T2> &p) const {
return hash<T1>()(p.first) ^ hash<T2>()(p.second);
}
};
string convert(int x, int w) {
string ret;
while (x > 0) {
ret.push_back(x % w + '0');
x /= w;
}
reverse(ret.begin(), ret.end());
return ret;
}
void simple_solve(int ncase) {
int N = 256 * 4;
vector<int> a;
vector<int> z(N + 1);
for (int i = 1;; i++) {
while (i < N && z[i]) i++;
z[i] = 1;
if (i >= N) break;
int j = i + 1;
while (j < N) {
if (z[j]) {
j++;
continue;
}
if (z[i ^ j]) {
j++;
continue;
}
break;
}
if (j >= N) break;
if ((i ^ j) >= N) break;
z[j] = 1;
z[i ^ j] = 1;
printf("%d %d %d\n", i, j, (i ^ j));
a.push_back(i);
a.push_back(j);
a.push_back(i ^ j);
}
}
int col[3][4] = {{0, 1, 2, 3}, {0, 2, 3, 1}, {0, 3, 1, 2}};
long long calc(long long idx, int c, long long total) {
if (total == 4) {
return col[c][idx];
}
return col[c][idx / (total / 4)] * (total / 4) +
calc(idx % (total / 4), c, total / 4);
}
void solve(int ncase) {
long long n;
cin >> n;
if (n < 4) {
cout << n << endl;
return;
}
n--;
long long T = 1;
long long v = 0;
while (n >= T * 3) {
n -= T * 3;
T *= 4;
v++;
}
int c = n % 3;
cout << T * (c + 1) + calc((n - c) / 3, c, T) << endl;
}
void solve_all_cases() {
int T = 1;
cin >> T;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
int main() {
cout << std::fixed;
cout << setprecision(9);
solve_all_cases();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double a, b, c, d;
cin >> a >> b >> c >> d;
double ans = ((a / b) / (1.0 - ((b - a) * (d - c) / (b * d))));
cout << fixed << setprecision(12) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int q, n;
long long int sum, ans;
long long int gcd(long long int a, long long int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long int powe(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a);
}
a = (a * a);
b /= 2;
}
return res;
}
void the_happiest_place_on_earth() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
}
const int N = 300040;
long long int a[N], b[N], p[N], par[N], Size[N], present[N], color[N];
void testcase() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
vector<pair<long long int, long long int>> ans;
vector<long long int> v1, v2;
int cnt = 0;
for (int i = n; i >= 1; --i) {
if (a[i] == 1) {
ans.push_back({i, p[i] = ++cnt});
v1.push_back(i);
} else if (a[i] == 2) {
if (v1.empty()) {
cout << "-1\n";
return;
}
int x = v1.back();
v1.pop_back();
ans.push_back({i, p[i] = p[x]});
v2.push_back(i);
} else if (a[i] == 3) {
int x = -114514;
if (!v2.empty()) {
x = v2.back();
v2.pop_back();
} else if (!v1.empty()) {
x = v1.back();
v1.pop_back();
}
if (x < 0) {
cout << "-1\n";
return;
}
p[i] = ++cnt, ans.push_back({i, cnt}), ans.push_back({x, cnt});
v2.push_back(i);
}
}
cout << ans.size() << "\n";
for (auto it : ans) cout << n - it.second + 1 << " " << it.first << "\n";
return;
}
int main() {
the_happiest_place_on_earth();
the_happiest_place_on_earth();
q = 1;
int t = 0;
while (q--) {
testcase();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) in >> x;
return in;
}
template <typename T>
ostream& operator<<(ostream& in, vector<T>& v) {
for (auto& x : v) in << x << " ";
return in;
}
class solve {
long long n, m, k;
vector<vector<int> > Rail;
vector<int> visited;
int bfs(int type) {
queue<int> Q, times;
Q.push(0);
visited[0] = 1;
times.push(0);
while (!Q.empty()) {
int twn = Q.front();
int tim = times.front();
Q.pop();
times.pop();
for (int i = 0; i < n; i++) {
if (!visited[i] && Rail[twn][i] == type) {
if (i + 1 - n == 0) return tim + 1;
Q.push(i);
visited[i] = 1;
times.push(tim + 1);
}
}
}
return -1;
}
public:
solve() {
cin >> n >> m;
visited.resize(n);
Rail.resize(n, vector<int>(n));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
Rail[u][v]++;
Rail[v][u]++;
}
if (Rail[0][n - 1]) {
cout << bfs(0);
} else
cout << bfs(1);
}
};
int main() {
int t = 1, i = 1;
while (t--) {
if (0) printf("Case #%d: ", i);
new solve;
++i;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<bool> alive(n, true);
vector<int> sz(n);
vector<int> pv(n);
vector<pair<int, int>> ret;
vector<int> all;
vector<int> tin(n);
vector<int> tout(n);
int T = -1;
function<void(int)> Dfs = [&](int v) {
all.push_back(v);
tin[v] = ++T;
sz[v] = 1;
for (int u : g[v]) {
if (alive[u] && u != pv[v]) {
pv[u] = v;
Dfs(u);
sz[v] += sz[u];
}
}
tout[v] = ++T;
};
function<void(int)> Solve = [&](int v) {
all.clear();
pv[v] = -1;
Dfs(v);
int total = sz[v];
while (true) {
bool found = false;
for (int u : g[v]) {
if (alive[u] && pv[u] == v && 2 * sz[u] >= total) {
v = u;
found = true;
break;
}
}
if (!found) {
break;
}
}
alive[v] = false;
set<int> best;
for (int u : g[v]) {
if (alive[u]) {
all.clear();
pv[u] = -1;
Dfs(u);
set<int> cur;
for (int w : g[u]) {
if (alive[w]) {
cur.insert(w);
}
}
if (cur.size() > best.size()) {
best = cur;
}
}
}
all.clear();
pv[v] = -1;
Dfs(v);
for (int u : all) {
if (u != v && pv[u] != v && best.find(u) == best.end()) {
ret.emplace_back(u, v);
}
}
vector<int> children;
for (int u : g[v]) {
if (alive[u]) {
children.push_back(u);
}
}
for (int u : children) {
Solve(u);
}
};
Solve(0);
assert((int)ret.size() <= 10 * n);
cout << ret.size() << '\n';
for (auto& p : ret) {
cout << p.first + 1 << " " << p.second + 1 << '\n';
}
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int ans = 1;
for (int i = 1; i <= n - 1; i++) {
int k = n - i;
int f = a / i, s = b / k;
ans = max(ans, min(f, s));
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> h[100001];
int n, m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie();
int t;
cin >> t;
while (t--) {
int res = 0;
cin >> n >> m;
for (int i = 0; i < n * m; i++) {
cin >> h[i].first;
h[i].second = i;
}
sort(h, h + n * m);
for (int i = 0; i < n; i++) {
for (int j = i * m; j < i * m + m; j++) {
for (int k = j + 1; k < i * m + m; k++) {
if (h[j].second < h[k].second && h[j].first < h[k].first) res++;
}
}
}
cout << res << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int n, m, connComps;
vector<int> Sadj[maxn], Madj[maxn], buildG[maxn], ansKey;
vector<pair<pair<int, int>, bool> > edgList;
int par[maxn];
map<pair<pair<int, int>, bool>, int> getNum;
int getpar(int a) { return (a == par[a] ? a : par[a] = getpar(par[a])); }
bool merge(int a, int b) {
if (getpar(a) == getpar(b)) {
return false;
}
par[getpar(a)] = getpar(b);
return true;
}
void kruskal() {
int curAdded = 0, ind = 0;
while (curAdded < connComps - 1 && ind < edgList.size()) {
int a = edgList[ind].first.first, b = edgList[ind].first.second;
if (edgList[ind].second && merge(a, b)) {
ansKey.push_back(
getNum[pair<pair<int, int>, bool>(pair<int, int>(a, b), true)]);
buildG[a].push_back(b);
buildG[b].push_back(a);
curAdded++;
}
ind++;
}
for (int i = 0; i < n; i++) {
par[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < buildG[i].size(); j++) {
merge(i, buildG[i][j]);
}
}
ind = 0;
while (curAdded < (n - 1) / 2 && ind < edgList.size()) {
int a = edgList[ind].first.first, b = edgList[ind].first.second;
if (edgList[ind].second && merge(a, b)) {
ansKey.push_back(
getNum[pair<pair<int, int>, bool>(pair<int, int>(a, b), true)]);
curAdded++;
}
ind++;
}
if (curAdded < (n - 1) / 2) {
cout << "-1\n";
exit(0);
}
}
void kruskal2() {
int curAdded = 0, ind = 0;
while (curAdded < (n - 1) / 2 && ind < edgList.size()) {
int a = edgList[ind].first.first, b = edgList[ind].first.second;
if ((!edgList[ind].second) && merge(a, b)) {
ansKey.push_back(
getNum[pair<pair<int, int>, bool>(pair<int, int>(a, b), false)]);
curAdded++;
}
ind++;
}
if (curAdded < (n - 1) / 2) {
cout << "-1\n";
exit(0);
}
}
void dfs_vis(vector<int> graph[], int cur) {
for (int i = 0; i < graph[cur].size(); i++) {
int nxt = graph[cur][i];
if (par[nxt] == 0) {
par[nxt] = 1;
dfs_vis(graph, nxt);
}
}
}
int cnt_Conn_Comp(vector<int> graph[]) {
int conn_comp = 0;
memset(par, 0, sizeof(par));
for (int i = 0; i < n; i++) {
if (par[i] == 0) {
conn_comp++;
par[i] = 1;
dfs_vis(graph, i);
}
}
return conn_comp;
}
int main() {
cin >> n >> m;
if (n % 2 == 0) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < m; i++) {
int a, b;
char t;
cin >> a >> b >> t;
a--, b--;
getNum[pair<pair<int, int>, bool>(pair<int, int>(a, b), t == 'S')] =
getNum[pair<pair<int, int>, bool>(pair<int, int>(b, a), t == 'S')] =
i + 1;
edgList.push_back(
pair<pair<int, int>, bool>(pair<int, int>(a, b), t == 'S'));
if (t == 'S') {
Sadj[a].push_back(b);
Sadj[b].push_back(a);
} else {
Madj[a].push_back(b);
Madj[b].push_back(a);
}
}
connComps = cnt_Conn_Comp(Madj);
if (connComps - 1 > (n - 1) / 2) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < n; i++) {
par[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < Madj[i].size(); j++) {
merge(i, Madj[i][j]);
}
}
kruskal();
kruskal2();
cout << ansKey.size() << '\n';
for (int i = 0; i < ansKey.size(); i++) {
if (i != 0) cout << ' ';
cout << ansKey[i];
}
cout << '\n';
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[3][333333], x, y, sum[4][333333], r[4][333333];
set<pair<long long, long long> > s[333333];
map<pair<long long, long long>, long long> d;
map<long long, long long> last[4];
void read(long long &x) { scanf("%lld", &x); }
int main() {
cin >> n;
for (long long i = 1; i <= 2; i++)
for (long long j = 1; j <= n; j++) read(a[i][j]);
for (long long i = 1; i <= 2; i++)
for (long long j = n; j >= 1; j--) {
sum[i][j] = sum[i][j + 1] + a[i][j];
sum[3][j] += sum[i][j];
}
last[1][0] = last[2][0] = last[3][0] = n + 1;
r[1][n + 1] = r[2][n + 1] = r[3][n + 1] = n + 1;
for (long long i = 1; i <= 3; i++)
for (long long j = n; j >= 1; j--) {
r[i][j] = r[i][j + 1];
if (last[i].count(sum[i][j]))
r[i][j] = min(r[i][j], last[i][sum[i][j]] - 1);
last[i][sum[i][j]] = j;
}
s[0].insert(make_pair(0, 0));
d[make_pair(0, 0)] = 0;
for (long long i = 0; i < n; i++) {
for (pair<long long, long long> cur : s[i]) {
x = cur.first;
y = cur.second;
if (x <= y) {
s[min(x + 1, y)].insert(make_pair(x + 1, y));
d[make_pair(x + 1, y)] =
max(d[make_pair(x + 1, y)], d[make_pair(x, y)]);
s[min(r[1][x + 1], y)].insert(make_pair(r[1][x + 1], y));
d[make_pair(r[1][x + 1], y)] =
max(d[make_pair(r[1][x + 1], y)], d[make_pair(x, y)] + 1);
}
if (y <= x) {
s[min(x, y + 1)].insert(make_pair(x, y + 1));
d[make_pair(x, y + 1)] =
max(d[make_pair(x, y + 1)], d[make_pair(x, y)]);
s[min(r[2][y + 1], x)].insert(make_pair(x, r[2][y + 1]));
d[make_pair(x, r[2][y + 1])] =
max(d[make_pair(x, r[2][y + 1])], d[make_pair(x, y)] + 1);
}
if (x == y) {
s[r[3][x + 1]].insert(make_pair(r[3][x + 1], r[3][x + 1]));
d[make_pair(r[3][x + 1], r[3][x + 1])] =
max(d[make_pair(r[3][x + 1], r[3][x + 1])], d[make_pair(x, y)] + 1);
}
d.erase(make_pair(x, y));
}
s[i].clear();
}
cout << d[make_pair(n, n)];
}
| 22 |
#include <iostream>
#include <string>
#include <cstring>
#include <set>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <typeinfo>
#include <iomanip>
#include <cmath>
////// #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<long long> vll;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
#define INF 1000000000
#define mod 1000000007
#define MAXN 100001
int n, k, q;
ll dp[5001][5001];
ll a[50001];
ll arr[5001];
void solve() {
cin >> n >> k >> q;
for (int i = 1; i<=n; ++i) {
cin >>arr[i];
}
for(int j=0; j<=k; ++j){
for (int i = 1; i <= n; ++i)
if (j == 0)
dp[i][0] = 1;
else
dp[i][j] = (dp[i - 1][j - 1] + dp[i + 1][j - 1]) % mod;
}
ll ans = 0;
for(int i=1; i<=n; ++i){
for(int j = 0; j<=k; ++j){
a[i] += dp[i][j] * dp[i][k - j]% mod;
a[i] %= mod;
}
ans = (ans+a[i] * arr[i])% mod;
}
for(int j=0; j<q;++j){
int i,x;
cin >> i >> x;
ans = (ans + (a[i] * x)%mod - (a[i]*arr[i])%mod + mod)%mod;
arr[i] = x;
cout << ans << "\n";
}
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.sync_with_stdio(false);
cout.tie(0);
solve();
return 0;
} | 14 |
#include <bits/stdc++.h>
using namespace std;
set<int> s[201000];
set<int> t;
vector<int> seq[201000];
int ssum[201000];
int main() {
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int n;
scanf("%d", &n);
for (int j = 0; j < n; j++) {
int t;
scanf("%d", &t);
seq[i].push_back(t);
ssum[i] += t;
}
for (int j = 0; j < n; j++) {
int ins = ssum[i] - seq[i][j];
if (t.find(ins) != t.end()) {
for (int new_t = 0; new_t < i; new_t++) {
if (s[new_t].find(ins) != s[new_t].end()) {
for (int new_idx = 0; new_idx < seq[new_t].size(); new_idx++) {
if (ssum[new_t] - seq[new_t][new_idx] == ins) {
printf("YES\n");
printf("%d %d\n", new_t + 1, new_idx + 1);
printf("%d %d\n", i + 1, j + 1);
return 0;
}
}
}
}
}
}
for (int j = 0; j < n; j++) {
int ins = ssum[i] - seq[i][j];
if (s[i].find(ins) == s[i].end()) {
s[i].insert(ins);
t.insert(ins);
}
}
}
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, res = 0;
cin >> n >> d;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = n - 1; i > 0; i--) {
for (int k = i - 1; k >= 0; k--) {
if (a[i] - a[k] <= d) res++;
}
}
cout << 2 * res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string MAX(int x, int y) {
if (x > y)
return "Misha";
else if (x < y)
return "Vasya";
else
return "Tie";
}
int max(int p, int q) {
if (p > q)
return p;
else
return q;
}
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int p = max((3 * a) / 10, a - (a / 250) * c);
int q = max((3 * b) / 10, b - (b / 250) * d);
cout << MAX(p, q);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p[50];
int main() {
cin >> m >> n;
for (int i = 1; i <= n; i++) {
cout << 1 << endl;
fflush(stdout);
cin >> p[i];
if (p[i] == 0) return 0;
if (p[i] == 1)
p[i] = 0;
else
p[i] = 1;
}
int low = 1, high = m, cnt = 1;
while (high >= low) {
int mid = (high + low) / 2;
cout << mid << endl;
fflush(stdout);
int x;
cin >> x;
if (x == 0) return 0;
if (x == -1) {
if (p[cnt])
low = mid + 1;
else
high = mid - 1;
} else {
if (p[cnt])
high = mid - 1;
else
low = mid + 1;
}
cnt++;
if (cnt == n + 1) cnt = 1;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << n + m - 1 << "\n";
for (int i = 1; i <= m; i++) {
cout << "1"
<< " " << i << "\n";
}
for (int i = 2; i <= n; i++) {
cout << i << " "
<< "1"
<< "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[10000001];
priority_queue<int, vector<int>, greater<int> > c;
void pop() {
int m = c.top();
while (!c.empty() && m == c.top()) c.pop(), k--;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
c.push(a[i]);
}
if (k == 0 && c.top() > 1) {
cout << 1;
exit(0);
}
while (1) {
int kq = c.top();
pop();
if (k == 0) {
cout << kq;
break;
}
if (k < 0) {
cout << -1;
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, set<pair<int, string>>> mp;
string a, b;
int n, x;
int main() {
cin >> n;
while (n--) {
cin >> a;
cin >> x;
while (x--) {
cin >> b;
mp[a].insert({b.length(), b});
}
}
cout << mp.size() << endl;
for (auto p : mp) {
string name = p.first;
set<pair<int, string>> s = p.second;
set<string> tmp;
for (auto bb : s) {
string b = bb.second;
int len = bb.first;
for (int i = 1; i <= len; i++) tmp.erase(b.substr(len - i));
tmp.insert(b);
}
int k = tmp.size();
cout << name << " " << k;
for (auto a : tmp) {
cout << " " << a;
}
cout << endl;
}
return 0;
}
| 6 |
Subsets and Splits