solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool tab[500][500];
char slowo[500];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) slowo[i] = 'x';
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
tab[a][b] = tab[b][a] = 1;
}
for (int i = 0; i < n; i++) {
int ile = 0;
bool z_a = 0, z_c = 0;
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (tab[i][j]) ile++;
if (!tab[i][j] && slowo[j] == 'a') z_a = 1;
if (!tab[i][j] && slowo[j] == 'c') z_c = 1;
}
if (ile == n - 1) {
slowo[i] = 'b';
continue;
}
if (z_a && z_c) {
cout << "No\n";
return 0;
}
if (z_a)
slowo[i] = 'c';
else
slowo[i] = 'a';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if ((slowo[i] == 'a' && slowo[j] == 'c') ||
(slowo[i] == 'c' && slowo[j] == 'a')) {
if (tab[i][j] == 1) {
cout << "No\n";
return 0;
}
} else {
if (tab[i][j] == 0) {
cout << "No\n";
return 0;
}
}
}
}
cout << "Yes\n";
for (int i = 0; i < n; i++) cout << slowo[i];
cout << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dfs(int p, int root, vector<set<int> >& adj, vector<int>& nc) {
if (p != -1) {
adj[root].erase(adj[root].find(p));
}
set<int>::const_iterator it;
for (it = adj[root].begin(); it != adj[root].end(); it++) {
nc[root] += dfs(root, *it, adj, nc);
}
nc[root]++;
return nc[root];
}
int main() {
int n;
cin >> n;
vector<set<int> > adj(n, set<int>());
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
adj[x - 1].insert(y - 1);
adj[y - 1].insert(x - 1);
}
vector<int> nc(n, 0);
dfs(-1, 0, adj, nc);
set<int> ans;
set<int>::iterator ii;
vector<int>::iterator it;
for (int i = 0; i < n; i++) {
if (i == 0 and adj[i].size() == 1) {
continue;
}
if (i > 0 and adj[i].size() == 0) {
continue;
}
vector<int> v;
for (ii = adj[i].begin(); ii != adj[i].end(); ii++) {
v.push_back(nc[*ii]);
}
if (i > 0) {
int sum = 0;
for (it = v.begin(); it != v.end(); it++) {
sum += *it;
}
v.push_back(n - 1 - sum);
}
set<int> r[2];
r[0].insert(0);
r[1].insert(0);
int last = 0, next = 1;
for (it = v.begin(); it != v.end(); it++) {
for (ii = r[last].begin(); ii != r[last].end(); ii++) {
r[next].insert(*ii);
r[next].insert(*ii + *it);
}
swap(last, next);
}
for (ii = r[last].begin(); ii != r[last].end(); ii++) {
if (*ii > 0 and n - 1 - *ii > 0) {
ans.insert(*ii);
ans.insert(n - 1 - *ii);
}
}
}
cout << ans.size() << endl;
for (ii = ans.begin(); ii != ans.end(); ii++) {
cout << *ii << " " << n - 1 - *ii << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int i, j, n;
long int a[100000], b[100000];
cin >> n;
for (i = n - 1; i >= 0; i--) cin >> a[i];
b[0] = a[0];
for (i = 1; i < n; i++) {
b[i] = a[i] + a[i - 1];
}
for (i = n - 1; i >= 0; i--) cout << b[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const unsigned long long infl = 0x3f3f3f3f3f3f3f3fLL;
template <typename T>
inline void umax(T &a, T b) {
a = max(a, b);
}
template <typename T>
inline void umin(T &a, T b) {
a = min(a, b);
}
const int MAXN = 100005;
const unsigned long long MOD = 1e9 + 7;
vector<pair<int, unsigned long long> > G[MAXN];
int n, m;
vector<unsigned long long> xorv;
unsigned long long xpath[MAXN], base[100], qz[200];
bool used[MAXN];
unsigned long long cnt[100][2];
void dfs(int u, int fa) {
int v;
unsigned long long w;
used[u] = true;
for (int i = 0; i < G[u].size(); ++i) {
tie(v, w) = G[u][i];
if (v == fa) continue;
if (used[v]) {
xorv.push_back(xpath[v] ^ xpath[u] ^ w);
} else {
xpath[v] = xpath[u] ^ w;
dfs(v, u);
}
}
for (int j = 0; j <= 62; ++j) {
++cnt[j][xpath[u] >> j & 1];
}
}
int Guass_base() {
int rank = 0;
for (int i = 0; i <= 62; ++i) base[i] = 0;
for (int i = 0; i < xorv.size(); ++i) {
for (int j = 62; j >= 0; --j) {
if (!(xorv[i] >> j & 1)) continue;
if (!base[j]) {
base[j] = xorv[i];
++rank;
break;
}
xorv[i] ^= base[j];
}
}
return rank;
}
int main() {
int u, v;
unsigned long long w;
qz[0] = 1;
for (int i = 1; i < 200; ++i) qz[i] = qz[i - 1] * 2 % MOD;
while (~scanf("%d %d", &n, &m)) {
for (int i = 1; i <= n; ++i) {
G[i].clear();
used[i] = false;
}
for (int i = 1; i <= m; ++i) {
scanf("%d %d %llu", &u, &v, &w);
G[u].push_back(pair<int, unsigned long long>(v, w));
G[v].push_back(pair<int, unsigned long long>(u, w));
}
unsigned long long ans = 0;
for (int i = 1; i <= n; ++i) {
if (used[i]) continue;
xorv.clear();
memset(cnt, 0, sizeof(cnt));
dfs(i, 0);
sort(xorv.begin(), xorv.end());
xorv.erase(unique(xorv.begin(), xorv.end()), xorv.end());
reverse(xorv.begin(), xorv.end());
int rank = Guass_base();
for (int j = 0; j <= 62; ++j) {
bool sign = false;
for (int k = 0; k <= 62; ++k) sign |= (base[k] >> j & 1);
if (!sign) {
unsigned long long temp = (unsigned long long)(cnt[j][0] * cnt[j][1]);
ans = (ans + temp % MOD * qz[j + rank]) % MOD;
} else {
unsigned long long temp = (unsigned long long)(cnt[j][0] * cnt[j][1]);
temp += (unsigned long long)cnt[j][0] * (cnt[j][0] - 1) / 2;
temp += (unsigned long long)cnt[j][1] * (cnt[j][1] - 1) / 2;
ans = (ans + temp % MOD * qz[j + rank - 1]) % MOD;
}
}
}
printf("%llu\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long n, m, grp, ans, timer;
vector<pair<long long, long long>> g[N];
vector<long long> tree[N], comp[N];
long long isBridge[N], tin[N], low[N], vis[N], tout[N];
void dfs1(long long v, long long p) {
vis[v] = 1;
timer++;
tin[v] = timer;
low[v] = timer;
for (auto it : g[v]) {
long long u = it.first, idx = it.second;
if (!vis[u]) {
dfs1(u, v);
low[v] = min(low[v], low[u]);
if (low[u] > tin[v]) {
isBridge[idx] = 1;
}
} else if (u != p) {
low[v] = min(low[v], tin[u]);
}
}
tout[v] = timer;
}
void dfs2(long long v, long long cmp) {
queue<long long> q;
q.push(v);
vis[v] = 0;
while (q.size()) {
v = q.front();
q.pop();
comp[cmp].push_back(v);
for (auto it : g[v]) {
long long u = it.first, idx = it.second;
if (!vis[u]) {
continue;
}
if (isBridge[idx]) {
grp++;
tree[grp].push_back(cmp);
tree[cmp].push_back(grp);
dfs2(u, grp);
} else {
q.push(u);
vis[u] = 0;
}
}
}
}
long long dfs3(long long v) {
long long mx1 = 0;
vis[v] = 1;
for (auto u : tree[v]) {
if (vis[u]) {
continue;
}
long long mx2 = 1 + dfs3(u);
ans = max(ans, mx1 + mx2);
mx1 = max(mx1, mx2);
}
return mx1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
dfs1(1, 0);
grp++;
dfs2(1, 1);
dfs3(1);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int solve(int k, int r, int t) {
int median;
int maxi = max(k, max(r, t));
int mini = min(k, min(r, t));
if (k != maxi && k != mini)
median = k;
else if (r != maxi && r != mini)
median = r;
else if (t != maxi && t != mini)
median = t;
return abs(median - k) + abs(median - r) + abs(median - t);
}
int main() {
int k, r, t;
cin >> k >> r >> t;
cout << solve(k, r, t);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 14;
const int M = 101;
int n, m, q;
int edge[N][2];
int lca[M][3];
int lowbit(int x) { return x & (-x); }
bool check_edge(int mask1, int mask2, int sp1, int sp2) {
for (int i = 0; i < m; i++)
for (int t = 0; t < 2; t++) {
if (((mask1 >> edge[i][0]) & 1) && ((mask2 >> edge[i][1]) & 1))
if (edge[i][0] != sp1 || edge[i][1] != sp2) return false;
swap(edge[i][0], edge[i][1]);
}
return true;
}
bool check_lca(int mask1, int mask2, int root) {
for (int i = 0; i < q; i++)
for (int t = 0; t < 2; t++) {
if (((mask1 >> lca[i][0]) & 1) && ((mask2 >> lca[i][1]) & 1))
if (lca[i][2] != root) return false;
swap(lca[i][0], lca[i][1]);
}
return true;
}
long long memo[N][1 << N];
long long dp(int root, int mask) {
if (mask - lowbit(mask) == 0) return 1;
if (memo[root][mask] != -1) return memo[root][mask];
long long ret = 0;
mask ^= (1 << root);
for (int nxt = mask; nxt > 0; nxt = (nxt - 1) & mask)
if (lowbit(nxt) == lowbit(mask))
for (int i = 0; i < n; i++)
if ((nxt >> i) & 1) {
int r = mask ^ nxt ^ (1 << root);
if (check_edge(nxt, r, i, root) && check_lca(nxt, r, root))
ret += (long long)dp(i, nxt) * dp(root, r);
}
memo[root][mask ^ (1 << root)] = ret;
return ret;
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 0; i < m; i++)
for (int j = 0; j < 2; j++) {
cin >> edge[i][j];
edge[i][j]--;
}
for (int i = 0; i < q; i++) {
for (int j = 0; j < 3; j++) {
cin >> lca[i][j];
lca[i][j]--;
}
if (lca[i][0] == lca[i][1] && lca[i][0] != lca[i][2]) {
cout << 0 << '\n';
return 0;
}
}
memset(memo, -1, sizeof(memo));
cout << dp(0, (1 << n) - 1) << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int s[N + 10];
int main() {
ios_base::sync_with_stdio(false);
int n, a, b;
cin >> n >> a >> b;
int fi, sum = 0, ans = 0;
cin >> fi, sum = fi;
for (int i = 0; i < n - 1; i++) cin >> s[i], sum += s[i];
sort(s, s + n - 1);
if ((long double)a * fi / sum >= b) return cout << ans, 0;
for (int i = n - 2; i >= 0; i--) {
sum -= s[i], ans++;
if ((long double)a * fi / sum >= b) return cout << ans, 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, sum = 0;
cin >> n >> m;
vector<vector<int> > square(n, vector<int>(m));
vector<vector<int> > ans(n, vector<int>(m));
for (int i = 0; i <= n - 1; ++i) {
for (int j = 0; j <= m - 1; ++j) ans[i][j] = 0;
}
for (int i = 0; i <= n - 1; ++i) {
for (int j = 0; j <= m - 1; ++j) {
char ch;
cin >> ch;
if (ch == 'W')
square[i][j] = 1;
else
square[i][j] = -1;
}
}
for (int i = n - 1; i >= 0; --i) {
for (int j = m - 1; j >= 0; --j) {
if (ans[i][j] != square[i][j]) {
int temp = square[i][j] - ans[i][j];
for (int k = 0; k <= i; ++k) {
for (int l = 0; l <= j; ++l) {
ans[k][l] += temp;
}
}
++sum;
}
}
}
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod(long long n);
long long gcd(long long a, long long b);
long long modM(long long n, long long m);
long long modA(long long n, long long m);
long long modS(long long n, long long m);
long long N = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
long long n, h;
long long currH = 0;
cin >> n;
long long time = 2 * n - 1;
while (n--) {
cin >> h;
time += abs(h - currH);
currH = h;
}
cout << time;
return 0;
}
long long gcd(long long a, long long b) {
if (b > a) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
long long mod(long long n) { return (n % N + N) % N; }
long long modM(long long n, long long m) { return ((n % N * m % N) + N) % N; }
long long modA(long long n, long long m) { return ((n % N + m % N) + N) % N; }
long long modS(long long n, long long m) { return ((n % N - m % N) + N) % N; }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
if (n & 1)
puts("-1");
else {
for (int i = 1; i <= n; ++i) {
cout << (i % 2 ? i + 1 : i - 1) << ((i == n) ? "\n" : " ");
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000005;
int read() {
int x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int T, n, m, tot, cnt, Index, f[M];
int dfn[M], low[M], in[M], col[M];
stack<int> s;
struct edge {
int v, next;
} e[M];
void dfs(int u) {
dfn[u] = low[u] = ++Index;
in[u] = 1;
s.push(u);
for (int i = f[u]; i; i = e[i].next) {
int v = e[i].v;
if (!dfn[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (in[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
int v = 0;
cnt++;
do {
v = s.top();
s.pop();
col[v] = cnt;
in[v] = 0;
} while (v != u);
}
}
signed main() {
T = read();
while (T--) {
n = read();
m = read();
tot = Index = cnt = 0;
for (int i = 1; i <= n; i++) f[i] = 0;
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
if (u == v) continue;
e[++tot] = edge{v, f[u]}, f[u] = tot;
}
for (int i = 1; i <= n; i++) dfn[i] = low[i] = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
if (cnt == 1) {
puts("No");
continue;
}
puts("Yes");
int ans = 0;
for (int i = 1; i <= n; i++) ans += (col[i] == 1);
printf("%d %d\n", ans, n - ans);
for (int i = 1; i <= n; i++)
if (col[i] == 1) printf("%d ", i);
puts("");
for (int i = 1; i <= n; i++)
if (col[i] != 1) printf("%d ", i);
puts("");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000006] = {0};
long long ans[1000006] = {0};
long long last_occ[1000006] = {0};
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
memset(last_occ, 0, sizeof(last_occ));
memset(ans, 0, sizeof(ans));
ans[0] = 0;
double sum = 0.0;
for (long long i = 1; i <= n; i++) {
ans[i] = ans[i - 1] + (i - last_occ[a[i]]);
last_occ[a[i]] = i;
sum = sum + ans[i];
}
double finalAns = 0.0;
finalAns = (2 * (sum - n) + n) / (n * n * 1.0);
cout << fixed << setprecision(6) << finalAns << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const mod = 1e9 + 7;
inline void SAFE_ADD(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
struct Matr {
vector<vector<int> > _data;
Matr(int sz) : _data(sz, vector<int>(sz, 0)) {}
void ones() {
for (int i = 0; i < _data.size(); ++i) _data[i][i] = 1;
}
};
Matr operator*(Matr const& a, Matr const& b) {
int n = a._data.size();
Matr ans(n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
SAFE_ADD(ans._data[i][k], a._data[i][j] * 1LL * b._data[j][k] % mod);
}
return ans;
}
inline int getnum(char c) {
if (c >= 'a' && c <= 'z')
return c - 'a';
else
return 26 + c - 'A';
}
Matr pow(Matr const& a, long long b) {
Matr ans(a._data.size());
ans.ones();
Matr tmp(a);
while (b) {
if (b & 1) ans = ans * tmp;
tmp = tmp * tmp;
b >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
long long n;
int m, k;
cin >> n >> m >> k;
if (n == 1) {
cout << m << '\n';
return 0;
};
Matr a(m);
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) a._data[i][j] = 1;
for (int i = 0; i < k; ++i) {
string tmp;
cin >> tmp;
a._data[getnum(tmp[0])][getnum(tmp[1])] = 0;
}
a = pow(a, n - 1);
int ans = 0;
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) SAFE_ADD(ans, a._data[i][j]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int N, a[MaxN];
bool check(long long x) {
long long r = 0;
for (int i = 0; i < N; ++i) {
r += x - a[i];
if (r >= x) return true;
}
return false;
}
int main(void) {
scanf("%d", &N);
long long lo = 1;
for (int i = 0; i < N; ++i) {
scanf("%d", &a[i]);
lo = max(lo, (long long)a[i]);
}
long long hi = 1000000000000000LL, ret = hi;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (check(mid)) {
hi = mid - 1;
ret = mid;
} else
lo = mid + 1;
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, H;
long long D[35 + 1][35 + 1];
long long first(int n, int h) {
int i;
long long t = 0;
if (!n) return 1;
if (!h) return 0;
if (n == 1) return 1;
if (D[n][h]) return D[n][h];
for (i = n - 1; i >= 0; i--) {
t += first(i, h - 1) * first(n - 1 - i, h - 1);
}
return D[n][h] = t;
}
int main() {
scanf(" %d %d", &N, &H);
cout << first(N, N) - first(N, H - 1) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[101] = {0}, b[101] = {0}, n, m, x, y, z, num = 0;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> z;
a[y] += z;
if (a[x] < z) {
b[x] += z - a[x];
a[x] = 0;
} else {
a[x] = a[x] - z;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] < b[i]) num += b[i] - a[i];
}
cout << num;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.0);
const int inf = (int)1e9 + 7;
const long long INF = (long long)1e18 + 7;
const int mod = (int)1e9 + 7;
const int N = (int)2e5 + 7;
int n, dp[N], ans[N];
vector<int> g[N], pref[N], suff[N];
int binpow(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = (res * 1ll * a) % mod;
a = (a * 1ll * a) % mod;
n >>= 1;
}
return res;
}
void dfs0(int v) {
dp[v] = 1;
for (int to : g[v]) {
dfs0(to);
dp[v] = (dp[v] * 1ll * (dp[to] + 1)) % mod;
}
}
void dfs(int v, int prev) {
ans[v] = (dp[v] * 1ll * (prev + 1)) % mod;
int curp = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
pref[v].push_back(curp);
curp = curp * 1ll * (dp[to] + 1) % mod;
}
int curs = 1;
for (int i = g[v].size() - 1; i >= 0; i--) {
int to = g[v][i];
suff[v].push_back(curs);
curs = curs * 1ll * (dp[to] + 1) % mod;
}
reverse((suff[v]).begin(), (suff[v]).end());
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
dfs(to, ((prev + 1) * 1ll * ((pref[v][i] * 1ll * suff[v][i]) % mod)) % mod);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
x--;
g[x].push_back(i);
}
dfs0(0);
dfs(0, 0);
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int block_size = 360;
const int maxn = 100010;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
template <typename T>
int sign(const T& a) {
if (a < 0) {
return -1;
}
if (a > 0) {
return 1;
}
return 0;
}
long long cross_product(const complex<long long>& from, complex<long long> a,
complex<long long> b) {
a -= from;
b -= from;
return a.imag() * b.real() - a.real() - b.imag();
}
bool shuzu[15][15];
int r, c, n, k;
void read() {
scanf("%d", &r);
scanf("%d", &c);
scanf("%d", &n);
scanf("%d", &k);
for (long long i = 0; i < n; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
a--;
b--;
shuzu[a][b] = 1;
}
}
void solve() {
int way = 0;
for (long long sx = 0; sx < r; sx++) {
for (long long bx = sx; bx < r; bx++) {
for (long long sy = 0; sy < c; sy++) {
for (long long by = sy; by < c; by++) {
int cnt = 0;
for (long long i = 0; i < r; i++) {
for (long long j = 0; j < c; j++) {
if (i >= sx && i <= bx && j >= sy && j <= by) {
cnt += shuzu[i][j];
}
}
}
way += (cnt >= k);
}
}
}
}
cout << way;
}
int main() {
read();
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class pt {
public:
int x1, y1, x2, y2;
void print() { printf("%d %d %d %d\n", x1, y1, x2, y2); }
} ans[400];
int m = 0, k = 2, len = 2, a[30];
long long n;
int main() {
scanf("%lld", &n);
for (; n; n /= 6) a[++m] = n % 6;
ans[1] = (pt){1, 2, 2, 2};
ans[2] = (pt){2, 1, 2, 2};
for (int i = m; i >= 1; i--) {
if (a[i] <= 2) ans[++k] = (pt){len - 1, len + 1, len, len + 1};
if (a[i] % 3 == 0) ans[++k] = (pt){len - 1, len + 2, len, len + 2};
ans[++k] = (pt){len + 1, len - 1, len + 1, len};
if (a[i] % 3 != 2) ans[++k] = (pt){len + 2, len - 1, len + 2, len};
len += 2;
if (i == 1) break;
ans[++k] = (pt){len - 2, len, len - 2, len + 1};
ans[++k] = (pt){len - 1, len, len - 1, len + 1};
ans[++k] = (pt){len - 2, len + 2, len - 1, len + 2};
ans[++k] = (pt){len, len - 2, len + 1, len - 2};
ans[++k] = (pt){len, len - 1, len + 1, len - 1};
ans[++k] = (pt){len + 2, len - 2, len + 2, len - 1};
if (len <= 4) continue;
ans[++k] = (pt){len - 4, len + 1, len - 3, len + 1};
ans[++k] = (pt){len + 1, len - 4, len + 1, len - 3};
}
printf("%d %d\n%d\n", len, len, k);
for (int i = 1; i <= k; i++) ans[i].print();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 104;
const int maxDate = 1e7 + 2;
int n;
int lmost, rmost;
vector<pair<int, int> > v[maxDate];
int sol[maxN];
int main() {
cin >> n;
lmost = maxDate;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
lmost = min(lmost, x);
rmost = max(rmost, y);
v[x].push_back(make_pair(y, i));
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
heap;
for (int tm = lmost; tm <= rmost; tm++) {
for (auto it : v[tm]) {
heap.push(it);
}
if (!heap.empty()) {
int index = heap.top().second;
sol[index] = tm;
heap.pop();
}
}
for (int i = 1; i <= n; i++) {
cout << sol[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, ans, dp[101][2501], M = 1e9 + 7;
string str;
void pre() {
dp[0][0] = 1;
for (int i = 1; i < 101; ++i)
for (int j = 0; j < 2501; ++j)
for (int k = 0; k < 26 && (j - k) >= 0; ++k) {
dp[i][j] += dp[i - 1][j - k];
dp[i][j] %= M;
}
}
int main() {
pre();
cin >> t;
while (t--) {
cin >> str;
n = str.size();
ans = 0;
for (int i = 0; i < n; ++i) ans += (int)(str[i] - 'a');
cout << (dp[n][ans] - 1 + M) % M << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char A[1000] = {0};
int main() {
int a, b, c, d = 0;
cin >> a >> b;
if (a % b == 0) {
for (c = 1; c <= b; c++) {
cout << a / b;
if (c != b) {
printf(" ");
}
}
} else {
while (1) {
d++;
if (d * b >= a) {
d = d * b - a;
break;
}
}
for (c = 1; c <= d; c++) {
cout << a / b;
printf(" ");
}
for (c = d + 1; c <= b; c++) {
cout << a / b + 1;
if (c != b) {
printf(" ");
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 5017;
bool a[Nmax] = {0}, rez[Nmax] = {0};
int ans = 0;
int main(void) {
std::ios::sync_with_stdio(false);
int p, q, l, r;
cin >> p >> q >> l >> r;
int x, y;
while (p--) {
cin >> x >> y;
for (; x <= y; x++) a[x] = 1;
}
while (q--) {
cin >> x >> y;
for (int i = l; i <= r; i++)
for (int z = x + i; z <= 1000 && z <= y + i; z++)
if (a[z]) {
if (rez[i] == 0) {
ans++;
rez[i] = 1;
break;
}
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
long long i, x, y;
string S;
cin >> n;
while (n--) {
cin >> S;
bool type1 = true;
for (i = 0; !(S[i] >= '0' && S[i] <= '9'); i++)
;
for (; S[i] != '\0'; i++) {
if (S[i] >= 'A' && S[i] <= 'Z') {
type1 = false;
break;
}
}
if (!type1) {
long long r = 0, c = 0;
for (i = 1; S[i] != 'C'; i++) r = (10 * r) + (S[i] - '0');
for (i = i + 1; S[i] != '\0'; i++) c = (10 * c) + (S[i] - '0');
i = 26;
y = 1;
swap(r, c);
while (1) {
if (r > i) {
r -= i;
i *= 26;
y++;
} else
break;
}
S.clear();
S.append(y, 'A');
r--;
i = 0;
while (r != 0) {
S[i] += (r % 26);
r /= 26;
i++;
}
for (i = S.length() - 1; i >= 0; i--) cout << S[i];
cout << c << "\n";
} else {
long long len;
for (i = 0; !(S[i] >= '0' && S[i] <= '9'); i++)
;
len = i;
cout << "R";
for (; S[i] != '\0'; i++) cout << S[i];
cout << "C";
x = 0;
y = 26;
for (i = 1; i < len; i++) {
x += y;
y *= 26;
}
x++;
y = 1;
for (i = len - 1; i >= 0; i--) {
x += (y * (S[i] - 'A'));
y *= 26;
}
cout << x << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, p;
bool is_prime(long long int x) {
for (long long int i = 2; i * i <= x && i <= p; i++)
if (x % i == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> p >> n;
long long int ans = n;
while (ans > p) {
if (is_prime(ans)) break;
ans--;
}
if (ans == p)
cout << -1 << endl;
else
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int n, m, f[N][N], ans;
char s1[N], s2[N];
signed main() {
scanf("%d%d%s%s", &n, &m, s1 + 1, s2 + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
int &x = f[i][j];
if (s1[i] == s2[j])
x = max(x, f[i - 1][j - 1] + 2);
else
x = max(x, f[i - 1][j] - 1), x = max(x, f[i][j - 1] - 1),
x = max(x, f[i - 1][j - 1] - 2);
ans = max(ans, x);
}
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:60777216")
const int max_n = 100050;
int n;
vector<int> neigh[max_n];
int val[max_n];
int c;
int s[max_n], s_ed;
int b[2 * max_n], b_ed;
void run_dfs(int v) {
s[++s_ed] = v;
val[v] = s_ed;
b[++b_ed] = val[v];
for (int j = 0; j < int(neigh[v].size()); j++) {
int w = neigh[v][j];
if (val[w] == -1)
run_dfs(w);
else
while (val[w] < b[b_ed]) b_ed--;
}
if (val[v] == b[b_ed]) {
b_ed--;
c++;
while (val[v] <= s_ed) val[s[s_ed--]] = c;
}
}
void strong() {
s_ed = b_ed = -1;
for (int v = 0; v < n; v++) val[v] = -1;
c = n - 1;
for (int v = 0; v < n; v++)
if (val[v] == -1) run_dfs(v);
for (int v = 0; v < n; v++)
if (val[v] != -1) val[v] -= n;
}
const int inf = 1000000000;
int ans = inf;
int ans_v;
bool vis[max_n] = {false};
bool is_sink;
int dfs(int v) {
assert(vis[v] == false);
int sz = 1;
vis[v] = true;
for (int w : neigh[v]) {
if (val[w] == val[v] && !vis[w]) {
sz += dfs(w);
}
if (val[w] != val[v]) is_sink = false;
}
return sz;
}
void print(int v) {
assert(vis[v] == false);
printf("%d ", v + 1);
vis[v] = true;
for (int w : neigh[v])
if (!vis[w]) print(w);
}
void run() {
for (int i = 0; i < n; i++)
if (!vis[i]) {
is_sink = true;
int sz = dfs(i);
if (is_sink && ans > sz) {
ans = sz;
ans_v = i;
}
}
for (int i = 0; i < n; i++) vis[i] = false;
printf("%d\n", ans);
print(ans_v);
printf("\n");
}
int u[100050];
int c1[100050], c2[100050];
int main() {
scanf("%d", &n);
int m, h;
scanf("%d %d", &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 0; i < m; i++) scanf("%d %d", &c1[i], &c2[i]);
for (int i = 0; i < m; i++) {
if ((u[c1[i]] + 1) % h == u[c2[i]]) neigh[c1[i] - 1].push_back(c2[i] - 1);
if ((u[c2[i]] + 1) % h == u[c1[i]]) neigh[c2[i] - 1].push_back(c1[i] - 1);
}
strong();
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (k > n) {
cout << -1;
} else {
sort(arr, arr + n, greater<int>());
cout << arr[k - 1] << " " << arr[k - 1];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int hh, mm;
cin >> hh >> mm;
int h, d, c, n;
cin >> h >> d >> c >> n;
double ans = 1e9;
int start_minutes = hh * 60 + mm;
int minutes_rest = 20 * 60;
int final_health = h + d * max(0, (minutes_rest - start_minutes));
int have_to_buy = (final_health + n - 1) / n;
ans = min(ans, 0.8 * have_to_buy * c);
have_to_buy = (h + n - 1) / n;
ans = min(ans, 1.0 * have_to_buy * c);
cout << setprecision(15) << fixed << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i = 0, j = 0, k = 0, l = 0, m = 0, a = 0, b = 0, sum = 0, x = 0,
y = 0, z = 0, c, p;
cin >> c;
while (c--) {
cin >> n;
x = n;
i = 4 * n;
while (x--) {
cout << i << " ";
i -= 2;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename L>
bool smax(T &x, L y) {
return x < y ? (x = y, true) : false;
}
template <typename T, typename L>
bool smin(T &x, L y) {
return y < x ? (x = y, true) : false;
}
void update(int, int, int, int, int, int);
const int MAXN = 15e4 + 15;
int tree[MAXN << 2], lz[MAXN << 2];
int n, len, h, m;
int a[MAXN], b[MAXN];
int ans;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cerr << "HELLO WORLD :)\n";
cin >> n >> len >> h;
for (int i = 0; i < len; i++) cin >> b[i];
m = len;
sort(b, b + m);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) update(1, 0, n, i, i + 1, m - i);
for (int i = 0; i < m; i++)
update(1, 0, n, 0, lower_bound(b, b + m, h - a[i]) - b + 1, -1);
ans += (tree[1] >= 0);
for (int i = 0; i + m < n; i++) {
update(1, 0, n, 0, lower_bound(b, b + m, h - a[i]) - b + 1, 1);
update(1, 0, n, 0, lower_bound(b, b + m, h - a[i + m]) - b + 1, -1);
ans += (tree[1] >= 0);
}
return cout << ans << '\n', false;
}
void update(int id, int b, int e, int l, int r, int val) {
if (b >= r || e <= l) return;
if (b >= l && e <= r) {
tree[id] += val;
lz[id] += val;
return;
}
int mid = (b + e) >> 1;
update(id << 1, b, mid, l, r, val);
update(id << 1 | 1, mid, e, l, r, val);
tree[id] = min(tree[id << 1], tree[id << 1 | 1]) + lz[id];
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
struct covjek {
int low, high;
int suma;
int index;
};
bool cmp(covjek prvi, covjek drugi) { return prvi.suma < drugi.suma; }
covjek ljudi[MAXN];
vector<int> rjesenje;
int main() {
int n, d;
int a, b;
scanf("%d %d", &n, &d);
scanf("%d %d", &a, &b);
for (int i = 0; i < n; i++) {
scanf("%d %d", &ljudi[i].low, &ljudi[i].high);
ljudi[i].suma = ljudi[i].low * a + ljudi[i].high * b;
ljudi[i].index = i + 1;
}
sort(ljudi, ljudi + n, cmp);
for (int i = 0; i < n && d >= 0; i++) {
if (d - ljudi[i].suma >= 0) rjesenje.push_back(ljudi[i].index);
d -= ljudi[i].suma;
}
printf("%d\n", rjesenje.size());
for (int i = 0; i < rjesenje.size(); i++) printf("%d ", rjesenje[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long aa[8] = {1, 8, 64, 512, 4096, 32768, 262144};
int main() {
long long j, jgy = 0;
cin >> j;
for (int i = 0; i < 7; i++) {
if (j / aa[6 - i] == 1) jgy++;
j -= aa[6 - i] * (j / aa[6 - i]);
}
cout << jgy << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const double PI(acos(-1.0));
const double PI_2 = PI * 2.0;
double eps = 1e-9;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int r, g, b;
cin >> r >> g >> b;
int t = 0, k = 0;
while (r + g + b > 0) {
k++;
if (t == 0) {
r -= min(2, r);
} else if (t == 1) {
g -= min(2, g);
} else
b -= min(2, b);
t = (t + 1) % 3;
}
cout << k - 1 + 30 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005, mod = 998244353;
int p[N], noww[2 * N], goal[2 * N], siz[N];
int anc[N], dep[N], imp[N], top[N], col[N], dp[N][2];
int n, k, cnt, t1, t2;
vector<int> ve[N];
void Link(int f, int t) {
noww[++cnt] = p[f];
goal[cnt] = t, p[f] = cnt;
noww[++cnt] = p[t];
goal[cnt] = f, p[t] = cnt;
}
void Add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void Mul(int &x, int y) { x = 1ll * x * y % mod; }
void DFS(int nde, int fth, int dth) {
int tmp = 0;
siz[nde] = 1, anc[nde] = fth, dep[nde] = dth;
for (int i = p[nde]; i; i = noww[i])
if (goal[i] != fth) {
DFS(goal[i], nde, dth + 1);
siz[nde] += siz[goal[i]];
if (siz[goal[i]] > tmp) tmp = siz[goal[i]], imp[nde] = goal[i];
}
}
void Decompose(int nde, int tpp) {
top[nde] = tpp;
if (imp[nde]) {
Decompose(imp[nde], tpp);
for (int i = p[nde]; i; i = noww[i])
if (goal[i] != anc[nde] && goal[i] != imp[nde])
Decompose(goal[i], goal[i]);
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = anc[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
void Climb(int nde, int lca, int cor) {
while (nde != lca) {
nde = anc[nde];
if (col[nde]) {
if (col[nde] == cor)
return;
else
printf("0"), exit(0);
}
col[nde] = cor;
}
}
void Getans(int nde, int fth) {
vector<int> v1, v2;
dp[nde][(bool)col[nde]] = 1;
for (int i = p[nde]; i; i = noww[i])
if (goal[i] != fth) {
int g = goal[i];
Getans(g, nde);
int s = (dp[g][0] + dp[g][1]) % mod;
v1.push_back(s), v2.push_back(s);
col[nde] ? Mul(dp[nde][1], s) : Mul(dp[nde][0], s);
}
if (!col[nde] && v1.size()) {
int sz = v1.size(), pt = 0;
for (int i = 1; i < sz; i++) Mul(v1[i], v1[i - 1]);
for (int i = sz - 2; i >= 0; i--) Mul(v2[i], v2[i + 1]);
for (int i = p[nde]; i; i = noww[i])
if (goal[i] != fth) {
int pre = pt ? v1[pt - 1] : 1, suf = (pt == sz - 1) ? 1 : v2[pt + 1];
int tmp = dp[goal[i]][1];
Mul(tmp, pre), Mul(tmp, suf), Add(dp[nde][1], tmp), pt++;
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &col[i]);
if (col[i]) ve[col[i]].push_back(i);
}
for (int i = 1; i < n; i++) scanf("%d%d", &t1, &t2), Link(t1, t2);
DFS(1, 0, 1), Decompose(1, 1);
for (int i = 1; i <= k; i++) {
vector<int> v = ve[i];
int lca = *v.begin();
if (v.size() > 1) {
vector<int>::iterator it = ++v.begin();
while (it != v.end()) lca = LCA(lca, *it++);
}
vector<int>::iterator it = v.begin();
while (it != v.end()) Climb(*it++, lca, i);
}
Getans(1, 0);
printf("%d", dp[1][1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535;
long long int n, m;
const int mx = 69;
char grid[mx][mx];
long long int blocked[mx][mx];
long long int vis[mx][mx];
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int power(long long int a, long long int b) {
long long int res = 1;
for (int i = 1; i <= b; ++i) res *= a;
return res;
}
int main() {
FAST();
string s;
cin >> s;
int num = s[s.size() - 1] + s[s.size() - 2] * 10;
if (num % 4 == 0 || num == 0) {
cout << "4\n";
} else
cout << "0\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cont[13];
int main() {
int n;
cin >> n;
bool pod = true;
int m;
for (int i = 0; i < n; i++) {
cin >> m;
if (m == 5 || m == 7) pod = false;
cont[m]++;
}
if (!pod)
cout << -1 << endl;
else {
if (cont[4] > cont[2]) pod = false;
if (cont[4] > cont[1]) pod = false;
int unos = cont[1] - cont[4];
int dos = cont[2] - cont[4];
if (cont[6] != unos || (cont[6] != dos + cont[3])) pod = false;
if (!pod) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < cont[4]; i++) cout << 1 << " " << 2 << " " << 4 << endl;
for (int i = 0; i < dos; i++) cout << 1 << " " << 2 << " " << 6 << endl;
for (int i = 0; i < cont[3]; i++) cout << 1 << " " << 3 << " " << 6 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
for (int test = 1; test <= t; test++) {
long long x, y;
long long c1, c2, c3, c4, c5, c6;
cin >> x >> y;
cin >> c1 >> c2 >> c3 >> c4 >> c5 >> c6;
long long rez = 0;
if (x <= 0 && y >= 0) {
x = (-x);
cout << 1LL * (min(1LL * x * c3, 1LL * x * c4 + 1LL * x * c2) +
min(1LL * y * c2, 1LL * y * c1 + 1LL * y * c3))
<< '\n';
} else if (x >= 0 && y <= 0) {
y = (-y);
cout << 1LL * (min(1LL * x * c6, 1LL * x * c1 + 1LL * x * c5) +
min(1LL * y * c5, 1LL * y * c4 + 1LL * y * c6))
<< '\n';
} else if (x <= 0 && y <= 0) {
x = (-x);
y = (-y);
if (x >= y) {
cout << 1LL * min(1LL * x * c3 + 1LL * y * c5,
min(1LL * x * c4 + 1LL * (x - y) * c2,
1LL * y * c4 + 1LL * (x - y) * c3))
<< '\n';
} else {
cout << 1LL * min(1LL * x * c3 + 1LL * y * c5,
min(1LL * x * c4 + 1LL * (y - x) * c5,
1LL * y * c4 + 1LL * (y - x) * c6))
<< '\n';
}
} else if (x >= 0 && y >= 0) {
if (x >= y) {
cout << 1LL * min(1LL * x * c6 + 1LL * y * c2,
min(1LL * x * c1 + 1LL * (x - y) * c5,
1LL * y * c1 + 1LL * (x - y) * c6))
<< '\n';
} else {
cout << 1LL * min(1LL * x * c6 + 1LL * y * c2,
min(1LL * x * c1 + 1LL * (y - x) * c2,
1LL * y * c1 + 1LL * (y - x) * c3))
<< '\n';
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2000;
bool check(vector<int> v) {
sort(v.begin(), v.end());
if (2 * v[3] - 2 * v[0] != v[1] + v[2]) return false;
if (4 * v[3] - 4 * v[0] != v[0] + v[1] + v[2] + v[3]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
if (n == 0) cout << "YES\n1\n1\n3\n3\n";
if (n == 1)
cout << "YES\n" << 2 * v[0] << '\n' << 2 * v[0] << '\n' << 3 * v[0] << '\n';
if (n == 2) {
v.push_back(0);
v.push_back(0);
for (int i = 1; i < MAX; i++) {
v[2] = i;
for (int j = 1; j < MAX; j++) {
v[3] = j;
if (check(v)) {
cout << "YES\n" << i << '\n' << j << '\n';
return 0;
}
}
}
cout << "NO\n";
}
if (n == 3) {
v.push_back(0);
for (int i = 1; i < MAX; i++) {
v[3] = i;
if (check(v)) {
cout << "YES\n" << i << '\n';
return 0;
}
}
cout << "NO\n";
}
if (n == 4) cout << (check(v) ? "YES\n" : "NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
inline T dis(T x1, T y1, T x2, T y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
template <class T>
inline bool odd(T x) {
return x & 1;
}
template <class T>
inline bool even(T x) {
return !odd(x);
}
void solve() {
long long n;
long long d;
cin >> d >> n;
long long tmp;
long long res = 0;
for (long long i = 0; i < n; i++) {
cin >> tmp;
if (d > tmp && i != n - 1) res += (d - tmp);
}
cout << res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T;
T = 1;
while (T--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0, root, ans = 0x3f3f3f3f;
int head[60], a[60], cd[60], c[60][60];
int f[2][60], dp[60][60][60][60];
struct edge {
int u, v, w, next;
} e[120];
void add(int u, int v, int w) {
e[++cnt] = (edge){u, v, w, head[u]};
head[u] = cnt;
}
void dfs(int u, int fa) {
for (int i = head[u]; i; i = e[i].next)
if (e[i].v != fa) dfs(e[i].v, u), a[u] += a[e[i].v];
}
int solve(int u, int v, int s1, int s2) {
if (!s1 && !s2) return 0;
if (!s1) return 0x3f3f3f3f;
int &ret = dp[u][v][s1][s2];
if (ret < 0x3f3f3f3f) return ret;
if (cd[v] == 1) {
ret = solve(v, u, s2, 0) + c[u][v];
return ret;
}
for (int i = head[v]; i; i = e[i].next)
if (e[i].v != u)
for (int k = 0; k <= s1; k++) solve(v, e[i].v, k, s1 + s2 - k);
memset(f[1], 0, sizeof(f[1]));
f[1][0] = 0x3f3f3f3f;
bool b = 0;
for (int i = head[v]; i; i = e[i].next) {
if (e[i].v != u) {
memset(f[b], 0, sizeof(f[b]));
for (int j = 0; j <= s1; j++)
for (int k = 0; k + j <= s1; k++)
f[b][j + k] = max(f[b][j + k],
min(f[b ^ 1][j], solve(v, e[i].v, k, s1 + s2 - k)));
b ^= 1;
}
}
ret = f[b ^ 1][s1] + c[u][v];
return ret;
}
int main() {
int x, y, z;
memset(dp, 0x3f, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
cd[x]++;
cd[y]++;
c[x][y] = c[y][x] = z;
}
scanf("%d%d", &root, &m);
for (int i = 1; i <= m; i++) scanf("%d", &x), a[x]++;
dfs(root, 0);
for (int i = head[root]; i; i = e[i].next)
ans = min(ans, solve(root, e[i].v, a[e[i].v], m - a[e[i].v]));
printf("%d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int sta[2000005], a[100005];
char ans[3][6] = {"Vanya", "Vova", "Both"};
int main() {
int n, x, y;
scanf("%d %d %d", &n, &x, &y);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int hit_x = 0, hit_y = 0, idx = 0, total = x + y;
while (hit_x < x && hit_y < y) {
double next_x = (double)(hit_x + 1) / x, next_y = (double)(hit_y + 1) / y;
if (next_x < next_y)
sta[idx] = 0, hit_x++;
else if (next_x > next_y)
sta[idx] = 1, hit_y++;
else
sta[idx] = 2, sta[++idx] = 2, hit_x++, hit_y++;
++idx;
}
for (int i = 0; i < n; ++i) {
int last = (a[i] - 1) % total;
printf("%s\n", ans[sta[last]]);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll>ii;
#define X first
#define Y second
#define pb push_back
#define FOR(i,a,b) for(ll i=a;i<=b;i++)
#define FORD(i,a,b) for(ll i=a;i>=b;i--)
#define all(a) (a).begin(),(a).end()
#define uni(a) (a).resize(unique(all(a)) - (a).begin())
const ll mod = 1e9+7;
const ll maxN = 1e6+5;
const ll N = 1e6;
void solve() {
ll n;
cin >> n;
if (n == 1) cout << 0 << "\n";
else if (n == 2) cout << 1 << "\n";
else if (n == 3) cout << 2 << "\n";
else {
if (n % 2 == 0) cout << 2 << "\n";
else cout << 3 << "\n";
}
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(0);
ll T = 1;
cin >> T;
while (T--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct s {
long long id, v;
} a[300005];
bool cmp(s aa, s bb) { return aa.v > bb.v; }
int main() {
long long n, x1, x2;
scanf("%I64d %I64d %I64d", &n, &x1, &x2);
for (long long i = 1; i <= n; ++i) {
a[i].id = i;
scanf("%I64d", &a[i].v);
}
sort(a + 1, a + 1 + n, cmp);
long long zt = 1, l, r, ll, rr;
for (long long i = 1; i <= n - 1; ++i) {
if (x1 <= a[i].v * i) {
for (long long j = i + 1; j <= n; ++j) {
if (x2 <= a[j].v * (j - i)) {
zt = 0;
l = 1;
r = i;
ll = i + 1;
rr = j;
break;
}
}
break;
}
}
if (zt) {
for (long long i = 1; i <= n - 1; ++i) {
if (x2 <= a[i].v * i) {
for (long long j = i + 1; j <= n; ++j) {
if (x1 <= a[j].v * (j - i)) {
zt = 0;
l = i + 1;
r = j;
ll = 1;
rr = i;
break;
}
}
break;
}
}
}
if (zt)
printf("No\n");
else {
printf("Yes\n");
printf("%I64d %I64d\n", r - l + 1, rr - ll + 1);
for (long long i = l; i <= r; ++i)
printf("%I64d%c", a[i].id, i == r ? '\n' : ' ');
for (long long i = ll; i <= rr; ++i)
printf("%I64d%c", a[i].id, i == rr ? '\n' : ' ');
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long _set(long long N, long long pos) { return N = N | (1 << pos); }
long long _reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool _check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
bool _upper(char a) { return a >= 'A' && a <= 'Z'; }
bool _lower(char a) { return a >= 'a' && a <= 'z'; }
bool _digit(char a) { return a >= '0' && a <= '9'; }
long long dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
long long dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
long long a[100010];
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) a[i] = i;
for (long long i = 2; i <= n; i += 2) {
if (n % 2)
swap(a[i], a[i + 1]);
else
swap(a[i], a[i - 1]);
}
for (long long i = 1; i <= n; i++) cout << a[i] << ' ';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int sx, sy;
char graph[1508][1508];
int chgx[4] = {0, 0, 1, -1};
int chgy[4] = {1, -1, 0, 0};
struct node {
int x, y;
};
node vis[1508][1508];
bool vis2[1508][1508];
bool bfs(int x, int y) {
node u, v;
u.x = x;
u.y = y;
vis[x][y].x = x;
vis[x][y].y = y;
vis2[x][y] = 1;
queue<node> que;
que.push(u);
int tx, ty;
while (!que.empty()) {
u = que.front();
que.pop();
x = u.x;
y = u.y;
for (int i = 0; i < 4; i++) {
tx = x + chgx[i];
ty = y + chgy[i];
if (vis2[((tx % n) + n) % n][((ty % m) + m) % m]) {
if (vis[((tx % n) + n) % n][((ty % m) + m) % m].x != tx ||
vis[((tx % n) + n) % n][((ty % m) + m) % m].y != ty) {
return true;
} else
continue;
} else {
if (graph[((tx % n) + n) % n][((ty % m) + m) % m] == '.') {
v.x = tx;
v.y = ty;
vis[((tx % n) + n) % n][((ty % m) + m) % m].x = tx;
vis[((tx % n) + n) % n][((ty % m) + m) % m].y = ty;
vis2[((tx % n) + n) % n][((ty % m) + m) % m] = 1;
que.push(v);
}
}
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
vis[i][j].x = 2e9;
vis[i][j].y = 2e9;
scanf(" %c", &graph[i][j]);
if (graph[i][j] == 'S') {
sx = i;
sy = j;
graph[i][j] = '.';
}
}
}
if (bfs(sx, sy)) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005, M = 200005;
int n, a[N], cn[N], c[N], c0[N], ans, maxn, p[N];
template <class I>
void Max(I& p, int q) {
p = (p > q ? p : q);
}
void ins(int x) { --c0[c[x]], ++c[x], ++c0[c[x]], Max(maxn, c[x]); }
void del(int x) { --c0[c[x]], --c[x], ++c0[c[x]], maxn -= (c0[maxn] == 0); }
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), ++cn[a[i]], cn[a[i]] > cn[mx] ? mx = a[i] : 0;
if (cn[mx] == n) return putchar('0'), 0;
int lim = (cn[mx] < 512 ? cn[mx] : 512);
for (int i = 1; i <= n; i++)
if (i != mx && cn[i] >= 512) {
for (int j = -n; j <= n; j++) p[j + M] = -1;
for (int sum = p[M] = 0, j = 1; j <= n; j++)
sum += (a[j] == mx), sum -= (a[j] == i),
~p[sum + M] ? Max(ans, j - p[sum + M]), 0 : p[sum + M] = j;
}
for (int i = 1; i <= lim; i++) {
for (int j = 1; j <= n; j++) c[j] = c0[j] = 0;
c0[maxn = 0] = n;
for (int j = 1, k = 1, x = 0; j <= n; j++) {
while (k <= n && x + (a[k] == mx) <= i) ins(a[k]), x += (a[k] == mx), ++k;
c0[maxn] >= 2 ? Max(ans, k - j), 0 : 0, del(a[j]), x -= (a[j] == mx);
}
}
printf("%d", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string symbol;
bool cmp(string a, string b) {
if (a + symbol < b + symbol) return true;
return false;
}
int main() {
int n;
while (cin >> n) {
string s[10005];
bool used[10005];
int length = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
length += s[i].length();
used[i] = false;
}
int average = length * 2 / n;
cin >> symbol;
stable_sort(s, s + n, cmp);
for (int i = 0; i < n; i++) {
if (used[i] == true) continue;
used[i] = true;
for (int j = i + 1; j < n; j++) {
if (!used[j] && s[i].length() + s[j].length() == average) {
cout << s[i] << symbol << s[j] << endl;
used[j] = true;
break;
}
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = int(1e5) + 10;
int CHAR;
inline void eat() {
do {
CHAR = getchar();
} while (CHAR == ' ' || CHAR == '\n' || CHAR == '\t');
}
inline long long getnumber() {
eat();
long long ret = 0;
while (isdigit(CHAR)) {
ret = 10 * ret + CHAR - 48;
CHAR = getchar();
}
return ret;
}
inline void getstring(char *str) {
eat();
int cc = 0;
while (isalpha(CHAR)) {
str[cc++] = CHAR;
CHAR = getchar();
}
str[cc] = '\0';
}
bool win(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return false;
if (!win(b % a, a)) return true;
long long x = b / a;
return x % (a + 1) % 2 == 0;
}
int main() {
for (int test = getnumber(); test; test--) {
long long a = getnumber(), b = getnumber();
if (win(a, b))
cout << "First\n";
else
cout << "Second\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N, T;
cin >> N >> T;
if (T == 10 && N == 1) {
cout << -1;
return 0;
}
if (T != 10) {
for (int i = 0; i < N; i++) cout << T;
}
if (T == 10) {
for (int i = 0; i < N - 1; i++) cout << 1;
cout << 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} a[100010];
int main() {
int n;
cin >> n;
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].y;
if (!i) {
if (a[i].x > a[i].y) swap(a[i].x, a[i].y);
} else {
if (min(a[i].x, a[i].y) > a[i - 1].y)
flag = 1;
else {
int x = a[i - 1].y - a[i].x;
int y = a[i - 1].y - a[i].y;
if (x >= 0 and y >= 0) {
if (x < y) swap(a[i].x, a[i].y);
} else if (x >= 0)
swap(a[i].x, a[i].y);
}
}
}
if (!flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, mo = 1000000009;
long long f1[N], f2[N], f3[N], f[N], g[N];
int main() {
f1[2] = f2[2] = f3[2] = 1;
f[1] = 1;
f[2] = 5;
g[0] = 1;
for (int i = (1); i <= (N - 1); i++) g[i] = (2 * g[i - 1] + 3) % mo;
for (int i = (3); i <= (N - 1); i++) {
if (i % 2 == 0) {
f1[i] = f1[i - 1];
f2[i] = (f2[i - 1] + 2 * f1[i - 1]) % mo;
f3[i] = (2 * f2[i - 1] + 3 * f1[i - 1]) % mo;
} else {
long long tmp = g[(i - 3) / 2];
f1[i] = f1[i - 1] * tmp % mo * tmp % mo;
f2[i] = f2[i - 1] * tmp % mo + f1[i - 1] * tmp % mo +
f1[i - 1] * tmp % mo * tmp % mo;
f3[i] = 2 * f2[i - 1] % mo * tmp % mo;
f3[i] =
f3[i] + 2 * f1[i - 1] * tmp % mo + f1[i - 1] * tmp % mo * tmp % mo;
f3[i] %= mo;
}
f[i] = (f1[i] + 2 * f2[i] + f3[i] + f[i - 1]) % mo;
}
int n;
while (cin >> n) cout << f[n] * 2 % mo << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int s;
string a;
cin >> s;
cin >> a;
if (s < 11)
cout << "NO" << '\n';
else {
bool flag = false;
int keep;
for (int j = 0; j < a.size(); ++j) {
if (a[j] == '8') {
keep = j;
flag = true;
break;
}
}
if (flag == true) {
if (a.size() - keep >= 11)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
} else
cout << "NO" << '\n';
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d[200];
int f[1100000];
char type[50];
int num[50];
int n;
void dodo(int x) {
int c = n;
int first = -1;
int min = 100000000;
int mmin;
int max = -100000000;
int mmax;
for (int i = 0; i < n; i++)
if (x >> i & 1) {
c--;
if (first == -1) first = i;
int y = x ^ 1 << i;
if (f[y] < min) {
min = f[y];
mmin = i;
}
if (f[y] > max) {
max = f[y];
mmax = i;
}
}
if (type[c] == 'p') {
int y = x ^ 1 << first;
if (num[c] == 1)
f[x] = f[y] + d[first];
else
f[x] = f[y] - d[first];
} else {
if (num[c] == 1)
f[x] = max;
else
f[x] = min;
}
}
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%d", &d[i]);
sort(d, d + n, greater<int>());
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf(" %c %d", &type[i], &num[i]);
int h = 1 << n;
for (int i = 1; i < h; i++) {
dodo(i);
}
printf("%d\n", f[h - 1]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, x, k;
vector<int> G[100005];
bool can(int idx) {
vector<bool> seen(G[idx].size() + 10, 0);
seen[0] = true;
for (int i = 0; i < G[idx].size(); i++) {
int val = G[idx][i];
if (val >= seen.size()) return 0;
if (!seen[val - 1]) return 0;
seen[val] = 1;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &k);
G[k].push_back(x + 1);
}
bool ans = 1;
for (int i = 1; i < 100005; i++)
if (G[i].size() > 0)
if (can(i) == 0) {
ans = 0;
}
puts(ans ? "YES" : "NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
FILE* _fin = stdin;
FILE* _fout = stdout;
void reversei(int* data, int n) {
int k = n >> 1;
for (int i = 0; i < k; ++i) {
int tmp = data[i];
data[i] = data[n - i - 1];
data[n - i - 1] = tmp;
}
}
int bsearch(int val, int* data, int n) {
if (data[0] > val) return -1;
if (data[n - 1] < val) return n;
int l = 0;
int r = n - 1;
for (; l < r;) {
int mid = (l + r + 1) >> 1;
if (data[mid] <= val)
l = mid;
else
r = mid - 1;
}
if (data[r] != val) ++r;
return r;
}
struct Veci {
int* data;
int size;
int n;
};
void init(Veci* t, int size) {
t->data = (int*)malloc(sizeof(int) * size);
t->size = size;
t->n = 0;
}
void resize(Veci* t) {
int ns = t->size * 1.2f;
t->data = (int*)realloc(t->data, sizeof(int) * ns);
t->size = ns;
}
void add(Veci* t, int val) {
if (t->n >= t->size) resize(t);
int k = t->n;
t->data[k] = val;
t->n = k + 1;
}
void free(Veci* t) {
free(t->data);
*t = {0};
}
struct Vecll {
long long* data;
int size;
int n;
};
void init(Vecll* t, int size) {
t->data = (long long*)malloc(sizeof(long long) * size);
t->size = size;
t->n = 0;
}
void resize(Vecll* t) {
int ns = t->size * 1.2f;
t->data = (long long*)realloc(t->data, sizeof(long long) * ns);
t->size = ns;
}
void add(Vecll* t, long long val) {
if (t->n >= t->size) resize(t);
int k = t->n;
t->data[k] = val;
t->n = k + 1;
}
void free(Vecll* t) {
free(t->data);
*t = {0};
}
struct Vecs {
char** data;
int size;
int n;
};
void init(Vecs* t, int size) {
t->data = (char**)malloc(sizeof(char*) * size);
t->size = size;
t->n = 0;
}
void resize(Vecs* t) {
int ns = t->size * 1.2f;
t->data = (char**)realloc(t->data, sizeof(char*) * ns);
t->size = ns;
}
void add(Vecs* t, char* val) {
if (t->n >= t->size) resize(t);
int k = t->n;
t->data[k] = val;
t->n = k + 1;
}
void free(Vecs* t) {
free(t->data);
*t = {0};
}
int ispali(int* a, int* b, int n) {
for (int i = 0; i < n; ++i) {
if (a[i] != b[n - i - 1]) {
return 0;
}
}
return 1;
}
int ispalc(char* a, char* b, int n) {
for (int i = 0; i < n; ++i) {
if (a[i] != b[n - i - 1]) {
return 0;
}
}
return 1;
}
struct Pairi {
int x, y;
};
int cmp_Pairi(const void* _a, const void* _b) {
Pairi* a = (Pairi*)_a;
Pairi* b = (Pairi*)_b;
if (a->x == b->x) {
if (a->y < b->y)
return -1;
else
return 1;
}
if (a->x < b->x)
return -1;
else
return 1;
}
void sort_Pairi(Pairi* d, int n) { qsort(d, n, sizeof(Pairi), cmp_Pairi); }
long long THIS_WAS_AN_OVERKILL_maxsum(int* a, int n) {
int left = 0;
int right = 0;
long long bestsum = 0;
int bestleft = 0;
int bestright = right;
long long currentsum = a[0];
for (;;) {
if (left >= n) break;
if (a[left] <= 0) {
currentsum = 0;
left++;
right = left;
continue;
}
if (left == right) currentsum = a[left];
if (currentsum > bestsum) {
bestsum = currentsum;
bestleft = left;
bestright = right;
} else if (currentsum < 0) {
left = right;
}
right++;
if (right >= n) break;
currentsum += a[right];
}
return bestsum;
}
long long maxsum(int* a, int n) {
long long bestsum = a[0];
long long currentsum = 0;
for (int i = 0; i < n; ++i) {
currentsum += a[i];
if (currentsum > bestsum) bestsum = currentsum;
if (currentsum < 0) currentsum = 0;
}
return bestsum;
}
int main() {
{
_fin = fopen("data1287A.txt", "r");
if (_fin == NULL) _fin = stdin;
};
int ntests = 0;
fscanf(_fin, "%d", &ntests);
for (int t = 0; t < ntests; ++t) {
int n = 0;
fscanf(_fin, "%d", &n);
static char s[101];
for (;;) {
fgets(s, 101, _fin);
if (s[0] != '\n') break;
};
int firstA = -1;
for (int i = 0; i < n; ++i) {
if (s[i] == 'A') {
firstA = i;
break;
}
}
if (firstA == -1) {
fprintf(_fout, "%d\n", 0);
continue;
}
int maxcount = 0;
int count = 0;
for (int i = firstA; i < n; ++i) {
if (s[i] == 'A')
count = 0;
else
count++;
if (count > maxcount) maxcount = count;
}
fprintf(_fout, "%d\n", maxcount);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MAXN = 100 + 10;
int n, m;
int main() {
while (~scanf("%d %d%*c", &n, &m)) {
int cnt = 0, p = 0;
if (((n & 1) && m * 2 <= n * n + 1) || (!(n & 1) && m * 2 <= n * n)) {
puts("YES");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (cnt < m)
p ^= 1;
else
p = 0;
if (p) cnt++;
putchar(p ? 'L' : 'S');
}
if (!(n & 1)) p ^= 1;
putchar('\n');
}
} else
puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[7010], b[7010], deg[14010], ans[14010], q[14010];
vector<int> e[14010];
int main() {
int n;
scanf("%d", &n);
int n1;
scanf("%d", &n1);
for (int i = 0; i < n1; i++) scanf("%d", &a[i]);
int n2;
scanf("%d", &n2);
for (int i = 0; i < n2; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < n1; j++) {
int first = (i - a[j] + n - 1) % n + 1;
deg[first]++;
}
for (int j = 0; j < n2; j++) {
int first = (i - b[j] + n - 1) % n + 1;
deg[n + first]++;
}
}
for (int i = 1; i <= 2 * n; i++) ans[i] = 2;
ans[1] = ans[n + 1] = 1;
int f = 1, r = 2;
q[1] = 1;
q[2] = n + 1;
while (f <= r) {
int first = q[f++];
if (first > n)
for (int j = 0; j < n1; j++) {
int second = (first - a[j] + n - 1) % n + 1;
if (ans[second] == 2) {
if (ans[first] == 1) {
q[++r] = second;
ans[second] = 0;
} else if (--deg[second] == 0) {
q[++r] = second;
ans[second] = 1;
}
}
}
else
for (int j = 0; j < n2; j++) {
int second = (first - b[j] + n - 1) % n + 1 + n;
if (ans[second] == 2) {
if (ans[first] == 1) {
q[++r] = second;
ans[second] = 0;
} else if (--deg[second] == 0) {
q[++r] = second;
ans[second] = 1;
}
}
}
}
for (int i = 2; i <= n; i++)
printf(ans[i] ? (ans[i] == 1 ? "Lose " : "Loop ") : "Win ");
puts("");
for (int i = n + 2; i <= 2 * n; i++)
printf(ans[i] ? (ans[i] == 1 ? "Lose " : "Loop ") : "Win ");
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 107;
int vis[MAX];
int cost[MAX][MAX];
int coord[MAX][2];
int max_times[MAX];
int add[MAX];
int d, n;
bool is_possible(int start) {
for (int i = 1; i <= n; i++) max_times[i] = vis[i] = 0;
bool changed = 1;
max_times[1] = start;
while (changed) {
changed = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (cost[i][j] > max_times[i] || i == j) continue;
vis[j] = 1;
if (max_times[i] - cost[i][j] + add[j] > max_times[j]) {
max_times[j] = max_times[i] - cost[i][j] + add[j];
changed = 1;
}
}
}
if (vis[n]) return 1;
return 0;
}
int bin_search() {
int left = 0, right = 1000000000;
while (left < right) {
int mid = left + (right - left) / 2;
if (is_possible(mid))
right = mid;
else
left = mid + 1;
}
return left;
}
int main() {
cin >> n >> d;
for (int i = 2; i < n; i++) {
cin >> add[i];
}
for (int i = 1; i <= n; i++) {
cin >> coord[i][0] >> coord[i][1];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
cost[i][j] =
d * (abs(coord[i][0] - coord[j][0]) + abs(coord[i][1] - coord[j][1]));
cout << bin_search();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5, inf = 1 << 30;
inline long long read() {
register long long f = 1, sum = 0;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
sum = (sum << 1) + (sum << 3) + (ch ^ 48);
ch = getchar();
}
return f * sum;
}
int n;
int l[N], s[N], dp[N];
signed main() {
n = read();
for (register int i = 1; i <= n; i++) {
s[i] = s[i - 1] + read();
dp[i] = l[i] = inf;
}
for (register int i = 1; i <= n; i++) {
for (register int j = 0; j <= i; j++) {
if (s[i] - s[j] >= l[j] && dp[i] >= dp[j] + i - j - 1) {
dp[i] = dp[j] + i - j - 1;
l[i] = min(l[i], s[i] - s[j]);
}
}
}
printf("%d\n", dp[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int l = 1, r, n, m;
int x, y;
string ask(int a, int b) {
fflush(stdout);
cout << 1 << ' ' << a << ' ' << b << endl;
fflush(stdout);
string s;
cin >> s;
return s;
}
int main() {
cin >> n >> m;
l = 1;
r = n;
while (l != r) {
int mid = (l + r) / 2;
string ans = ask(mid, mid + 1);
if (ans == "TAK") {
r = mid;
} else
l = mid + 1;
}
x = l;
l = 1;
r = x - 1;
if (x == 1) goto anc;
while (l != r) {
int mid = (l + r) / 2;
string ans = ask(mid, mid + 1);
if (ans == "TAK") {
r = mid;
} else
l = mid + 1;
}
if (x == n || ask(l, l + 1) == "TAK") {
y = l;
} else {
anc:
l = x + 1;
r = n;
while (l != r) {
int mid = (l + r) / 2;
string ans = ask(mid, mid + 1);
if (ans == "TAK") {
r = mid;
} else
l = mid + 1;
}
y = l;
}
if (x > y) swap(x, y);
cout << 2 << ' ' << x << ' ' << y << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, len;
int a[300010], c[300010];
pair<int, int> q[300010];
long long ans;
void push(pair<int, int> x) {
q[++len] = x;
for (int i = len; i / 2 && q[i] > q[i >> 1]; i >>= 1) swap(q[i], q[i >> 1]);
}
pair<int, int> get() {
int i, j;
pair<int, int> t = q[1];
q[1] = q[len--];
for (i = 1; i * 2 <= len; i = j) {
if (i * 2 + 1 > len || q[i << 1] > q[i << 1 | 1])
j = i << 1;
else
j = i << 1 | 1;
if (q[i] > q[j]) break;
swap(q[i], q[j]);
}
return t;
}
int main() {
int i;
pair<int, int> x;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; ++i) scanf("%d", &c[i]);
for (i = 1; i <= min(k, n); ++i) push(make_pair(c[i], i));
for (i = k + 1; i <= k + n; ++i) {
if (i <= n) push(make_pair(c[i], i));
x = get();
a[x.second] = i;
ans += (long long)(i - x.second) * x.first;
}
printf("%I64d\n", ans);
for (i = 1; i <= n; ++i) {
printf("%d", a[i]);
if (i < n) putchar(' ');
}
putchar(13);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
while (n--) cout << "1 ";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int diff = k, first = 1, last = n;
cout << first++ << " ";
while (diff > 2) {
cout << last-- << " ";
cout << first++ << " ";
diff = diff - 2;
}
if (diff == 1) {
while (first != last + 1) cout << first++ << " ";
} else {
while (first != last + 1) cout << last-- << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (b < a || c < a) {
cout << "No";
return 0;
}
cout << "Yes";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll N = 2e5+5;
const ll M = 1e9+7;
ll n;
ll b[N];
map<ll,ll> dp;
//dp[i] represents hybrid array count with sum i
int main(){
ll t;
cin >> t;
while (t--){
cin >> n;
dp.clear();
for (ll i = 0; i<n; i++){
cin >> b[i];
}
ll w = 0;
//venice technique - water level
//optimize transition from all dp[j] -> dp[j+bi]
dp[0] = 1;
ll sum = 1;
for (ll i = 0; i<n; i++){
ll p = dp[-w];
dp[-w] = sum;
w += b[i];
sum = (2*sum-p+M)%M;
}
cout << sum << endl;
}
}
| 8 |
#include <bits/stdc++.h>
const int mod = 1000000007;
int n, p[1000];
long long d[1001];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i]);
p[i]--;
}
d[0] = 0;
d[1] = 2;
for (int i = 2; i <= n; ++i)
d[i] = ((2 * d[i - 1]) % mod + mod - d[p[i - 1]] + 2) % mod;
printf("%I64d\n", d[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0) {
putchar('-'), write(-x);
} else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 1e6 + 5;
int n, a[N];
bool v[N];
void doit() {
vector<int> ans;
read(n);
for (int i = 1; i <= n; i++) {
a[i] = i - read(a[i]);
v[i] = 0;
}
int aim = 1;
for (; !v[aim]; aim = a[aim]) v[aim] = 1;
ans.push_back(aim);
for (int i = a[aim]; i ^ aim; i = a[i]) ans.push_back(i);
write(ans.size());
puts("");
for (int i = 0; i < ans.size(); i++) write(ans[i]), putchar(' ');
puts("");
}
signed main() {
int t;
read(t);
while (t--) doit();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 262150;
int n, q, a[N], l, L[20], R[20], loc[20], rt;
int sw[N * 4], rev[N * 4], m;
struct T {
int l, r;
long long sum;
bool rev;
} t[N * 4];
void inline pushup(int p) { t[p].sum = t[t[p].l].sum + t[t[p].r].sum; }
int inline getSwap(int x) {
int res = 0;
for (; x; x -= x & -x) res += sw[x];
return res;
}
int inline getRev(int x) {
int res = 0;
for (; x; x -= x & -x) res += rev[x];
return res;
}
void inline addSwap(int x, int k) {
for (; x <= m; x += x & -x) sw[x] += k;
}
void inline addRev(int x, int k) {
for (; x <= m; x += x & -x) rev[x] += k;
}
void inline pushdown(int p, int k) {
if (getSwap(p) & 1) {
swap(t[p].l, t[p].r);
addSwap(p, -1);
addSwap(p + 1, 1);
}
if (getRev(p) & 1) {
swap(t[p].l, t[p].r);
addRev(p, -1);
addRev(p + 1, 1);
addRev(t[p].l, 1);
addRev(t[p].l + 1, -1);
addRev(t[p].r, 1);
addRev(t[p].r + 1, -1);
}
}
void build(int &p, int l, int r, int c) {
p = (++R[c]);
if (l == r) {
t[p].sum = a[r];
return;
}
int mid = (l + r) >> 1;
build(t[p].l, l, mid, c - 1);
build(t[p].r, mid + 1, r, c - 1);
pushup(p);
}
void change(int p, int l, int r, int c, int x, int k) {
if (l == r) {
t[p].sum = k;
return;
}
pushdown(p, c);
int mid = (l + r) >> 1;
if (x <= mid)
change(t[p].l, l, mid, c - 1, x, k);
else
change(t[p].r, mid + 1, r, c - 1, x, k);
pushup(p);
}
long long query(int p, int l, int r, int c, int x, int y) {
if (x <= l && r <= y) return t[p].sum;
pushdown(p, c);
int mid = (l + r) >> 1;
long long res = 0;
if (x <= mid) res += query(t[p].l, l, mid, c - 1, x, y);
if (mid < y) res += query(t[p].r, mid + 1, r, c - 1, x, y);
return res;
}
int main() {
scanf("%d%d", &n, &q);
l = n;
n = 1 << n;
for (int i = l - 1; i >= 0; i--) R[i] = R[i + 1] + (1 << (l - (i + 1)));
for (int i = 0; i <= l; i++) L[i] = R[i] + 1;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
build(rt, 1, n, l);
m = R[0];
while (q--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int x, k;
scanf("%d%d", &x, &k);
change(1, 1, n, l, x, k);
} else if (opt == 2) {
int k;
scanf("%d", &k);
addRev(L[k], 1);
addRev(R[k] + 1, -1);
} else if (opt == 3) {
int k;
scanf("%d", &k);
++k;
addSwap(L[k], 1);
addSwap(R[k] + 1, -1);
} else if (opt == 4) {
int a, b;
scanf("%d%d", &a, &b);
printf("%lld\n", query(1, 1, n, l, a, b));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
int n, i, x, y, maxi = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
sort(v.begin(), v.end());
for (i = 0; i < n; i++) {
if (v[i].second >= maxi)
maxi = v[i].second;
else {
maxi = v[i].first;
}
}
cout << maxi;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:256000000")
int main() {
string a[30005];
int n, ans = 0, t;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int h = a[1].length();
for (; ans < h; ++ans) {
t = 1;
for (int j = 2; j <= n; ++j)
if (a[j][ans] != a[1][ans]) t = 0;
if (!t) break;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void debug() { cout << endl; }
template <typename T, typename... Args>
void debug(T a, Args... args) {
cout << a << ' ';
debug(args...);
}
const int MOD = 1e9 + 7;
long long mulmod(long long a, long long b, long long m) {
long long r = a * b - (long long)((long double)a * b / m + .5) * m;
return r < 0 ? r + m : r;
}
long long expmod(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return mulmod(b, expmod(b, e - 1, m), m);
b = expmod(b, e >> 1, m);
return mulmod(b, b, m);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int k, xp = 1;
cin >> k;
bool par = false;
for (int i = 0, gon = k; i < gon; ++i) {
long long n;
cin >> n;
par |= !(n & 1);
xp = mulmod(n % (MOD - 1), xp, MOD - 1);
}
xp = (xp - 1 + (MOD - 1)) % (MOD - 1);
int num, den;
num = den = expmod(2, xp, MOD);
if (par)
num = (num + 1) % MOD;
else
num = (num - 1 + MOD) % MOD;
int inv = expmod(3, MOD - 2, MOD);
num = mulmod(num, inv, MOD);
cout << num << "/" << den << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> unseen;
set<int> uadj[300005];
int ci[300005], C;
int nin[300005];
int n, m, k;
void go(int i, int cn) {
ci[i] = cn;
unseen.erase(unseen.find(i));
int j = 0;
while (1) {
auto it = unseen.lower_bound(j + 1);
if (it == unseen.end()) break;
j = *it;
if (!uadj[i].count(j)) {
go(j, cn);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = (0); i < (m); i++) {
int x, y;
scanf("%d%d", &x, &y);
uadj[x].insert(y);
uadj[y].insert(x);
}
for (int i = (2); i < (n + 1); i++) unseen.insert(i);
for (int i = (2); i < (n + 1); i++)
if (ci[i] == 0) {
go(i, ++C);
}
for (int i = (2); i < (n + 1); i++) {
if (!uadj[1].count(i)) nin[ci[i]]++;
}
int tsum = 0;
for (int i = (1); i < (C + 1); i++) {
tsum += nin[i];
if (nin[i] == 0) {
printf("impossible\n");
return 0;
}
}
if (C <= k && k <= tsum) {
printf("possible\n");
} else {
printf("impossible\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1000 + 100;
const long long mod = 1000000007;
int n, m, k;
long long d[maxn][maxn];
long long c(int a, int b) {
if (a == 1) return 1;
if (d[a][b] != -1) return d[a][b];
long long res = 0;
for (int l = 1; l <= b - 2; l++)
res = (res + c(a - 2, l) * (b - l - 1)) % mod;
return d[a][b] = res;
}
int main() {
cin >> n >> m >> k;
k++;
if (n > m) swap(n, m);
if (k * 2 - 1 > n) {
cout << 0 << endl;
return 0;
}
memset(d, -1, sizeof d);
long long a = c(2 * k - 1, m);
long long b = c(2 * k - 1, n);
cout << (a * b) % mod << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, a[MAXN * 3], u[MAXN * 3], v[MAXN * 3], front, rear;
int main() {
int Q;
long long x;
scanf("%d%d", &n, &Q);
front = 1;
rear = n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= 2 * n - 2; i++) {
u[i] = a[front], v[i] = a[front + 1];
if (u[i] < v[i])
a[++front] = v[i], a[++rear] = u[i];
else
a[++front] = u[i], a[++rear] = v[i];
}
while (Q--) {
cin >> x;
if (x > n - 1) x = x % (n - 1) + n - 1;
printf("%d %d\n", u[x], v[x]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const int N = 100005;
vector<int> g[N];
double dp[N];
int s[N];
void dfs1(int v, int pr = -1) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pr) {
continue;
}
dfs1(to, v);
s[v] += s[to];
}
s[v]++;
}
void dfs2(int v, int pr = -1) {
double p = g[v].size() - 1;
if (pr == -1) {
p += 2;
dp[v] = 1;
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pr) {
continue;
}
dp[to] = (dp[v] + 1 + (1. / 4) * ((s[v] - 1) * 2 - (s[to]) * 2));
dfs2(to, v);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
int q;
cin >> q;
g[q].push_back(i);
g[i].push_back(q);
}
dfs1(1);
dfs2(1);
cout.precision(9);
for (int i = 1; i <= n; i++) {
cout << fixed << dp[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
int main() {
int q;
cin >> q;
int type, l, r;
int k;
while (q--) {
scanf("%d%d%d", &type, &l, &r);
if (type == 1) {
scanf("%d", &k);
if (k > 0) {
for (int i = l; i < r; i++) {
if (!a[i] || a[i] && a[i] > k) a[i] = k;
if (b[i]) c[i] = a[i] + b[i];
}
} else {
k = -k;
for (int i = l; i < r; i++) {
if (!b[i] || b[i] && b[i] > k) b[i] = k;
if (a[i]) c[i] = a[i] + b[i];
}
}
} else {
long long ans = 0;
for (int i = l; i < r; i++) ans = ans + c[i];
printf("%lld\n", ans);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string solve1(string s) {
string temp1 = "";
string temp2 = "";
if (s[0] != 9) {
for (int i = 0; i < s.length(); i++) {
temp1 += s[0];
temp2 += s[0] + 1;
}
if (temp1 >= s) {
return temp1;
} else {
return temp2;
}
} else {
for (int i = 0; i < s.length(); i++) {
temp1 += s[0];
}
return temp1;
}
}
void solve2(string s) {
string res = solve1(s);
for (char a = '0'; a <= '9'; a++) {
for (char b = '1'; b <= '9'; b++) {
bool s_ok = true;
for (int i = 0; i < s.length(); i++) {
if (s[i] < b) {
string t = s;
if (t[i] < a) {
t[i] = a;
} else {
t[i] = b;
}
for (int j = i + 1; j < s.length(); j++) {
t[j] = a;
}
if (res > t) {
res = t;
}
}
if (s[i] != a && s[i] != b) {
s_ok = false;
break;
}
}
if (s_ok) {
cout << s << endl;
return;
}
}
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
string s = "";
long long int temp = n;
while (temp != 0) {
s.push_back((temp % 10) + '0');
temp /= 10;
}
reverse(s.begin(), s.end());
if (k == 1) {
cout << solve1(s) << endl;
} else {
solve2(s);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int h[1000005], arr[1000005], ind[1000005], size[1000005];
vector<pair<long long int, long long int> > tree[4 * 1000005];
vector<long long int> o;
vector<long long int> v[1000005];
void dfs(long long int cur, long long int par) {
if (par != -1) h[cur] = h[par] + 1;
size[cur] = 1;
o.push_back(cur);
for (long long int i = 0; i < v[cur].size(); i++) {
long long int x = v[cur][i];
if (x == par) continue;
dfs(x, cur);
size[cur] += size[x];
}
}
void build(long long int node, long long int a, long long int b) {
if (a == b) {
tree[node].resize(1);
tree[node][0] = make_pair(h[o[a]], arr[o[a]]);
return;
}
long long int mid = (a + b) / 2;
build(2 * node, a, mid);
build(2 * node + 1, mid + 1, b);
tree[node].resize(tree[2 * node].size() + tree[2 * node + 1].size());
merge(tree[2 * node].begin(), tree[2 * node].end(),
tree[2 * node + 1].begin(), tree[2 * node + 1].end(),
tree[node].begin());
for (long long int i = 1; i < tree[node].size(); i++)
tree[node][i].second = min(tree[node][i].second, tree[node][i - 1].second);
return;
}
long long int query(long long int node, long long int a, long long int b,
long long int l, long long int r, long long int val) {
if (a > b || a > r || b < l) return 1000000000000;
if (a >= l && b <= r) {
if (tree[node][0].first > val) return 1000000000000;
long long int lo = 0;
long long int hi = tree[node].size();
while (hi - lo > 1) {
long long int mid = (lo + hi) / 2;
if (tree[node][mid].first <= val)
lo = mid;
else
hi = mid;
}
return tree[node][lo].second;
}
long long int mid = (a + b) / 2;
return min(query(2 * node, a, mid, l, r, val),
query(2 * node + 1, mid + 1, b, l, r, val));
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, n, x, y, root, ans, q, l, r, k, node;
cin >> n >> root;
for (i = 1; i <= n; i++) cin >> arr[i];
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
o.push_back(-1);
dfs(root, -1);
for (i = 1; i <= n; i++) ind[o[i]] = i;
build(1, 1, n);
cin >> q;
ans = 0;
while (q--) {
cin >> x >> y;
node = ((x + ans) % n) + 1;
k = (y + ans) % n;
l = ind[node];
r = ind[node] + size[node] - 1;
ans = query(1, 1, n, l, r, h[node] + k);
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a1, a2, a3, a4, a5, a6;
int main() {
cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6;
int sub = a1 * a1 + a3 * a3 + a5 * a5;
int mit = a1 + a2 + a3;
cout << mit * mit - sub;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const long long int MOD = 1e9 + 7;
int N, a, b;
long long int fact[MAXN];
long long int pw(long long int a, long long int b) {
long long int rev = 1LL;
while (b) {
if (b & 1) rev = (rev * a) % MOD;
b >>= 1;
a = (a * a) % MOD;
}
return rev;
}
long long int div(long long int k) { return pw(k, MOD - 2LL); }
long long int comb(int n, int r) {
return ((fact[n] * div(fact[n - r])) % MOD * div(fact[r])) % MOD;
}
int main() {
scanf(" %d", &N);
for (int c, i = 0; i < N; i++) {
scanf(" %d", &c);
if (c == 1)
a++;
else
b++;
}
fact[0] = 1LL;
for (long long int i = 1; i <= N; i++) fact[i] = (fact[i - 1] * i) % MOD;
if (a <= 2) {
cout << fact[N] << endl;
return 0;
}
long long int T = 1LL;
long long int p1 = 1LL, p2 = 1LL, p3 = 0LL;
for (int i = 1; i <= a / 2; i++) {
T = (T * comb(a - i * 2 + 2, 2)) % MOD;
p1 += (T * div(fact[i])) % MOD;
p1 %= MOD;
}
long long int x = a;
for (int i = 0; i < b; i++) {
p2 = (p2 * x) % MOD;
x++;
}
x--;
for (int i = 0; i <= b; i++) {
p3 += ((comb(b, i) * fact[i]) % MOD * p2) % MOD;
p3 %= MOD;
p2 = (p2 * div(x)) % MOD;
x--;
}
cout << (p1 * p3) % MOD << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
int n, w, a[MAXN], b[MAXN], ans, pi[MAXN], k;
void out(int *a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << " \n"[i == n - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> w;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < w; ++i) cin >> b[i];
if (w == 1)
cout << n << endl;
else {
--w, --n;
for (int i = 0; i < n; ++i) a[i] = a[i] - a[i + 1];
for (int i = 0; i < w; ++i) b[i] = b[i] - b[i + 1];
int k = pi[0] = -1;
for (int i = 0; i < w; ++i) {
for (; k >= 0 && b[i] != b[k]; k = pi[k])
;
pi[i + 1] = ++k;
}
for (int i = k = 0; i < n; ++i) {
for (; k >= 0 && a[i] != b[k]; k = pi[k])
;
if (++k == w) {
++ans;
k = pi[k];
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long res = 0, f = 1;
char c = getchar();
while (!(c >= '0' && c <= '9') && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while ((c >= '0' && c <= '9'))
res = (res << 3) + (res << 1) + (c ^ 48), c = getchar();
return res * f;
}
const int maxn = 1e5 + 10;
int n, b[100], val[maxn];
long long a[maxn], c[maxn];
vector<long long> vec[100];
map<long long, int> ma;
int e[maxn][2], h[maxn], cnt;
void add_edge(int u, int v) {
e[++cnt][0] = v;
e[cnt][1] = h[u];
h[u] = cnt;
return;
}
int vis[maxn];
int ans = 99999999;
void dfs(int u, int fa, int y) {
vis[u] = 1;
for (int i = h[u]; i; i = e[i][1]) {
int v = e[i][0];
if (v == fa) continue;
if (vis[v])
ans = min(ans, y);
else
dfs(v, u, y + 1);
}
vis[u] = 0;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read(), c[i] = a[i];
sort(c + 1, c + n + 1);
int m = unique(c + 1, c + n + 1) - c - 1;
for (int i = 1; i <= n; i++) {
int id = lower_bound(c + 1, c + m + 1, a[i]) - c;
val[id]++;
}
for (int i = 1; i <= m; i++) {
long long x = c[i];
for (int j = 0; j <= 62; j++)
if (x & (1LL << j)) {
b[j] += val[i];
if (b[j] > 2) {
printf("3\n");
return 0;
}
vec[j].push_back(x);
}
}
int tot = 0;
for (int i = 0; i <= 62; i++)
if (vec[i].size() == 2) {
if (ma.count(vec[i][0]) == 0) {
ma[vec[i][0]] = ++tot;
}
if (ma.count(vec[i][1]) == 0) {
ma[vec[i][1]] = ++tot;
}
add_edge(ma[vec[i][0]], ma[vec[i][1]]);
add_edge(ma[vec[i][1]], ma[vec[i][0]]);
}
for (int i = 1; i <= tot; i++) {
dfs(i, 0, 1);
}
if (ans != 99999999)
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 3;
const long long max_val = 2e5 + 10;
long long mod = 998244353;
const long long bits = 20;
long long caseNumber = 1;
void jabru() {
int n, k, d;
cin >> n >> k >> d;
vector<int> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
long long ans = 0;
map<int, int> m;
for (int i = 0; i < d; i++) {
if (m[v[i]] == 0) ans++;
m[v[i]]++;
}
long long curr = ans;
for (int j = d; j < n; j++) {
int toadd = j, toremove = j - d;
m[v[toadd]]++;
m[v[toremove]]--;
if (m[v[toremove]] == 0) ans--;
if (m[v[toadd]] == 1 && v[toadd] != v[toremove]) ans++;
curr = min(curr, ans);
}
cout << curr << endl;
}
bool TestCase = 1;
bool isGoogles = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
t = 1;
if (TestCase) {
cin >> t;
}
while (t--) {
if (isGoogles) {
cout << "Case #" << caseNumber << ": ";
}
caseNumber++;
jabru();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long> > heap;
const int N = 300010;
int n;
long long a[N], ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (!heap.empty() && heap.top() < a[i]) {
ans += a[i] - heap.top();
heap.pop();
heap.push(a[i]);
}
heap.push(a[i]);
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int a[maxn];
vector<pair<int, int> > p;
int dp[maxn][maxn];
int main() {
int n, d;
cin >> n >> d;
for (int i = 1; i < n - 1; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
p.push_back(make_pair(x, y));
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
dp[i][j] =
d * (abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second));
}
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (i != j && k != i && k != j) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[j][k] - a[k]);
}
cout << dp[0][n - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const int INF = (1ll << 30);
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const long long N = 2e5 + 7;
const long long mod = 1e9 + 7;
string f[N], tp, a, b, c;
long long n, m, cnt, lens, len[N], nxt[N];
char ch[N];
struct Matrix {
long long num[3][3];
inline void print() {
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
printf("%lld ", num[i][j]);
}
puts("");
}
}
inline void init() {
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
num[i][j] = 0;
}
}
}
} ans, base;
Matrix operator*(Matrix a, Matrix b) {
Matrix c;
c.init();
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
for (long long k = 0; k < 2; k++) {
c.num[i][j] =
(c.num[i][j] + 1ll * a.num[i][k] * b.num[k][j] % mod) % mod;
}
}
}
return c;
}
inline void qpow(long long b) {
if (b < 0) return;
base.init();
base.num[0][0] = base.num[0][1] = base.num[1][0] = 1;
while (b) {
if (b & 1) ans = ans * base;
base = base * base;
b >>= 1;
}
}
inline long long fib(long long x) {
ans.num[0][0] = ans.num[0][1] = 1;
if (x == 0) return 0;
qpow(x - 2);
return ans.num[0][0];
}
inline void init() {
f[1] = 'a';
f[2] = 'b';
for (long long i = 3;; i++) {
f[i] = f[i - 1] + f[i - 2];
len[i] = f[i].length();
cnt = i;
if (len[i - 1] >= N - 7) break;
}
base.num[0][0] = base.num[0][1] = base.num[1][0] = 1;
}
inline long long get() {
long long ret = 0;
for (long long i = 0, j = 0, le = tp.length(); i < le; i++) {
while (j >= 0 && ch[j + 1] != tp[i]) j = nxt[j];
j++;
if (j == lens) ret++, j = nxt[j];
}
return ret;
}
inline long long solve() {
nxt[0] = -1;
lens = strlen(ch + 1);
for (long long i = 2, j = 0; i <= lens; i++) {
while (j >= 0 && ch[j + 1] != ch[i]) j = nxt[j];
j++;
nxt[i] = j;
}
long long p = lower_bound(len + 1, len + cnt + 1, lens) - len;
++p;
a = f[p].substr(0, lens - 1);
b = f[p].substr(len[p] - lens + 1, lens - 1);
c = f[p + 1].substr(len[p + 1] - lens + 1, lens - 1);
if (n <= p + 1) {
tp = f[n];
return get();
}
long long n0, n1, n2, n3;
long long pos = n - p, ret = 0;
tp = c + a;
n0 = get();
tp = b + a;
n1 = get();
tp = f[p];
n2 = get();
tp = f[p + 1];
n3 = get();
ret = (ret + 1ll * (fib(pos) - (pos & 1)) * n0 % mod) % mod;
ret = (ret + 1ll * (fib(pos - 1) - 1 + (pos & 1)) * n1 % mod) % mod;
ans.init();
ans.num[0][0] = n3;
ans.num[0][1] = n2;
qpow(pos - 1);
ret = (ret + ans.num[0][0]) % mod;
return ret;
}
signed main() {
read(n);
read(m);
init();
for (long long i = 1; i <= m; i++) {
scanf("%s", ch + 1);
printf("%lld\n", solve());
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long Ol(long long n) {
long long ans = n;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
ans = ans / i * (i - 1);
}
if (n > 1) ans = ans / n * (n - 1);
return ans;
}
int main() {
cin >> n >> k;
for (long long i = 1; i <= k; i += 2) {
n = Ol(n);
if (n == 1) break;
}
cout << n % 1000000007 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 15;
int inf = 0x3f3f3f3f;
int sum[maxn], p[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
memset(p, inf, sizeof(p));
sum[0] = 0;
for (int i = 1; i <= n * 2; i++) {
int a;
scanf("%d", &a);
if (a == 2) a = -1;
sum[i] = sum[i - 1] + a;
if (i <= n) p[sum[i] + 100000] = i;
}
if (p[100000] == inf) p[100000] = 0;
int minn = inf;
for (int j = n; j <= 2 * n; j++) {
int h = sum[2 * n] - sum[j];
if (p[-h + 100000] != inf) minn = min(minn, j - p[-h + 100000]);
}
printf("%d\n", minn);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double dp[100110][110];
int a[100110];
double ans;
double tt[110];
int mx[100110];
void copy(int t) {
for (int i = 0; i <= 100; ++i) dp[t][i] = tt[i];
}
double c(double n, double m) {
double ret = 1;
while (m >= 1.0) {
ret *= n / m;
n -= 1.0;
m -= 1.0;
}
return ret;
}
void take(int u, int g, int w) {
for (int i = 0; i <= min(g, w); ++i) {
double tmp = dp[u][g] * c(g, i) * c(a[u] - g, w - i) / c(a[u], w);
tt[g - i] += tmp;
}
}
void solve() {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
memset(tt, 0, sizeof(tt));
ans -= dp[u][0];
for (int i = 0; i <= 100; ++i)
if (dp[u][i] > 1e-12) take(u, i, w);
copy(u);
a[u] -= w;
a[v] += w;
ans += dp[u][0];
printf("%.15lf\n", ans);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) dp[i][a[i]] = 1.0;
ans = 0.0;
for (int i = 1; i <= n; ++i)
if (!a[i]) ans++;
int q;
scanf("%d", &q);
while (q--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double add(double s) {
double ans = 0;
for (double i = 1.00; i <= s; i++) {
ans += 1.00 / i;
}
return ans;
}
int main() {
double s;
cin >> s;
s = add(s);
cout << fixed << setprecision(12) << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i, ans = 0;
scanf("%d", &(n));
string s;
cin >> s;
a = b = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'L') {
if (a == 0) {
a = -1;
continue;
}
if (a == 1) {
ans++;
a = -1;
b = 0;
}
} else if (s[i] == 'R') {
if (a == 0) {
a = 1;
continue;
}
if (a == -1) {
ans++;
a = 1;
b = 0;
}
} else if (s[i] == 'U') {
if (b == 0) {
b = 1;
continue;
}
if (b == -1) {
ans++;
b = 1;
a = 0;
}
} else {
if (b == 0) {
b = -1;
continue;
}
if (b == 1) {
ans++;
b = -1;
a = 0;
}
}
}
printf("%d", (ans + 1));
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> gph(100005);
bool vis[100005];
double DFS(int sv) {
vis[sv] = true;
double tdis = 0;
int chd = 0;
for (long long int i = 0; i < gph[sv].size(); ++i) {
if (!vis[gph[sv][i]]) {
tdis += DFS(gph[sv][i]) + 1;
chd++;
}
}
if (chd) tdis /= chd;
return tdis;
}
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
for (long long int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
gph[x].push_back(y);
gph[y].push_back(x);
}
for (long long int i = 0; i < n + 1; ++i) vis[i] = false;
double ans = DFS(1);
printf("%0.6f", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
const int N = 5050, P = 998244353;
inline int fpow(int x, int y) {
int ret = 1;
for (; y; y >>= 1, x = 1ll * x * x % P)
if (y & 1) ret = 1ll * ret * x % P;
return ret;
}
int n, m, K, p, q, fac[N], inv[N], S[N][N], ans, down[N];
inline int binom(int x, int y) {
if (x < y) return 0;
return 1ll * fac[x] * inv[y] % P * inv[x - y] % P;
}
int main() {
std::cin >> n >> m >> K;
fac[0] = 1;
for (int i = 1; i < N; ++i) fac[i] = 1ll * fac[i - 1] * i % P;
inv[N - 1] = fpow(fac[N - 1], P - 2);
for (int i = N - 1; i; --i) inv[i - 1] = 1ll * inv[i] * i % P;
down[0] = 1;
for (int i = 1, j = n; i <= n && i <= K; ++i, --j)
down[i] = 1ll * down[i - 1] * j % P;
p = fpow(m, P - 2), q = 1 + P - p;
if (n <= K) {
for (int i = 0; i <= n; ++i)
ans = (ans + 1ll * fpow(p, i) * fpow(q, n - i) % P * binom(n, i) % P *
fpow(i, K)) %
P;
} else {
S[0][0] = 1;
for (int i = 1; i < N; ++i) {
for (int j = 1; j <= i; ++j)
S[i][j] = (S[i - 1][j - 1] + 1ll * j * S[i - 1][j]) % P;
}
for (int i = 0; i <= K; ++i)
ans = (ans + 1ll * S[K][i] * down[i] % P * fpow(p, i)) % P;
}
std::cout << ans << std::endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T *p, T *q, string Gap = " ", bool flag = false) {
int d = p < q ? 1 : -1;
while (p != q) {
if (flag)
cout << Gap[0] << *p << Gap[1];
else
cout << *p;
p += d;
if (p != q && !flag) cout << Gap;
}
cout << endl;
}
template <typename T>
void print(const T &a, string bes = "") {
int len = bes.length();
if (len >= 2)
cout << bes[0] << a << bes[1] << endl;
else
cout << a << endl;
}
template <typename T>
void debug(T *p, T *q, string Gap = " ", bool flag = false) {}
template <typename T>
void debug(const T &a, string bes = "") {}
void IO_Init() { ios::sync_with_stdio(false); }
long long LLabs(const long long a) { return a >= 0 ? a : -a; }
const double PI = 3.1415926535898;
const double eps = 1e-10;
const int MAXM = 1e5 + 5;
const int MAXN = 4e5 + 5;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
int n, x, y;
int Head[MAXN], tot, son[MAXN];
int pson[MAXN], ans[MAXN];
struct o {
int to, cost, nxt;
} E[MAXN << 1];
void init_edge() {
memset(Head, -1, sizeof(Head));
tot = 0;
}
void add_edge(int u, int v, int cost) {
E[tot].to = v;
E[tot].cost = cost;
E[tot].nxt = Head[u];
Head[u] = tot++;
}
void dfs_v(int u, int f) {
ans[u] = 1;
son[u] = 1;
pson[u] = 0;
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
dfs_v(e.to, u);
son[u] += son[e.to];
pson[u] = max(pson[u], pson[e.to]);
}
if (son[u] <= n >> 1) pson[u] = max(pson[u], son[u]);
}
void dfs_b(int u, int f, int val) {
vector<pair<int, int> > P;
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
P.push_back(pair<int, int>(pson[e.to], e.to));
}
sort(P.begin(), P.end(), greater<pair<int, int> >());
for (int v = Head[u]; ~v; v = E[v].nxt) {
o &e = E[v];
if (e.to == f) continue;
int nx_val = val;
if (n - son[e.to] <= n >> 1) nx_val = max(nx_val, n - son[e.to]);
if (e.to == P[0].second) {
if (P.size() > 1) {
nx_val = max(nx_val, P[1].first);
}
} else {
nx_val = max(nx_val, P[0].first);
}
if (son[e.to] - pson[e.to] > n >> 1) {
ans[u] = 0;
}
dfs_b(e.to, u, nx_val);
}
if (n - son[u] - val > n >> 1) {
ans[u] = 0;
}
}
int main() {
IO_Init();
while (~scanf("%d", &n)) {
init_edge();
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add_edge(x, y, 1);
add_edge(y, x, 1);
}
dfs_v(1, 0);
dfs_b(1, 0, 0);
for (int i = 1; i <= n; i++) {
printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, join;
cin >> a;
join = a;
reverse(join.begin(), join.end());
cout << a << join << endl;
}
| 1 |
#include <bits/stdc++.h>
template <typename T>
class IntegerIterator
: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
explicit IntegerIterator(T value) : value(value) {}
IntegerIterator& operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator& operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const { return value; }
bool operator==(IntegerIterator rhs) const { return value == rhs.value; }
bool operator!=(IntegerIterator rhs) const { return !(*this == rhs); }
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
public:
ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
std::reverse_iterator<IntegerIterator<T>> begin() const {
return std::reverse_iterator<IntegerIterator<T>>(
IntegerIterator<T>(begin_));
}
std::reverse_iterator<IntegerIterator<T>> end() const {
return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
}
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
return ReversedIntegerRange<T>(from + 1, to);
}
inline std::mt19937& randomEngine() {
static std::random_device device;
static std::mt19937 engine(device());
return engine;
}
inline int randomInteger() {
std::uniform_int_distribution<int> d;
return d(randomEngine());
}
inline int randomInteger(int to) {
;
std::uniform_int_distribution<int> d(0, to - 1);
return d(randomEngine());
}
inline int randomInteger(int from, int to) {
return from + randomInteger(to - from);
}
using namespace std;
class TaskF {
int testNumber = 0;
public:
void solve(std::istream& in, std::ostream& out) {
int n, k;
in >> n >> k;
vector<int> p(n);
for (int i : range(n)) {
in >> p[i];
--p[i];
}
vector<int> l;
vector<int> used(n);
for (int i : range(n)) {
if (!used[i]) {
int len = 0;
while (!used[i]) {
++len;
used[i] = true;
i = p[i];
}
l.push_back(len);
}
}
if (can_get(l, k)) {
out << k << ' ';
} else {
out << k + 1 << " ";
}
int max_mult = 0;
for (int x : l) {
max_mult += x / 2;
}
out << min(n, k + min(k, max_mult)) << "\n";
}
bool can_get(const vector<int>& l, int val) {
using BS = bitset<1000100>;
BS bs;
bs.set(0);
vector<int> len(1000100);
for (int i : l) {
len[i]++;
}
for (auto i : range(len.size())) {
if (len[i] >= 3) {
int pere = (len[i] - 1) / 2;
assert(2 * i < len.size());
len[2 * i] += pere;
len[i] -= 2 * pere;
}
}
for (auto i : range(len.size())) {
for (int j : range(len[i])) {
bs |= (bs << i);
}
}
return bs.test(val);
}
};
int main() {
std::ios_base::sync_with_stdio(false);
TaskF solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(nullptr);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long int oo = 1e18;
const int mx = 370;
int main() {
int n, t{};
cin >> n;
for (int i = 0; i < 500; ++i) {
if (t > n) break;
if (t == n) {
cout << "YES" << endl;
return 0;
}
t += i;
}
cout << "NO" << endl;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.