solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, sum = 0;
cin >> a >> b;
int c = (a < b) ? a : b;
sum += c;
cout << sum << " ";
sum = 0;
a -= c, b -= c;
c = (a > b) ? a / 2 : b / 2;
sum += c;
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
const long double eps = 1e-9;
const long double pi = 3.14159265358979323846;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
long long a, b;
cin >> a >> b;
bool swp = false;
if (a > b) {
swap(a, b);
swp = true;
}
long long t = lcm(a, b);
long long c[2];
memset(c, 0, sizeof(c));
long long ttime = 0;
while (ttime + a < t) {
ttime += a;
c[0] += a;
if ((ttime - a) / b < ttime / b) {
c[1] += (ttime - ttime / b * b);
c[0] -= (ttime - ttime / b * b);
}
}
c[1] += a;
if (swp) swap(c[0], c[1]);
if (c[0] == c[1]) {
puts("Equal");
return 0;
}
if (c[0] < c[1]) {
puts("Masha");
return 0;
}
puts("Dasha");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int d[100005];
int b[100005];
int e[100005];
int chk[100005];
vector<pair<int, int> > v;
int main() {
int n, m;
cin >> n >> m;
int i;
for (i = 1; i <= n; i++) {
cin >> d[i];
}
for (i = 1; i <= m; i++) {
cin >> a[i];
}
a[0] = 0;
int net = 1000000;
int l = 1;
int r = n;
while (l <= r) {
if (l == r) {
int mid = (l + r) / 2;
v.resize(0);
for (i = 1; i <= m; i++) {
chk[i] = 0;
}
for (i = mid; i >= 1; i--) {
if (d[i] == 0) continue;
if (chk[d[i]] == 0) {
chk[d[i]] = 1;
v.push_back(make_pair(a[d[i]], i));
}
}
if (v.size() < m) {
l = mid + 1;
break;
}
int tmp = 0;
int flag = 1;
int j = 0;
for (i = v.size() - 1; i >= 0; i--) {
j++;
tmp += v[i].first;
if (v[i].second < tmp + j) {
flag = 0;
}
}
if (flag == 1) {
net = min(net, mid);
r = mid - 1;
} else {
l = mid + 1;
}
break;
}
int mid = (l + r) / 2;
v.resize(0);
for (i = 1; i <= m; i++) {
chk[i] = 0;
}
for (i = mid; i >= 1; i--) {
if (d[i] == 0) continue;
if (chk[d[i]] == 0) {
chk[d[i]] = 1;
v.push_back(make_pair(a[d[i]], i));
} else {
}
}
if (v.size() < m) {
l = mid + 1;
continue;
}
int tmp = 0;
int flag = 1;
int j = 0;
for (i = v.size() - 1; i >= 0; i--) {
j++;
tmp += v[i].first;
if (mid == 6) {
}
if (v[i].second < tmp + j) {
flag = 0;
}
}
if (flag == 1) {
net = min(net, mid);
r = mid - 1;
} else {
l = mid + 1;
}
}
if (net == 1000000) {
cout << "-1" << endl;
} else {
cout << net << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long int n, i, k, a;
scanf("%lld", &n);
k = n;
for (i = 0; i < 10; i++) {
a = k % 10;
k = k / 10;
if (k == 0 && a == 1) {
printf("YES\n");
break;
} else if (k == 0 && a != 1) {
printf("NO\n");
break;
}
if (a == 1) {
continue;
} else if (a == 4) {
a = k % 10;
k = k / 10;
if (a == 4) {
a = k % 10;
k = k / 10;
if (k == 0 && a == 1) {
printf("YES\n");
break;
} else if (a == 1) {
continue;
} else {
printf("NO\n");
break;
}
} else if (k == 0 && a == 1) {
printf("YES\n");
break;
} else if (a == 1) {
continue;
} else {
printf("NO\n");
break;
}
} else {
printf("NO\n");
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int solve(vector<int> v) {
vector<int> s;
int res = v[0] ^ v[1], n = v.size();
for (int i = 0; i < n; i++) {
while (!s.empty() && s.back() < v[i]) s.pop_back();
s.push_back(v[i]);
if (s.size() >= 2) res = max(res, s[s.size() - 1] ^ s[s.size() - 2]);
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int res = solve(v);
reverse(v.begin(), v.end());
cout << max(res, solve(v));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int s0, s1, mn, z;
char a[5009];
char b[5009];
int main() {
scanf("%s", a);
scanf("%s", b);
s0 = strlen(a);
s1 = strlen(b);
mn = s1;
for (int i = 0 - s1; i < s0; i++) {
z = 0;
for (int j = 0; j < s1; j++) {
if (j < 0 || a[i + j] != b[j] || j + i >= s0) z++;
}
mn = min(z, mn);
}
printf("%d", mn);
getchar();
getchar();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
int k, q, f = 0;
double p;
scanf("%d", &a), scanf("%d", &b);
if (b + a > 0) {
c = b + a;
q = c / (2 * (b));
if (q >= 1) {
f = 1;
p = (double)c / (double)(2 * q);
}
}
if (b - a <= 0) {
c = a - b;
q = c / (2 * b);
if (q >= 1 && !f) {
f = 1;
p = (double)c / (double)(2 * q);
}
}
if (f == 0)
printf("-1\n");
else
cout << setprecision(10) << p << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e7 + 7;
const int bigN = 1e9 + 5;
int mod = 1e9 + 7;
int arr[N], temp[N], arr2[N];
int arr1[N];
int matrix1[100][100], matrix2[100][100], matrix3[100][100];
bool boolArr[N];
void init() {
cin.tie(0);
cin.sync_with_stdio(0);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
int sizeArr(int arr[]) { return sizeof(arr) / sizeof(arr[0]); }
void solve() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
cout << i << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << i << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << (i + i) % n << " ";
}
}
}
long long n, m, ans;
char x;
int main() {
init();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool viz[100003];
int main() {
int i, sol, mindr, maxst, x, y, st, dr;
cin >> n >> m;
mindr = 200000;
maxst = 0;
for (i = 1; i <= m; ++i) {
cin >> x >> y;
viz[x] = viz[y] = true;
st = min(x, y);
dr = max(x, y);
if ((st >= mindr) || (dr <= maxst)) {
cout << "0\n";
return 0;
}
maxst = max(maxst, st);
mindr = min(mindr, dr);
}
for (i = 1; i <= n; ++i) {
if (!viz[i]) {
if (i < maxst) viz[i] = true;
if (i > mindr) viz[i] = true;
}
}
sol = 1;
for (i = 1; i <= n; ++i)
if (!viz[i]) sol++;
if (m == 0) sol -= 2;
cout << sol << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
inline int _min(const register int& x, const register int& y) {
return x < y ? x : y;
}
inline int _max(const register int& x, const register int& y) {
return x > y ? x : y;
}
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long q, num, min = -2000000000, max = 2000000000;
string op;
char ans;
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> op >> num >> ans;
if (op == ">=") {
if (ans == 'Y') {
min = std::max(num, min);
} else {
max = std::min(num - 1, max);
}
} else if (op == ">") {
if (ans == 'Y') {
min = std::max(num + 1, min);
} else {
max = std::min(num, max);
}
} else if (op == "<") {
if (ans == 'N') {
min = std::max(num, min);
} else {
max = std::min(num - 1, max);
}
} else {
if (ans == 'N') {
min = std::max(num + 1, min);
} else {
max = std::min(num, max);
}
}
}
if (min > max)
cout << "Impossible\n" << nl;
else
cout << min;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, d;
cin >> n >> m >> d;
vector<int> adj1;
vector<pair<int, int>> ps;
int c = 0;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
ps.push_back({a, b});
if (min(a, b) == 1) c++, adj1.push_back(max(a, b));
}
if (c < d) {
cout << "NO\n";
return;
}
vector<int> id(n + 2);
iota(id.begin(), id.end(), 0);
function<int(int)> Find = [&](int x) {
return id[x] == x ? x : id[x] = Find(id[x]);
};
c = 0;
set<int> g[n + 2];
for (auto p : ps) {
int a = Find(p.first);
int b = Find(p.second);
if (a != b) {
if (min(p.first, p.second) == 1) {
if (c == 0) {
id[a] = id[b];
g[p.first].insert(p.second);
g[p.second].insert(p.first);
c++;
}
} else {
id[a] = id[b];
g[p.first].insert(p.second);
g[p.second].insert(p.first);
}
}
}
for (int x : adj1) {
if (Find(x) != Find(1)) {
id[Find(x)] = id[Find(1)];
g[x].insert(1);
g[1].insert(x);
c++;
}
}
if (c > d) {
cout << "NO\n";
return;
}
if (c < d) {
for (int x : adj1) {
if (c == d) break;
if (g[1].find(x) == g[1].end()) {
g[1].insert(x);
c++;
}
}
}
vector<pair<int, int>> ans;
vector<bool> vis(n + 2, 0);
auto bfs = [&](int x) {
queue<int> Q;
Q.push(x);
vis[x] = 1;
while (!Q.empty()) {
int f = Q.front();
Q.pop();
for (int x : g[f]) {
if (vis[x] == false) {
vis[x] = true;
Q.push(x);
ans.push_back({f, x});
}
}
}
};
bfs(1);
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
cout << "NO\n";
return;
}
}
if (ans.size() != n - 1) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (auto x : ans) {
cout << x.first << ' ' << x.second << "\n";
}
return;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ar;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, tmp;
cin >> n;
ar.resize(n);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar.rbegin(), ar.rend());
long long int ans = 0;
long long int sum = 0;
int curr = 0;
int req = 1;
for (int i = 0; i < n; i++) {
sum += ar[i];
curr++;
if (curr == req) {
ans += sum;
req *= 4;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int d, h, v, e;
double r;
while (scanf("%d %d %d %d", &d, &h, &v, &e) != EOF) {
r = d * 1.0 / 2;
double de = r * r * acos(-1.0) * e;
if ((v - de) >= 0) {
printf("YES\n");
printf("%.10lf\n", (r * r * h * acos(-1.0) * 1.0) / (v - de));
} else
printf("NO\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int id[110];
int n, m, k, x, y;
map<int, int> mp;
int fun(int &x, int &y) {
int ans = 1;
for (int i = x + 1; i <= y; i++) {
if (mp[i] < mp[i - 1]) ans++;
}
return ans;
}
void h(int x, int y) {
int nx = id[x];
int ny = id[y];
mp[nx] = y;
mp[ny] = x;
swap(id[x], id[y]);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> id[i];
mp[id[i]] = i;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> k >> x >> y;
if (2 == k) {
h(x, y);
continue;
}
cout << fun(x, y) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 17, N = 1 << SZ;
int Rev(int x) {
int i, r = 0;
for (i = 0; i < SZ; i++) {
r = r << 1 | (x & 1);
x >>= 1;
}
return r;
}
void FFT(long long *a, bool f) {
int i, j, k;
long long z;
for (i = 0; i < N; i++) {
j = Rev(i);
if (i < j) {
z = a[i];
a[i] = a[j];
a[j] = z;
}
}
for (i = 1; i < N; i <<= 1)
for (j = 0; j < N; j += i << 1)
for (k = 0; k < i; k++) {
z = a[i + j + k];
a[i + j + k] = a[j + k] - z;
a[j + k] += z;
}
if (f)
for (i = 0; i < N; i++) a[i] /= N;
}
const int MOD = 1e9 + 7;
long long X[3][N], Y[3][N], Z[N];
long long S[N];
long long F[N + 10];
void solve() {
F[0] = 0, F[1] = 1;
for (int i = 2; i < N + 10; i++) F[i] = (F[i - 1] + F[i - 2]) % MOD;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
S[x]++;
}
for (int i = 0; i < N; i++) X[1][i] = S[i];
for (int i = 0; i < N; i++) {
int ni = (N - 1 - i);
for (int j = i;; j = (j - 1) & i) {
X[0][ni | j] += S[ni] * S[j];
if (j == 0) break;
}
}
FFT(S, false);
for (int i = 0; i < N; i++) S[i] *= S[i];
FFT(S, true);
for (int i = 0; i < N; i++) X[2][i] = S[i];
for (int u = 0; u < 3; u++)
for (int i = 0; i < N; i++) {
X[u][i] %= MOD;
X[u][i] = X[u][i] * F[i] % MOD;
}
for (int u = 0; u < 3; u++) {
for (int i = 0; i < N; i++) {
for (int j = i;; j = (j - 1) & i) {
Y[u][j] += X[u][i];
if (j == 0) break;
}
}
for (int i = 0; i < N; i++) Y[u][i] %= MOD;
}
for (int i = 0; i < N; i++) Z[i] = Y[0][i] * Y[1][i] % MOD * Y[2][i] % MOD;
for (int i = 1; i < N; i++) {
int ni = N - 1 - i;
for (int j = (i - 1) & i;; j = (j - 1) & i) {
int nj = N - 1 - j;
Z[ni] -= Z[nj];
if (j == 0) break;
}
}
for (int i = 0; i < N; i++) Z[i] = (Z[i] % MOD + MOD) % MOD;
long long ans = 0;
for (int i = 0; i < SZ; i++) ans = (ans + Z[1 << i]) % MOD;
printf("%lld\n", ans);
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, ans, p = 0, sum = -1;
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i < m)
p += arr[i];
else if (i >= m) {
if (p <= sum || sum == -1) ans = i + 1, sum = p;
p = p - arr[i - m] + arr[i];
}
}
if (p <= sum || sum == -1) ans = n + 1;
cout << ans - m << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i % 2 == 0)
printf("#");
else if (j == 0 && (i + 1) % 4 == 0)
printf("#");
else if (j == m - 1 && (i + 1) % 4 == 2)
printf("#");
else
printf(".");
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
using namespace std;
const int maxx = 3e5 + 10;
vector<long long> adj[maxx + 5], par(maxx + 5), dp(maxx + 5);
long long nodes, x, y, f = 0;
void dfs(int p, int c) {
dp[c] = 0;
for (auto v : adj[c]) {
if (v != p) {
dfs(c, v);
dp[c] += dp[v];
}
}
dp[c]++;
}
int main() {
long long xx, yy;
cin >> nodes >> x >> y;
for (int i = 1; i < nodes; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, x);
yy = dp[y];
dfs(0, y);
xx = dp[x];
long long ans = nodes * (nodes - 1);
ans = ans - (long long)(xx * yy);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 500500;
int n, m, fa[N][20], dep[N], bj[N];
vector<int> e[N];
void GG() {
puts("-1");
exit(0);
}
void dfs1(int u, int Fa, int Dep) {
fa[u][0] = Fa;
dep[u] = Dep;
for (int v : e[u])
if (v != Fa) dfs1(v, u, Dep + 1);
}
int kthfa(int u, int del) {
for (register int i = (19); i >= (0); i--)
if (del >> i & 1) u = fa[u][i];
return u;
}
int getlca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int del = dep[u] - dep[v];
for (register int i = (19); i >= (0); i--)
if (del >> i & 1) u = fa[u][i];
if (u == v) return u;
for (register int i = (19); i >= (0); i--)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
vector<pair<int, int> > cons[N];
int dfn[N], num, col[N];
vector<int> d;
vector<vector<int> > f[N];
void getcol(int u, int c, int tar) {
col[u] = c;
d.push_back(u);
for (auto x : cons[u])
if (dfn[x.first] == tar)
if (col[x.first] == -1)
getcol(x.first, c ^ x.second, tar);
else if (col[x.first] != (col[u] ^ x.second))
GG();
}
void dfs2(int u, int Fa) {
for (int v : e[u])
if (v != Fa) dfs2(v, u), bj[u] += bj[v];
if (bj[u])
cons[u].push_back(make_pair(Fa, 0)), cons[Fa].push_back(make_pair(u, 0));
vector<int> dot;
dfn[u] = u, dot.push_back(u);
for (int v : e[u])
if (v != Fa) dfn[v] = u, dot.push_back(v);
for (int x : dot) col[x] = -1;
for (int x : dot)
if (col[x] == -1) {
d.clear();
getcol(x, 0, u);
f[u].push_back(d);
}
}
int mid;
bool gg;
int dp[N], ans[N];
void upd(pair<int, int> &s, pair<int, int> a) {
s = make_pair(max(s.first, a.first), min(s.second, a.second));
}
void dfs(int u, int Fa) {
if (gg) return;
for (int v : e[u])
if (v != Fa) dfs(v, u);
pair<int, int> jiao(0, mid - (Fa > 0)), sub(mid / 2 + 1, mid / 2);
for (int x : f[u][0])
if (x != u) {
if (col[x] == 0)
umax(jiao.first, dp[x]);
else
umin(jiao.second, mid - dp[x] - 1);
}
for (auto a : f[u])
if (a[0] != f[u][0][0]) {
int l = 0, r = 0;
for (int x : a)
if (col[x] == 0)
umax(l, dp[x]);
else
umax(r, dp[x]);
if (l > r) swap(l, r);
upd(jiao, make_pair(l, mid - 1 - l));
if (mid - r <= r - 1) {
if (sub.first <= sub.second)
umax(sub.second, r - 1), umin(sub.first, mid - r);
else
sub = make_pair(mid - r, r - 1);
}
}
dp[u] = -1;
if (jiao.first <= jiao.second) {
if (sub.first > sub.second || sub.first > jiao.first ||
sub.second < jiao.first)
dp[u] = jiao.first;
else if (sub.second + 1 <= jiao.second)
dp[u] = sub.second + 1;
}
if (dp[u] == -1) gg = 1;
dp[u]++;
}
int dir[N];
void dfs3(int u, int Fa, bool rev) {
for (int x : f[u][0])
if (x != u) {
dir[x] = col[x];
}
for (auto a : f[u])
if (a[0] != f[u][0][0]) {
int l = 0, r = 0;
for (int x : a)
if (col[x] == 0)
umax(l, dp[x]);
else
umax(r, dp[x]);
bool flag = 0;
if (dp[u] - 1 >= l && dp[u] - 1 <= mid - 1 - r)
flag = 0;
else
flag = 1;
for (int x : a) dir[x] = col[x] ^ flag;
}
for (int x : e[u])
if (x != Fa) dir[x] ^= rev;
for (int x : e[u])
if (x != Fa && dir[x] == 0) dfs3(x, u, 0), umax(ans[u], ans[x]);
ans[u]++;
for (int x : e[u])
if (x != Fa && dir[x] == 1) umax(ans[x], ans[u]), dfs3(x, u, 1);
}
int main() {
read(n);
read(m);
for (register int i = (1); i <= (n - 1); i++) {
int u, v;
read(u);
read(v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs1(1, 0, 0);
for (register int j = (1); j <= (19); j++)
for (register int i = (1); i <= (n); i++)
fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (register int i = (1); i <= (m); i++) {
int u, v;
read(u);
read(v);
int l = getlca(u, v), x = 0, y = 0;
if (dep[u] > dep[l]) bj[u]++, bj[x = kthfa(u, dep[u] - dep[l] - 1)]--;
if (dep[v] > dep[l]) bj[v]++, bj[y = kthfa(v, dep[v] - dep[l] - 1)]--;
if (dep[u] > dep[l] && dep[v] > dep[l]) {
cons[x].push_back(make_pair(y, 1));
cons[y].push_back(make_pair(x, 1));
}
}
dfs2(1, 0);
int L = 1, R = n;
while (L < R) {
mid = (L + R) >> 1;
gg = 0;
dfs(1, 0);
if (gg)
L = mid + 1;
else
R = mid;
}
mid = L;
gg = 0;
dfs(1, 0);
dfs3(1, 0, 0);
printf("%d\n", L);
for (register int i = (1); i <= (n); i++) printf("%d ", ans[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int cmp1(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int cmp2(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
vector<pair<int, int> > v;
int n, a, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end(), cmp1);
int mi_x = v[0].first, ma_x = v[n - 1].first;
sort(v.begin(), v.end(), cmp2);
int mi_y = v[0].second, ma_y = v[n - 1].second;
long long z = max(abs(mi_x - ma_x), abs(mi_y - ma_y));
cout << z * z << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a1, a2;
int fz(int x) {
int t = 0;
while (x) {
t *= 10;
t += x % 10;
x /= 10;
}
return t;
}
int main() {
cin >> a1 >> a2;
cout << a1 + fz(a2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
void printans() {
printf("2 * 1 = 2\n");
printf("2 * 3 = 6\n");
printf("6 * 4 = 24\n");
}
int main() {
int i, j, fl, test;
scanf("%d", &n);
if (n <= 3)
printf("NO\n");
else {
printf("YES\n");
if (n == 4) {
printans();
return 0;
}
for (i = n; i >= 6; i -= 2) {
printf("%d - %d = 1\n", i, i - 1);
if (i != n) printf("1 * 1 = 1\n");
}
if (i == 5) {
if (n > 5) {
printf("5 * 1 = 5\n");
}
printf("5 - 2 = 3\n");
printf("3 - 1 = 2\n");
printf("4 * 3 = 12\n");
printf("12 * 2 = 24\n");
} else {
printf("1 * 1 = 1\n");
printans();
}
}
return 0;
}
| 3 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <string>
#include <vector>
#include <queue>
#define ll long long
#define dd long double
#define ff first
#define ss second
#define cini(n) int n; cin>>n;
#define cinl(n) long long n; cin>>n;
#define cins(s) string s; cin>>s;
#define vecti(v) vector<int> v(n);
#define vectl(v) vector<long long> v;
#define vects(s) vector<string> v;
#define all(v) v.begin(), v.end()
#define upi(init, n) for(ll i = init; i < n; ++i)
#define upj(init, n) for(ll j = init; j < n; ++j)
#define upk(init, n) for(ll k = init; k < n; ++k)
#define upl(init, n) for(ll l = init; l < n; ++l)
#define upm(init, n) for(ll m = init; m < n; ++m)
#define downi(init, n) for(ll i = init; i > n; --i)
#define downj(init, n) for(ll j = init; j > n; --j)
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
#define el "\n"
#define PI 3.1415926535897932384626433832795
#define eps 0.0000000000001
using namespace std;
ll gcd(ll a, ll b)
{
if(a%b==0)
return b;
else
return gcd(b,a%b);
}
ll lcm(ll a, ll b)
{
ll temp = a * b;
temp /= gcd(max(a,b), min(a,b));
return temp;
}
int bsearch(ll arr[], ll req, int n)
{
sort(arr,arr+n);
int start = 0, end = n-1;
while(start <= end)
{
int temp = start + end;
temp /=2;
if(arr[temp]>req)
end = temp-1;
if(arr[temp]<req)
start = temp+1;
if(arr[temp]==req)
return temp;
}
return -1;
}
ll fastpower(ll a, ll b)
{
ll res = 1;
while(b>0)
{
if(b & 1)
{
res = res*a;
}
b /= 2;
a = a * a;
}
return res;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cini(tc);
while(tc--)
{
cini(n);
if(n==1)
cout<<0<<el;
else if(n==2)
cout<<1<<el;
else if(n==3)
cout<<2<<el;
else
{
if(n%2==0)
cout<<2<<el;
else
cout<<3<<el;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long l1 = 1LL;
const int Len = 200000;
vector<int> ans;
stack<int> S[Len + 5], modS[3];
int am[3], A[Len + 5], nA[Len + 5];
int n;
void Init() {
ans.clear();
for (int i = 0; i < n; ++i) {
while (!S[i].empty()) S[i].pop();
}
memset(am, -1, sizeof(am));
}
void solve() {
int cur = 0;
while (1) {
if (S[cur].size() <= 0) break;
while (S[cur].size() > 0 && cur < n) {
ans.push_back(S[cur].top());
S[cur].pop();
if (S[cur].size() <= 0 && cur >= am[cur % 3]) {
int tmp = cur;
while (tmp >= 0 && S[tmp].size() <= 0) tmp -= 3;
am[cur % 3] = tmp;
}
++cur;
}
int tmp = cur;
while (S[tmp].size() <= 0) tmp -= 3;
cur = tmp;
if (cur < 0) break;
}
if (ans.size() >= n) {
puts("Possible");
for (int i = 0; i < ans.size(); ++i) {
if (i) printf(" ");
printf("%d", ans[i] + 1);
}
puts("");
} else {
puts("Impossible");
}
}
int main() {
while (scanf("%d", &n) != EOF) {
Init();
int cc = -1;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
A[i] = a;
if (cc == -1) cc = a;
S[a].push(i);
am[a % 3] = max(am[a % 3], a);
}
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[109];
int b[109];
vector<int> v;
int main() {
int t;
cin >> t;
while (t--) {
v.clear();
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
if (!b[i]) v.push_back(a[i]);
}
int pos = 0;
sort(v.begin(), v.end(), greater<int>());
for (int i = 0; i < n; i++) {
if (!b[i]) a[i] = v[pos++];
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[300006];
int col[300007];
string s;
long long MD = 998244353;
long long res0 = 1, res1 = 1, res;
bool fl = 0;
void dfs(int u) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (col[v] == -1) {
col[v] = 1 - col[u];
if (col[v] == 0) {
res0 *= 2;
if (res0 >= MD) res0 %= MD;
} else {
res1 *= 2;
if (res1 >= MD) res1 %= MD;
}
dfs(v);
} else {
if (col[u] == col[v]) {
fl = 1;
return;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t, n, e, u, v;
cin >> t;
while (t--) {
res = 1;
fl = 0;
cin >> n >> e;
for (int tt = 1; tt <= n; tt++) adj[tt].clear();
for (int i = 1; i <= n; i++) col[i] = -1;
for (int i = 0; i < e; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (col[i] == -1) {
col[i] = 0;
res0 = 2, res1 = 1;
dfs(i);
res = (res * (res0 + res1) % MD) % MD;
}
}
if (fl == 1)
cout << 0 << endl;
else
cout << res << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
c++;
if (c > a - b)
cout << a - b;
else
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, z, u, l, s, h, k, y, x, t, a[976869], b[987654], d[987654],
e[685868], c[2001][2001];
long long i, j;
map<long long, long long> f;
string r, p, q, w[7675];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 4; j++) {
cin >> p[j];
}
a[0] =
(p[0] - 48) * 1000 + (p[1] - 48) * 100 + (p[3] - 48) * 10 + (p[2] - 48);
a[1] =
(p[1] - 48) * 1000 + (p[3] - 48) * 100 + (p[2] - 48) * 10 + (p[0] - 48);
a[2] =
(p[3] - 48) * 1000 + (p[2] - 48) * 100 + (p[0] - 48) * 10 + (p[1] - 48);
a[3] =
(p[2] - 48) * 1000 + (p[0] - 48) * 100 + (p[1] - 48) * 10 + (p[3] - 48);
x = min(a[3], min(a[2], min(a[1], a[0])));
b[x]++;
cin >> r;
}
for (i = 0; i < 10000; i++) {
if (b[i] > 0) {
s++;
}
}
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxSize = 200010;
int n, m;
vector<pair<int, int> > V[MaxSize];
int main() {
int K, a, x, y, P, t, i, j, c, ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d%d%d%d", &K, &a, &x, &y, &P);
if (c = 0, m < MaxSize) V[0].push_back(pair<int, int>(a, i)), ++m;
while (--K) {
if (t = ((long long)a * x + y) % P, t < a) ++c;
if (a = t, m < MaxSize) V[c].push_back(pair<int, int>(a, i)), ++m;
}
ans = max(ans, c);
}
printf("%d\n", ans);
if (m > 200000) return 0;
for (i = 0; i <= ans; ++i) {
vector<pair<int, int> >& V = ::V[i];
sort(V.begin(), V.end());
for (j = 0; j < V.size(); ++j) printf("%d %d\n", V[j].first, V[j].second);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5001;
double x[MAXN], y[MAXN], z[MAXN];
double dis[MAXN];
inline double calc(double x1, double y1, double z1, double x2, double y2,
double z2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) +
(z1 - z2) * (z1 - z2));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf%lf", &x[i], &y[i], &z[i]);
for (int i = 1; i < n; i++) dis[i] = calc(x[0], y[0], z[0], x[i], y[i], z[i]);
double ans = 2147483647.0;
for (int i = 1; i < n; i++)
for (int j = 1; j < n; j++)
if (i != j) {
double d = calc(x[i], y[i], z[i], x[j], y[j], z[j]);
double t = (dis[i] + dis[j] + d) / 2.0;
ans = min(t, ans);
}
printf("%.10f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002, md = 1000000007, INF = 10000001;
using namespace std;
int n, l, x, y, m, q, A1, fe, P[N], D[21];
vector<vector<int> > g;
vector<int> tin, tout, pa, X[N], ans, ans1, mn[N][20];
int timer;
vector<vector<int> > up;
void dfs(int v, int p = 0) {
tin[v] = ++timer;
P[v] = p;
up[v][0] = p;
if (X[v].size())
for (int i = 0; i < X[v].size(); i++) mn[v][0].push_back(X[v][i]);
for (int i = 1; i <= l; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
merge(mn[v][i - 1].begin(), mn[v][i - 1].end(),
mn[up[v][i - 1]][i - 1].begin(), mn[up[v][i - 1]][i - 1].end(),
back_inserter(mn[v][i]));
if (mn[v][i].size() > 10) mn[v][i].resize(10);
}
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to != p) dfs(to, v);
}
tout[v] = ++timer;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = l; i >= 0; --i)
if (!upper(up[a][i], b)) a = up[a][i];
return up[a][0];
}
void get(int v, int p) {
for (int i = l; i >= 0; --i)
if (!upper(up[v][i], p)) {
merge(mn[v][i].begin(), mn[v][i].end(), ans.begin(), ans.end(),
back_inserter(ans1));
ans = ans1;
v = up[v][i];
if (ans.size() > 10) ans.resize(10);
ans1.clear();
}
if (p == P[v])
if (X[v].size())
for (int i = 0; i < X[v].size(); i++) ans.push_back(X[v][i]);
sort(ans.begin(), ans.end());
if (ans.size() > 10) ans.resize(10);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
tin.resize(n + 1), tout.resize(n + 1), up.resize(n + 1), g.resize(n + 1);
l = 1;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
if (X[x].size() < 10) X[x].push_back(i);
}
while ((1 << l) <= n) ++l;
for (int i = 0; i <= n; ++i) up[i].resize(l + 1);
tin[0] = -123123;
tout[0] = 21324324;
dfs(1);
while (q--) {
scanf("%d%d%d", &x, &y, &A1);
int lc = lca(x, y);
ans.clear();
get(x, lc);
get(y, lc);
int f = ans.size();
if (X[lc].size()) {
for (int i = 0; i < X[lc].size(); i++) ans.push_back(X[lc][i]);
}
sort(ans.begin(), ans.end());
printf("%d ", min(A1, int(ans.size())));
for (int i = 0; i < min(A1, int(ans.size())); i++) printf("%d ", ans[i]);
puts("");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
using vv = vector<vector<T>>;
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
template <class A, class B>
pair<A, B> operator+(const pair<A, B> &p, const pair<A, B> &q) {
return {p.first + q.first, p.second + q.second};
}
template <class A, class B, class C, class D>
pair<A, B> &operator+=(pair<A, B> &p, const pair<C, D> &q) {
p.first += q.first;
p.second += q.second;
return p;
}
template <class A, class B>
pair<A, B> operator-(const pair<A, B> &p, const pair<A, B> &q) {
return {p.first - q.first, p.second - q.second};
}
template <class A, class B, class C, class D>
pair<A, B> &operator-=(pair<A, B> &p, const pair<C, D> &q) {
p.first -= q.first;
p.second -= q.second;
return p;
}
template <class A, class B>
istream &operator>>(istream &is, pair<A, B> &p) {
is >> p.first >> p.second;
return is;
}
template <class T = ll>
T read() {
T re;
cin >> re;
return move(re);
}
template <class T = ll>
T read(const T &dec) {
T re;
cin >> re;
return re - dec;
}
template <class T = ll>
vector<T> readV(const int sz) {
vector<T> re(sz);
for (auto &x : re) x = read<T>();
return move(re);
}
template <class T = ll>
vector<T> readV(const int sz, const T &dec) {
vector<T> re(sz);
for (auto &x : re) x = read<T>(dec);
return move(re);
}
vv<int> readG(const int &n, const int &m) {
vv<int> g(n);
for (int(_) = 0; (_) < (int)(m); ++(_)) {
const auto a = read<int>(1), b = read<int>(1);
g[a].push_back(b);
g[b].push_back(a);
}
return move(g);
}
vv<int> readG(const int &n) { return readG(n, n - 1); }
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
const auto n = read();
vector<int> seq(2 * n);
for (int(i) = 0; (i) < (int)(2 * n); ++(i)) {
char c;
cin >> c;
if (c == '-') cin >> seq[i];
};
reverse((seq).begin(), (seq).end());
vector<int> re;
vector<int> stk;
const auto no = []() {
cout << "NO"
<< "\n";
exit(0);
};
for (const auto x : seq) {
if (x) {
if (stk.size() && stk.back() < x) no();
stk.emplace_back(x);
} else {
if (stk.empty()) no();
re.emplace_back(stk.back());
stk.pop_back();
}
};
if (stk.size()) no();
reverse((re).begin(), (re).end());
cout << "YES"
<< "\n";
for (int(i) = 0; (i) < (int)(n); ++(i)) cout << re[i] << " \n"[i + 1 == n];
return 0;
}
| 4 |
#include <bits/stdc++.h>
bool comp(const int& a, const int& b) { return a < b ? false : true; }
using namespace std;
long long int a[100009];
long long int b[100009];
queue<int> q;
int z[100009];
multimap<long long int, int> asd;
int main() {
int n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
q.push(i);
}
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (i = 0; i < n; i++) {
asd.insert(std::pair<long long int, int>(b[i], i));
}
int grp = 0, max_index = -1;
for (i = 0; i < n; i++) {
multimap<long long int, int>::iterator it = asd.find(a[i]);
int index = it->second;
asd.erase(it);
if (max_index < index) max_index = index;
z[index] = 1;
while (!q.empty() && z[q.front()] == 1) {
q.pop();
}
int top = q.front();
if (!q.empty() && top >= max_index) {
grp++;
}
}
cout << grp + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m, a, b;
cin >> n >> m;
vector<int> graph[n + 1];
for (int i = 0; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
vector<int> ans1, ans2;
queue<pair<int, int> > q;
q.push({1, 1});
vector<bool> vis(n + 1, 0);
while (!q.empty()) {
auto x = q.front();
q.pop();
if (vis[x.first]) continue;
vis[x.first] = 1;
if (x.second)
ans1.push_back(x.first);
else
ans2.push_back(x.first);
for (auto z : graph[x.first])
if (!vis[z]) q.push({z, x.second ^ 1});
}
if (ans1.size() < ans2.size()) {
cout << ans1.size() << "\n";
for (auto x : ans1) cout << x << " ";
cout << "\n";
} else {
cout << ans2.size() << "\n";
for (auto x : ans2) cout << x << " ";
cout << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
const int maxn = 100005;
vector<bool> mark(maxn);
vector<bool> tree(4 * maxn);
int N;
void query(int pos, int i, int j, int l, int r) {
int esq = 2 * pos;
int dir = 2 * pos + 1;
int mid = (i + j) / 2;
int dl = 0;
int u;
if (i > r || j < l)
return;
else if (i >= l && j <= r) {
if (i == j && tree[pos] == false) {
tree[pos] = true;
mark[i] = true;
u = i;
for (auto v : g[u]) {
if (v - 1 >= dl) query(1, 0, N - 1, dl, v - 1);
dl = v + 1;
}
if (N - 1 >= dl) query(1, 0, N - 1, dl, N - 1);
} else if (i < j) {
if (tree[esq] == false) query(esq, i, mid, l, r);
if (tree[dir] == false) query(dir, mid + 1, j, l, r);
tree[pos] = tree[esq] & (tree[dir]);
}
} else {
if (tree[esq] == false) query(esq, i, mid, l, r);
if (tree[dir] == false) query(dir, mid + 1, j, l, r);
tree[pos] = tree[esq] & (tree[dir]);
}
}
int solve(int n) {
int cont = 0;
for (int i = 0; i < n; i++) {
if (mark[i] == false) {
cont++;
query(1, 0, n - 1, i, i);
}
}
return cont;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
g.resize(n + 3);
N = n;
while (m--) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++) sort(g[i].begin(), g[i].end());
cout << solve(n) - 1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, x;
cin >> a >> b >> x;
long long int i;
if (x == 1) {
for (i = 0; i < a; i++) cout << "0";
for (i = 0; i < b; i++) cout << "1";
return 0;
}
if (x % 2 == 1) {
long long int hl = x / 2;
for (i = 0; i < hl; i++)
cout << "0"
<< "1";
for (i = 0; i < a - hl; i++) cout << "0";
for (i = 0; i < b - hl; i++) cout << "1";
} else {
if (a > b) {
x = x - 1;
long long int hl = x / 2;
for (i = 0; i < hl; i++)
cout << "0"
<< "1";
for (i = 0; i < a - hl - 1; i++) cout << "0";
for (i = 0; i < b - hl; i++) cout << "1";
cout << "0";
} else {
x = x - 1;
long long int hl = x / 2;
for (i = 0; i < hl; i++)
cout << "1"
<< "0";
for (i = 0; i < b - hl - 1; i++) cout << "1";
for (i = 0; i < a - hl; i++) cout << "0";
cout << "1";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int get(int x) {
if (((int)(s[x - 1] - '0') * 10 + (int)(s[x] - '0')) % 4 == 0) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
long long ans = 0;
for (int i = 0; i < s.size(); i++)
if ((int)(s[i] - '0') % 4 == 0) ans++;
for (int i = 1; i < s.size(); i++) {
if (get(i)) ans += i;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
std::vector<int> visited1(100005), visited2(100005);
string s1, s2;
int n, k;
int dfs(int i, int p, int q) {
if (i + k >= n) return 1;
int x = 0, y = 0, z = 0;
if (p == 0) {
if (i + k >= q + 1 && s2[i + k] == '-' && visited2[i + k] == 0) {
visited2[i + k] = 1;
z = dfs(i + k, 1, q + 1);
}
if (i - 1 >= q + 1 && s1[i - 1] == '-' && visited1[i - 1] == 0) {
visited1[i - 1] = 1;
x = dfs(i - 1, 0, q + 1);
}
if (i + 1 >= q + 1 && s1[i + 1] == '-' && visited1[i + 1] == 0) {
visited1[i + 1] = 1;
y = dfs(i + 1, 0, q + 1);
}
} else {
if (i + k >= q + 1 && s1[i + k] == '-' && visited1[i + k] == 0) {
visited1[i + k] = 1;
z = dfs(i + k, 0, q + 1);
}
if (i - 1 >= q + 1 && s2[i - 1] == '-' && visited2[i - 1] == 0) {
visited2[i - 1] = 1;
x = dfs(i - 1, 1, q + 1);
}
if (i + 1 >= q + 1 && s2[i + 1] == '-' && visited2[i + 1] == 0) {
visited2[i + 1] = 1;
y = dfs(i + 1, 1, q + 1);
}
}
return x || y || z;
}
int main() {
std::iostream::sync_with_stdio(false);
cin >> n >> k;
cin >> s1 >> s2;
int i;
for (i = 0; i < n; i++) {
visited1[i] = visited2[i] = 0;
}
visited1[0] = 1;
if (dfs(0, 0, 0)) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, s;
cin >> n >> s;
long long val = s / n;
long long rem = s % n;
long long val1 = val;
long long val2 = val + rem;
if (val > 1) {
cout << "YES\n";
for (long long i = 0; i < n; i++) {
if (i == n - 1)
cout << val2 << " ";
else
cout << val1 << " ";
}
cout << "\n1\n";
} else {
cout << "NO\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 5e5 + 20;
vector<long long> v[MAX_N], d, adj[MAX_N];
long long ans[MAX_N], h[MAX_N], f[MAX_N], q[MAX_N], n;
string s;
void DFS(long long r) {
long long rs = adj[r].size();
q[r] = d.size();
for (int e = 0; e < rs; e++) {
int i = adj[r][e];
if (q[i] == -1) {
d.push_back(i);
DFS(i);
d.pop_back();
}
}
return;
}
void bDFS(long long r) {
long long rs = adj[r].size(), b = 1 << (s[r] - 'a'), vs = v[r].size();
for (int e = 0; e < vs; e++) {
int t = v[r][e];
ans[t] = f[h[t]];
}
f[q[r]] ^= b;
for (int e = 0; e < rs; e++) {
int i = adj[r][e];
if (q[i] > q[r]) {
bDFS(i);
}
}
for (int e = 0; e < vs; e++) {
int t = v[r][e];
ans[t] ^= f[h[t]];
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long m;
cin >> n >> m;
ans[0] = 0;
f[0] = 0;
for (int i = 1; i < n; i++) {
ans[i] = 0;
f[i] = 0;
q[i] = -1;
long long u;
cin >> u;
u--;
adj[i].push_back(u);
adj[u].push_back(i);
}
cin >> s;
for (int i = 0; i < m; i++) {
long long u;
cin >> u >> h[i];
u--;
v[u].push_back(i);
}
q[0] = 1;
d.push_back(0);
DFS(0);
d.clear();
bDFS(0);
for (int i = 0; i < m; i++) {
long long w = ans[i] & (ans[i] - 1);
if (w == 0) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int64_t> A(8, 8);
vector<int64_t> A_high(8, 0);
vector<int64_t> B(8, 8);
vector<int64_t> B_high(8, 8);
int64_t amax = 8;
int64_t bmax = 8;
char k;
for (int64_t i = 0; i < 8; i++) {
for (int64_t j = 0; j < 8; j++) {
cin >> k;
if (k == 'B') {
if (B_high[j] > i) {
B_high[j] = i;
}
B[j] = 7 - i;
} else if (k == 'W') {
A_high[j] = i;
if (A[j] > i) {
A[j] = i;
}
}
}
}
for (int64_t i = 0; i < 8; i++) {
if (amax > A[i] && (B_high[i] > A[i])) {
amax = A[i];
}
if (bmax > B[i] && (A_high[i] < 7 - B[i])) {
bmax = B[i];
}
}
if (amax <= bmax) {
cout << 'A' << endl;
} else {
cout << 'B' << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
vector<vector<int> > v(5, vector<int>(5));
for (int i = 0; i < 5; ++i) {
for (int j = 0; j < 5; ++j) {
cin >> v[i][j];
}
}
for (int i = 0; i < 5; ++i) {
for (int j = 0; j < 5; ++j) {
if (v[i][j] == 1) {
x = i + 1;
y = j + 1;
}
}
}
cout << abs(x - 3) + abs(y - 3);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct toado {
int u;
int v;
};
int main() {
int m, n, x, y, z;
vector<int> a;
vector<int> b;
vector<toado> c;
cin >> n >> m >> x >> y;
for (int i = 0; i < n; i++) {
cin >> z;
a.push_back(z);
}
for (int i = 0; i < m; i++) {
cin >> z;
b.push_back(z);
}
int army = 0;
int vest = 0;
int counts = 0;
while (army < n && vest < m) {
toado v;
while (b[vest] < a[army] - x && vest < m) {
vest++;
}
if (a[army] + y >= b[vest] && vest < m) {
v.u = army;
v.v = vest;
c.push_back(v);
counts++;
vest++;
}
army++;
}
cout << counts << endl;
for (int i = 0; i < counts; i++) {
cout << c[i].u + 1 << " " << c[i].v + 1 << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define si(a) scanf("%d",&a)
#define sl(a) scanf("%lld",&a)
#define sd(a) scanf("%lf",&a)
#define sc(a) scanf("%c",&a)
#define ss(a) scanf("%s",a)
#define pi(a) printf("%d\n",a)
#define pl(a) printf("%lld\n",a)
#define pc(a) putchar(a)
#define ms(a) memset(a,0,sizeof(a))
#define repi(i, a, b) for( int i=a;i<=b;++i)
#define repd(i, a, b) for(register int i=a;i>=b;--i)
#define reps(s) for(register int i=head[s];i;i=Next[i])
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define pii pair<int,int>
#define mii unordered_map<int,int>
#define msi unordered_map<string,int>
#define lowbit(x) ((x)&(-(x)))
#define ce(i, r) i==r?'\n':' '
#define pb push_back
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define INF 0x3f3f3f3f
#define pr(x) cout<<#x<<": "<<x<<endl
inline long long ceil_div(long long a, long long b) { return (a + b - 1) / b; }
using namespace std;
inline int qr() {
int f = 0, fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
return f * fu;
}
const int N = 3e5 + 10;
int head[N], ver[N << 1], Next[N << 1], tot;
int n, m, cnt;
bool v[N], tag[N];
vector<int> ans;
inline void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dfs(int x) {
cnt++, v[x] = true;
bool flag = true;
reps(x)
if (tag[ver[i]]) {
flag = false;
break;
}
if (flag)tag[x] = true, ans.pb(x);
reps(x) {
int y = ver[i];
if (v[y])continue;
dfs(y);
}
}
int T;
int main() {
T = qr();
while (T--) {
n = qr(), m = qr();
tot = cnt = 0, ans.clear();
memset(head, 0, sizeof(int) * (n + 1));
memset(v, false, sizeof(bool) * (n + 1));
memset(tag, false, sizeof(bool) * (n + 1));
while (m--) {
int x = qr(), y = qr();
add(x, y), add(y, x);
}
dfs(1);
if (cnt != n)puts("NO");
else {
puts("YES");
pi(ans.size());
for (auto x:ans)printf("%d ", x);
puts("");
}
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <class T>
inline T Bit(T x, long long i) {
return (x >> i) & 1;
}
template <class T>
bool umin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool umax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const long long N = 2e5 + 3;
void solve(long long tc) {
long long n;
cin >> n;
string s[2];
for (long long i = 0; i < 2; i++) cin >> s[i];
long long a[2][n];
memset(a, 0, sizeof(a));
a[0][0] = 1;
if (s[1][0] == '0') a[1][0] = 1;
for (long long i = 1; i < n; i++) {
if (a[0][i - 1] || a[1][i - 1]) {
if (s[0][i] == '0') a[0][i] = 1;
if (s[1][i] == '0') a[1][i] = 1;
}
}
if (a[1][n - 1]) {
cout << "YES" << '\n';
return;
};
{
cout << "NO" << '\n';
return;
};
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
for (long long i = 1; i <= t; i++) solve(i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < (2 * n); ++i) cin >> a[i];
sort(a, a + (2 * n));
cout << a[n] - a[n - 1] << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mxn = 1e9 + 7;
const long long inf = 1e18;
vector<long long> vec;
void fun(long long n, long long four, long long seven) {
if (n > mxn) {
return;
}
long long tem1 = (10 * n) + 4;
if ((four + 1) == seven) {
vec.push_back(tem1);
}
fun(tem1, four + 1, seven);
long long tem2 = (10 * n) + 7;
if (four == (seven + 1)) {
vec.push_back(tem2);
}
fun(tem2, four, seven + 1);
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long i, j, k, a, b, c, d, n, m, t, u, v, w, x, y, z;
cin >> n;
fun(0, 0, 0);
sort(vec.begin(), vec.end());
long long pos = lower_bound(vec.begin(), vec.end(), n) - vec.begin();
long long ans = vec[pos];
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[4444], cnt[4444];
map<int, int> id;
vector<int> pos[4444];
int dp[4444];
int vis[4444];
int prev1(int el, int idx) {
vector<int>::iterator it = lower_bound(pos[el].begin(), pos[el].end(), idx);
if (it == pos[el].begin())
return -1;
else {
it--;
return (*it);
}
}
bool pres(int el, int idx1, int idx2) {
vector<int>::iterator i1 = lower_bound(pos[el].begin(), pos[el].end(), idx1);
vector<int>::iterator i2 = lower_bound(pos[el].begin(), pos[el].end(), idx2);
int count = 3;
for (; i1 != i2 && count--; i1++)
if ((*i1) > idx1 && (*i1) < idx2)
return true;
else if ((*i1) > idx2)
return false;
return false;
}
int main() {
scanf("%d", &n);
int idc = 0, fans = -1;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (id.find(x) != id.end()) {
a[i] = id[x];
} else {
id[x] = ++idc;
a[i] = idc;
}
cnt[a[i]]++;
pos[a[i]].push_back(i);
fans = max(fans, cnt[a[i]]);
}
for (int i = 0; i < idc; i++) pos[i].push_back(4444);
if (n <= 2) {
printf("%d\n", n);
return 0;
}
fans = max(fans, 2);
for (int i = 0; i < n; i++) {
int p = a[i];
if (vis[p]) continue;
vis[p] = 1;
memset(dp, 0, sizeof dp);
int cans = -1;
for (int j = i + 1; j < n; j++) {
if (a[j] == p) {
} else {
int len = (int)pos[p].size() - 2;
int pidx = prev1(a[j], j);
if (pidx < i) {
dp[j] = 2;
if (pos[p][len] > j) {
cans = max(cans, dp[j] + 1);
}
} else {
if (pres(p, pidx, j)) {
dp[j] = max(dp[j], dp[pidx] + 2);
if (pos[p][len] > j) {
cans = max(cans, dp[j] + 1);
}
} else {
dp[j] = dp[pidx];
}
}
}
cans = max(cans, dp[j]);
}
fans = max(fans, cans);
}
printf("%d\n", fans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[55];
int calc(int T, int n) {
static pair<int, int> a[105], b[205];
int tot = 0;
for (int i = 1; i <= n; i++) {
a[++tot] = pair<int, int>(p[i].first - T, i);
a[++tot] = pair<int, int>(p[i].first + T + 1, -i);
}
sort(a + 1, a + tot + 1);
int ans = 0, cnt = 0;
for (int i = 1, j = 0; i <= tot; i = j + 1) {
while (a[j + 1].first == a[i].first) j++;
for (int k = i; k <= j; k++) {
int t = abs(a[k].second);
if (a[k].second > 0) {
b[++cnt] = pair<int, int>(p[t].second - T, 1);
b[++cnt] = pair<int, int>(p[t].second + T + 1, -1);
} else {
b[++cnt] = pair<int, int>(p[t].second - T, -1);
b[++cnt] = pair<int, int>(p[t].second + T + 1, 1);
}
}
sort(b + 1, b + cnt + 1);
int s = 0, val = 0;
for (int k = 1; k <= cnt; k++) {
if (val > 0) s += b[k].first - b[k - 1].first;
val += b[k].second;
}
ans = (ans + (long long)s * (a[j + 1].first - a[i].first)) % 998244353;
}
return ans;
}
inline long long S1(long long n) {
return n * (n + 1) % 998244353 * 499122177 % 998244353;
}
inline long long S2(long long n) {
return n * (n + 1) % 998244353 * (2LL * n + 1) % 998244353 * 166374059 %
998244353;
}
int getsum(int l, int r, int n) {
if (r - l < 3) {
int ans = 0;
for (int i = l; i <= r; i++) ans = (ans + calc(i, n)) % 998244353;
return ans;
} else {
long long s1 = calc(l, n), s2 = calc(l + 1, n), s3 = calc(l + 2, n);
long long v0 = s1,
v2 = ((s3 - s1 + 998244353) * 499122177 -
(s2 - s1 + 998244353) % 998244353 + 998244353) %
998244353,
v1 = ((s2 - v0 - v2) % 998244353 + 998244353) % 998244353;
return (v0 * (r - l + 1) + v1 * S1(r - l) + v2 * S2(r - l)) % 998244353;
}
}
int a[2505];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[i] = pair<int, int>(x, y);
}
int cnt = 0;
a[++cnt] = 0;
a[++cnt] = m;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int x = max((abs(p[i].first - p[j].first) + 1) >> 1,
(abs(p[i].second - p[j].second) + 1) >> 1);
if (x < m) a[++cnt] = x;
}
sort(a + 1, a + cnt + 1);
cnt = unique(a + 1, a + cnt + 1) - a - 1;
int ans = (long long)m * calc(m, n) % 998244353;
for (int i = 1; i < cnt; i++)
ans = (ans - getsum(a[i], a[i + 1] - 1, n) + 998244353) % 998244353;
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int x = 1;
int y = 1;
int levely = 1;
int levelx = 1;
vector<pair<int, int> > ans;
int left = n * m;
for (int i = 1; i <= m / 2; i++) {
for (int j = 1; j <= n; j++) {
ans.push_back({j, i});
ans.push_back({n - j + 1, m - i + 1});
}
}
if (m % 2 == 1) {
for (int j = 1; j <= n / 2; j++) {
ans.push_back({j, m / 2 + 1});
ans.push_back({n - j + 1, m / 2 + 1});
}
if (n % 2 == 1) ans.push_back({n / 2 + 1, m / 2 + 1});
}
for (auto elem : ans) cout << elem.first << " " << elem.second << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char str[5111];
bool dp[5111][5111];
vector<int> bits[5111];
vector<pair<int, int> > cur;
vector<char> ans;
int main() {
scanf("%s", str);
int n = strlen(str);
int cnt = 0;
while ((1 << cnt) < n) cnt++;
cnt--;
int finalsz = n, cursz = 1;
while (finalsz > cursz) {
finalsz -= cursz;
cursz *= 2;
}
for (int i = 0; i < (1 << cnt); i++) {
for (int j = 0; j < cnt; j++) {
if ((i & (1 << j)) == 0) bits[i].push_back(j);
}
}
dp[0][0] = 1;
cur.push_back(make_pair(0, 0));
while (ans.size() < finalsz) {
char minch = 'z';
for (int i = 0; i < cur.size(); i++) {
int pos = cur[i].first;
int mask = cur[i].second;
for (int i : bits[mask]) {
if (dp[pos + (1 << i)][mask ^ (1 << i)] == 0) {
dp[pos + (1 << i)][mask ^ (1 << i)] = 1;
cur.push_back(make_pair(pos + (1 << i), mask ^ (1 << i)));
}
}
minch = min(minch, str[pos]);
}
ans.push_back(minch);
vector<pair<int, int> > new_cur;
for (auto x : cur) {
int pos = x.first;
int mask = x.second;
if (str[pos] == minch) {
dp[pos + 1][mask] = 1;
new_cur.push_back(make_pair(pos + 1, mask));
}
}
cur = new_cur;
}
for (char c : ans) printf("%c", c);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void output_strings(int ind[], string s[]) {
for (int i = 0; i < 6; i++) {
cout << s[ind[i]] << " ";
}
cout << endl;
return;
}
bool check(int ind[], string s[]) {
int l[6];
char b[6], e[6];
for (int i = 0; i < 6; i++) {
l[i] = s[ind[i]].length();
b[i] = s[ind[i]][0];
e[i] = s[ind[i]][l[i] - 1];
}
bool cond = true;
cond &= (l[0] + l[2] == l[1] + 1);
cond &= (l[3] + l[5] == l[4] + 1);
if (!cond) {
return false;
}
cond &= (b[0] == b[3]);
cond &= (b[4] == e[0]);
cond &= (b[1] == e[3]);
cond &= (b[5] == e[1]);
cond &= (e[2] == e[5]);
cond &= (e[4] == b[2]);
if (!cond) {
return false;
}
cond &= (s[ind[1]][l[0] - 1] == s[ind[4]][l[3] - 1]);
if (!cond) {
return false;
}
return true;
};
void make_result(vector<string>* v, int ind[], string s[]) {
int rows = s[ind[4]].length();
int cols = s[ind[1]].length();
string ss = string(cols, '.');
(*v).resize(rows, ss);
int i;
int j;
string sx;
sx = s[ind[0]];
for (int k = 0; k < sx.length(); k++) {
i = 0;
j = k + 0;
(*v)[i][j] = sx[k];
}
sx = s[ind[1]];
for (int k = 0; k < sx.length(); k++) {
i = s[ind[3]].length() - 1;
j = k + 0;
(*v)[i][j] = sx[k];
}
sx = s[ind[2]];
for (int k = 0; k < sx.length(); k++) {
i = s[ind[4]].length() - 1;
j = s[ind[0]].length() - 1 + k;
(*v)[i][j] = sx[k];
}
sx = s[ind[3]];
for (int k = 0; k < sx.length(); k++) {
i = k + 0;
j = 0;
(*v)[i][j] = sx[k];
}
sx = s[ind[4]];
for (int k = 0; k < sx.length(); k++) {
i = k + 0;
j = s[ind[0]].length() - 1;
(*v)[i][j] = sx[k];
}
sx = s[ind[5]];
for (int k = 0; k < sx.length(); k++) {
i = s[ind[3]].length() - 1 + k;
j = s[ind[1]].length() - 1;
(*v)[i][j] = sx[k];
}
return;
};
bool is_smaller(vector<string>* v1, vector<string>* v2) {
if ((*v2).empty()) {
return true;
}
for (int i = 0; i < min((*v1).size(), (*v2).size()); i++) {
if ((*v1)[i] < (*v2)[i]) {
return true;
} else if ((*v1)[i] > (*v2)[i]) {
return false;
}
}
return false;
};
int main() {
int ind[] = {0, 1, 2, 3, 4, 5};
vector<string>* best;
vector<string>* curr;
best = new vector<string>;
string s[6];
for (int i = 0; i < 6; i++) {
getline(cin, s[i]);
}
do {
if (check(ind, s)) {
curr = new vector<string>;
make_result(curr, ind, s);
if (is_smaller(curr, best)) {
delete best;
best = curr;
}
}
} while (next_permutation(ind, ind + 6));
if ((*best).empty()) {
cout << "Impossible" << endl;
} else {
for (int i = 0; i < (*best).size(); i++) {
cout << (*best)[i] << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int m, n, ma = 11, mb = 11;
int ans = 110;
scanf("%d%d", &m, &n);
int fl[11], sl[11];
for (int a = 0; a < m; a++) {
scanf("%d", &fl[a]);
if (fl[a] < ma) ma = fl[a];
}
for (int a = 0; a < n; a++) {
scanf("%d", &sl[a]);
if (sl[a] < mb) mb = sl[a];
}
for (int a = 0; a < m; a++)
for (int b = 0; b < n; b++) {
if (fl[a] == sl[b] && fl[a] < ans) ans = fl[a];
}
if (ma * 10 + mb < ans) ans = ma * 10 + mb;
if (mb * 10 + ma < ans) ans = mb * 10 + ma;
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, j = 0;
int a[1000 + 10];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n % 2 == 0) {
cout << a[(n - 1) / 2] << endl;
} else
cout << a[n / 2] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
void go(long long x) {
if (x == 0) return;
long long f = 1;
while (f <= x) {
f *= 2;
}
x -= f / 2;
ans++;
go(x);
}
int main() {
cin >> n;
go(n);
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[4][4];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) cin >> arr[i][j];
if (arr[0][0] != arr[2][2] || arr[0][1] != arr[2][1] ||
arr[0][2] != arr[2][0] || arr[1][0] != arr[1][2])
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 2e5 + 5, inf = 1e9;
int dp[N][2], a[N];
bool bad[N][2];
int P[N][2];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
vector<int> ans(n + 1);
dp[0][0] = inf;
dp[0][1] = -1;
for (int i = 1, val; i <= n; i++) {
cin >> val;
a[i] = val;
dp[i][0] = INT_MIN;
dp[i][1] = INT_MAX;
bad[i][0] = bad[i][1] = 1;
if ((!bad[i - 1][0]) && (i == 1 || a[i - 1] < val))
dp[i][0] = dp[i - 1][0], bad[i][0] = 0, P[i][0] = 0;
if ((!bad[i - 1][1]) && dp[i - 1][1] < a[i] &&
(bad[i][0] || dp[i][0] < a[i - 1])) {
dp[i][0] = a[i - 1];
bad[i][0] = 0;
P[i][0] = 1;
}
if ((!bad[i - 1][1]) && (i == 1 || a[i - 1] > val))
dp[i][1] = dp[i - 1][1], bad[i][1] = 0, P[i][1] = 1;
if ((!bad[i - 1][0]) && dp[i - 1][0] > a[i] &&
(bad[i][1] || dp[i][1] > a[i - 1])) {
dp[i][1] = a[i - 1];
bad[i][1] = 0;
P[i][1] = 0;
}
if (bad[i][0] && bad[i][1]) {
cout << "NO";
return 0;
}
}
int tp = -1;
for (int i = n; i > 0;) {
if (tp == -1) {
if (bad[i][0] == 0)
tp = 0;
else
tp = 1;
}
ans[i] = tp;
tp = P[i][tp];
i--;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dfs(int u, vector<int> adj[], vector<bool> &vist, int p) {
int i;
vist[u] = true;
for (i = 0; i < adj[u].size(); i++) {
if (vist[adj[u][i]] == true && adj[u][i] != p) return 1;
if (vist[adj[u][i]] == false && adj[u][i] != p) {
if (dfs(adj[u][i], adj, vist, u) == 1) return 1;
}
}
return 0;
}
int main() {
int n, m, c = 0, u, v, i;
cin >> n >> m;
vector<int> adj[100009];
for (i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<bool> vist(100009, false);
for (i = 1; i <= n; i++) {
if (vist[i] == false) {
if (dfs(i, adj, vist, 0) == 0) c++;
}
}
cout << c << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long get_ans(vector<long long> arr, long long bit) {
vector<long long> left_ans, right_ans;
for (auto& x : arr) {
if (x & (1 << bit)) {
right_ans.push_back(x ^ (1 << bit));
} else {
left_ans.push_back(x);
}
}
if (!bit) {
return left_ans.size() + right_ans.size();
}
if (right_ans.empty()) {
return get_ans(left_ans, bit - 1);
}
if (left_ans.empty()) {
return get_ans(right_ans, bit - 1);
}
long long ans1 = get_ans(left_ans, bit - 1);
long long ans2 = get_ans(right_ans, bit - 1);
return max(1 + ans1, 1 + ans2);
}
void solve() {
long long n;
cin >> n;
vector<long long> arr(n);
for (auto& x : arr) {
cin >> x;
}
cout << n - get_ans(arr, 31);
}
signed main() {
solve();
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n;
cin >> n;
vector<int> last_pos(n, -1);
vector<int> max_dist(n);
for (int i = 0; i < n; ++i) {
int t;
cin >> t;
--t;
max_dist[t] = max(max_dist[t], i - last_pos[t]);
last_pos[t] = i;
}
for (int i = 0; i < n; ++i) {
max_dist[i] = max(max_dist[i], n - last_pos[i]);
}
vector<pair<int, int>> sorted;
sorted.reserve(n);
for (int i = 0; i < n; ++i) {
sorted.emplace_back(i, max_dist[i]);
}
vector<int> ans(n, -1);
for (int i = 0; i < n; ++i) {
if (max_dist[i] > n) {
continue;
}
int k = max_dist[i] - 1;
for (int j = k; j < n && ans[j] == -1; ++j) {
ans[j] = i + 1;
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int x;
vector<int> even, odd;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x % 2 == 0) {
even.push_back(i);
} else {
odd.push_back(i);
}
}
if (even.size() == 0 && odd.size() < 2) {
cout << -1 << endl;
} else if (even.size() > 0) {
cout << 1 << endl;
cout << even[0] << endl;
} else if (odd.size() >= 2) {
cout << 2 << endl;
cout << odd[0] << " " << odd[1] << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100010];
int A[200];
memset(A, 0, sizeof A);
scanf("%s", str);
int len = strlen(str);
int ans = 1;
char temp;
for (int i = 0; i < len; i++) {
if (i == 0 && str[i] == '?')
ans *= 9;
else if (str[i] == '?' && i != 0)
ans *= 10;
else if (isalpha(str[i]))
A[str[i] - 'A']++;
}
int count = 0;
sort(A, A + 200);
reverse(A, A + 200);
for (int i = 0; i < 200; i++)
if (A[i] == 0) {
count = i;
break;
}
if (isalpha(str[0])) {
for (int i = 2; i <= count; i++) ans *= (11 - i);
ans *= 9;
} else
for (int i = 1; i <= count; i++) ans *= (11 - i);
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
struct max {
int num, much;
} max;
int a[55], b[55];
int main() {
int i, an, bn;
max.num = -1, max.much = 0;
scanf("%d", &an);
for (i = 0; i < an; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &bn);
for (i = 0; i < bn; i++) {
scanf("%d", &b[i]);
}
for (i = 0; i < an; i++) {
for (int j = 0; j < bn; j++) {
if (b[j] % a[i] == 0) {
if (b[j] / a[i] > max.num) {
max.num = b[j] / a[i];
max.much = 1;
} else if (b[j] / a[i] == max.num) {
max.much++;
}
}
}
}
printf("%d\n", max.much);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int n, m;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int i = 0, t = 0, f = 0;
while (i < n - 1) {
if (a[0] != 1) {
f = 1;
cout << "First\n";
break;
} else if (a[0] == 1) {
while (i < n - 1 && a[i] == 1) {
t++;
i++;
}
break;
}
i++;
}
if (t % 2 == 0 && f == 0) {
cout << "First\n";
} else if (t % 2 == 1 && f == 0) {
cout << "Second\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
vector<int> nums;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int y;
scanf("%*d%d", &y);
nums.push_back(y);
}
sort(nums.begin(), nums.end());
int i;
for (i = 1;; i++) {
int vv;
if (i % 2 == 1) vv = (i * i - i + 2) / 2;
if (i % 2 == 0) vv = i * i / 2;
if (vv > n) break;
}
i = min(i - 1, m);
int sm = 0;
for (int j = 0; j < i; j++) {
sm += nums[m - j - 1];
}
printf("%d", sm);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> arr(n);
long long int sum = 0, cnt = 0;
for (long long int i = 0; i < n; i++) {
long long int temp;
cin >> temp;
sum += temp;
}
for (long long int i = 1; i <= 5; i++) {
if ((sum + i) % (n + 1) != 1) cnt++;
}
cout << cnt << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
long long sum = 0;
sum = a + 2 * b + 3 * c;
if (sum % 2 == 0)
cout << 0 << endl;
else
cout << 1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long int 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;
}
vector<long long int> prime;
void sieve(long long int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (long long int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (long long int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
vector<long long int> merge(vector<long long int> v1,
vector<long long int> v2) {
vector<long long int> temp;
long long int i = 0, j = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[j])
temp.push_back(v1[i]), i++;
else
temp.push_back(v2[j]), j++;
}
while (i < v1.size()) temp.push_back(v1[i]), i++;
while (j < v2.size()) temp.push_back(v2[j]), j++;
return temp;
}
long long int dp[1002][1002], n, m;
long long int ar[1000005];
bool fun(long long int id, long long int val) {
if (val == 0) return 1;
if (id == n) return 0;
if (dp[id][val] != -1) return dp[id][val];
return dp[id][val] = (fun(id + 1, (val + ar[id]) % m) || fun(id + 1, val));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m;
for (long long int i = 0; i < n; i++) cin >> ar[i], ar[i] %= m;
if (n > m) return cout << "YES", 0;
memset(dp, -1, sizeof(dp));
bool ans = fun(0, m);
if (ans == 1)
cout << "YES\n";
else
cout << "NO\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void bmin(long long &a, long long b) { a = (a < b) ? a : b; }
int read() {
int x = 0, w = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x * w;
}
const int N = 2e5 + 5;
int n, m, q, to[N << 1], nxt[N << 1], ww[N << 1], head[N], vis[N], o[N], len,
pre[N], id[N], mrk[N];
long long dis[N], sid[N], tr[N << 2];
vector<int> g[N];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
void spfa(int s) {
memset(dis, 63, sizeof(dis));
memset(vis, 0, sizeof(vis));
Q.push(make_pair(dis[s] = 0, s));
pre[s] = 0;
while (!Q.empty()) {
int u = Q.top().second;
Q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int e = head[u]; e; e = nxt[e]) {
int v = to[e], w = ww[e];
if (dis[v] > dis[u] + w)
pre[v] = e, Q.push(make_pair(dis[v] = dis[u] + w, v));
}
}
}
void DFS(int u) {
for (int v : g[u]) {
if (!id[v]) id[v] = id[u];
DFS(v);
}
}
void Modify(int pos, int L, int R, int l, int r, long long val) {
if (l <= L && R <= r) {
bmin(tr[pos], val);
return;
}
int mid = (L + R) >> 1;
if (l <= mid) Modify(pos << 1, L, mid, l, r, val);
if (r > mid) Modify(pos << 1 | 1, mid + 1, R, l, r, val);
}
long long Query(int pos, int l, int r, int x) {
if (l == r) return tr[pos];
int mid = (l + r) >> 1;
return (x <= mid) ? min(tr[pos], Query(pos << 1, l, mid, x))
: min(tr[pos], Query(pos << 1 | 1, mid + 1, r, x));
}
int main() {
n = read();
m = read();
q = read();
for (int i = 1, j = 1; i <= m; ++i) {
int u = read(), v = read(), w = read();
to[++j] = v;
nxt[j] = head[u];
ww[j] = w;
head[u] = j;
to[++j] = u;
nxt[j] = head[v];
ww[j] = w;
head[v] = j;
}
spfa(n);
memcpy(sid, dis, sizeof(sid));
spfa(1);
for (int i = n; i > 1; i = to[pre[i] ^ 1]) o[++len] = i, mrk[pre[i] >> 1] = 1;
o[++len] = 1;
reverse(o + 1, o + len + 1);
for (int i = 1; i <= len; ++i) id[o[i]] = i;
for (int i = 2; i <= n; ++i)
if (pre[i]) g[to[pre[i] ^ 1]].push_back(i);
DFS(1);
memset(tr, 63, sizeof(tr));
for (int i = 1; i <= n; ++i)
for (int e = head[i]; e; e = nxt[e]) {
int u = i, v = to[e];
if (id[u] >= id[v] || mrk[e >> 1]) continue;
Modify(1, 1, len - 1, id[u], id[v] - 1, dis[u] + ww[e] + sid[v]);
}
while (q--) {
int x = read() << 1, y = read();
if (mrk[x >> 1]) {
if (id[to[x]] > id[to[x ^ 1]]) x ^= 1;
printf("%lld\n",
min(dis[n] - ww[x] + y, Query(1, 1, len - 1, id[to[x]])));
} else {
printf("%lld\n", min(dis[n], min(dis[to[x]] + sid[to[x ^ 1]],
dis[to[x ^ 1]] + sid[to[x]]) +
y));
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, n, m, t, tc;
string str = "aabb";
scanf("%lld", &n);
if (n % 2)
m = n / 2;
else
m = n / 2 - 1;
printf("%lld", m);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int _, n, m, s[30];
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
int i, x, y;
for (scanf("%d", &_); _; _--) {
scanf("%d%d\n", &n, &m);
memset(s, 0, sizeof(s));
for (i = 1; i <= n; i++) s[getchar() - 96]++;
while (1) {
x = gcd(n, m);
y = 0;
for (i = 1; i <= 26; i++) y += s[i] / (n / x);
if (y >= x) break;
n--;
}
printf("%d\n", n);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, s1, s2, s3, a[5005], i, s;
int main() {
cin >> n;
cout << "? " << 1 << " " << 2 << "\n";
cout.flush();
cin >> s1;
cout << "? " << 1 << " " << 3 << "\n";
cout.flush();
cin >> s2;
cout << "? " << 2 << " " << 3 << "\n";
cout.flush();
cin >> s3;
a[1] = (s2 - s3 + s1) / 2;
a[2] = s1 - a[1];
a[3] = s2 - a[1];
for (i = 4; i <= n; i++) {
cout << "? " << 1 << " " << i << "\n";
cout.flush();
cin >> s;
a[i] = s - a[1];
}
cout << "! ";
for (i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n, k, l;
int d;
int ta[300010];
vector<int> kk;
vector<int> zz;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n >> k >> l;
bool czy = true;
zz.clear();
kk.clear();
kk.push_back(0);
for (int j = 1; j <= n; j++) {
cin >> d;
ta[j] = min(k, l - d);
if (d > l) czy = false;
}
if (czy) {
ta[0] = k;
bool sp = true;
int poz = k;
for (int j = 1; j <= n && czy; j++) {
if (ta[j] == k) {
sp = true;
poz = k;
} else {
if (sp) {
poz = min(poz - 1, ta[j]);
} else {
if (ta[j] > poz)
poz++;
else
czy = false;
}
}
if (poz == 0) sp = false;
}
}
if (czy)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long merge(string &s, long long lo, long long mid, long long hi) {
long long inversion_count = 0;
string x = s.substr(lo, hi - lo + 1);
long long start1 = lo, start2 = mid + 1;
long long k = start1;
while (start1 <= mid && start2 <= hi) {
if (x[start1 - lo] > x[start2 - lo]) {
inversion_count += mid + 1 - start1;
s[k++] = x[start2 - lo];
start2++;
} else {
s[k++] = x[start1 - lo];
start1++;
}
}
while (start1 <= mid) {
s[k++] = x[start1 - lo];
start1++;
}
while (start2 <= hi) {
s[k++] = x[start2 - lo];
start2++;
}
return inversion_count;
}
long long mergesort(string &s, long long lo, long long hi) {
long long mid = lo + (hi - lo) / 2;
long long inv = 0;
if (lo < hi) {
inv = mergesort(s, lo, mid);
inv += mergesort(s, mid + 1, hi);
inv += merge(s, lo, mid, hi);
}
return inv;
}
signed main() {
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
long long x = mergesort(s1, 0, s1.length() - 1);
long long y = mergesort(s2, 0, s2.length() - 1);
if (s1 == s2) {
if (x % 2 == 1 && y % 2 == 1)
cout << "YES\n";
else if (x % 2 == 0 && y % 2 == 0)
cout << "YES\n";
else {
bool flag = 1;
for (long long i = 0; i < n - 1; i++)
if (s1[i] == s1[i + 1]) flag = 0;
for (long long i = 0; i < n - 1; i++)
if (s2[i] == s2[i + 1]) flag = 0;
if (!flag)
cout << "YES\n";
else
cout << "NO\n";
}
} else
cout << "NO\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
double x;
cin >> n >> m;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> m >> x;
int ind = upper_bound(v.begin(), v.end(), m) - v.begin();
if (ind == v.size())
v.push_back(m);
else
v[ind] = m;
}
cout << n - v.size() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
bool flg = false;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flg = true;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return flg ? -x : x;
}
int n;
int c[200010];
vector<int> e[200010];
long long f[200010], g[200010];
vector<pair<long long, int> > S[200010];
void dfs(int x, int fa) {
if (fa && e[x].size() == 1) {
f[x] = c[x];
g[x] = 0;
return;
}
vector<pair<long long, int> > &S = ::S[x];
long long w = 0;
for (const int &y : e[x])
if (y ^ fa) {
dfs(y, x);
w += f[y];
S.emplace_back(g[y] - f[y], y);
}
sort((S).begin(), (S).end());
f[x] = w;
f[x] = min(f[x], w + S[0].first + c[x]);
g[x] = w + S[0].first;
}
vector<int> T;
bool s[200010], t[200010];
void dfs2(int x, int fa) {
if (fa && e[x].size() == 1) {
if (s[x]) T.push_back(x);
return;
}
const auto &S = ::S[x];
long long w = 0;
for (const int &y : e[x])
if (y ^ fa) w += f[y];
if (s[x]) {
if (f[x] == w) {
for (const int &y : e[x])
if (y ^ fa) s[y] = 1;
}
if (S.size() && f[x] == w + S[0].first + c[x]) {
T.push_back(x);
const long long mn = S[0].first;
for (const int &y : e[x])
if (y ^ fa) {
const long long h = g[y] - f[y];
if (h > mn || h == mn && S.size() > 1 && S[1].first == mn) s[y] = 1;
if (h == mn) t[y] = 1;
}
}
}
if (t[x]) {
if (g[x] == w + S[0].first) {
const long long mn = S[0].first;
for (const int &y : e[x])
if (y ^ fa) {
const long long h = g[y] - f[y];
if (h > mn || h == mn && S.size() > 1 && S[1].first == mn) s[y] = 1;
if (h == mn) t[y] = 1;
}
}
}
for (const int &y : e[x])
if (y ^ fa) dfs2(y, x);
}
void solve() {
n = read();
for (int i(1), _i(n); i <= _i; i++) c[i] = read();
for (int i(2), _i(n); i <= _i; i++) {
int u = read(), v = read();
e[u].push_back(v), e[v].push_back(u);
}
dfs(1, 0);
printf("%lld\n", f[1]);
s[1] = 1;
dfs2(1, 0);
for (int i(1), _i(n); i <= _i; i++)
if (!c[i]) T.push_back(i);
sort((T).begin(), (T).end());
T.erase(unique((T).begin(), (T).end()), T.end());
printf("%d\n", int(T.size()));
for (int x : T) printf("%d ", x);
puts("");
}
int main() {
for (int T = 1; T--;) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int R, C, res, total;
int cnt[155];
int mn[155], mx[155];
char ar[155][155];
void F(int r, int c) {
if (ar[r][c] == 'W') {
cnt[r]--;
total--;
}
if (total == 0) return;
res++;
if (r % 2 == 0) {
if (cnt[r] == 0 && c >= mx[r + 1])
F(r + 1, c);
else
F(r, c + 1);
} else {
if (cnt[r] == 0 && c <= mn[r + 1])
F(r + 1, c);
else
F(r, c - 1);
}
}
int main() {
scanf("%d%d", &R, &C);
for (int i = 0; i < R; i++) scanf("%s", ar[i]);
for (int i = 1; i < R; i++) {
mx[i] = -1;
for (int j = C - 1; j >= 0; j--)
if (ar[i][j] == 'W') {
mx[i] = j;
break;
}
}
for (int i = 2; i < R; i++) {
mn[i] = C + 1;
for (int j = 0; j < C; j++)
if (ar[i][j] == 'W') {
mn[i] = j;
break;
}
}
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++)
if (ar[i][j] == 'W') cnt[i]++;
total += cnt[i];
}
F(0, 0);
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
const int MX = 1e6 + 1;
const int D = 1000;
const int INF = 1e9;
map<vector<int>, int> mm;
vector<vector<int>> gg;
int tmp[D];
int tmp2[D];
int ds[300][D];
int aa[300][300];
int bb[MX];
vector<int> pr;
int ggg[MX];
int cnt = 0;
int get(vector<int> vv) {
if (mm.count(vv))
return mm[vv];
else {
gg.push_back(vv);
return mm[vv] = cnt++;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (int i = 0; i < MX; ++i) bb[i] = i;
for (int i = 2; i < MX; ++i) {
if (bb[i] == i) pr.push_back(i);
for (int j : pr) {
if (j * i >= MX || bb[i] < j) break;
bb[i * j] = j;
}
}
for (int i = 1; i < MX; ++i) {
vector<int> vv;
int x = i;
while (x != 1) {
int j = bb[x];
int cnt = 0;
while (x % j == 0) x /= j, ++cnt;
vv.push_back(cnt + 1);
}
sort((vv).begin(), (vv).end());
reverse((vv).begin(), (vv).end());
ggg[i] = get(vv);
}
for (int i = 0; i < gg.size(); ++i) {
fill(tmp, tmp + D, INF);
tmp[1] = 0;
for (int j : gg[i]) {
fill(tmp2, tmp2 + D, INF);
for (int k = 1; k <= j + 10; ++k) {
for (int x = 1; x * k < D; ++x)
tmp2[x * k] = min(tmp2[x * k], tmp[x] + abs(k - j));
}
memcpy(tmp, tmp2, sizeof(tmp));
}
for (int i = 1; i < D; ++i) {
if (tmp[i] >= INF) continue;
for (int j = 2; i * j < D; ++j)
tmp[i * j] = min(tmp[i * j], tmp[i] + j - 1);
}
for (int j = 0; j < D; ++j) ds[i][j] = tmp[j];
}
for (int i = 0; i < gg.size(); ++i) {
for (int j = 0; j < gg.size(); ++j) {
int ans = INF;
for (int k = 0; k < D; ++k) ans = min(ans, ds[i][k] + ds[j][k]);
aa[i][j] = ans;
}
}
int tt;
cin >> tt;
for (int i = 0; i < tt; ++i) {
int a, b;
cin >> a >> b;
a = ggg[a], b = ggg[b];
cout << aa[a][b] << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int i, j, a, b, n, k;
scanf("%d", &n);
scanf("%d", &a);
int x[a];
for (k = 0; k < a; k++) {
scanf("%d", &x[k]);
}
scanf("%d", &b);
int y[b], z[a + b];
for (k = 0; k < b; k++) {
scanf("%d", &y[k]);
}
for (i = 0; i < a; i++) {
z[i] = x[i];
}
for (i = a; i < a + b; i++) {
z[i] = y[i - a];
}
for (i = 1; i <= n; i++) {
for (j = 0; j < a + b; j++) {
if (z[j] == i) {
break;
}
}
if (j == a + b) {
break;
}
}
if (i == n + 1) {
printf("I become the guy.");
} else {
printf("Oh, my keyboard!");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int x = a / c;
if (a % c != 0) x++;
int y = b / d;
if (b % d != 0) y++;
if (x + y > k)
cout << -1;
else
cout << x << " " << y;
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
const long long MOD = 1e9 + 7;
long long bin_pow(long long base, long long p) {
if (p == 1) return base;
if (p % 2 == 0) {
long long t = bin_pow(base, p / 2);
return t * t % MOD;
} else
return bin_pow(base, p - 1) * base % MOD;
}
long long inverse_element(long long x) { return bin_pow(x, MOD - 2); }
long long divide(long long a, long long b) {
return a * inverse_element(b) % MOD;
}
long long mult(long long a, long long b) { return (a * b) % MOD; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
string res = "";
int cnt = 0;
for (int i = (0), __i = (n); i < __i; i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
res += s[i];
cnt = 0;
} else {
if (i > 0 && s[i] == s[i - 1] && cnt == 1) {
while (s[i] == s[i - 1]) res += s[i++];
i--;
cnt = 2;
} else {
cnt++;
if (cnt == 3) {
cnt = 1;
res += ' ';
}
res += s[i];
}
}
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[300005], bit[300005];
vector<vector<int>> queries;
bool cmp(vector<int>& a, vector<int>& b) { return a[1] < b[1]; }
int query(int x) {
int sm = 0;
while (x) {
sm += bit[x];
x -= x & -x;
}
return sm;
}
void update(int x, int val) {
while (x < 300005) {
bit[x] += val;
x += x & -x;
}
}
int find_idx(int lo, int hi, int val) {
int ans = 0;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (query(mid) >= val) {
lo = mid + 1;
ans = mid;
} else {
hi = mid - 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] = i - a[i];
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
queries.push_back({x + 1, n - y, i});
}
sort(queries.begin(), queries.end(), cmp);
vector<int> ans(q);
int idx = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= 0) {
int x = find_idx(1, i, a[i]);
if (query(x) >= a[i] && x > 0) {
update(1, 1);
update(x + 1, -1);
}
}
while (idx < q && queries[idx][1] == i) {
ans[queries[idx][2]] = query(queries[idx][0]);
idx++;
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, c, m;
cin >> a >> b >> c >> m;
int maxl = max(a - 1, 0) + max(b - 1, 0) + max(c - 1, 0);
int maxv = max(a, max(b, c));
int rest = a + b + c - maxv;
int minl = max(0, maxv - rest - 1);
if (maxl >= m and m >= minl) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int tt;
cin >> tt;
while (tt--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2034567891;
const long long int INF64 = 4234567890123456789ll;
long long nc3(long long v) { return (v * (v - 1ll) * (v - 2ll)) / 6ll; }
long long nc2(long long v) { return (v * (v - 1ll)) / 2ll; }
long long int gcd(long long int a, long long int b) {
return (b == 0 ? a : gcd(b, a % b));
}
long long int lcm(long long int a, long long int b) {
return (a * (b / gcd(a, b)));
}
const int N = 10 + 1e6;
int main() {
long long int n, be, en;
cin >> n;
string s;
long long int f = 0;
for (long long int i = 0; i < n; i++) {
cin >> s >> be >> en;
if (en > be && be >= 2400) f = 1;
}
if (f)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void in(T &x) {
x = 0;
bool f = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
if (f) x = -x;
}
char tc[1000005];
int a[1000005], b[1000005];
int n, m;
int sum[1000005][3][3];
signed main() {
scanf("%s", tc + 1);
n = strlen(tc + 1);
for (register int i = 1; i <= n; ++i)
a[i] = (tc[i] == 'R' ? 0 : (tc[i] == 'G' ? 1 : 2));
scanf("%s", tc + 1);
m = strlen(tc + 1);
for (register int i = 1; i <= m; ++i)
b[i] = (tc[i] == 'R' ? 0 : (tc[i] == 'G' ? 1 : 2));
for (register int i = 2; i <= m; ++i) {
for (register int j = 0; j < 3; ++j)
for (register int k = 0; k < 3; ++k) sum[i][j][k] = sum[i - 1][j][k];
++sum[i][b[i - 1]][b[i]];
}
int l = 1, r = 0;
long long ans = 0;
for (register int i = 1; i <= n; ++i) {
++r;
while (r < m && b[r] != a[i]) ++r;
if (r > m) r = m;
if (i > 1 && b[l] == a[i - 1]) ++l;
if (l > m) break;
ans += r - l + 1;
if (i > 1 && a[i] != a[i - 1])
ans -= sum[r][a[i]][a[i - 1]] - sum[l - 1][a[i]][a[i - 1]];
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int caseno = 0;
void yesno(bool okk) { cout << (okk ? "YES" : "NO") << '\n'; }
const int primemod = 1000000007;
const long long maxsize = 1 * 1000000 + 9;
const double eps = 1e-10;
const int N = 210;
int freq[maxsize];
bool sortbysec(pair<string, int> a, pair<string, int> b) {
return a.second < b.second;
}
long long n;
void solve() {
cin >> n;
vector<pair<string, int>> v(n + 1);
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin() + 1, v.end(), sortbysec);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (v[i + 1].second > i) {
cout << -1 << '\n';
return;
}
}
vector<int> ans(n + 1, 1);
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
ans[i] = 0 - v[i].second + i;
for (__typeof(i) j = (1) - ((1) > (i)); j != (i) - ((1) > (i));
j += 1 - 2 * ((1) > (i))) {
if (ans[j] >= ans[i]) ans[j]++;
}
}
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1)))
cout << v[i].first << " " << ans[i] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
T = 1;
while (T--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void rd(T &x) {
x = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
}
const long long N = 5e5 + 5;
long long n, m, a[N], b[N];
struct node {
long long fi, se;
};
bool operator<(node a, node b) { return a.fi > b.fi; }
signed main() {
rd(n), rd(m);
for (long long i = 1; i <= n; i++) rd(a[i]);
for (long long i = 1; i <= n; i++) rd(b[i]);
long long l = 0, r = 2e9;
while (l <= r) {
long long mid = (l + r) / 2, res = 0, cnt = 0;
priority_queue<node> pq;
for (long long i = 1; i <= n; i++) {
pq.push((node){a[i] - mid, 0});
long long val = b[i] + pq.top().fi;
if (val < 0) {
res += val;
if (pq.top().se == 0) cnt++;
pq.pop(), pq.push((node){-b[i], 1});
}
}
if (cnt == m) return cout << res + m * mid << endl, 0;
if (cnt > m)
r = mid - 1;
else
l = mid + 1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
void solve() {
long long int n;
cin >> n;
long long int a[n];
map<long long int, long long int> ma;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
ma[a[i]]++;
}
long long int m = 0;
for (auto x : ma) {
if (x.second >= m) {
m = x.second;
}
}
n++;
if (m <= n / 2) {
cout << "YES";
} else
cout << "NO";
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) solve();
return 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 150;
int n, m, k, ar[MAXN][MAXN], sum[MAXN][MAXN], ans1, ans2, tmpans1, tmpans2;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &ar[i][j]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i][j - 1] + ar[j][i];
}
}
for (int i = 1; i <= m; i++) {
tmpans1 = tmpans2 = 0;
for (int j = 1; j <= n; j++) {
int r = min(n, j + k - 1);
if (sum[i][r] - sum[i][j - 1] > tmpans1) {
tmpans1 = sum[i][r] - sum[i][j - 1];
tmpans2 = sum[i][j - 1];
}
}
ans1 += tmpans1;
ans2 += tmpans2;
}
printf("%d %d", ans1, ans2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class TAT>
void read(TAT &a) {
static char cc;
static bool fff;
while (((cc = getchar()) < '0' || cc > '9') && cc != '-')
;
if (cc == '-')
fff = 1, a = 0;
else
fff = 0, a = cc - 48;
while ((cc = getchar()) >= '0' && cc <= '9') a = a * 10 + cc - 48;
if (fff) a = -a;
}
template <class TAT>
void write(TAT a) {
static char cc[25];
static int ct;
if (a == 0) {
putchar('0');
return;
}
if (a < 0) {
putchar('-');
a = -a;
}
ct = 0;
while (a) {
cc[++ct] = a % 10 + 48;
a /= 10;
}
while (ct) {
putchar(cc[ct--]);
}
}
void begin() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void end() {
fclose(stdin);
fclose(stdout);
}
template <class TAT>
void Ckmin(TAT &a, const TAT &b) {
if (a > b) a = b;
}
template <class TAT>
void Ckmax(TAT &a, const TAT &b) {
if (a < b) a = b;
}
const int maxn = 105;
const int maxm = 1005;
const int maxs = 100005;
int n, m, Ts = 0;
int A[maxn] = {0};
long double f[2][maxs] = {0};
long double Sum[maxs] = {0};
void Init() {
register int i, j, k;
read(n), read(m);
for (i = 1; i <= n; ++i) {
read(A[i]);
Ts += A[i];
}
}
void Solve() {
register int i, j, k;
register int nt = 0;
register long double S = 0;
if (m == 1) {
puts("1.00000000000000");
return;
}
f[nt][0] = 1;
for (i = 1; i <= n; ++i) {
Sum[1] = f[nt][0];
for (j = 1; j < Ts; ++j) Sum[j + 1] = Sum[j] + f[nt][j];
f[nt ^ 1][0] = 0;
for (j = 1; j < Ts; ++j) {
f[nt ^ 1][j] = Sum[j] - Sum[j - min(j, m)];
if (A[i] <= min(j, m)) f[nt ^ 1][j] -= f[nt][j - A[i]];
f[nt ^ 1][j] /= (long double)(m - 1);
}
nt ^= 1;
}
for (i = 0; i < Ts; ++i) S += f[nt][i];
S *= (m - 1);
S += 1;
printf("%.18f\n", (double)(S + 1e-18));
}
int main() {
Init();
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 2000000;
long long INFF = 8000000000000000000LL;
double PI = acos(-1);
inline string IntToString(int a) {
char x[100];
sprintf(x, "%d", a);
string s = x;
return s;
}
inline int StringToInt(string a) {
char x[100];
int res;
strcpy(x, a.c_str());
sscanf(x, "%d", &res);
return res;
}
inline string GetString(void) {
char x[1000005];
scanf("%s", x);
string s = x;
return s;
}
inline bool angka(char a) { return (a >= '0' && a <= '9'); }
inline bool kecil(char a) { return (a >= 'a' && a <= 'z'); }
inline bool besar(char a) { return (a >= 'A' && a <= 'Z'); }
inline string uppercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (kecil(s[i])) s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); (i)++)
if (besar(s[i])) s[i] = s[i] - 'A' + 'a';
return s;
}
int solve(int a, int b) {
if (b == 0) return INF;
if (b == 1) return a - 1;
return (solve(b, a % b) + a / b);
}
int main() {
int n;
scanf("%d", &n);
int ans = INF;
for (int(i) = (1); (i) <= (n); (i)++) ans = min(ans, solve(n, i));
;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, i, j, cnt = 1;
cin >> n;
for (i = 2; i <= n; i++) {
if (ans[i] == 0) {
for (j = i; j <= n; j += i) ans[j] = cnt;
cnt++;
}
}
for (i = 2; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char *sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
vector<string> split(string s) {
istringstream buf(s);
istream_iterator<string> beg(buf), end;
vector<string> list(beg, end);
return list;
}
bool isvowel(char c) {
string s = "aeiouAEIOU";
if (find(s.begin(), s.end(), c) != s.end()) return true;
return false;
}
vector<long long> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) {
prime[j] = 0;
}
}
vector<long long> p;
for (int i = 2; i <= prime.size(); i++)
if (prime[i]) p.push_back(i);
return p;
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true && (n != 1);
}
int ncr(long long n, long long r) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[r];
}
bool special(string s) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') continue;
if (s[i] == '#')
return true;
else
return false;
}
return false;
}
void solve() {
cout << fixed << setprecision(10);
double n, a, d;
cin >> n >> a >> d;
vector<pair<int, int> > v(n);
double max_ans = 0;
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
double s1 = 1.0 * v[i].second * v[i].second / (2 * a);
double t = v[i].first;
if (d < s1)
t += sqrt(2 * d / a);
else
t += 1.0 * v[i].second / a + (d - s1) / v[i].second;
if (t > max_ans) max_ans = t;
cout << max_ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long n, m;
long long pow_log(long long k) {
if (k == 0) {
return 1;
}
long long b = pow_log(k / 2);
b = (b * b) % MOD;
if (k % 2) {
b = (b * 2) % MOD;
}
return b;
}
int main() {
cin >> n;
m = pow_log(n - 1);
if (n == 0) {
cout << 1;
return 0;
}
cout << (m * ((m * 2) % MOD + 1)) % MOD;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, S, T, dis[6010], ans, path[6010], a[3010];
bool used[6010];
int cnt = 1, head[6010], to[50010], nxt[50010], v[50010], w[50010];
void add(int x, int y, int z, int f) {
cnt++;
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
v[cnt] = f;
w[cnt] = z;
}
void ins(int x, int y, int z, int f) {
add(x, y, z, f);
add(y, x, -z, 0);
}
bool spfa() {
memset(used, false, sizeof(used));
for (int i = S; i <= T; i++) {
dis[i] = inf;
}
queue<int> q;
while (!q.empty()) {
q.pop();
}
dis[S] = 0;
used[S] = true;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (v[i] && dis[y] > dis[x] + w[i]) {
path[y] = i;
dis[y] = dis[x] + w[i];
if (!used[y]) {
q.push(y);
used[y] = true;
}
}
}
used[x] = false;
}
if (dis[T] < inf) {
return true;
} else {
return false;
}
}
void min_cost_max_flow() {
while (spfa()) {
int x = T, f = inf;
while (x != S) {
f = min(f, v[path[x]]);
x = to[path[x] ^ 1];
}
ans += f * dis[T];
x = T;
while (x != S) {
v[path[x] ^ 1] += f;
v[path[x]] -= f;
x = to[path[x] ^ 1];
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
S = 0;
T = (n + 1) << 1;
ins(S, 1, 0, 4);
for (int i = 1; i <= n; i++) {
ins(1, i << 1, 0, 1);
ins(i << 1, i << 1 | 1, -1, 1);
ins(i << 1, i << 1 | 1, 0, inf);
ins(i << 1 | 1, T, 0, 1);
}
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if ((a[i] - a[j]) % 7 == 0) {
ins(i << 1 | 1, j << 1, 0, inf);
break;
}
}
for (int j = i + 1; j <= n; j++) {
if (a[i] == a[j] + 1) {
ins(i << 1 | 1, j << 1, 0, inf);
break;
}
}
for (int j = i + 1; j <= n; j++) {
if (a[i] == a[j] - 1) {
ins(i << 1 | 1, j << 1, 0, inf);
break;
}
}
}
min_cost_max_flow();
cout << -ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans += abs(arr[i - 1] - i);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int bigMod(long long int x, long long int y,
long long int MOD = 10000007) {
if (y == 0) return 1 % MOD;
long long int haha = bigMod(x, y / 2, MOD);
haha = (haha * haha) % MOD;
if (y & 1) return (haha * x) % MOD;
return haha;
}
long long int modInverse(long long int x, long long int MOD) {
return bigMod(x, MOD - 2, MOD);
}
long long int sieveMama() {
bool isPrime[1000000];
memset(isPrime, true, sizeof(isPrime));
isPrime[1] = false;
long long int n;
cin >> n;
vector<long long int> v;
for (long long int i = 2; i <= n; i += 2) isPrime[i] = false;
for (long long int i = 3; i * i <= n; i += 2) {
if (isPrime[i]) {
for (long long int m = i * i; m <= n; m += i) {
isPrime[m] = false;
}
}
}
}
vector<long long int> primeFactorize(long long int n) {
vector<long long int> primeFactors;
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n = n / i;
primeFactors.push_back(i);
}
}
if (n > 1) primeFactors.push_back(n);
return primeFactors;
}
int binarySearch(int arr[], int lo, int hi, int x) {
if (hi >= lo) {
int mid = lo + (hi - lo) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, lo, mid - 1, x);
return binarySearch(arr, mid + 1, hi, x);
}
return -1;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int one = 0, zero = 0;
string s, s2 = "";
cin >> s;
for (long long int i = 0; i < s.size(); i++) {
if (s[i] == '1')
one++;
else
zero++;
}
if (one == s.size() || zero == s.size())
cout << s << endl;
else {
for (long long int i = 1; i <= s.size() * 2; i++) {
if (i % 2 == 1)
s2 += "1";
else
s2 += "0";
}
cout << s2 << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, c4, c5, c3, s;
int I, J, K;
int main() {
scanf("%d %d", &n, &s);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
c3 += x == 3;
c4 += x == 4;
c5 += x == 5;
}
int ans = 1e9 + 10;
for (int i = s / n; i >= 0; --i) {
for (int j = (s - c3 * i) / (n - c3); j >= i; --j) {
int tot3 = i * c3;
int tot4 = j * c4;
int k = (s - tot3 - tot4) / c5;
int tot5 = k * c5;
if (tot5 - tot4 >= ans) break;
if (tot3 + tot4 + tot5 == s &&
ans > abs(tot3 - tot4) + abs(tot4 - tot5)) {
ans = abs(tot3 - tot4) + abs(tot4 - tot5);
I = i;
J = j;
K = k;
}
}
}
if (ans != 1e9 + 10)
printf("%d %d %d\n", I, J, K);
else
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
double pi = acos((double)-1);
const int MOD = 1000000007;
const int INF = 2147483647;
vector<int> s;
vector<int> mulres;
vector<int> move_perm;
vector<int> sort_perm;
void multiply_perm(vector<int>& perm, vector<int>& by, int n) {
for (int i = 0; i < n; i++) {
mulres[i] = perm[by[i]];
}
for (int i = 0; i < n; i++) {
perm[i] = mulres[i];
}
}
void binpow(vector<int>& perm, vector<int>& res, int p, int k, int str_len) {
while (p) {
if (p & 1) {
multiply_perm(res, perm, str_len);
}
multiply_perm(perm, perm, str_len);
p >>= 1;
}
}
void fill_sort_perm(int d, int k, int str_len) {
int si = 0;
for (int x = 0; x < d; x++) {
int y = x;
while (y < k) {
sort_perm[si++] = y;
y += d;
}
}
for (int x = si; x < str_len; x++) {
sort_perm[x] = x;
}
}
int main() {
clock_t tStart = clock();
int tests = 1;
for (int test = 1; test <= tests; test++) {
string str;
cin >> str;
int n, k, d;
cin >> n;
int str_len = str.length();
for (int i = 0; i < str_len; i++) {
s.push_back(i);
}
mulres.resize(str_len);
sort_perm.resize(str_len);
for (int i = 0; i < str_len - 1; i++) {
move_perm.push_back(i + 1);
}
move_perm.push_back(0);
for (int r = 0; r < n; r++) {
scanf("%d %d", &k, &d);
fill_sort_perm(d, k, str_len);
multiply_perm(sort_perm, move_perm, str_len);
binpow(sort_perm, s, str_len - k + 1, k, str_len);
for (int i = 0; i < str_len; i++) mulres[i] = s[(i + k - 1) % str_len];
for (int i = 0; i < str_len; i++) s[i] = mulres[i];
for (int x = 0; x < s.size(); x++) {
putchar(str[s[x]]);
}
puts("");
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
int t, n, k;
struct ab {
int l, r;
int ll, rr;
} aa[N + 5];
int cc[N * 2 + 5];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &k);
set<int> q;
for (int i = 1; i <= n; ++i) {
q.insert(i);
q.insert(i + n);
}
int co = 0;
for (int i = 1; i <= k; ++i) {
scanf("%d%d", &aa[i].l, &aa[i].r);
if (aa[i].l > aa[i].r) {
swap(aa[i].l, aa[i].r);
}
aa[i].ll = aa[i].l;
aa[i].rr = aa[i].r;
q.erase(aa[i].l);
q.erase(aa[i].r);
cc[++co] = aa[i].l;
cc[++co] = aa[i].r;
}
sort(cc + 1, cc + co + 1);
for (int i = 1; i <= n; ++i) {
aa[i].l = lower_bound(cc + 1, cc + co + 1, aa[i].l) - cc;
aa[i].r = lower_bound(cc + 1, cc + co + 1, aa[i].r) - cc;
}
co = 0;
for (auto v : q) {
cc[++co] = v;
}
long long ans = 0;
for (int p = 1; p <= k; ++p) {
int mx = k + 1;
int mi = 0;
int noww = k - p + 1;
for (int i = 1; i <= k; ++i) {
if (aa[i].l <= 0) {
continue;
}
int c = abs(aa[i].l % (2 * noww) - aa[i].r % (2 * noww));
if (min(c, noww * 2 - c) < mx) {
mi = i;
mx = min(c, noww * 2 - c);
}
}
ans += mx - 1;
for (int i = 1; i <= k; ++i) {
if (i == mi || aa[i].l <= 0) {
continue;
}
if (aa[i].r > aa[mi].r) {
aa[i].r -= 2;
} else if (aa[i].r > aa[mi].l) {
aa[i].r -= 1;
}
if (aa[i].l > aa[mi].r) {
aa[i].l -= 2;
} else if (aa[i].l > aa[mi].l) {
aa[i].l -= 1;
}
}
int ll = lower_bound(cc + 1, cc + co + 1, aa[mi].ll) - cc;
int rr = lower_bound(cc + 1, cc + co + 1, aa[mi].rr) - cc;
ans += min(rr - ll, co - (rr - ll));
aa[mi].l = -1e5;
}
ans += (long long)(n - k) * (long long)(n - k - 1) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.