solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string solve(string &str) {
string ans;
int len = str.length();
int idx = 0;
for (int i = 25; i >= 0; i--) {
char ch = (char)(i + 'a');
for (int j = idx; j < len; j++) {
if (str[j] == ch) {
ans.push_back(ch);
idx = j + 1;
}
}
}
return ans;
}
int main() {
string str;
cin >> str;
cout << solve(str) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[300002];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
map<long long int, long long int> my;
long long int n, k, i;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> arr[i];
my[0] = 1;
long long int ans = 0;
long long int pp = (1 << k) - 1;
long long int kk = 0;
for (i = n - 1; i >= 0; i--) {
if (my[(kk ^ arr[i])] < my[(kk ^ (pp - arr[i]))]) {
ans += n - i - my[(kk ^ arr[i])];
} else {
arr[i] = pp - arr[i];
ans += n - i - my[(kk ^ arr[i])];
}
kk ^= arr[i];
my[kk]++;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, m;
int pos;
struct event {
int op, x, v, u;
} a[210000];
int v[210000];
vector<int> f[210000];
int cnt;
int b[210000];
int l[210000], r[210000];
int cx[210000];
void dfs(int x, int fa) {
b[++cnt] = x;
cx[x] = cnt;
l[x] = cnt;
for (int i = 0; i < f[x].size(); i++) dfs(f[x][i], x);
r[x] = cnt;
}
long long pow_mod(long long a, long long e) {
long long res = 1;
for (; e; a = a * a % mod, e >>= 1)
if (e & 1) res = res * a % mod;
return res;
}
int sz[210000];
struct node {
long long f, v, sum, lazy;
int l, r;
} tr[1100000];
void update(int k) { tr[k].sum = (tr[k << 1].sum + tr[k << 1 | 1].sum) % mod; }
void pushdown(int k) {
if (tr[k].lazy != 1 && tr[k].l != tr[k].r) {
int p = k << 1;
tr[p].f = tr[p].f * tr[k].lazy % mod;
tr[p].sum = tr[p].sum * tr[k].lazy % mod;
tr[p].lazy = tr[p].lazy * tr[k].lazy % mod;
p = k << 1 | 1;
tr[p].f = tr[p].f * tr[k].lazy % mod;
tr[p].sum = tr[p].sum * tr[k].lazy % mod;
tr[p].lazy = tr[p].lazy * tr[k].lazy % mod;
tr[k].lazy = 1;
}
}
void build(int k, int l, int r) {
tr[k].l = l, tr[k].r = r;
tr[k].lazy = tr[k].f = 1;
if (l == r) {
if (l == 1) tr[k].f = 1, tr[k].v = v[1], tr[k].sum = v[1];
return;
}
int mid = (l + r) / 2;
build(k << 1, l, mid), build(k << 1 | 1, mid + 1, r);
update(k);
}
void change(int k, int a, long long b) {
int l = tr[k].l, r = tr[k].r;
pushdown(k);
if (l == r) {
tr[k].v = b;
tr[k].sum = tr[k].f * b % mod;
return;
}
int mid = (l + r) / 2;
if (a <= mid)
change(k << 1, a, b);
else
change(k << 1 | 1, a, b);
update(k);
}
void change2(int k, int a, int b, long long c) {
int l = tr[k].l, r = tr[k].r;
pushdown(k);
if (l == a && r == b) {
tr[k].f = tr[k].f * c % mod;
tr[k].sum = tr[k].sum * c % mod;
tr[k].lazy = c;
return;
}
int mid = (l + r) / 2;
if (b <= mid)
change2(k << 1, a, b, c);
else if (a > mid)
change2(k << 1 | 1, a, b, c);
else
change2(k << 1, a, mid, c), change2(k << 1 | 1, mid + 1, b, c);
update(k);
}
long long ask(int k, int a) {
int l = tr[k].l, r = tr[k].r;
pushdown(k);
if (l == r) return pow_mod(tr[k].f, mod - 2);
int mid = (l + r) / 2;
long long res;
if (a <= mid)
res = ask(k << 1, a);
else
res = ask(k << 1 | 1, a);
update(k);
return res;
}
long long ask2(int k, int a, int b) {
int l = tr[k].l, r = tr[k].r;
pushdown(k);
if (l == a && r == b) return tr[k].sum;
int mid = (l + r) / 2;
long long res;
if (b <= mid)
res = ask2(k << 1, a, b);
else if (a > mid)
res = ask2(k << 1 | 1, a, b);
else
res = (ask2(k << 1, a, mid) + ask2(k << 1 | 1, mid + 1, b)) % mod;
update(k);
return res;
}
int main() {
pos = 1;
scanf("%d %d", &v[1], &m);
for (int i = 1; i <= m; i++) {
int op;
scanf("%d", &op);
a[i].op = op;
if (op == 1) {
int x;
pos++;
scanf("%d %d", &x, &v[pos]);
f[x].push_back(pos);
a[i].x = x, a[i].u = v[pos];
} else {
int x;
scanf("%d", &x);
a[i].u = x;
}
}
sz[1] = 1;
dfs(1, 0);
build(1, 1, pos);
pos = 1;
for (int i = 1; i <= m; i++) {
if (a[i].op == 1) {
pos++;
change(1, cx[pos], v[pos]);
long long tmp =
(long long)(sz[a[i].x] + 1) * pow_mod(sz[a[i].x], mod - 2) % mod;
sz[a[i].x]++;
sz[pos]++;
change2(1, l[a[i].x], r[a[i].x], tmp);
} else {
long long tmp = ask(1, cx[a[i].u]) * ask2(1, l[a[i].u], r[a[i].u]) % mod;
tmp = tmp * (long long)sz[a[i].u] % mod;
cout << tmp << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m, ans = 0;
cin >> n >> m;
vector<int> v(m);
cin >> v[0];
for (int i = 1; i < m; i++) {
cin >> v[i];
for (int j = 0; j < i; j++) {
if (v[j] < v[i]) {
ans++;
}
}
}
cout << ans << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, d;
cin >> n >> d >> h;
if (d > (2 * h) || (h == d && h == 1 && n > 2) || n < d + 1 || n < h) {
cout << -1 << endl;
} else {
int lowernode = 1;
int upprenode = 2;
int node = 0;
while (node < min(d, h)) {
cout << lowernode << " " << upprenode << endl;
node++;
lowernode++;
upprenode++;
}
lowernode = 1;
while (d > node) {
cout << lowernode << " " << upprenode << endl;
lowernode = upprenode;
upprenode++;
node++;
}
int x;
if (d == h)
x = 2;
else
x = 1;
int s = upprenode;
while (upprenode <= n) {
cout << x << " " << upprenode << endl;
upprenode++;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
string s1[105], s2[105];
char c, c2;
for (long long int i = 0; i < n; i++) {
cin >> s1[i];
}
if (n & 1)
printf("contest\n");
else
printf("home\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
inline bool pan(int x) {
while (x) {
if ((x % 10) != 4 && (x % 10) != 7) return false;
x /= 10;
}
return true;
}
int n;
int d[N + 5];
struct Edge {
int to;
bool f;
};
vector<Edge> V[N + 5];
inline Edge make_edge(const int v, const bool f) {
Edge t;
t.to = v;
t.f = f;
return t;
}
inline void Add_edge(int u, int v, int val) {
V[u].push_back(make_edge(v, pan(val)));
V[v].push_back(make_edge(u, pan(val)));
}
void dfs(int u, int fa) {
d[u] = 1;
for (int i = V[u].size() - 1; i >= 0; i--) {
int v = V[u][i].to;
if (v != fa) {
dfs(v, u);
if (!V[u][i].f) {
d[u] += d[v];
d[v] = 1;
}
}
}
}
int main() {
int u, v, val;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", &u, &v, &val);
Add_edge(u, v, val);
}
dfs(1, -1);
long long ans = 1ll * n * (n - 1) * (n - 2);
for (int i = 1; i <= n; i++)
if (d[i] > 1) {
ans -= 1ll * d[i] * (d[i] - 1) * (d[i] - 2);
ans -= 2ll * d[i] * (d[i] - 1) * (n - d[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline char getch() {
static char buf[10000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long s = 0, f = 1;
char ch = getch();
while (ch < '0' || ch > '9') f = (ch == '-' ? -1 : 1), ch = getch();
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getch();
return s * f;
}
void File() {
freopen(
"filename"
".in",
"r", stdin);
freopen(
"filename"
".out",
"w", stdout);
}
const int MaxN = 2e5 + 5;
int ch[MaxN * 30][2], siz[MaxN * 30];
int rt = 1, tot = 1;
void Insert(int x) {
int p = rt;
for (int i = 30; i >= 0; i--) {
siz[p]++;
int c = (x >> i) & 1;
if (!ch[p][c]) ch[p][c] = ++tot;
p = ch[p][c];
}
siz[p]++;
}
int n, Ans;
void DFS(int x, int sum) {
if (!x) return;
if (ch[x][0] && ch[x][1] && siz[ch[x][0]] == 1 && siz[ch[x][1]] == 1)
Ans = max(Ans, sum + 2);
DFS(ch[x][0], sum + (ch[x][1] != 0));
DFS(ch[x][1], sum + (ch[x][0] != 0));
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read();
Insert(x);
}
DFS(rt, 0);
cout << n - Ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class X>
void print_v(vector<X> A) {
for (auto a : A) cout << a << " ";
cout << "\n";
}
template <class X>
void scan_v(vector<X> &A, int n) {
for (int i = 0; i < n; i++) cin >> A[i];
}
void test() {
long long w, h;
cin >> w >> h;
long long x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long w1, h1;
cin >> w1 >> h1;
long long ans = INT_MAX;
long long shift;
shift = max(0ll, w1 - x1);
if (x2 + shift <= w) ans = min(ans, shift);
shift = max(0ll, w1 - w + x2);
if (x1 - shift >= 0) ans = min(ans, shift);
shift = max(h1 - y1, 0ll);
if (y2 + shift <= h) ans = min(ans, shift);
shift = max(0ll, h1 - h + y2);
if (y1 - shift >= 0) ans = min(ans, shift);
if (ans != INT_MAX)
cout << ans;
else
cout << -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
test();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 55;
int n;
int a[N];
vector<vector<int> > ans;
void ubd(vector<int> v) {
vector<int> vv;
for (int i = 0; i < ((int)(v).size()); ++i) {
if (v[i]) vv.push_back(v[i]);
}
v = vv;
if (((int)(v).size()) == 1) return;
ans.push_back(v);
vector<vector<int> > u;
int s = 1;
for (int i = 0; i < ((int)(v).size()); ++i) {
vector<int> t;
for (int j = s; j < s + v[i]; ++j) t.push_back(a[j]);
u.push_back(t);
s += v[i];
}
reverse((u).begin(), (u).end());
s = 1;
for (int i = 0; i < ((int)(u).size()); ++i) {
for (int j = 0; j < ((int)(u[i]).size()); ++j) a[s++] = u[i][j];
}
}
void solv() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
while (1) {
bool z = true;
for (int i = 1; i < n; ++i) {
if (a[i + 1] != (a[i] % n + 1)) {
z = false;
break;
}
}
if (z) break;
int u;
if (a[1] == 1)
u = n;
else
u = a[1] - 1;
for (int i = 1; i <= n; ++i) {
if (a[i] == u) {
for (int j = i;; --j) {
if (a[j] != (a[j - 1] % n + 1)) {
ubd({j - 1, i - j + 1, n - i});
break;
}
}
break;
}
}
}
for (int i = 1; i <= n; ++i) {
if (a[i] == 1) {
ubd({i - 1, n - i + 1});
break;
}
}
printf("%d\n", ((int)(ans).size()));
for (int i = 0; i < ((int)(ans).size()); ++i) {
printf("%d ", ((int)(ans[i]).size()));
for (int j = 0; j < ((int)(ans[i]).size()); ++j) printf("%d ", ans[i][j]);
printf("\n");
}
}
int main() {
solv();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using i128 = __int128_t;
using u128 = __uint128_t;
const long long MOD = 998244353;
const long double PI = 3.141592653589793238;
const long long pi = 31415926;
const long long inf = 1000000000000000000;
const long long small_inf = INT_MAX;
long long int modpow(long long int x, long long int n,
long long int mod = MOD) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
void init() {}
void solve() {
int n, m;
cin >> n >> m;
std::vector<int> v[2][n + 1];
vector<pair<int, pair<long long int, long long int>>> v1[2 * n + 1];
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[0][x].push_back(y);
v[1][y].push_back(x);
v1[x].push_back(make_pair(y, make_pair(0, 1)));
v1[n + y].push_back(make_pair(n + x, make_pair(0, 1)));
}
for (int i = 1; i <= n; i++) {
v1[i].push_back(make_pair(n + i, make_pair(1, 0)));
v1[n + i].push_back(make_pair(i, make_pair(1, 0)));
}
std::vector<std::vector<long long>> dist(
2, std::vector<long long int>(n + 1, inf));
dist[0][1] = 0;
for (int fu = 0; fu <= 30; fu++) {
int f = fu % 2;
set<pair<long long int, int>> s;
for (int i = 1; i <= n; i++) {
if (dist[f][i] != inf) s.insert(make_pair(dist[f][i], i));
}
std::vector<int> vis(n + 1, 0);
while (!s.empty()) {
pair<long long int, int> p = *s.begin();
s.erase(s.begin());
int x = p.second;
long long int d = p.first;
if (vis[x]) continue;
vis[x] = 1;
for (auto y : v[f][x]) {
if (!vis[y] && d + 1 < dist[f][y]) {
dist[f][y] = d + 1;
s.insert(make_pair(d + 1, y));
}
}
}
for (int i = 1; i <= n; i++) {
dist[f ^ 1][i] = min(dist[f ^ 1][i], dist[f][i] + power(2, fu));
}
}
if (dist[0][n] != inf || dist[1][n] != inf) {
cout << min(dist[0][n], dist[1][n]) % MOD << endl;
return;
}
vector<pair<long long int, long long int>> dis(2 * n + 1,
make_pair(inf, inf));
{
set<pair<pair<long long int, long long int>, int>> s;
dis[1] = make_pair(0, 0);
s.insert(make_pair(dis[1], 1));
std::vector<int> vis(2 * n + 1, 0);
while (!s.empty()) {
pair<pair<long long int, long long int>, int> p = *s.begin();
s.erase(s.begin());
if (vis[p.second]) continue;
vis[p.second] = 1;
int x = p.second;
long long int num = p.first.first, d = p.first.second;
for (auto y : v1[x]) {
if (vis[y.first] || make_pair(num + y.second.first,
d + y.second.second) >= dis[y.first])
continue;
dis[y.first] = make_pair(num + y.second.first, d + y.second.second);
s.insert(make_pair(dis[y.first], y.first));
}
}
}
pair<long long int, long long int> p;
if (dis[n].first < dis[2 * n].first)
p = dis[n];
else if (dis[2 * n].first < dis[n].first)
p = dis[2 * n];
else if (dis[2 * n].second < dis[n].second)
p = dis[2 * n];
else
p = dis[2 * n + 1];
long long int ans = p.second % MOD;
for (int i = 0; i <= p.first - 1; i++) {
ans += modpow(2, i);
ans %= MOD;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t23 = 1, tt23 = 1;
init();
while (tt23 <= t23) {
solve();
tt23++;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int n;
int main() {
string s;
cin >> s;
if (s.size() < 3) {
cout << -1 << endl;
return 0;
}
vector<string> v;
vector<vector<string> > v1(5000);
int w = 1, u = 0, p = 0;
for (int i = 0; i < s.size() - 2; i++) {
for (int j = 0; j < s.size() - i; j++) {
string q;
for (int k = j; k < j + w; k++) {
q += s[k];
string x;
stringstream tok;
tok << k;
tok >> x;
v1[u].push_back(x);
}
v.push_back(q);
u++;
}
w++;
}
for (int i = 0; i < v.size(); i++) {
stringstream tok;
tok << v[i];
tok >> n;
if (n > 1000000) {
v.erase(v.begin() + i);
v1.erase(v1.begin() + i);
i--;
continue;
} else if (v[i][0] == '0' && v[i].size() > 1) {
v.erase(v.begin() + i);
v1.erase(v1.begin() + i);
i--;
}
}
long long int max = -1;
int x;
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v.size(); ++j) {
if (i == j) {
continue;
}
if (v[i].size() + v[j].size() > s.size()) {
continue;
}
x = 0;
for (int z = 0; z < v[i].size(); z++) {
for (int c = 0; c < v[j].size(); c++) {
if (v1[i][z] == v1[j][c]) {
x = 1;
break;
}
}
if (x) break;
}
if (x) {
continue;
}
for (int k = 0; k < v.size(); ++k) {
x = 0;
if (k == j || k == i) {
continue;
}
if (v[i].size() + v[j].size() + v[k].size() > s.size() ||
v[i].size() + v[j].size() + v[k].size() < s.size()) {
continue;
}
for (int z = 0; z < v[i].size(); z++) {
for (int c = 0; c < v[k].size(); c++) {
if (v1[i][z] == v1[k][c]) {
x = 1;
break;
}
}
if (x) {
break;
}
}
if (x) {
continue;
}
for (int z = 0; z < v[j].size(); z++) {
for (int c = 0; c < v[k].size(); c++) {
if (v1[j][z] == v1[k][c]) {
x = 1;
break;
}
}
if (x) break;
}
if (x) {
continue;
}
long long int f, g, h;
stringstream tok;
tok << v[i];
tok >> f;
stringstream tok1;
tok1 << v[j];
tok1 >> g;
stringstream tok2;
tok2 << v[k];
tok2 >> h;
if (f + g + h > max) {
max = f + g + h;
}
}
}
}
cout << max << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const long long INF = LLONG_MAX >> 1;
int N;
long long a[MAXN];
int rt, key[MAXN], ls[MAXN], rs[MAXN], fa[MAXN], Tlen;
long long val[MAXN], suf[MAXN], sum[MAXN], t1[MAXN], t2[MAXN], siz[MAXN];
int newnode(long long v) {
int x = ++Tlen;
key[x] = rand(), siz[x] = 1, val[x] = sum[x] = suf[x] = v;
return x;
}
void pushup(int x) {
sum[x] = sum[ls[x]] + sum[rs[x]] + val[x];
siz[x] = siz[ls[x]] + siz[rs[x]] + 1;
suf[x] = rs[x] ? suf[rs[x]] : val[x];
}
void add1(int x, long long k) {
if (x) val[x] += k, suf[x] += k, sum[x] += k * siz[x], t1[x] += k;
}
void add2(int x, long long k) {
if (x)
val[x] += k * (siz[ls[x]] + 1), suf[x] += k * siz[x],
sum[x] += k * ((siz[x] + 1) * siz[x] / 2), t2[x] += k;
}
void pushdown(int x) {
if (t2[x])
add2(ls[x], t2[x]), add1(rs[x], (siz[ls[x]] + 1) * t2[x]),
add2(rs[x], t2[x]);
if (t1[x]) add1(ls[x], t1[x]), add1(rs[x], t1[x]);
t1[x] = t2[x] = 0;
}
void split(int now, int k, int& x, int& y) {
if (!now) {
x = y = 0;
return;
}
pushdown(now);
if (siz[ls[now]] + 1 <= k)
x = now, split(rs[now], k - (siz[ls[x]] + 1), rs[x], y), fa[rs[x]] = x;
else
y = now, split(ls[now], k, x, ls[y]), fa[ls[y]] = y;
pushup(now);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
pushdown(x), pushdown(y);
if (key[x] < key[y]) {
rs[x] = merge(rs[x], y), fa[rs[x]] = x, pushup(x);
return x;
} else {
ls[y] = merge(x, ls[y]), fa[ls[y]] = y, pushup(y);
return y;
}
}
long long gsuf(int x) {
if (ls[x]) return suf[ls[x]];
int p = x;
while (p && ls[fa[p]] == p) p = fa[p];
return val[fa[p]];
}
long long ans = 0;
void getans(int x) {
pushdown(x);
if (ls[x]) getans(ls[x]);
ans = max(ans, val[x]);
if (rs[x]) getans(rs[x]);
}
void dfs(int x) {
pushdown(x);
if (ls[x]) dfs(ls[x]);
printf("%lld ", val[x]);
if (rs[x]) dfs(rs[x]);
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%lld", &a[i]);
for (int i = 1; i <= N; ++i) {
int p = rt, k = 0, ret = 0, retk = 0, r1 = 0, r2 = 0;
while (p) {
pushdown(p);
if (val[p] >= gsuf(p) + (k + siz[ls[p]] + 1) * a[i]) {
ret = p, k += siz[ls[p]] + 1, retk = k, p = rs[p];
} else
p = ls[p];
}
split(rt, retk, r1, r2);
r2 = merge(newnode(val[ret]), r2);
add1(r2, 1ll * a[i] * retk), add2(r2, a[i]);
rt = merge(r1, r2);
}
getans(rt);
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
const double eps = 0.0000001;
using namespace std;
inline int sgn(double x) { return (x > eps) - (x < -eps); }
static char buf[100000], *pa = buf, *pd = buf;
inline long long read() {
register long long x(0), f(1);
register char c(
pa == pd && (pd = (pa = buf) + fread(buf, 1, 100000, stdin), pa == pd)
? EOF
: *pa++);
while (c > '9' || c < '0')
f = c == '-' ? -1 : 1,
c = pa == pd && (pd = (pa = buf) + fread(buf, 1, 100000, stdin), pa == pd)
? EOF
: *pa++;
while (c >= '0' && c <= '9')
x = x * 10 + c - 48,
c = pa == pd && (pd = (pa = buf) + fread(buf, 1, 100000, stdin), pa == pd)
? EOF
: *pa++;
return f * x;
}
long long c[104][104];
long long ans[104][104];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
int u = -0x3f3f3f3f;
for (int i = 1; i <= 100; ++i) {
ans[1][i] = ans[i][1] = 1;
}
ans[1][1] = 0;
int k = 1;
for (int i = 2; i <= 99; ++i) {
for (int j = i + 1; j <= 100; ++j) {
if (ans[i][j]) continue;
ans[i][j] = ans[j][i] = 1;
n -= (i - 1);
u = max(max(i, j), u);
if (n == 0) break;
for (int k = i + 1; k < j; ++k) {
if (ans[k][j]) continue;
if (n - (k - 1) < 0) break;
ans[k][j] = ans[j][k] = 1;
u = max(u, k);
n -= (k - 1);
if (n == 0) break;
}
if (n == 0) break;
}
if (n == 0) break;
}
cout << u << endl;
for (int i = 1; i <= u; ++i) {
for (int j = 1; j <= u; ++j) cout << ans[i][j];
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, x;
char a, b, c, d;
bool o = 1;
int j = 0;
cin >> s >> x;
if (x.size() != s.size())
cout << "NO";
else {
for (int i = 0; i < s.size(); i++) {
if (x[i] != s[i]) {
if (o) {
o = 0;
a = x[i];
b = s[i];
} else {
c = x[i];
d = s[i];
}
j++;
}
}
if (j != 2)
cout << "NO";
else {
if (a == d && b == c)
cout << "YES";
else
cout << "NO";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans[1500], t, i, j, v[1100];
memset(v, 0, sizeof(v));
for (i = 2; i * i <= 1100; i++) {
if (v[i] == 0) {
for (j = i + i; j <= 1100; j += i) v[j] = 1;
}
}
while (scanf("%d", &n) != EOF) {
if (n == 1)
printf("0\n");
else {
t = 0;
for (j = 2; j <= n; j++) {
if (v[j] == 0) {
for (i = j; i <= n; i *= j) {
ans[t] = i;
t++;
}
}
}
printf("%d\n", t);
for (i = 0; i < t - 1; i++) printf("%d ", ans[i]);
printf("%d\n", ans[t - 1]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, fa[500005], f[500005], cnt, head[500005], num, res[500005],
dep[500005];
long long ans;
struct edge {
int to, nxt, typ;
} e[500005 << 1];
struct node {
int x, y, w;
node() {}
node(int x_, int y_, int w_) { x = x_, y = y_, w = w_; }
} a[500005];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void adde(int x, int y, int typ) {
e[++cnt].to = y;
e[cnt].nxt = head[x];
head[x] = cnt;
e[cnt].typ = typ;
}
void dfs(int u) {
for (int i = head[u]; i; i = e[i].nxt)
if (e[i].to != f[u]) {
int v = e[i].to;
f[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
}
}
int main() {
scanf("%d%d%d", &n, &k, &m);
int x, y, w;
for (int i = (1); i <= (n); i++) fa[i] = i;
for (int i = (1); i <= (k); i++)
scanf("%d%d", &x, &y), adde(x, y, 0), adde(y, x, 0),
fa[getfa(x)] = getfa(y);
for (int i = (1); i <= (m); i++) {
scanf("%d%d%d", &x, &y, &w);
if (getfa(x) != getfa(y))
adde(x, y, 1), adde(y, x, 1), fa[getfa(x)] = getfa(y);
else
a[++num] = node(x, y, w);
}
dfs(1);
for (int i = (1); i <= (n); i++) fa[i] = i;
for (int i = (1); i <= (num); i++) {
x = getfa(a[i].x), y = getfa(a[i].y);
while (x != y)
if (dep[x] > dep[y])
res[x] = a[i].w, fa[x] = getfa(f[x]), x = fa[x];
else
res[y] = a[i].w, fa[y] = getfa(f[y]), y = fa[y];
}
for (int u = (1); u <= (n); u++)
for (int i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].to) == f[u] && !e[i].typ)
if (fa[u] == u)
return puts("-1"), 0;
else
ans += res[u];
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void solve() {
string s;
cin >> s;
int n;
cin >> n;
vector<int> v(n);
string res(n, 'a');
for (int i = 0; i < (n); ++i) {
cin >> v[i];
}
vector<int> alpha(26, 0);
for (auto c : s) {
alpha[c - 'a']++;
}
int j = 25;
vector<int> index;
int c = n;
while (c) {
index.clear();
for (int i = 0; i < (n); ++i) {
if (v[i] == 0) index.push_back(i);
}
for (int i = 0; i < (n); ++i) {
if (v[i] > 0) {
for (auto d : index) {
v[i] -= abs(i - d);
}
}
}
while (alpha[j] < index.size()) {
j--;
}
for (auto d : index) {
res[d] = 'a' + j;
v[d] = -1;
c--;
}
j--;
}
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
int a[N];
int main() {
int n;
scanf("%d", &n);
long long s = 0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]), s += a[i];
if (s == 1) return 0 * printf("%d\n", -1);
vector<long long> p;
for (long long i = 2; i * i <= s; i++) {
if (s % i == 0) p.push_back(i);
while (s % i == 0) s /= i;
}
if (s != 1) p.push_back(s);
long long ans = 1e18;
for (long long d : p) {
long long tmp = 0;
long long rem = 0;
for (int i = 0; i < n; i++) {
if (rem < d / 2 + 1) tmp += rem;
rem += a[i];
rem %= d;
}
rem = 0;
for (int i = n - 1; i >= 0; i--) {
if (rem < d / 2 + 1 - (d % 2 == 0)) tmp += rem;
rem += a[i];
rem %= d;
}
ans = min(ans, tmp);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("-O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long mod = 1e9 + 7;
struct edge {
int u, v;
long long w, c;
int in;
};
bool comp(edge a, edge b) { return a.w < b.w; }
int n;
vector<int> p, rang;
void make_set(int v) {
p[v] = v;
rang[v] = 1;
}
int find_set(int v) {
if (v == p[v]) return v;
return p[v] = find_set(p[v]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rang[a] < rang[b]) swap(a, b);
p[b] = a;
rang[a] += rang[b];
}
}
vector<int> h;
const int logN = 19;
const long long INF = LONG_LONG_MAX;
vector<vector<pair<int, long long> > > g, dp;
void dfs(int v, int p, int height) {
dp[v][0].first = p;
h[v] = height;
for (int j = 0; j < g[v].size(); j++) {
int to = g[v][j].first;
if (to != p) {
dp[to][0].second = g[v][j].second;
dfs(to, v, height + 1);
}
}
}
void preprocess() {
for (int j = 1; j < logN; j++) {
for (int i = 0; i < n; i++) {
dp[i][j].first = dp[dp[i][j - 1].first][j - 1].first;
dp[i][j].second =
max(dp[i][j - 1].second, dp[dp[i][j - 1].first][j - 1].second);
}
}
}
long long max_dissat(int u, int v) {
if (h[u] < h[v]) swap(u, v);
long long max_edge = -INF;
for (int j = logN - 1; j >= 0; j--) {
if (h[dp[u][j].first] >= h[v]) {
max_edge = max(max_edge, dp[u][j].second);
u = dp[u][j].first;
}
}
if (u == v) return max_edge;
for (int j = logN - 1; j >= 0; j--) {
if (dp[u][j].first != dp[v][j].first) {
max_edge = max(max_edge, max(dp[u][j].second, dp[v][j].second));
u = dp[u][j].first;
v = dp[v][j].first;
}
}
max_edge = max(max_edge, max(dp[u][0].second, dp[v][0].second));
return max_edge;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m;
cin >> n >> m;
vector<edge> edges(m);
for (int i = 0; i < m; i++) cin >> edges[i].w;
for (int i = 0; i < m; i++) cin >> edges[i].c;
for (int i = 0; i < m; i++) {
cin >> edges[i].u >> edges[i].v;
edges[i].u--;
edges[i].v--;
edges[i].in = i;
}
sort(edges.begin(), edges.end(), comp);
p.resize(n);
rang.resize(n);
for (int i = 0; i < n; i++) make_set(i);
h.resize(n);
g.resize(n);
dp.resize(n, vector<pair<int, long long> >(logN));
long long sum = 0;
set<pair<int, long long> > min_ost;
for (int i = 0; i < m; i++) {
edge e = edges[i];
int u = e.u, v = e.v;
if (find_set(u) != find_set(v)) {
int in = e.in;
long long w = e.w;
min_ost.insert({in, w});
sum += w;
g[u].push_back({v, w});
g[v].push_back({u, w});
union_set(u, v);
}
}
dfs(0, 0, 1);
preprocess();
long long s;
cin >> s;
long long ans = INF;
int edge_in = 0;
for (int i = 0; i < m; i++) {
edge e = edges[i];
long long max_edge = max_dissat(e.u, e.v);
long long val = sum - max_edge + e.w - s / e.c;
if (val < ans) {
ans = val;
edge_in = i;
}
}
edges[edge_in].w -= s / edges[edge_in].c;
sort(edges.begin(), edges.end(), comp);
min_ost.clear();
ans = 0;
for (int i = 0; i < n; i++) make_set(i);
for (int i = 0; i < m; i++) {
edge e = edges[i];
int u = e.u, v = e.v;
if (find_set(u) != find_set(v)) {
int in = e.in;
long long w = e.w;
min_ost.insert({in, w});
ans += w;
union_set(u, v);
}
}
cout << ans << "\n";
for (auto i = min_ost.begin(); i != min_ost.end(); i++) {
pair<int, long long> x = *i;
cout << x.first + 1 << " " << x.second << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30, N = 17, M = 44000;
int n, m, t, tot = 1;
int a[200005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
long long sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
double b = 2.0 * sum / n;
long long c = b;
if (b - c >= 0.0000001) {
printf("0\n");
continue;
}
long long ans = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (a[i] > (b / 2) + 0.00001) break;
int p = lower_bound(a + 1, a + 1 + n, c - a[i]) - a;
p = max(i + 1, p);
int op = upper_bound(a + 1, a + 1 + n, c - a[i]) - a;
op = max(i + 1, op);
ans += (op - p);
}
printf("%lld\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
const int NMax = 2e3 + 5;
const ll inf_ll = 1e18 + 5;
const int inf_int = 1e9 + 5;
const int mod = 1e9 + 7;
using zint = ll;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) {
return a.second > b.second;
}
return a.first < b.first;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> a(N + 1);
vector<bool> notCoPrime(1e7 + 5, false);
notCoPrime[1] = true;
int idx = -1;
for (int i = 1; i <= N; ++i) {
cin >> a[i];
if (notCoPrime[a[i]]) {
idx = i - 1;
break;
}
int aux = a[i];
for (ll d = 2; d * d <= aux; ++d) {
if (aux % d != 0) {
continue;
}
while (aux % d == 0) {
aux /= d;
}
if (notCoPrime[d]) {
continue;
}
for (ll j = d; j <= 1e7; j += d) {
notCoPrime[j] = true;
}
}
if (aux != 1) {
if (notCoPrime[aux]) {
continue;
}
for (ll j = aux; j <= 1e7; j += aux) {
notCoPrime[j] = true;
}
}
}
if (idx == -1) {
for (int i = 1; i <= N; ++i) {
cout << a[i] << ' ';
}
return 0;
}
for (int i = a[idx + 1] + 1; i <= 1e7; ++i) {
if (notCoPrime[i]) {
continue;
}
a[++idx] = i;
int aux = i;
for (ll d = 2; d * d <= aux; ++d) {
if (aux % d != 0) {
continue;
}
aux /= d;
if (notCoPrime[d]) {
continue;
}
for (ll j = d; j <= 1e7; j += d) {
notCoPrime[j] = true;
}
}
if (aux != 1) {
if (notCoPrime[aux]) {
continue;
}
for (ll j = aux; j <= 1e7; j += aux) {
notCoPrime[j] = true;
}
}
break;
}
if (idx < N) {
for (int i = 2; i <= 1e7; ++i) {
if (notCoPrime[i]) {
continue;
}
a[++idx] = i;
if (idx == N) {
break;
}
for (int j = i; j <= 1e7; j += i) {
notCoPrime[j] = true;
}
}
}
for (int i = 1; i <= N; ++i) {
cout << a[i] << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline void chkmax(T &x, const T2 &y) {
if (x < y) x = y;
}
template <class T, class T2>
inline void chkmin(T &x, const T2 &y) {
if (x > y) x = y;
}
const int MAXN = (1 << 10);
string s;
void read() { cin >> s; }
vector<int> perm;
void solve() {
perm.push_back(1);
perm.push_back(6);
perm.push_back(8);
perm.push_back(9);
do {
int mask = 0, o = 0;
string ret;
for (int i = 0; i < perm.size(); i++) {
o = (o * 10 + perm[i]) % 7;
ret += (char)(perm[i] + '0');
}
for (int i = 0; i < s.size(); i++) {
bool ok = 1;
for (int j = 0; j < perm.size(); j++)
if (!((mask >> j) & 1) && perm[j] == s[i] - '0') {
ok = 0;
mask |= (1 << j);
break;
}
if (ok) {
o = (o * 10 + s[i] - '0') % 7;
ret += s[i];
}
}
if (o == 0) {
cout << ret << '\n';
return;
}
} while (next_permutation(perm.begin(), perm.end()));
cout << 0 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
scanf("%d%d%d", &a, &b, &c);
for (int(i) = (0); (i) < (10000); (i)++)
if (i * a <= c && (c - i * a) % b == 0) {
puts("Yes");
return 0;
}
puts("No");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, i, a[10000], k, l, s = 0, x, t, s1 = 0, r = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
i = 0;
t = 0;
x = n - 1;
while (n > i) {
if (i % 2 == 0)
if (a[t] > a[x]) {
s1 = s1 + a[t];
t++;
i++;
} else {
s1 = s1 + a[x];
x--;
i++;
}
else {
if (a[t] > a[x]) {
s = s + a[t];
t++;
i++;
} else {
s = s + a[x];
x--;
i++;
}
}
}
cout << s1 << " " << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long mul[1000010], inv[1000010];
long long pw(long long a, long long b) {
long long ret = 1;
while (b > 0) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
long long C(int n, int m) {
if (m > n) return 0;
if (m == n) return 1;
if (m == 0) return 1;
if (n < m || n < 0 || m < 0) return 0;
long long t1 = mul[n];
long long t2 = inv[n - m] * inv[m];
return ((t1 % mod) * (t2 % mod)) % mod;
}
long long A(int n, int m) {
if (n < 0 || m < 0) return 0;
if (m > n) return 0;
long long t1 = mul[n];
long long t2 = inv[n - m];
return ((t1 % mod) * (t2 % mod)) % mod;
}
void init() {
mul[0] = 1;
inv[0] = 1;
mul[1] = 1;
inv[1] = 1;
for (int i = 2; i <= 1000000; ++i) {
mul[i] = (mul[i - 1] * i) % mod;
inv[i] = (inv[i - 1] * pw(i, mod - 2)) % mod;
}
}
int main() {
int n, m, a, b;
scanf("%d%d%d%d", &n, &m, &a, &b);
init();
long long ans = 0;
for (int k = 0; k <= n - 2; ++k) {
long long t1 = (A(n - 2, k) * C(m - 1, k)) % mod;
long long t2 = 0;
if (k == n - 2) {
t2 = (pw(m, n - 1 - k - 1)) % mod;
} else {
t2 = ((((k + 2) * pw(n, n - k - 3)) % mod) * pw(m, n - 1 - k - 1)) % mod;
}
ans = (ans + t1 * t2) % mod;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<vector<string>> prices;
vector<string> cur_price;
string cur = "";
for (char c : s) {
if (isalpha(c)) {
if (cur.size() > 0) {
cur_price.push_back(cur);
prices.push_back(cur_price);
}
cur = "";
cur_price.clear();
} else if (c == '.') {
cur_price.push_back(cur);
cur = "";
} else {
cur += c;
}
}
if (cur.size() > 0) {
cur_price.push_back(cur);
prices.push_back(cur_price);
}
uint64_t dollars = 0, cents = 0;
for (auto p : prices) {
uint64_t cur_dollars = 0;
for (int i = 0; i < p.size() - 1; ++i) {
cur_dollars = cur_dollars * 1000 + stoi(p[i]);
}
if (p.size() == 1) {
cur_dollars = stoi(p[0]);
} else if (p[p.size() - 1].size() == 2) {
cents += stoi(p[p.size() - 1]);
} else {
cur_dollars = cur_dollars * 1000 + stoi(p[p.size() - 1]);
}
dollars += cur_dollars;
}
dollars += cents / 100;
cents %= 100;
if (dollars == 0) {
cout << "0." << setfill('0') << setw(2) << cents << endl;
} else {
list<uint64_t> parts;
while (dollars >= 1000) {
parts.push_front(dollars % 1000);
dollars /= 1000;
}
cout << dollars;
for (auto p : parts) cout << "." << setfill('0') << setw(3) << p;
if (cents > 0) {
cout << "." << setfill('0') << setw(2) << cents;
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55, mod = 1e9 + 7;
int n, p, a[N];
long long ans, pw[N], f[N][8];
inline int calc(int x, int y, int z) { return (x << 2) | (y << 1) | z; }
int main() {
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
pw[0] = 1;
for (int i = 1; i <= n; i++) {
pw[i] = pw[i - 1] * 2 % mod;
}
f[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 8; j++) {
int x = (j >> 2) & 1, y = (j >> 1) & 1, z = j & 1;
if (!f[i][j]) {
continue;
}
if (a[i + 1] != 0) {
if (z) {
f[i + 1][calc(x, y, z)] =
(f[i + 1][calc(x, y, z)] + f[i][j] * pw[i - 1] % mod) % mod;
f[i + 1][calc(x ^ 1, 1, z)] =
(f[i + 1][calc(x ^ 1, 1, z)] + f[i][j] * pw[i - 1] % mod) % mod;
} else {
f[i + 1][calc(x ^ 1, 1, z)] =
(f[i + 1][calc(x ^ 1, 1, z)] + pw[i] * f[i][j] % mod) % mod;
}
}
if (a[i + 1] != 1) {
if (y) {
f[i + 1][calc(x, y, z)] =
(f[i + 1][calc(x, y, z)] + f[i][j] * pw[i - 1] % mod) % mod;
f[i + 1][calc(x ^ 1, y, 1)] =
(f[i + 1][calc(x ^ 1, y, 1)] + f[i][j] * pw[i - 1] % mod) % mod;
} else {
f[i + 1][calc(x ^ 1, y, 1)] =
(f[i + 1][calc(x ^ 1, y, 1)] + pw[i] * f[i][j]) % mod;
}
}
}
}
for (int j = 0; j < 4; j++) {
ans = (ans + f[n][(p << 2) | j]) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 62);
const int inf = (1 << 30);
const int nmax = 1e6 + 50;
const long long mod = 1e9 + 7;
using namespace std;
int n, x, i, j, t;
long long f[2][22][2];
int nr(int x, int y) {
int rs = (1 << x);
if (y) rs *= 3;
return n / rs;
}
void ad(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
while ((1 << x) <= n) x++;
x--;
f[1][x][0] = 1;
if ((1 << (x - 1)) * 3 <= n) f[1][x - 1][1] = 1;
for (i = 1; i < n; i++) {
for (j = 0; j <= x; j++) {
for (t = 0; t <= 1; t++) {
ad(f[0][j][t], f[1][j][t] * 1LL * (nr(j, t) - i) % mod);
if (j)
ad(f[0][j - 1][t],
f[1][j][t] * 1LL * (nr(j - 1, t) - nr(j, t)) % mod);
if (t)
ad(f[0][j][t - 1],
f[1][j][t] * 1LL * (nr(j, t - 1) - nr(j, t)) % mod);
}
}
for (j = 0; j <= x; j++) {
for (t = 0; t <= 1; t++) {
f[1][j][t] = f[0][j][t];
f[0][j][t] = 0;
}
}
}
cout << f[1][0][0] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, mx = 0, cnt = 0;
bool valid = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 1; i < n; i++) {
mx = max(mx, arr[i]);
}
if (arr[0] > mx) valid = 0;
while (arr[0] <= mx && valid == 1) {
for (int i = 1; i < n; i++) {
if (arr[i] == mx) {
arr[i] -= 1;
mx--;
arr[0] += 1;
cnt++;
break;
}
}
for (int i = 1; i < n; i++) {
mx = max(mx, arr[i]);
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
uint mod = 1;
struct mint {
uint v;
mint(ll vv = 0) { s(vv % mod + mod); }
mint& s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
mint operator-() const { return mint() - *this; }
mint& operator+=(const mint& rhs) { return s(v + rhs.v); }
mint& operator-=(const mint& rhs) { return s(v + mod - rhs.v); }
mint& operator*=(const mint& rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
mint& operator/=(const mint& rhs) { return *this *= rhs.inv(); }
mint operator+(const mint& rhs) const { return mint(*this) += rhs; }
mint operator-(const mint& rhs) const { return mint(*this) -= rhs; }
mint operator*(const mint& rhs) const { return mint(*this) *= rhs; }
mint operator/(const mint& rhs) const { return mint(*this) /= rhs; }
mint pow(ll n) const {
mint res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
mint inv() const { return pow(mod - 2); }
friend ostream& operator<<(ostream& os, const mint& m) { return os << m.v; }
};
const ll Vmax = (1 << 21) + 10;
mint fact[Vmax], finv[Vmax], inv[Vmax];
void initfact() {
fact[0] = 1;
for (ll i = ll(1); i < ll(Vmax); i++) {
fact[i] = fact[i - 1] * i;
}
finv[Vmax - 1] = fact[Vmax - 1].inv();
for (ll i = Vmax - 2; i >= 0; i--) {
finv[i] = finv[i + 1] * (i + 1);
}
for (ll i = Vmax - 1; i >= 1; i--) {
inv[i] = finv[i] * fact[i - 1];
}
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n, h;
cin >> n >> h;
cin >> mod;
initfact();
chmin(h, 20);
ll s = min(ll(1) << (h - 1), n);
ll sz[2], cnt[2];
sz[0] = n / s;
sz[1] = sz[0] + 1;
cnt[1] = n % s;
cnt[0] = s - cnt[1];
mint ans = 0;
for (ll i = ll(1); i < ll(n); i++) {
ll k = n - i + 1;
mint den = choose(n, k) * k * (k - 1);
mint num = 0;
for (ll first = ll(0); first < ll(2); first++)
for (ll second = ll(0); second < ll(2); second++) {
mint wab = cnt[first] * (cnt[second] - (first == second));
mint sum = 0;
for (ll c = ll(0); c < ll(2); c++)
for (ll d = ll(0); d < ll(2); d++) {
mint x = 0;
ll rem = n;
if (c) rem -= sz[first];
if (d) rem -= sz[second];
if (rem >= k) x = choose(rem, k);
if (c ^ d)
sum -= x;
else
sum += x;
}
num += wab * sum;
}
ans += (mint(1) - num / den) / 2 * i;
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &make_pair) {
int remain = make_pair.size();
os << "{";
for (auto e : make_pair)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
long long t[3];
long long n[3];
long long k;
long long ans[10010];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> k;
for (int i = 0; i < (3); i++) {
cin >> n[i];
}
for (int i = 0; i < (3); i++) {
cin >> t[i];
}
memset(ans, 0, sizeof(ans));
for (int i = 0; i < (3); i++) {
for (int j = 0; j < (k); j++) {
ans[j] = max(ans[j], (j - n[i] < 0) ? 0 : ans[j - n[i]]) + t[i];
}
}
cout << *max_element(ans, ans + k) << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<T> &v) {
for (typename vector<T>::size_type i = 0; i < v.size(); ++i)
out << v[i] << " ";
out << "\n";
return out;
}
template <typename T, typename N>
std::ostream &operator<<(std::ostream &out, vector<pair<T, N> > &v) {
for (size_t i = 0; i < v.size(); ++i)
out << "(" << v[i].first << ", " << v[i].second << ") ";
out << "\n";
return out;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, vector<vector<T> > &v) {
for (size_t i = 0; i < v.size(); ++i) {
for (size_t j = 0; j < v[i].size(); ++j) {
out << v[i][j] << " ";
}
out << "\n";
}
return out;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> concentration(n);
for (int i = 0; i < n; ++i) {
cin >> concentration[i];
}
sort(concentration.rbegin(), concentration.rend());
int factor = 1;
long long penalty = 0;
vector<long long> blocks(m + 1);
for (int i = 0; i < n; ++i) {
penalty += (long long)factor * concentration[i];
if ((i + 1) % m == 0) {
++factor;
}
blocks[i % m] += concentration[i];
}
vector<long long> penalties(n);
penalties[n - 1] = penalty;
for (int i = 0, j = n - 2; i < n - 1; ++i, --j) {
penalty -= blocks[i % m];
blocks[i % m] -= concentration[i];
penalties[j] = penalty;
}
cout << penalties;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n;
scanf("%d", &n);
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
int h = (s[i] - '0');
if (h == 9) {
v.push_back(3);
v.push_back(3);
v.push_back(2);
v.push_back(7);
} else if (h == 8) {
v.push_back(2);
v.push_back(2);
v.push_back(2);
v.push_back(7);
} else if (h == 6) {
v.push_back(3);
v.push_back(5);
} else if (h == 4) {
v.push_back(2);
v.push_back(2);
v.push_back(3);
} else if (h >= 2) {
v.push_back(h);
}
}
sort(v.rbegin(), v.rend());
for (int i = 0; i < v.size(); i++) {
printf("%d", v[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
struct circle {
double x, y, r;
} c[3];
double p2(double x) { return x * x; }
double dis(double x, double y, double xx, double yy) {
return sqrt(p2(x - xx) + p2(y - yy));
}
double f(double x, double y) {
double tmp[3];
for (int i = 0; i < 3; i++) tmp[i] = dis(x, y, c[i].x, c[i].y) / c[i].r;
double ans = 0;
for (int i = 0; i < 3; i++) ans += p2(tmp[i] - tmp[(i + 1) % 3]);
return ans;
}
int main() {
double x = 0, y = 0;
for (int i = 0; i < 3; i++) {
scanf("%lf%lf%lf", &c[i].x, &c[i].y, &c[i].r);
x += c[i].x / 3;
y += c[i].y / 3;
}
double step = 1;
while (step > 1e-6) {
double tmp = f(x, y);
int tag = -1;
for (int i = 0; i < 4; i++) {
double cnt = f(x + dir[i][0] * step, y + dir[i][1] * step);
if (cnt < tmp) {
tmp = cnt;
tag = i;
}
}
if (tag == -1)
step /= 2;
else {
x = x + dir[tag][0] * step;
y = y + dir[tag][1] * step;
}
}
if (f(x, y) < 1e-6) printf("%.5lf %.5lf\n", x, y);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long mod = 1e9 + 7;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, a = 0, b = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x > y)
a++;
else if (x < y)
b++;
}
if (a > b)
cout << "Mishka\n";
else if (a < b)
cout << "Chris\n";
else
cout << "Friendship is magic!^^\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long N;
cin >> N;
N--;
long long g = N / 3;
long long pow = 1;
while (g >= pow) {
g -= pow;
pow <<= 2;
}
long long a = pow + g;
long long trans[4] = {0, 2, 3, 1};
long long b = 0;
for (int i = 0; i < 60; i += 2) {
b += trans[a >> i & 3] * (1LL << i);
}
if (N % 3 == 0) {
cout << a;
} else if (N % 3 == 1) {
cout << b;
} else {
cout << (a ^ b);
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
class item {
private:
int a[4];
public:
item() {}
void read() {
char c;
for (int i = 0; i < 4; i++) {
do {
c = getchar();
} while (!isdigit(c));
a[i] = c - '0';
}
}
void rotate() {
swap(a[0], a[1]);
swap(a[2], a[3]);
swap(a[0], a[3]);
}
bool operator==(item &z) {
bool f;
for (int i = 0; i < 4; i++) {
rotate();
f = true;
for (int j = 0; j < 4; j++) {
if (a[j] != z.a[j]) {
f = false;
break;
}
}
if (f) return true;
}
return false;
}
};
int main() {
int n;
cin >> n;
vector<item> a;
item t;
bool f;
for (int i = 0; i < n; i++) {
t.read();
f = true;
for (int j = 0; j < a.size(); j++)
if (t == a[j]) {
f = false;
break;
}
if (f) a.push_back(t);
}
cout << a.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct BIT {
int n;
vector<T> dat;
BIT(int n = 0) { initialize(n); }
void initialize(int nin) {
n = nin;
dat.resize(n, 0);
}
T sum(int i) {
T s = 0;
while (i >= 0) {
s += dat[i];
i = (i & (i + 1)) - 1;
}
return s;
}
T sum_between(int i, int j) { return sum(j) - sum(i - 1); }
void plus(int i, T x) {
while (i < n) {
dat[i] += x;
i |= i + 1;
}
}
int lower_bound(T x) {
if (x < 0) return -1;
int ret = -1;
int k = 1;
while (2 * k <= n) k <<= 1;
for (; k > 0; k >>= 1) {
if (ret + k < n && dat[ret + k] < x) {
x -= dat[ret + k];
ret += k;
}
}
return ret + 1;
}
};
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N + M), mn(N), mx(N);
for (int i = 0; i < N; i++) A[N - 1 - i] = mn[i] = mx[i] = i;
for (int i = 0; i < M; i++) {
scanf("%d", &A[i + N]);
A[i + N]--;
mn[A[i + N]] = 0;
}
M += N;
vector<vector<int>> pos(N);
for (int i = 0; i < M; i++) pos[A[i]].push_back(i);
vector<pair<int, int>> R2LI(M);
for (int i = 0; i < N; i++) {
int sz = pos[i].size();
for (int j = 0; j < sz - 1; j++) R2LI[pos[i][j + 1]] = {pos[i][j], i};
}
BIT<int> bit(M);
for (int r = N; r < M; r++) {
int l = R2LI[r].first, i = R2LI[r].second;
bit.plus(l, 1);
int res = r - l - bit.sum_between(l, r);
mx[i] = max(mx[i], res);
}
for (int i = 0; i < N; i++) {
int l = pos[i].back(), r = M - 1;
int res = r - l - bit.sum_between(l, r);
mx[i] = max(mx[i], res);
}
for (int i = 0; i < N; i++) printf("%d %d\n", mn[i] + 1, mx[i] + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100005;
int n, m, tot, head[M], Next[M * 2], vet[M * 2], len[M * 2], dt, dfn[M], h[M];
int L, d[M], f[18][M];
long long g[18][M], ans;
set<int> s;
void add(int a, int b, int c) {
Next[++tot] = head[a], vet[tot] = b, len[tot] = c;
head[a] = tot;
}
void dfs(int x, int pre) {
for (int i = head[x]; i; i = Next[i]) {
int y = vet[i], z = len[i];
if (y == pre) continue;
d[y] = d[x] + 1;
f[0][y] = x;
g[0][y] = z;
for (int j = 1; j < L; j++) {
f[j][y] = f[j - 1][f[j - 1][y]];
g[j][y] = g[j - 1][y] + g[j - 1][f[j - 1][y]];
}
dfs(y, x);
}
}
void dfst(int x, int pre) {
dfn[x] = ++dt;
h[dt] = x;
for (int i = head[x]; i; i = Next[i]) {
int y = vet[i];
if (y == pre) continue;
dfst(y, x);
}
}
long long lca(int x, int y) {
long long r = 0;
if (d[x] < d[y]) swap(x, y);
for (int i = L - 1; i >= 0; i--)
if (d[f[i][x]] >= d[y]) r += g[i][x], x = f[i][x];
if (x == y) return r;
for (int i = L - 1; i >= 0; i--)
if (f[i][x] != f[i][y]) r += g[i][x] + g[i][y], x = f[i][x], y = f[i][y];
return r + g[0][x] + g[0][y];
}
int main() {
scanf("%d", &n);
while ((1 << L) < n) L++;
for (int i = 1; i <= n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
add(b, a, c);
}
dfs(1, 0);
dfst(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
char op[3];
scanf("%s", op);
if (op[0] == '+') {
int x;
scanf("%d", &x);
if (s.size()) {
set<int>::iterator ir = s.lower_bound(dfn[x]), il;
if (ir == s.end()) ir = s.begin();
if (ir == s.begin())
il = s.end();
else
il = ir;
--il;
int a = h[*il], b = h[*ir];
ans += lca(x, a) + lca(x, b) - lca(a, b);
}
s.insert(dfn[x]);
} else if (op[0] == '-') {
int x;
scanf("%d", &x);
set<int>::iterator it = s.find(dfn[x]), il, ir;
if (it == s.begin())
il = s.end();
else
il = it;
--il;
ir = it;
++ir;
if (ir == s.end()) ir = s.begin();
int a = h[*il], b = h[*ir];
ans -= lca(x, a) + lca(x, b) - lca(a, b);
s.erase(dfn[x]);
} else
printf("%lld\n", ans / 2);
}
return 0;
}
| 11 |
#include<bits/stdc++.h>
using namespace std;
void solve(void){
int n,k;
cin >> n >> k;
while(k > 3) cout << "1 ",k--,n--;
if(n % 2) cout << "1 " << (n - 1) / 2 << " " << (n - 1) / 2;
else if(n % 4) cout << "2 " << (n - 2) / 2 << " " << (n - 2) / 2;
else cout << n / 2 << " " << n / 4 << " " << n / 4;
cout << "\n";
}
int main(void){
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--) solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int main() {
int n, a, b;
cin >> n >> a >> b;
a--;
b--;
scanf("%s", s);
if (s[a] == s[b])
cout << 0 << endl;
else
cout << 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 10;
const int MOD = 1000 * 1000 * 1000 + 7;
const int POD = 983;
vector<int> Graf[N];
long long SubtreeHash[N];
long long Pot[N];
int Size[N];
map<long long, int> Rozne;
int diff;
pair<int, int> result;
void Wczytaj(int &n) {
int i, v, u;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &v, &u);
Graf[v].push_back(u);
Graf[u].push_back(v);
}
Pot[0] = 1;
for (i = 1; i < N; i++) Pot[i] = (Pot[i - 1] * POD) % MOD;
}
long long DFSInicjuj(int v, int ojciec) {
int i, suma;
long long aktualny_hasz;
vector<pair<long long, pair<int, int> > > Hasze;
Size[v] = 1;
Hasze.push_back(make_pair((long long)'(', make_pair(1, -1)));
for (i = 0; i < Graf[v].size(); i++) {
if (Graf[v][i] != ojciec) {
SubtreeHash[Graf[v][i]] = DFSInicjuj(Graf[v][i], v);
Hasze.push_back(make_pair(SubtreeHash[Graf[v][i]],
make_pair(2 * Size[Graf[v][i]], Graf[v][i])));
Size[v] += Size[Graf[v][i]];
}
}
Hasze.push_back(make_pair((long long)')', make_pair(1, -1)));
sort(Hasze.begin() + 1, Hasze.end() - 1);
aktualny_hasz = 0;
suma = 0;
for (i = 0; i < Hasze.size(); i++) {
aktualny_hasz = (aktualny_hasz + Pot[suma] * Hasze[i].first) % MOD;
suma += Hasze[i].second.first;
}
return aktualny_hasz;
}
void Update(int v, long long nowy, long long stary) {
Rozne[stary]--;
if (Rozne[stary] == 0) diff--;
Rozne[nowy]++;
if (Rozne[nowy] == 1) diff++;
result = max(result, make_pair(diff, v));
}
void DFSPopraw(int v, int ojciec, long long upper_hash, int n) {
int i, suma;
long long aktualny_hasz, new_upper;
vector<int> Suma_Pref;
vector<long long> DiffHasze, Hasze_Pref;
vector<pair<long long, pair<int, int> > > Hasze;
Hasze.push_back(make_pair((long long)'(', make_pair(1, -1)));
for (i = 0; i < Graf[v].size(); i++) {
if (Graf[v][i] != ojciec) {
Hasze.push_back(make_pair(SubtreeHash[Graf[v][i]],
make_pair(2 * Size[Graf[v][i]], Graf[v][i])));
DiffHasze.push_back(SubtreeHash[Graf[v][i]]);
}
}
if (upper_hash != -1) {
DiffHasze.push_back(upper_hash);
Hasze.push_back(
make_pair(upper_hash, make_pair(2 * (n - Size[v]), ojciec)));
}
Hasze.push_back(make_pair((long long)')', make_pair(1, -1)));
sort(Hasze.begin() + 1, Hasze.end() - 1);
Hasze_Pref.push_back(0);
Suma_Pref.push_back(0);
suma = 0;
for (i = 0; i < Hasze.size(); i++) {
Hasze_Pref.push_back((Hasze_Pref.back() + Pot[suma] * Hasze[i].first) %
MOD);
suma += Hasze[i].second.first;
Suma_Pref.push_back(suma);
}
aktualny_hasz = Hasze.back().first;
for (i = Hasze.size() - 2; i >= 1; i--) {
new_upper = (Hasze_Pref[i] + Pot[Suma_Pref[i]] * aktualny_hasz) % MOD;
if (Hasze[i].second.second != ojciec) {
Update(Hasze[i].second.second, new_upper,
SubtreeHash[Hasze[i].second.second]);
DFSPopraw(Hasze[i].second.second, v, new_upper, n);
Update(v, SubtreeHash[Hasze[i].second.second], new_upper);
}
aktualny_hasz =
(aktualny_hasz * Pot[Hasze[i].second.first] + Hasze[i].first) % MOD;
}
}
int main() {
int n, i;
Wczytaj(n);
SubtreeHash[1] = DFSInicjuj(1, 1);
for (i = 2; i <= n; i++) {
Rozne[SubtreeHash[i]]++;
if (Rozne[SubtreeHash[i]] == 1) diff++;
}
result = make_pair(diff, 1);
DFSPopraw(1, 1, -1, n);
printf("%d\n", result.second);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long var, a, b, c, la, lb, lc, l, rele, x;
long long min(long long x, long long y) {
if (x < y) return x;
return y;
}
int main() {
cin >> a >> b >> c >> l;
var = (l + 1) * (l + 2) * (l + 3) / 6;
for (la = 0; la <= l; la++) {
x = min(l - la, a - b - c + la);
if (x >= 0) rele += (x + 1) * (x + 2) / 2;
}
for (lb = 0; lb <= l; lb++) {
x = min(l - lb, b - a - c + lb);
if (x >= 0) rele += (x + 1) * (x + 2) / 2;
}
for (lc = 0; lc <= l; lc++) {
x = min(l - lc, c - b - a + lc);
if (x >= 0) rele += (x + 1) * (x + 2) / 2;
}
cout << (var - rele);
}
| 6 |
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int mod = read();
long long l, r, k;
bool judge(long long x) { return r / x - (l - 1) / x >= k; }
struct juzhen {
long long m[3][3];
void clearit() {
memset(m, 0, sizeof m);
m[1][1] = m[2][2] = 1;
}
void clear() { memset(m, 0, sizeof m); }
juzhen operator*(const juzhen &b) const {
int i, j, k;
juzhen ans;
ans.clear();
for (i = 1; i < 3; ++i) {
for (j = 1; j < 3; ++j) {
for (k = 1; k < 3; ++k) {
ans.m[i][j] = (ans.m[i][j] + m[i][k] * b.m[k][j]) % mod;
}
}
}
return ans;
}
};
juzhen operator^(juzhen a, long long b) {
juzhen c;
c.clearit();
for (; b; b >>= 1, a = a * a)
if (b & 1) c = c * a;
return c;
}
int main() {
read(l), read(r), read(k);
long long ans = 0;
for (long long i = 1; i * i <= r; ++i) {
if (judge(i)) ans = max(ans, i);
if (judge(r / i)) ans = max(ans, r / i);
}
juzhen tmp;
tmp.clear();
tmp.m[1][1] = tmp.m[1][2] = tmp.m[2][1] = 1;
tmp = tmp ^ ans - 1;
write((tmp.m[1][1] + mod) % mod);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, p, x;
int main() {
cin >> n >> k >> p;
while (p--) {
cin >> x;
if (k == 0) {
cout << '.';
continue;
}
if (n % 2 == 0) {
if (x % 2 == 0 && k >= (n - x + 2) / 2)
cout << "X";
else if (x % 2 == 1 && k >= n / 2 + (n - x + 1) / 2)
cout << "X";
else
cout << ".";
}
if (n % 2 == 1) {
if (x == n) {
cout << "X";
continue;
}
n--;
k--;
if (x % 2 == 0 && k >= (n - x + 2) / 2)
cout << "X";
else if (x % 2 == 1 && k >= n / 2 + (n - x + 1) / 2)
cout << "X";
else
cout << ".";
n++;
k++;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
long long l = 1, r = n;
long long diff = n - 1;
long long L = 1, R = n;
while (l <= r) {
if (l * r > n) {
--r;
} else if (l * r < n) {
++l;
} else if (l * r == n) {
if (abs(l - r) < diff) diff = abs(l - r), L = l, R = r;
--l, --r;
}
}
cout << L << " " << R;
cout << "\n";
;
}
}
| 0 |
#include <bits/stdc++.h>
long long int binpow(long long int a, long long int b, long long int m) {
long long int res = 1;
for (b %= m - 1, a %= m; b > 0; b >>= 1, a = a * a % m)
if (b & 1) res = res * a % m;
return res;
}
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
using namespace std;
const long long int mx = 5e6 + 5;
signed main() {
long long int n;
cin >> n;
vector<long long int> deg(n + 1);
long long int ans = n;
for (long long int i = (1); i < (n); i++) {
long long int u, v;
cin >> u >> v;
deg[u]++;
deg[v]++;
ans = (((ans * deg[u]) % 998244353) * deg[v]) % 998244353;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long int x, y;
point() {}
point(long long int _x, long long int _y) {
x = _x;
y = _y;
}
};
bool cmp(const point &a, const point &b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
struct freq {
long long int x_freq;
set<long long int> y_freq;
};
freq freq_list[200005];
point S[200010];
long long int mod;
long long int fact_mod(long long int k) {
long long int ans = 1;
while (k > 0) {
ans = (ans % mod * k % mod) % mod;
--k;
}
return ans % mod;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
S[i] = point(x, i);
}
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
S[N + i] = point(x, i);
}
cin >> mod;
sort(S, S + 2 * N, cmp);
int last = -1, cnt = -1, m;
for (int i = 0; i < 2 * N; ++i) {
if (S[i].x != last) {
++cnt;
last = S[i].x;
freq_list[cnt].x_freq = 1;
freq_list[cnt].y_freq.insert(S[i].y);
} else {
++freq_list[cnt].x_freq;
freq_list[cnt].y_freq.insert(S[i].y);
}
}
long long int ans = 1, n;
for (int i = 0; i <= cnt; ++i) {
m = freq_list[i].x_freq - freq_list[i].y_freq.size();
n = freq_list[i].x_freq;
int k = n;
for (int j = 0; j < m; ++j) {
ans = ((ans % mod) * ((n * (n - 1) / 2LL) % mod)) % mod;
n -= 2;
}
ans = ((ans % mod) * (fact_mod(k - 2 * m) % mod)) % mod;
}
cout << ans % mod << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int md = 1e9 + 7;
const long long inf = 2e18;
const int OO = 1;
const int OOO = 1;
using namespace std;
int d, m;
void solve() {
cin >> d >> m;
vector<long long> a;
int lo = 1, hi = 2;
while (lo <= d) {
a.push_back(min(d + 1, hi) - lo);
lo *= 2, hi *= 2;
}
long long ans = 1;
for (auto &i : a) ans = (ans * (1 + i)) % m;
ans = (ans - 1 + m) % m;
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 25;
int n;
set<int> s;
void solve(int d1, int d2, long long x, int k, int len) {
if (x > n) return;
if (k == len) {
if (x <= n) {
s.insert(x);
}
return;
}
solve(d1, d2, 10 * x + d1, k + 1, len);
solve(d1, d2, 10 * x + d2, k + 1, len);
}
int main(int argc, char *argv[]) {
cin >> n;
if (n < 100) {
cout << n << endl;
return 0;
}
for (int len = (3), _b = (11); len < (_b); ++len) {
for (int i = (1), _b = (10); i < (_b); ++i)
for (int j = (0), _b = (10); j < (_b); ++j) {
if (j == i) continue;
int x = (i * 10 + j);
solve(i, j, x, 0, len - 2);
}
for (int i = (1), _b = (10); i < (_b); ++i) {
int x = i * 10 + i;
for (int j = (0), _b = (10); j < (_b); ++j)
if (j != i) solve(i, j, x, 0, len - 2);
}
}
cout << s.size() + 99 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int aa[15], a[15], bb[15];
void work(int dep, int r, int &xx, int &yy, int fx, int fy) {
if (r == 0) return;
if (r && r % a[dep - 1] == 0) {
int x = r / a[dep - 1];
if (x == 1) yy += aa[dep - 1] * fy;
if (x == 2) xx += aa[dep - 1] * fx, yy += aa[dep - 1] * fy;
if (x == 3) xx += (2 * aa[dep - 1] - 1) * fx, yy += (aa[dep - 1] - 1) * fy;
return;
}
if (r < a[dep - 1]) {
work(dep - 1, r, yy, xx, fy, fx);
return;
}
if (r > 3 * a[dep - 1]) {
xx += (2 * aa[dep - 1] - 1) * fx;
yy += (aa[dep - 1] - 1) * fy;
work(dep - 1, r % a[dep - 1], yy, xx, -fy, -fx);
return;
}
if (r > 2 * a[dep - 1]) xx += aa[dep - 1] * fx;
yy += aa[dep - 1] * fy;
work(dep - 1, r % a[dep - 1], xx, yy, fx, fy);
}
int main() {
int A, B;
cin >> A >> B;
aa[0] = a[0] = 1;
for (int i = 1; i <= A; i++)
aa[i] = aa[i - 1] * 2, a[i] = a[i - 1] * 4, bb[i] = a[i] - 1;
int xx = 0, yy = 0;
work(A, B, xx, yy, 1, 1);
cout << xx << ' ' << yy << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long k;
cin >> k;
if (k < 10) {
cout << k << endl;
return 0;
}
k -= 9;
long long div1 = 10;
long long div2 = 100;
long long indice = 2;
while (k > (div2 - div1) * indice) {
k -= ((div2 - div1) * indice);
div2 *= 10;
div1 *= 10;
indice++;
}
long long temp = k / indice;
k -= (temp * indice);
div1 += (temp - 1);
div1++;
div2 = 10;
while (div2 <= div1) {
div2 *= 10;
}
div2 /= 10;
if (k == 0) {
div1--;
cout << div1 % 10 << endl;
} else {
k--;
while (k > 0) {
div2 /= 10;
k--;
}
cout << ((div1 / div2) % 10) << endl;
}
return 0;
}
| 5 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mxn = 100001;
int n, m, k;
int d[mxn], f[mxn], dp[mxn], p[mxn];
vector<int> g[mxn], a[mxn], v[mxn];
void dfs(int c){
m = max(m, d[c]);
a[d[c]].push_back(c);
for(int i : g[c]) d[i] = d[c] + 1, dfs(i);
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for(int i = 1; i < n; i++){
int x;
cin >> x;
g[--x].push_back(i);
}
dfs(0);
m++;
for(int i = 0; i < m; i++) v[a[i].size()].push_back(i);
memset(dp, -1, sizeof(dp));
dp[0] = -2;
for(int i = 0; i <= n; i++) if(!v[i].empty())
for(int j = n; ~j; j--) if(~dp[j])
for(int l = 0; l < v[i].size() && !~dp[j + (l + 1) * i]; l++){
dp[j + (l + 1) * i] = v[i][l];
}
if(~dp[k]){
cout << m << endl;
for(int i = k; i; i -= a[dp[i]].size())
for(int j : a[dp[i]]){
f[j] = 1;
}
}else{
cout << (m + 1) << endl;
int w = 0, x = 0, y = k, z = n - k;
for(int i = 0, j = 1; i < m; i++, x += j){
if(a[i].size() > max(y, z)){
j = 0;
continue;
}
for(int l : a[i]) f[l] = (y > z);
(y > z ? y : z) -= a[i].size();
}
for(int i : a[x]){
if(!g[i].empty()) f[i] = (y > z), w++;
}
(y > z ? y : z) -= w;
for(int i : a[x]){
if(g[i].empty()) f[i] = y > z, (y > z ? y : z)--;
}
}
for(int i = 0; i < n; i++) cout << (f[i] ? 'a' : 'b');
return 0;
} | 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, i;
cin >> n >> m >> k;
int a[n];
int res = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
if (m > 0)
m--;
else
res++;
} else {
if (k > 0)
k--;
else if (m > 0)
m--;
else
res++;
}
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e6;
struct st {
int n;
vector<int> t;
st(int sz) {
n = sz;
t.resize(2 * n);
for (int& x : t) x = INF;
}
void upd(int pos, int val) {
for (t[pos += n] = val; pos > 1; pos >>= 1)
t[pos >> 1] = min(t[pos], t[pos ^ 1]);
}
int qry(int l, int r) {
int ans = INF;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans = min(ans, t[l++]);
if (r & 1) ans = min(ans, t[--r]);
}
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, mxd, len;
cin >> n >> mxd >> len;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
map<int, int> cnt;
int g[n];
int l = 0, r = 0, mn, mx;
while (r < n) {
cnt[a[r]]++;
mn = cnt.begin()->first;
mx = (--cnt.end())->first;
while (mx - mn > mxd) {
if (--cnt[a[l]] == 0) {
cnt.erase(a[l]);
if (a[l] == mn)
mn = cnt.begin()->first;
else if (a[l] == mx)
mx = (--cnt.end())->first;
}
l++;
}
g[r] = r - l + 1;
r++;
}
st rmq(n);
int dp[n];
for (int i = 0; i < n; i++) {
l = i - g[i];
r = i - len;
if (l <= r) {
if (l == -1)
dp[i] = 1;
else
dp[i] = rmq.qry(l, r + 1) + 1;
} else
dp[i] = INF;
rmq.upd(i, dp[i]);
}
if (dp[n - 1] > n)
cout << -1;
else
cout << dp[n - 1];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const long long MOD = 1111998244353;
const int MAXN = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const long long ll_INF = 9223372036854775807;
long long qm(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
double a[MAXN];
int a_integer[MAXN];
int b[MAXN];
int n;
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
a_integer[i] = (int)a[i];
sum += a_integer[i];
}
if (sum == 0) {
for (int i = 1; i <= n; i++) {
printf("%d\n", a_integer[i]);
}
} else if (sum > 0) {
for (int i = 1; i <= n; i++) {
if (a[i] != a_integer[i] && a[i] < 0 && sum > 0) {
printf("%d\n", a_integer[i] - 1);
sum--;
} else {
printf("%d\n", a_integer[i]);
}
}
} else if (sum < 0) {
for (int i = 1; i <= n; i++) {
if (a[i] != a_integer[i] && a[i] > 0 && sum < 0) {
printf("%d\n", a_integer[i] + 1);
sum++;
} else
printf("%d\n", a_integer[i]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
void read(int &x) {
char c = x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
}
inline void add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
struct BIT {
int bi[N] =
{
0,
},
bt[N] =
{
0,
},
n = 1e5;
inline int low(int x) { return x & -x; }
void upd(int x, int v) {
int w = 1LL * x * v % MOD;
for (; x <= N; x += low(x)) {
add(bi[x], v);
add(bt[x], w);
}
}
int que(int x) {
int v = 0, w = 0;
for (int i = x; i; i ^= low(i)) {
add(v, bi[i]);
add(w, bt[i]);
}
return (1LL * v * (x + 1) - w + MOD) % MOD;
}
} f, w;
void cmax(int &x, int y) {
if (x < y) x = y;
}
inline int fpow(int x, int p) {
int rs = 1;
while (p) {
if (p & 1) rs = 1LL * rs * x % MOD;
x = 1LL * x * x % MOD;
p >>= 1;
}
return rs;
}
int siz[N], mx[N], p[N], l[N], r[N];
vector<int> g[N];
bool vis[N];
int rt, n, tot, L, R, ans;
void getroot(int u, int fa) {
int m = tot - 1;
siz[u] = 1;
mx[u] = 0;
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
getroot(v, u);
siz[u] += siz[v];
m -= siz[v];
cmax(mx[u], siz[v]);
}
cmax(mx[u], m);
if (rt == -1 || mx[u] < mx[rt]) rt = u;
}
void getsiz(int u, int fa) {
siz[u] = 1;
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
getsiz(v, u);
siz[u] += siz[v];
}
}
void ins(int u, int fa, int d) {
int ff = 1LL * d * p[u] % MOD, ww = p[u];
f.upd(l[u], ff);
f.upd(r[u] + 1, (MOD - ff) % MOD);
w.upd(l[u], ww);
w.upd(r[u] + 1, (MOD - ww) % MOD);
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
ins(v, u, d + 1);
}
}
inline int cnt(int u, int fa, int d) {
int ff = f.que(r[u]);
add(ff, MOD - f.que(l[u] - 1));
int ww = w.que(r[u]);
add(ww, MOD - w.que(l[u] - 1));
int rs = (1LL * ff * p[u] + 1LL * ww * p[u] % MOD * d) % MOD;
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
add(rs, cnt(v, u, d + 1));
}
return rs;
}
void del(int u, int fa, int d) {
int ff = 1LL * d * p[u] % MOD, ww = p[u];
f.upd(l[u], MOD - ff);
f.upd(r[u] + 1, ff);
w.upd(l[u], MOD - ww);
w.upd(r[u] + 1, ww);
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
tot = siz[v];
del(v, u, d + 1);
}
}
void divide(int u) {
if (tot == 1) return;
rt = -1;
getroot(u, u);
u = rt;
vis[u] = true;
w.upd(l[u], p[u]);
w.upd(r[u] + 1, MOD - p[u]);
for (int v : g[u]) {
if (vis[v]) continue;
add(ans, cnt(v, u, 1));
ins(v, u, 1);
}
del(u, u, 0);
getsiz(u, u);
for (int v : g[u]) {
if (vis[v]) continue;
tot = siz[v];
divide(v);
}
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(l[i]);
read(r[i]);
p[i] = fpow(r[i] - l[i] + 1, MOD - 2);
}
for (int i = 2; i <= n; i++) {
int u, v;
read(u);
read(v);
g[u].push_back(v);
g[v].push_back(u);
}
tot = n;
divide(1);
for (int i = 1; i <= n; i++) ans = 1LL * ans * (r[i] - l[i] + 1) % MOD;
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int aa[1005][1005], bb[1005][1005], n, a[1005], b[1005];
int main() {
int ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
if (i == j)
aa[i][j] = a[i];
else
aa[i][j] = a[j] | aa[i][j - 1];
}
}
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
if (i == j)
bb[i][j] = b[i];
else
bb[i][j] = b[j] | bb[i][j - 1];
}
}
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) ans = max(ans, aa[i][j] + bb[i][j]);
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> v;
int main() {
scanf("%lld", &n);
scanf("%lld", &k);
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
v.push_back(i);
if (i != n / i) v.push_back(n / i);
}
}
sort(v.begin(), v.end());
if (v.size() < k)
printf("-1\n");
else
printf("%lld\n", v[k - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t-- > 0) {
long long n, m;
cin >> n >> m;
set<long long> se;
for (long long i = 1; i <= (3 * n); i++) {
se.insert(i);
}
vector<long long> v;
for (long long i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
if (se.find(x) != se.end() && se.find(y) != se.end()) {
se.erase(x);
se.erase(y);
v.push_back(i);
}
}
if (v.size() >= n) {
cout << "Matching"
<< "\n";
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << "\n";
} else {
cout << "IndSet"
<< "\n";
long long cnt = 0;
for (auto x : se) {
if (cnt == n) break;
cout << x << " ";
cnt += 1;
}
cout << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
const int N = 100010;
int n;
int head[N], to[2 * N], next[2 * N], graphmr;
double ans;
inline void add(int x, int y) {
int p = graphmr++;
to[p] = y;
next[p] = head[x];
head[x] = p;
}
inline void dfs(int x, int fa, int dis) {
ans += 1.0 / dis;
for (int i = head[x]; ~i; i = next[i])
if (to[i] != fa) dfs(to[i], x, dis + 1);
}
int main() {
scanf("%d", &n);
memset(head, -1, sizeof head);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0, 1);
printf("%lf\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, s, f;
cin >> n >> m >> s >> f;
map<long long int, pair<long long int, long long int> > hash;
int i;
long long int mx = INT_MIN;
for (i = 0; i < m; i++) {
long long int x, y, z;
cin >> x >> y >> z;
hash[x] = {y, z};
}
int step = 1;
while (s != f) {
if (hash.find(step) != hash.end()) {
long long int l = hash[step].first;
long long int r = hash[step].second;
if (s >= l && s <= r) {
cout << "X";
} else {
if (f > s && !(s + 1 >= l && s + 1 <= r)) {
cout << "R";
s++;
} else if (f < s && !(s - 1 >= l && s - 1 <= r)) {
cout << "L";
s--;
} else {
cout << "X";
}
}
} else {
if (f > s) {
cout << "R";
s++;
} else if (f < s) {
cout << "L";
s--;
}
}
step++;
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100005];
int cur[100005];
int main() {
int n, m;
cin >> n >> m;
int num = 1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
cnt[x]++;
cur[cnt[x]]++;
if (cur[num] == n) {
cout << 1;
num++;
} else
cout << 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int q;
long long a, b, c, n;
int main() {
cin >> q;
while (q--) {
cin >> a >> b >> c >> n;
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
n -= (c - b);
n -= (c - a);
if (n < 0 || n % 3) {
cout << "NO\n";
continue;
}
cout << "YES\n";
}
}
| 0 |
#include <bits/stdc++.h>
char S[100010];
unsigned int N, L, R, dp[100010 * 3];
int main() {
scanf("%d%s", &N, S);
dp[L = N + 2] = 1;
R = L + 1;
for (int i = 0; i < N; i++) {
if (S[i] != '?')
--L;
else {
R += 2;
for (int j = R - 1; j >= L + 1; j--) dp[j] += dp[j - 2] * 25;
dp[L++] = 0;
}
while (R - L >= (N - i)) dp[R--] = 0;
}
printf("%u\n", dp[L]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int const N = 60000;
int const mod = 1000000007;
set<pair<int, int> > s[5];
vector<vector<int> > g;
int memo[10000];
int dp(int u) {
if (memo[u] != -1) return memo[u];
int ans = 0;
for (int i = 0, to = g[u].size(); i < to; i++) {
int v = g[u][i];
ans = max(ans, dp(v));
}
return memo[u] = ans + 1;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int p = 0, to = k; p < to; p++) {
for (int i = 0, to = n; i < to; i++) {
int u;
scanf("%d", &u);
u--;
s[p].insert(pair<int, int>(u, i));
}
}
memset(memo, -1, sizeof memo);
g.resize(n);
for (int i = 0, to = n; i < to; i++)
for (int j = 0, to = n; j < to; j++) {
if (i == j) continue;
bool f = 1;
for (int p = 0, to = k; p < to; p++) {
int pi = (*s[p].lower_bound(pair<int, int>(i, 0))).second;
int pj = (*s[p].lower_bound(pair<int, int>(j, 0))).second;
if (pj < pi) {
f = 0;
break;
}
}
if (f) g[i].push_back(j);
}
int mx = 0;
for (int i = 0, to = n; i < to; i++) mx = max(mx, dp(i));
printf("%d\n", mx);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x;
int y;
};
struct vec {
int x;
int y;
};
point r_array[12], b_array[12];
int root[12]{}, ocupied[12]{};
int r, b;
double cross(point a, point b, point c) {
vec v1 = {c.x - a.x, c.y - a.y};
vec v2 = {b.x - a.x, b.y - a.y};
return (v1.x * v2.y - v1.y * v2.x);
}
bool r_check(int r1_index, int b1_index, int r2_index, int b2_index) {
point r1_cor = r_array[r1_index];
point r2_cor = r_array[r2_index];
point b1_cor = b_array[b1_index];
point b2_cor = b_array[b2_index];
double kq_r1 = cross(r1_cor, r2_cor, b2_cor);
double kq_b1 = cross(b1_cor, r2_cor, b2_cor);
double kq_r2 = cross(r2_cor, r1_cor, b1_cor);
double kq_b2 = cross(b2_cor, r1_cor, b1_cor);
if (kq_r1 * kq_b1 > 0) return 0;
if (kq_r2 * kq_b2 > 0) return 0;
return 1;
}
bool check() {
bool kq = 1;
for (int i = 1; i < r; i++)
for (int j = i + 1; j <= r; j++) {
kq = min(kq, r_check(i, root[i], j, root[j]));
if (kq == 0) return 0;
}
return kq;
}
bool sinh(int r_pos) {
if (r_pos > r) {
return check();
}
for (int i = 1; i <= b; i++) {
if (ocupied[i]) continue;
ocupied[i] = 1;
root[r_pos] = i;
bool kq = sinh(r_pos + 1);
ocupied[i] = 0;
if (kq) return kq;
}
}
int main() {
cin >> r >> b;
for (int i = 1; i <= r; i++) cin >> r_array[i].x >> r_array[i].y;
for (int i = 1; i <= b; i++) cin >> b_array[i].x >> b_array[i].y;
if (r != b) {
cout << "No";
return 0;
}
bool kq = sinh(1);
if (kq)
puts("Yes");
else
puts("No");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:256000000")
template <class T>
T sqr(T a) {
return a * a;
}
int n, q, nu = 1, k;
int bor[100001][27];
int win[100001], was[100001];
vector<int> pr;
void init() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
string st;
cin >> st;
int v = 0;
for (int j = 0; j < st.size(); ++j) {
if (!bor[v][st[j] - 'a']) bor[v][st[j] - 'a'] = nu++;
v = bor[v][st[j] - 'a'];
}
}
}
int fun(int u) {
if (was[u]) return win[u];
int k = 1;
was[u] = 1;
for (int i = 0; i < 27; ++i) {
if (!bor[u][i]) continue;
k = fun(bor[u][i]);
if (!k) return win[u] = 1;
}
return 0;
}
int fun1(int u) {
if (was[u]) return win[u];
int k = 1, q = 1;
was[u] = 1;
for (int i = 0; i < 27; ++i) {
if (!bor[u][i]) continue;
q = 0;
k = fun1(bor[u][i]);
if (!k) return win[u] = 1;
}
return win[u] = q;
}
void solve() {
int w = 0, l = 0;
for (int i = 0; i < 27; ++i) {
if (!bor[0][i]) continue;
int k = fun(bor[0][i]);
if (!k) {
w = 1;
break;
}
}
memset(was, 0, sizeof(was));
for (int i = 0; i < 27; ++i) {
if (!bor[0][i]) continue;
int k = fun1(bor[0][i]);
if (!k) {
l = 1;
break;
}
}
cerr << l << ' ' << w;
if (l && w) cout << "First";
if (!l && !w) cout << "Second";
if (!l && w)
if (k & 1)
cout << "First";
else
cout << "Second";
if (l && !w) cout << "Second";
}
int main() {
init();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-9;
const int INF = 1000000000;
long long n, m, s;
long long ans;
long long cnt(long long a, long long b, long long c, long long d) {
long long xmn = max(a, c) + 1;
long long ymn = max(b, d) + 1;
long long xmx = n - max(a, c);
long long ymx = m - max(b, d);
if (xmn > xmx || ymn > ymx) return 0;
return (xmx - xmn + 1) * (ymx - ymn + 1);
}
int main() {
cin >> n >> m >> s;
for (long long a = 0; a <= (n - 1) / 2; ++a)
for (long long b = 0; b <= (m - 1) / 2; ++b)
for (long long c = 0; c <= (n - 1) / 2; ++c) {
long long ss = (2 * a + 1) * (2 * b + 1);
if (ss > s) continue;
long long p = 1;
long long d = 0;
if (ss == s) {
if (c <= a) {
p = (b + 1);
d = b;
} else {
continue;
}
}
if (ss < s) {
if (c == a) {
d = s / (2 * a + 1);
if (d * (2 * a + 1) != s || d % 2 != 1) continue;
d /= 2;
}
if (c < a) {
long long dd = (s - ss) / 2 / (2 * c + 1);
if (dd * (2 * c + 1) * 2 != s - ss) continue;
d = b + dd;
}
if (c > a && (2 * b + 1) * (2 * c + 1) <= s) {
d = s / (2 * c + 1);
if (d * (2 * c + 1) != s || d % 2 != 1) continue;
d /= 2;
}
if (c > a && (2 * b + 1) * (2 * c + 1) > s) {
d = (s - ss) / 2 / (c - a);
if (2 * d * (c - a) != s - ss || d % 2 != 1) continue;
d /= 2;
}
}
ans += p * cnt(a, b, c, d);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0LLU >> 1;
int rd() { return RAND_MAX == 32767 ? ((rand() << 15) ^ rand()) : rand(); }
const long long lim = 1e18;
int a[20];
long long g[10], h[10], f[20][1 << 9][9][9];
void Init(int m) {
for (int i = 1; i <= m; i++)
for (int v = 0; v < (1 << 9); v++)
for (int x = 0; x < 9; x++)
for (int y = 0; y < 9; y++) f[i][v][x][y] = lim;
for (int v = 0; v < (1 << 9); v++)
for (int x = 0; x < 9; x++)
for (int y = 0; y < 9; y++)
if (9 - x >= y) {
for (int i = 0; i <= 9 - x - y; i++) g[i] = lim;
g[0] = 0;
for (int i = 0; i <= 9 - x - y; i++)
if (g[i] != lim)
for (int j = 1; j <= 9; j++)
if (i + j <= 9 - x - y &&
(9 - x - i == j || (v >> (j - 1) & 1)))
g[i + j] = min(g[i + j], g[i] + 1);
f[1][v][x][y] = g[9 - x - y];
}
for (int i = 2; i <= m; i++)
for (int v = 0; v < (1 << 9); v++) {
for (int j = 0; j < 9; j++) {
for (int k = 0; k < 9; k++) g[k] = lim;
g[j] = 0;
for (int k = 0; k <= 9; k++) {
for (int l = 0; l < 9; l++) {
h[l] = lim;
for (int o = 0; o < 9; o++)
h[l] = min(h[l],
g[o] + f[i - 1][k == 0 ? v : v | 1 << (k - 1)][l][o]);
}
if (k < 9) {
for (int l = 0; l < 9; l++) {
g[l] = lim;
for (int o = 1; o <= 9; o++)
if (k + 1 == o || l == o || (v >> (o - 1) & 1)) {
if (l >= o)
g[l] = min(g[l], g[l - o] + 1);
else
g[l] = min(g[l], h[o - l - 1] + 1);
}
}
}
}
for (int k = 0; k < 9; k++) f[i][v][k][j] = h[k];
}
}
}
int main() {
long long n, res = 0;
cin >> n;
if (n == 1e18) {
n--;
res++;
}
if (n == 0) {
cout << 0 << endl;
return 0;
}
if (n <= 9) {
cout << 1 << endl;
return 0;
}
int m = 0;
for (; n; n /= 10) a[++m] = n % 10;
Init(m);
for (int i = 0; i < 9; i++) g[i] = (i > 0);
int v = 0;
for (int i = m; i >= 2; i--) {
for (int j = 0; j < a[i]; j++) {
int vv = j > 0 ? v | 1 << (j - 1) : v;
for (int k = 0; k < 9; k++) {
h[k] = lim;
for (int o = 0; o < 9; o++) h[k] = min(h[k], g[o] + f[i - 1][vv][k][o]);
}
for (int k = 0; k < 9; k++) {
g[k] = lim;
for (int o = 1; o <= 9; o++)
if (j + 1 == o || k == o || (v >> (o - 1) & 1)) {
if (k >= o)
g[k] = min(g[k], g[k - o] + 1);
else
g[k] = min(g[k], h[o - k - 1] + 1);
}
}
}
if (a[i] > 0) v |= 1 << (a[i] - 1);
}
if (a[1] <= 8)
res += g[a[1]];
else {
long long cnt = lim;
for (int i = 1; i <= m; i++)
if (a[i] > 0) cnt = min(cnt, g[9 - a[i]] + 1);
res += cnt;
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
scanf("%d", &n);
int r = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d", &t);
if (i == j) r ^= t;
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d", &t);
if (t == 3)
printf("%d", r);
else {
scanf("%d", &t);
r = 1 - r;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 200025;
struct frac {
long long int a, b;
frac(long long int _a = 0, long long int _b = 1) : a(_a), b(_b) {}
};
bool operator<(const frac &x, const frac &y) { return x.a * y.b < y.a * x.b; }
int n;
int v[NMAX];
long long int s_part[NMAX];
long long int sum(int st, int dr) { return s_part[dr] - s_part[st - 1]; }
frac get_val(int where, int sz) {
return frac(
sum(where - sz, where) + sum(n - sz + 1, n) - (2ll * sz + 1) * v[where],
2ll * sz + 1);
}
vector<int> get_ans(int where, int sz) {
vector<int> ans;
for (int i = where - sz; i <= where; ++i) ans.push_back(v[i]);
for (int i = n - sz + 1; i <= n; ++i) ans.push_back(v[i]);
return ans;
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> v[i];
sort(v + 1, v + n + 1);
for (int i = 1; i <= n; ++i) s_part[i] = v[i] + s_part[i - 1];
frac best;
int where = 1, sz = 0;
frac val1, val2;
for (int i = 1; i <= n; ++i) {
int st = 0, dr = min(i - 1, n - i) - 1;
int mid1, mid2, ans = -1;
int mid;
while (st <= dr) {
mid = (st + dr) >> 1;
val1 = get_val(i, mid);
val2 = get_val(i, mid + 1);
if (val1 < val2) {
st = mid + 1;
ans = mid;
} else
dr = mid - 1;
}
++ans;
frac aux = get_val(i, ans);
if (best < aux) {
best = aux;
where = i;
sz = ans;
}
}
vector<int> ans = get_ans(where, sz);
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); ++i)
cout << ans[i] << " \n"[i + 1 == ans.size()];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, m, ans;
int cnt[maxn], sum[maxn], val[maxn];
int up[maxn], down[maxn], top;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
cnt[l]++;
cnt[r + 1]--;
}
for (int i = 1; i <= m; ++i) cnt[i] += cnt[i - 1];
for (int i = 1; i <= m; ++i) {
int t = upper_bound(up + 1, up + top + 1, cnt[i]) - up;
top = max(top, t);
up[t] = cnt[i];
sum[i] += t;
}
top = 0;
for (int i = 1; i <= top; ++i) up[i] = 0;
for (int i = m; i >= 1; --i) {
int t = upper_bound(up + 1, up + top + 1, cnt[i]) - up;
top = max(top, t);
up[t] = cnt[i];
sum[i] += t;
}
int ans = 0;
for (int i = 1; i <= m; ++i) ans = max(ans, sum[i]);
printf("%d\n", ans - 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.141592653589793;
const double EPS = 1e-9;
const int N = 1e6 + 5;
const long long mod = 1e9 + 7;
const int oo = 1e9;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
vector<vector<int> > g;
int n, m;
int d[N];
void dfs(int u, int p) {
bool leaf = 1;
for (int i = 0; i < g[u].size(); i++) {
if (p != g[u][i]) {
leaf = 0;
dfs(g[u][i], u);
d[u] += d[g[u][i]];
}
}
if (leaf) d[u] = 1;
}
int main() {
scanf("%d", &n);
g.resize(n + 1);
for (int i = 2; i <= n; i++) {
int a;
scanf("%d", &a);
g[i].push_back(a);
g[a].push_back(i);
}
dfs(1, -1);
sort(d + 1, d + n + 1);
for (int i = 1; i <= n; i++) printf("%d ", d[i]);
}
| 4 |
#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int N = 1e6 + 10;
LL l[N], r[N];
LL c[N], a[N], b[N];
int main()
{
int T;cin >> T;
while (T--)
{
int n;
cin >> n;
for (int i = 1; i <= n; i++)scanf("%lld",&c[i]);
for (int i = 1; i <= n; i++)scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++)scanf("%lld", &b[i]);
LL res = 0;
for (int i = 1; i < n;i++)
{
LL t = abs(a[i+1] - b[i+1]);
LL t2 = abs(a[i + 1] - b[i + 1]);
l[i] =t+1;
if (a[i+1] != b[i+1]&&i>1)
l[i] = max(l[i], l[i - 1] + c[i] - t + 1);
res = max(res, l[i] + c[i + 1]);
}
cout << res << endl;
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
bool pr[500005];
int prime[500005];
void seive() {
int i, j, k;
for (i = 4; i < 500005; i = i + 2) {
pr[i] = true;
}
for (i = 3; i < 500005 / i; i = i + 2) {
for (j = i * i; j < 500005; j = j + (2 * i)) {
pr[j] = true;
}
}
prime[0] = 2;
k = 1;
for (i = 3; i < 500005; i = i + 2) {
if (pr[i] == false) {
prime[k] = i;
k++;
}
}
}
int main() {
int t, i, j, k, n, fl, res, m, b, ans, x, q, y, co, p;
int l, r, ab;
cin >> p >> y;
int fg = -1;
for (i = y; i > p; i--) {
m = i;
fl = 0;
for (j = 2; j <= p && j <= m / j; j++) {
if (m % j == 0) {
fl = 1;
break;
}
}
if (fl == 0) {
fg = m;
break;
}
}
cout << fg << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000;
int N, M, K;
int a[NMAX + 2][NMAX + 2];
struct state {
int dad, sz;
int down;
};
state ds[NMAX + 2][NMAX + 2];
bool active[NMAX + 2][NMAX + 2];
int root(int col, int p) {
if (ds[p][col].dad != p) {
return ds[p][col].dad = root(col, ds[p][col].dad);
}
return ds[p][col].dad;
}
void join(int col, int p, int q) {
p = root(col, p);
q = root(col, q);
if (ds[p][col].sz > ds[q][col].sz) {
swap(p, q);
}
ds[p][col].dad = q;
ds[q][col].sz += ds[p][col].sz;
ds[q][col].down = max(ds[q][col].down, ds[p][col].down);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> K;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
cin >> a[i][j];
ds[i][j].dad = i;
ds[i][j].sz = 1;
ds[i][j].down = i;
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
}
}
for (int i = 1; i <= K; i++) {
int x = 1, y;
cin >> y;
while (true) {
if (active[x][y] == true) {
int r = root(y, x);
x = ds[r][y].down + 1;
}
if (x >= N + 1) {
cout << y << ' ';
break;
}
int old_x = x, old_y = y;
if (a[x][y] == 1) {
y++;
} else if (a[x][y] == 2) {
x++;
} else {
y--;
}
a[old_x][old_y] = 2;
assert(old_x <= N);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ")";
return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
vector<int> q;
int x;
for (int i = 0; i < k; ++i) {
cin >> x;
q.push_back(x);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> x;
for (int z = 0; z < k; ++z) {
if (q[z] == x) {
ans += z + 1;
q.erase(q.begin() + z);
q.insert(q.begin(), x);
break;
}
}
}
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
vector<T>& operator--(vector<T>& v) {
for (auto& i : v) --i;
return v;
}
template <typename T>
vector<T>& operator++(vector<T>& v) {
for (auto& i : v) ++i;
return v;
}
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>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) {
return v;
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
mt19937 gen(228);
void solve(int test_num) {
int n;
cin >> n;
string s;
cin >> s;
vector<int> bin(2 * n);
for (int i = 0; i < n; i++) {
bin[i] = (s[i % n] == 'L' ? 0 : 1);
}
function<int(int, int)> solve_if = [&](int fst, int snd) -> int {
((void)0);
int add = 0;
if (bin[0] != fst) add++;
if (bin[1] != snd) add++;
vector<array<int, 8>> dp(n + 5, array<int, 8>());
for (int m = 0; m < 7; m++) {
dp[2][m] = 1e9 + 7;
}
dp[2][(fst << 1) | snd] = 0;
dp[2][(fst << 1) | snd | 4] = 0;
for (int i = 0; i < n + 5; i++) {
dp[i][0] = 1e9 + 7;
dp[i][7] = 1e9 + 7;
}
for (int i = 3; i <= n; i++) {
for (int m = 1; m < 7; m++) {
dp[i][m] = min(dp[i - 1][(m >> 1) | 4], dp[i - 1][m >> 1]) +
(((m & 1) == bin[i - 1]) ? 0 : 1);
}
}
int ans = 1e9;
for (int m = 0; m < 8; m++) {
if ((fst ^ snd) == 0 && fst == (m & 1)) continue;
if ((((m & 2) >> 1) ^ (m & 1)) == 0 && fst == (m & 1)) continue;
ans = min(ans, dp[n][m]);
}
return ans + add;
};
int ans = 1e9;
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++) {
ans = min(ans, solve_if(x, y));
}
cout << ans << "\n";
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
for (int i = 1; i <= t; i++) solve(i);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
long long col[100005];
int num[100005];
int tam[100005];
long long rpta[100005];
long long ans[100005];
long long maxf[100005];
int posr[100005];
unordered_map<int, int> frec[100005];
void dfs(int v) {
tam[v] = 1;
for (int i = (0); i < (adj[v].size()); i++) {
int w = adj[v][i];
if (num[w] == -1) {
num[w] = num[v] + 1;
dfs(w);
tam[v] += tam[w];
}
}
}
long long w, val, cnt, lstfrec, nwfrec;
inline void call(int v) {
pair<long long, long long> HL = make_pair(-1, -1);
for (int i = (0); i < (adj[v].size()); i++)
if (num[adj[v][i]] > num[v]) {
HL = max(HL, pair<long long, long long>(tam[adj[v][i]], adj[v][i]));
call(adj[v][i]);
}
if (HL.second != -1) {
posr[v] = posr[HL.second];
for (int i = (0); i < (adj[v].size()); i++) {
w = adj[v][i];
if (w == HL.second or num[w] < num[v]) continue;
for (unordered_map<int, int>::iterator it = frec[posr[w]].begin();
it != frec[posr[w]].end(); it++) {
val = it->first;
cnt = it->second;
if (frec[posr[v]].count(val))
lstfrec = frec[posr[v]][val];
else
lstfrec = 0;
nwfrec = lstfrec + cnt;
if (nwfrec > maxf[posr[v]]) {
rpta[posr[v]] = 0;
maxf[posr[v]] = nwfrec;
}
if (nwfrec == maxf[posr[v]]) rpta[posr[v]] += val;
frec[posr[v]][val] = nwfrec;
}
}
}
val = col[v];
cnt = 1;
if (frec[posr[v]].count(val))
lstfrec = frec[posr[v]][val];
else
lstfrec = 0;
nwfrec = lstfrec + cnt;
if (nwfrec > maxf[posr[v]]) {
rpta[posr[v]] = 0;
maxf[posr[v]] = nwfrec;
}
if (nwfrec == maxf[posr[v]]) rpta[posr[v]] += val;
frec[posr[v]][val] = nwfrec;
ans[v] = rpta[posr[v]];
}
int main() {
int H, M, T;
scanf("%d:%d", &H, &M);
T = 60 * H + M;
scanf("%d:%d", &H, &M);
T -= (60 * H + M);
T %= (60 * 24);
T += (60 * 24);
T %= (60 * 24);
printf("%02d:%02d\n", (T / 60) % 24, T % 60);
}
| 0 |
#include <bits/stdc++.h>
long long arr[55], cost[5], cnt[5], sum;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &arr[i]);
for (int i = 0; i < 5; i++) scanf("%lld", &cost[i]);
for (int i = 0; i < n; i++) {
sum += arr[i];
for (int j = 4; j >= 0; j--) {
if (cost[j] <= sum) {
cnt[j] += sum / cost[j];
sum -= (sum / cost[j]) * cost[j];
}
}
}
for (int i = 0; i < 5; i++) printf("%lld ", cnt[i]);
puts("");
printf("%lld\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
const int inf = 0x3f3f3f3f;
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;
const long double pi = 3.14159265358979;
const long double eps = 1e-7;
long long dogood(string& val, int from) {
long long cur = 1;
long long res = 0;
for (int i = (int((val).size())) - 1; i >= 0; i--, cur *= from) {
long long d = isdigit(val[i]) ? val[i] - '0' : val[i] - 'A' + 10;
res += d * cur;
}
return res;
}
string parse(int d) {
switch (d) {
case 0:
return "";
case 1:
return "I";
case 2:
return "II";
case 3:
return "III";
case 4:
return "IV";
case 5:
return "V";
case 6:
return "VI";
case 7:
return "VII";
case 8:
return "VIII";
case 9:
return "IX";
}
assert(false);
return "Q";
}
string pairs[] = {"IVX", "XLC", "CDM", "MZZ"};
string fuck(int val) {
string res;
int t = 0;
while (val) {
string tmp = parse(val % 10);
for (int i = 0; i < (int((tmp).size())); i++)
if (tmp[i] == 'I')
tmp[i] = pairs[t][0];
else if (tmp[i] == 'V')
tmp[i] = pairs[t][1];
else
tmp[i] = pairs[t][2];
res = tmp + res;
val /= 10;
t++;
}
return res;
}
string conv(long long val, int to) {
string res;
while (val) {
int q = val % to;
if (q < 10)
res = char(q + '0') + res;
else
res = char(q - 10 + 'A') + res;
val /= to;
}
if (res == "") res = "0";
return res;
}
int main() {
int a;
cin >> a;
string b;
cin >> b;
string c;
cin >> c;
long long goodc = dogood(c, a);
if (b == "R")
cout << fuck(goodc) << endl;
else {
int bb;
istringstream ss(b);
ss >> bb;
cout << conv(goodc, bb) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int ans = 0;
while (n) {
++ans;
n /= 2;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve_and_print();
long long int dfs_dp(long long int, int);
int ar[200009], n;
long long int dp[200009][3];
int main() {
int i;
while (cin >> n) {
for (i = 2; i <= n; i++) {
scanf("%d", &ar[i]);
}
solve_and_print();
}
}
void solve_and_print() {
int i, j, x;
for (i = 1; i <= n; i++) {
for (j = 0; j <= 2; j++) {
dp[i][j] = -1;
}
}
for (i = 2; i <= n; i++) {
dfs_dp(i, 0);
}
for (i = 1, x = 1; i <= n - 1; i++) {
if (dp[i + x][0] != -4) {
cout << dp[i + x][0] + i << endl;
} else
cout << "-1" << endl;
}
return;
}
long long int dfs_dp(long long int pos, int sign) {
if (pos > n || pos <= 0) return 0;
if (dp[pos][sign] == -3) return -4;
if (dp[pos][sign] != -1) return dp[pos][sign];
if (pos == 1 && sign == 1) return -4;
dp[pos][sign] = -3;
long long int value, ans;
if (sign)
value = pos + ar[pos];
else
value = pos - ar[pos];
ans = dfs_dp(value, 1 - (sign));
if (ans == -4)
return dp[pos][sign] = -4;
else
return dp[pos][sign] = ans + ar[pos];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, d, i, cnt = 0, sum = 0;
cin >> n >> b >> d;
int a[100000];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= b) {
sum += a[i];
}
if (sum > d) {
sum = 0;
cnt++;
}
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, A[50], i, con = 0, a, b;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a >> b;
A[i] = a * 50 - b;
}
sort(A, A + n);
for (i = 0; i < n; i++)
if (A[i] == A[n - k]) con++;
cout << con;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
struct edge {
int u, v, cost, id;
};
int pa[20][100005], maxi[20][100005];
int depth[100005];
int tot, eid[100005];
int fa[100005], dep[100005], sz[100005], wson[100005], top[100005],
spos[100005], tpos[100005];
edge es[1000005], backup[1000005];
int V, E;
int p[100005], r[100005];
bool use[1000005], uu[1000005];
bool cmp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
struct segtree {
int mini[4 * 100005], lazy[4 * 100005];
void pushup(int k) { mini[k] = min(mini[k * 2], mini[k * 2 + 1]); }
void pushdown(int k) {
if (lazy[k] == -1) return;
for (int i = k * 2; i <= k * 2 + 1; i++) {
lazy[i] = lazy[k];
mini[i] = lazy[k];
}
lazy[k] = -1;
}
void build(int k, int l, int r) {
lazy[k] = -1;
mini[k] = 1000000000;
if (l == r) return;
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
}
void update(int k, int l, int r, int x, int y, int v) {
if (l > y || x > r) return;
if (l >= x && r <= y) {
lazy[k] = v;
mini[k] = v;
return;
}
pushdown(k);
int mid = (l + r) / 2;
update(k * 2, l, mid, x, y, v);
update(k * 2 + 1, mid + 1, r, x, y, v);
pushup(k);
}
int query(int k, int l, int r, int x, int y) {
if (x > r || l > y) return 1000000000;
if (l >= x && r <= y) return mini[k];
pushdown(k);
int mid = (l + r) / 2;
return min(query(k * 2, l, mid, x, y), query(k * 2 + 1, mid + 1, r, x, y));
}
} tree;
struct ee {
int to, cost, id;
};
vector<ee> G[100005];
void dfs1(int v, int p, int d) {
dep[v] = d;
fa[v] = p;
sz[v] = 1;
for (int i = 0; i < (int)G[v].size(); i++) {
int to = G[v][i].to;
if (to == p) continue;
eid[to] = G[v][i].id;
dfs1(to, v, d + 1);
if (sz[to] > sz[wson[v]]) wson[v] = to;
sz[v] += sz[to];
}
}
void dfs2(int v, int p, int num) {
top[v] = num;
spos[v] = ++tot;
tpos[tot] = v;
if (wson[v]) dfs2(wson[v], v, num);
for (int i = 0; i < (int)G[v].size(); i++) {
int to = G[v][i].to;
if (to == p || to == wson[v]) continue;
dfs2(to, v, to);
}
}
void hld_init() {
tot = 0;
memset(wson, 0, sizeof(wson));
dfs1(1, 1, 1);
dfs2(1, 0, 1);
tree.build(1, 1, V);
}
void hld_update(int u, int v, int w) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
tree.update(1, 1, V, spos[top[u]], spos[u], w);
u = fa[top[u]];
}
if (dep[u] < dep[v]) swap(u, v);
tree.update(1, 1, V, spos[v] + 1, spos[u], w);
}
int hld_query(int u, int v) {
int res = 1000000000;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
res = min(res, tree.query(1, 1, V, spos[top[u]], spos[u]));
u = fa[top[u]];
}
if (dep[u] < dep[v]) swap(u, v);
res = min(res, tree.query(1, 1, V, spos[v], spos[u]));
return res;
}
void init_dsu(int n) {
for (int i = 1; i <= n; i++) {
p[i] = i;
r[i] = 0;
}
}
int find(int x) {
if (p[x] == x)
return x;
else
return p[x] = find(p[x]);
}
void unite(int x, int y, int w, int id) {
int xx = x, yy = y;
x = find(x);
y = find(y);
if (x == y) return;
G[xx].push_back((ee){yy, w, id});
G[yy].push_back((ee){xx, w, id});
if (r[x] < r[y])
p[x] = y;
else {
p[y] = x;
if (r[x] == r[y]) r[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int kruskal() {
sort(es, es + E, cmp);
init_dsu(V);
int res = 0;
for (int i = 0; i < E; i++) {
edge e = es[i];
if (!same(e.u, e.v)) {
use[e.id] = true;
uu[i] = true;
unite(e.u, e.v, e.cost, e.id);
res += e.cost;
}
}
return res;
}
void dfs(int v, int p, int d, int cost) {
pa[0][v] = p;
maxi[0][v] = cost;
depth[v] = d;
for (int i = 0; i < (int)G[v].size(); i++)
if (G[v][i].to != p) dfs(G[v][i].to, v, d + 1, G[v][i].cost);
}
void init(int V) {
dfs(1, -1, 0, -1000000000);
for (int k = 0; k + 1 < 20; k++) {
for (int v = 1; v <= V; v++) {
if (pa[k][v] < 0) {
pa[k + 1][v] = -1;
maxi[k + 1][v] = maxi[k][v];
} else {
pa[k + 1][v] = pa[k][pa[k][v]];
maxi[k + 1][v] = max(maxi[k][v], maxi[k][pa[k][v]]);
}
}
}
}
pair<int, int> get(int v, int x) {
int res = -1000000000;
for (int k = 0; k < 20; k++)
if ((x >> k) & 1) {
res = max(res, maxi[k][v]);
v = pa[k][v];
}
return pair<int, int>(v, res);
}
int get_ans(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
pair<int, int> p = get(v, depth[v] - depth[u]);
v = p.first;
int ans = p.second;
if (u == v) return ans;
for (int k = 20 - 1; k >= 0; k--) {
if (pa[k][u] != pa[k][v]) {
ans = max(ans, maxi[k][u]);
ans = max(ans, maxi[k][v]);
u = pa[k][u];
v = pa[k][v];
}
}
ans = max(ans, maxi[0][u]);
ans = max(ans, maxi[0][v]);
assert(ans != -1000000000);
return ans;
}
int ans[1000005];
int main() {
scanf("%d%d", &V, &E);
memset(use, false, sizeof(use));
memset(uu, false, sizeof(uu));
for (int i = 0; i < E; i++) {
int a, b, e;
scanf("%d%d%d", &a, &b, &e);
es[i] = backup[i] = (edge){a, b, e, i};
}
kruskal();
init(V);
for (int i = 0; i < E; i++) {
if (!use[i]) ans[i] = get_ans(backup[i].u, backup[i].v);
}
hld_init();
for (int i = E - 1; i >= 0; i--) {
if (!uu[i]) hld_update(es[i].u, es[i].v, es[i].cost);
}
for (int i = 2; i <= V; i++) ans[eid[i]] = hld_query(i, i);
for (int i = 0; i < E; i++) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> cd;
int getRes(int lb, int rb) {
int low = 0, high = cd.size() - 1;
int res = -1;
while (low <= high) {
int mid = (low + high) >> 1;
int t = cd[mid];
if (t <= rb && t >= lb) {
low = mid + 1;
res = max(t, res);
} else if (t < lb) {
low = mid + 1;
} else
high = mid - 1;
}
return res;
}
int main() {
int a, b;
int n;
cin >> a >> b;
if (a > b) swap(a, b);
for (int i = 1; i * i <= b; i++)
if (b % i == 0) {
if (a % i == 0) cd.push_back(i);
int t = b / i;
if (a % t == 0) cd.push_back(t);
}
cin >> n;
sort(cd.begin(), cd.end());
while (n--) {
int l, r;
scanf("%d%d", &l, &r);
cout << getRes(l, r) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long setBit(long long num, long long i) { return num | (1 << i); }
long long unsetBit(long long num, long long i) {
num ^= 1 << i;
return num;
}
bool checkBit(long long num, long long i) {
if (num & 1 << i)
return true;
else
return false;
}
long long bp(long long num) { return __builtin_popcount(num); }
long long giaithua(long long m) {
if (m == 1) return 1;
return m * giaithua(m - 1);
}
long long k, n, m, a[20], count1 = 0, dp[300000][105], used[105];
int main() {
cin >> n >> m;
k = n;
memset(used, 0, sizeof(used));
while (k != 0) {
a[count1] = k % 10;
used[a[count1]]++;
k = k / 10;
count1++;
}
memset(dp, 0, sizeof(dp));
for (int i = 0; i < count1; i++) {
if (a[i] != 0) {
dp[setBit(0, i)][a[i] % m] = 1;
} else {
dp[setBit(0, i)][a[i] % m] = 0;
}
}
int k = 1 << count1;
for (int i = 0; i < k; i++) {
for (int ij = 0; ij < m; ij++) {
if (dp[i][ij]) {
for (int j = 0; j < count1; j++) {
if (checkBit(i, j) == 0) {
dp[setBit(i, j)][(ij * 10 + a[j]) % m] += dp[i][ij];
}
}
}
}
}
for (int i = 0; i <= 9; i++) {
if (used[i] != 0) dp[k - 1][0] /= giaithua(used[i]);
}
cout << dp[k - 1][0];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const long long LINF = 1e18;
const double FINF = 1e15;
const double EPS = 1e-9;
const double PI = 2.0 * acos(0.0);
long long dp[2][5005];
int a[5005], b[5005];
int n;
inline void asmin(long long& a, long long b) {
if (a > b) a = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] -= i - 1;
b[i] = a[i];
}
sort(b + 1, b + n + 1);
b[0] = b[1];
for (int i = 0; i < 2; ++i)
for (int j = 0; j <= n; ++j) dp[i][j] = LINF;
dp[0][0] = 0;
for (int i = 0; i <= n; ++i) {
int ci = i % 2;
int ni = 1 - ci;
for (int j = 0; j <= n; ++j) {
if (i + 1 <= n) {
asmin(dp[ni][j], dp[ci][j] + abs(a[i + 1] - b[j]));
}
if (j + 1 <= n) {
asmin(dp[ci][j + 1], dp[ci][j]);
}
}
if (i == n) break;
for (int j = 0; j <= n; ++j) dp[ci][j] = LINF;
}
long long ans = LINF;
for (int i = 1; i <= n; ++i) asmin(ans, dp[n % 2][i]);
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toStr(const T &x) {
stringstream s;
s << x;
return s.str();
}
template <class T>
int toInt(const T &x) {
stringstream s;
s << x;
int r;
s >> r;
return r;
}
const double pi = acos(-1);
const double Pi2 = acos(0);
string m_tolower(string a) {
for (int i = 0; i < a.size(); ++i) a[i] = tolower(a[i]);
return a;
}
int is_lower(char x) {
if (x >= 'a' and x <= 'z') return 1;
return 0;
}
string original;
string my_repleace(string cad, int desde, int cuantos, char c) {
for (int i = 0; i < cuantos; ++i) {
if (is_lower(cad[desde + i]))
if (tolower(original[desde + i]) != tolower(c))
cad[desde + i] = tolower(c);
else {
char aa = 'a';
while (aa == c) ++aa;
cad[desde + i] = tolower(aa);
}
else if (tolower(original[desde + i]) != tolower(c))
cad[desde + i] = toupper(c);
else {
char aa = 'a';
while (aa == c) ++aa;
cad[desde + i] = toupper(aa);
}
}
return cad;
}
int my_find(int ini, string cad, string forb) {
int i = ini + 1;
for (; i < cad.size(); ++i) {
int ok = 1;
if (cad[i] == forb[0]) {
int j = 0;
for (; j < forb.size() and i + j < cad.size(); ++j) {
ok &= forb[j] == cad[i + j];
}
if (ok and j == forb.size()) return i;
}
}
return cad.size();
}
int main() {
int n;
cin >> n;
vector<string> forbidden(n);
for (int i = 0; i < n; ++i) cin >> forbidden[i];
string cad;
cin >> cad;
char c;
cin >> c;
string cad2 = m_tolower(cad);
original = cad;
for (int i = 0; i < n; ++i) {
int pos = my_find(-1, cad2, m_tolower(forbidden[i]));
while (pos < cad.size()) {
cad = my_repleace(cad, pos, forbidden[i].size(), c);
pos = my_find(pos, cad2, m_tolower(forbidden[i]));
}
}
cout << cad << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101;
int N;
int rval[MAXN];
double cprob[MAXN];
priority_queue<pair<double, int> > pq;
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> rval[i];
for (int i = 0; i < N; i++) {
pq.push(make_pair(1e9, i));
cprob[i] = 0;
}
double ans = 0, tot = 0;
for (int i = 1; i <= 3e6; i++) {
pair<double, int> ptop = pq.top();
pq.pop();
double rrate = ptop.first;
int rloc = ptop.second;
cprob[rloc] += rval[rloc] / 100. * (1 - cprob[rloc]);
if (rrate > 1e8) {
tot = 1.;
for (int j = 0; j < N; j++) tot *= cprob[j];
ans += tot * i;
} else {
ans += (rrate - 1) * tot * i;
tot *= rrate;
}
double nadd = rval[rloc] / 100. * (1 - cprob[rloc]);
pq.push(make_pair(nadd / cprob[rloc] + 1, rloc));
}
cout << fixed << setprecision(8);
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, q;
int p[N];
int centroid[N];
int subsize[N];
vector<int> adj[N];
void dfs(int u, int par) {
subsize[u] = 1;
for (int v : adj[u]) {
if (v == par) continue;
dfs(v, u);
subsize[u] += subsize[v];
}
if (subsize[u] == 1) {
centroid[u] = u;
} else {
for (int v : adj[u]) {
if (v == par) continue;
if (subsize[v] * 2 > subsize[u]) {
centroid[u] = centroid[v];
while ((subsize[u] - subsize[centroid[u]]) * 2 > subsize[u]) {
centroid[u] = p[centroid[u]];
}
}
}
if (centroid[u] == 0) {
centroid[u] = u;
}
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
adj[p[i]].push_back(i);
}
dfs(1, -1);
while (q--) {
int x;
scanf("%d", &x);
printf("%d\n", centroid[x]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long n, k, t, m, q, flag = 0;
long long power(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << "0"
<< "\n";
return;
}
set<long long> s;
map<long long, long long> m;
long long maxm = 0;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
m[a[i]]++;
maxm = max(maxm, m[a[i]]);
}
if (s.size() == 1) {
cout << "1"
<< "\n";
return;
}
long long ans = min(s.size() - 1, maxm);
ans = max(ans, min(s.size(), maxm - 1));
cout << ans << "\n";
}
int main() {
int T;
T = 1;
cin >> T;
while (T--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int al, ar, bl, br;
bool check(int n, int m) { return (m >= n - 1 && m <= 2 * (n + 1)); }
int main() {
scanf("%d%d", &al, &ar);
scanf("%d%d", &bl, &br);
if (check(al, br) || check(ar, bl))
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int v[30];
char s[N];
int m;
int main() {
scanf("%d", &m);
scanf("%s", s + 1);
int len = strlen(s + 1);
char maxc = 'a';
for (int i = 1; i <= len - m + 1; ++i) {
char u = 'z';
int nextpos = -1;
for (int j = i; j <= i + m - 1; ++j) {
if (s[j] <= u) {
u = s[j];
nextpos = j;
}
}
if (nextpos != -1) {
v[u - 'a']++;
s[nextpos] = '.';
if (u > maxc) maxc = u;
i = nextpos;
}
}
for (int i = 1; i <= len; ++i) {
if (s[i] != '.' && s[i] < maxc) v[s[i] - 'a']++;
}
for (int i = 0; i < 26; ++i) {
while (v[i]--) {
printf("%c", i + 'a');
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
using namespace std;
const int MAX = 100100;
int NXT[MAX][28];
priority_queue<int> Q[MAX];
int IND[MAX];
int CNT = 1;
int EN[MAX];
void addStr(string& s) {
int v = 0;
for (int i = (0); i < ((int)s.size()); ++i) {
int c = s[i] - 'a';
if (NXT[v][c] == -1) NXT[v][c] = CNT++;
v = NXT[v][c];
}
EN[v] = 1;
}
void merge(int& to, int& frm) {
if (Q[to].size() < Q[frm].size()) swap(to, frm);
while (Q[frm].size()) {
Q[to].push(Q[frm].top());
Q[frm].pop();
}
}
void dfs(int v, int len) {
for (int i = (0); i < (26); ++i) {
int to = NXT[v][i];
if (to == -1) continue;
dfs(to, len + 1);
merge(IND[v], IND[to]);
}
if (EN[v])
Q[IND[v]].push(len);
else if (len) {
Q[IND[v]].pop();
Q[IND[v]].push(len);
}
}
int main() {
memset(NXT, -1, sizeof(NXT));
for (int i = (0); i < (MAX); ++i) IND[i] = i;
int n;
cin >> n;
for (int i = (0); i < (n); ++i) {
string s;
cin >> s;
addStr(s);
}
dfs(0, 0);
int ans = 0;
int cnt = 0;
while (Q[IND[0]].size()) {
++cnt;
ans += Q[IND[0]].top();
Q[IND[0]].pop();
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool lucky(int x) {
while (x) {
int d = x % 10;
if (d != 4 && d != 7) return false;
x /= 10;
}
return true;
}
int pm(int a, int e) {
int r = 1;
while (e) {
if (e & 1) r = (1LL * r * a) % 1000000007;
e >>= 1;
a = (1LL * a * a) % 1000000007;
}
return r;
}
int inv(int a) { return pm(a, 1000000007 - 2); }
int fact[100005];
int comb(int n, int k) {
if (k < 0 || k > n) return 0;
return (1LL * fact[n] * inv((1LL * fact[k] * fact[n - k]) % 1000000007)) %
1000000007;
}
map<int, int> w;
int f[100005];
int n, k, nl;
int main() {
fact[0] = 1;
for (int i = 1, to = 100005; i < to; ++i)
fact[i] = (1LL * fact[i - 1] * i) % 1000000007;
scanf("%d%d", &n, &k);
for (int i = 0, to = n; i < to; ++i) {
int x;
scanf("%d", &x);
if (lucky(x)) {
w[x]++;
nl++;
}
}
f[0] = 1;
for (map<int, int>::iterator it = w.begin(); it != w.end(); ++it) {
int c = it->second;
for (int i = k; i > 0; --i)
f[i] += (1LL * f[i - 1] * c) % 1000000007, f[i] %= 1000000007;
}
int r = 0;
for (int i = 0, to = k + 1; i < to; ++i) {
r += (1LL * f[i] * comb(n - nl, k - i)) % 1000000007;
r %= 1000000007;
}
printf("%d\n", r);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long long MOD = 1000000007;
using namespace std;
long long jcn_1 = 1, inv_jcn_1, n, f[100], s, ans = 0;
long long pow(long long a, long long b) {
long long ans = 1;
a %= MOD;
while (b) {
if (b & 1) ans = (ans * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ans;
}
long long c(long long k) {
long long ans = 1;
for (long long i = s - k + 1; i <= n + s - k - 1; i++)
ans = (ans * (i % MOD)) % MOD;
return ans * inv_jcn_1 % MOD;
}
void dfs(long long pos, long long opt, long long x) {
if (pos == n) {
if (x > s) return;
ans = ((ans + opt * c(x)) % MOD + MOD) % MOD;
return;
}
dfs(pos + 1, opt, x);
dfs(pos + 1, -opt, x + f[pos + 1] + 1);
}
signed main() {
scanf("%I64d %I64d", &n, &s);
for (long long i = 1; i < n; i++) jcn_1 *= i;
inv_jcn_1 = pow(jcn_1, MOD - 2);
for (long long i = 1; i <= n; i++) scanf("%I64d", &f[i]);
dfs(0, 1, 0);
printf("%I64d\n", ans);
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.