solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
template <typename T_n>
void read(T_n &n) {
cin >> n;
}
template <typename T_n, typename T_a>
void read(T_a a[], T_n n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
template <typename T_n, typename T_a>
void read(vector<T_a> &a, T_n n) {
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
}
void _init_() { ios_base::sync_with_stdio(0), cin.tie(0); }
const int N = 1000 + 9, SEG = 131072;
const int Mod_M = 1e9 + 7;
void solve() {
int n, b[N];
map<int, int> cnt;
bool ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", b + i);
++cnt[b[i]];
if (cnt[b[i]] > 1) ans = 1;
}
(ans) ? puts("YES") : puts("NO");
}
int main() {
_init_();
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int P[] = {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
};
bool isPrime(int n) {
for (int i = 2; i < n; ++i) {
if ((n % i) == 0) return false;
}
return true;
}
bool call(int n) {
int cnt = 0;
for (int i = 0; i < 15; ++i) {
if ((n % P[i]) == 0) {
cnt++;
}
}
return cnt < 2;
}
bool test() {
for (int i = 2; i < 101; ++i) {
if (isPrime(i) != call(i)) {
printf("Error %d\n", i);
}
}
}
int main() {
int hits = 0;
string s;
for (int i = 0; i < 15; ++i) {
cout << P[i] << endl;
cout.flush();
cin >> s;
if (s == "yes") {
hits++;
if (hits == 1) {
if (P[i] * P[i] <= 100) {
cout << P[i] * P[i] << endl;
cout.flush();
cin >> s;
if (s == "yes") hits++;
}
}
}
if (hits >= 2) {
cout << "composite" << endl;
cout.flush();
return 0;
}
}
cout << "prime" << endl;
cout.flush();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, t;
cin >> n;
if (n == 1 || n == 2)
cout << "No" << endl;
else {
cout << "Yes" << endl;
t = (n + 1) / 2;
cout << "1 " << t << endl;
cout << n - 1;
for (int i = 1; i <= n; i++)
if (i != t) cout << " " << i;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
const int N = 2e5 + 10;
int n, m, k, cnt, head[N], a[N], up[N], dn[N], ans[N], tu[N], tv[N], in[N];
vector<int> g[N];
struct E {
int to, next;
} edge[N << 1];
struct node {
int val, pos;
bool operator<(const node &x) const { return x.val > val; }
};
inline void add(int u, int v) {
edge[++cnt] = {v, head[u]};
head[u] = cnt;
in[v]++;
}
priority_queue<node> q;
inline void topo(int opt) {
queue<int> p;
int cnt = 0;
for (int i = 1; i <= n; i++)
if (!in[i]) p.push(i), cnt++;
while (!p.empty()) {
int u = p.front();
p.pop();
if (up[u] < dn[u]) printf("-1"), exit(0);
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (opt)
chmax(dn[v], dn[u] + 1);
else
chmin(up[v], up[u] - 1);
if (!--in[v]) p.push(v), cnt++;
}
}
if (cnt < n) printf("-1"), exit(0);
}
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
if (!a[i])
up[i] = k, dn[i] = 1;
else
up[i] = dn[i] = a[i];
}
for (int i = 1; i <= m; i++) {
tu[i] = read(), tv[i] = read();
add(tu[i], tv[i]);
}
topo(0);
memset(head, 0, sizeof(head));
cnt = 0;
for (int i = 1; i <= m; i++) add(tv[i], tu[i]);
topo(1);
for (int i = 1; i <= n; i++) g[up[i]].push_back(i);
for (int i = k; i >= 1; i--) {
for (int j = 0; j < g[i].size(); j++) q.push((node){dn[g[i][j]], g[i][j]});
if (q.empty()) return printf("-1"), 0;
int x = q.top().pos;
ans[x] = i;
q.pop();
while (!q.empty()) {
int x = q.top().pos;
if (dn[x] < i) break;
ans[x] = i;
q.pop();
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int INF = 1e9;
string s[N];
int n, m;
int a[5][5];
bool used[N][N];
int dist[3][N][N];
vector<pair<int, int>> t[3];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
void bfs(int v) {
queue<pair<int, int>> q;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
used[i][j] = false;
dist[v][i][j] = INF;
}
for (int i = 0; i < t[v].size(); i++) {
q.push(t[v][i]);
used[t[v][i].first][t[v][i].second] = true;
dist[v][t[v][i].first][t[v][i].second] = 0;
}
while (!q.empty()) {
pair<int, int> u = q.front();
if (isdigit(s[u.first][u.second])) {
a[s[u.first][u.second] - '1'][v] = a[v][s[u.first][u.second] - '1'] =
min(a[v][s[u.first][u.second] - '1'], dist[v][u.first][u.second]);
}
q.pop();
for (int j = 0; j < 4; j++) {
int nx = u.first + dx[j];
int ny = u.second + dy[j];
if (nx >= 0 && ny >= 0 && nx < n && ny < m && s[nx][ny] != '#' &&
!used[nx][ny]) {
used[nx][ny] = true;
dist[v][nx][ny] = dist[v][u.first][u.second] + 1;
q.push(make_pair(nx, ny));
}
}
}
}
int main() {
cout.sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (isdigit(s[i][j])) t[s[i][j] - '1'].push_back(make_pair(i, j));
}
}
for (int j = 0; j < 5; j++)
for (int k = 0; k < 5; k++) {
if (j == k) {
a[j][k] = 0;
} else {
a[j][k] = INF;
}
}
bfs(0);
bfs(1);
bfs(2);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (a[i][j] > 0 && a[i][j] != INF) a[i][j]--;
}
}
int gg[3];
gg[0] = a[0][1];
gg[1] = a[0][2];
gg[2] = a[1][2];
int ans = INF;
for (int mask = 0; mask < (1 << 3); mask++) {
bool ok = true;
int tek = 0;
int cnt = 0;
for (int j = 0; j < 3; j++) {
if ((mask & (1 << j)) != 0) {
if (gg[j] == INF) ok = false;
tek += gg[j];
cnt++;
}
}
if (cnt >= 2 && ok) ans = min(ans, tek);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
if (dist[0][i][j] != INF && dist[1][i][j] != INF &&
dist[2][i][j] != INF)
ans = min(ans, dist[0][i][j] + dist[1][i][j] + dist[2][i][j] - 2);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
for (int v1 = 0; v1 < 3; v1++) {
for (int v2 = v1 + 1; v2 < 3; v2++) {
int r = 3 - v1 - v2;
int cost = min(a[r][v1], a[r][v2]);
if (dist[v1][i][j] != INF && dist[v2][i][j] != INF && cost != INF)
ans = min(ans, dist[v1][i][j] + dist[v2][i][j] - 1 + cost);
}
}
}
}
}
if (ans == INF) ans = -1;
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int L[1005][1005], R[1005][1005], U[1005][1005], D[1005][1005];
int a[1005][1005];
int n, m, q;
inline void init() {
for (int i = 1; i <= n; ++i) {
if (a[i][1])
L[i][1] = 1;
else
L[i][1] = 100000;
for (int j = 2; j <= m; ++j) {
if (a[i][j] && a[i][j - 1])
L[i][j] = L[i][j - 1];
else if (a[i][j])
L[i][j] = j;
else
L[i][j] = 100000;
}
}
for (int i = 1; i <= n; ++i) {
if (a[i][m])
R[i][m] = m;
else
R[i][m] = -1;
for (int j = m - 1; j >= 1; --j) {
if (a[i][j] && a[i][j + 1])
R[i][j] = R[i][j + 1];
else if (a[i][j])
R[i][j] = j;
else
R[i][j] = -1;
}
}
for (int j = 1; j <= m; ++j) {
if (a[1][j])
U[1][j] = 1;
else
U[1][j] = 100000;
for (int i = 2; i <= n; ++i) {
if (a[i][j] && a[i - 1][j])
U[i][j] = U[i - 1][j];
else if (a[i][j])
U[i][j] = i;
else
U[i][j] = 100000;
}
}
for (int j = 1; j <= m; ++j) {
if (a[n][j])
D[n][j] = n;
else
D[n][j] = -1;
for (int i = n - 1; i >= 1; --i) {
if (a[i][j] && a[i + 1][j])
D[i][j] = D[i + 1][j];
else if (a[i][j])
D[i][j] = i;
else
D[i][j] = -1;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", a[i] + j);
init();
while (q--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
a[x][y] ^= 1;
if (a[x][1])
L[x][1] = 1;
else
L[x][1] = 100000;
for (int i = 2; i <= m; ++i) {
if (a[x][i] && a[x][i - 1])
L[x][i] = L[x][i - 1];
else if (a[x][i])
L[x][i] = i;
else
L[x][i] = 100000;
}
if (a[x][m])
R[x][m] = m;
else
R[x][m] = -1;
for (int j = m - 1; j >= 1; --j) {
if (a[x][j] && a[x][j + 1])
R[x][j] = R[x][j + 1];
else if (a[x][j])
R[x][j] = j;
else
R[x][j] = -1;
}
if (a[1][y])
U[1][y] = 1;
else
U[1][y] = 100000;
for (int i = 2; i <= n; ++i) {
if (a[i][y] && a[i - 1][y])
U[i][y] = U[i - 1][y];
else if (a[i][y])
U[i][y] = i;
else
U[i][y] = 100000;
}
if (a[n][y])
D[n][y] = n;
else
D[n][y] = -1;
for (int i = n - 1; i >= 1; --i) {
if (a[i][y] && a[i + 1][y])
D[i][y] = D[i + 1][y];
else if (a[i][y])
D[i][y] = i;
else
D[i][y] = -1;
}
} else {
if (!a[x][y]) {
puts("0");
continue;
}
int l = L[x][y], r = R[x][y];
int ans = r - l + 1;
for (int i = x - 1; i >= 1; --i) {
l = max(l, L[i][y]);
r = min(r, R[i][y]);
if (l > r) break;
ans = max(ans, (r - l + 1) * (x - i + 1));
}
l = L[x][y];
r = R[x][y];
for (int i = x + 1; i <= n; ++i) {
l = max(l, L[i][y]);
r = min(r, R[i][y]);
if (l > r) break;
ans = max(ans, (r - l + 1) * (i - x + 1));
}
l = U[x][y];
r = D[x][y];
ans = max(ans, r - l + 1);
for (int i = y - 1; i >= 1; --i) {
l = max(l, U[x][i]);
r = min(r, D[x][i]);
if (l > r) break;
ans = max(ans, (r - l + 1) * (y - i + 1));
}
l = U[x][y];
r = D[x][y];
for (int i = y + 1; i <= m; ++i) {
l = max(l, U[x][i]);
r = min(r, D[x][i]);
if (l > r) break;
ans = max(ans, (r - l + 1) * (i - y + 1));
}
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
printf("YES\n");
int x, y, x1, y1, x2, y2;
for (int i = 0; i < N; i++) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
x = min(x1, x2);
y = min(y1, y2);
x = abs(x);
y = abs(y);
printf("%d\n", (x % 2) + 2 * (y % 2) + 1);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxv = 1e6 + 10;
int n, m, par[maxn], type[maxn], dp[maxn], h[maxn];
vector<pair<pair<int, int>, int>> w[maxv];
vector<pair<int, int>> adj[maxn];
vector<int> vec;
int mark[maxn];
string ans[3];
int get_par(int v) { return v == par[v] ? v : par[v] = get_par(par[v]); }
void merge(int v, int u) {
int gv = get_par(v), gu = get_par(u);
if (gv != gu) par[gv] = gu;
return;
}
void dfs(int v, int he, int e = -1) {
++mark[v];
dp[v] = he;
h[v] = he;
for (auto u : adj[v])
if (!mark[u.first]) {
dfs(u.first, he + 1, u.second);
if (dp[u.first] <= he) type[u.second] = 1;
dp[v] = min(dp[v], dp[u.first]);
} else if (u.second != e) {
type[u.second] = 1;
dp[v] = min(dp[v], h[u.first]);
}
return;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) par[i] = i;
for (int i = 0, v, u, we; i < m; ++i) {
cin >> v >> u >> we;
w[we].push_back({{v - 1, u - 1}, i});
}
for (int i = 1; i < maxv; ++i)
if (!w[i].empty()) {
for (auto j : w[i]) {
int v = j.first.first, u = j.first.second;
int gv = get_par(v), gu = get_par(u);
if (gv == gu) {
type[j.second] = 2;
continue;
}
vec.push_back(gu);
vec.push_back(gv);
adj[gv].push_back({gu, j.second});
adj[gu].push_back({gv, j.second});
}
for (auto j : vec)
if (!mark[j]) dfs(j, 0);
for (auto j : w[i]) {
int v = j.first.first, u = j.first.second;
merge(v, u);
}
for (auto j : vec) {
mark[j] = 0;
adj[j].clear();
}
vec.clear();
}
ans[0] = "any";
ans[1] = "at least one";
ans[2] = "none";
for (int i = 0; i < m; ++i) cout << ans[type[i]] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, i, j, t;
char c;
string s;
cin >> k;
for (i = 1; i < k; i++) {
for (j = 1; j < k; j++) {
if (j > 1) {
cout << " ";
}
t = i * j;
s = "";
while (t > 0) {
c = t % k + '0';
s = c + s;
t /= k;
}
cout << s;
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 200000;
int n, Q, delta;
multiset<int> Ans;
set<int> tree;
int f[M], P[M], H[M], id[M];
int g[M * 5], g2[M * 5];
int dfs(int *g, int x, int sl, int sr, int pos) {
if (pos <= sl) return g[x];
int sm = (sl + sr) / 2;
if (pos <= sm) return max(dfs(g, x * 2, sl, sm, pos), g[2 * x + 1]);
return dfs(g, x * 2 + 1, sm + 1, sr, pos);
}
void mod(int *g, int x, int sl, int sr, int pos, int val) {
if (sl == sr) {
g[x] = val;
return;
}
int sm = (sl + sr) / 2;
if (pos <= sm)
mod(g, x * 2, sl, sm, pos, val);
else
mod(g, x * 2 + 1, sm + 1, sr, pos, val);
g[x] = max(g[x * 2], g[x * 2 + 1]);
}
void del1(int p) { mod(g, 1, 1, M + 10, H[p] + M, 0); }
void ins1(int p) { mod(g, 1, 1, M + 10, H[p] + M, f[p]); }
void ins2(int p) { mod(g2, 1, 1, n, p, f[p]); }
void del2(int p) { mod(g2, 1, 1, n, p, 0); }
int main() {
cin >> n >> Q;
delta = 0;
memset(g, 0, sizeof g);
memset(g2, 0, sizeof g2);
for (int q = (1); q <= (Q); q++) {
int op;
scanf("%d", &op);
delta++;
if (q - 10 > 0 && P[q - 10] != -1) {
int p = P[q - 10];
ins2(p);
}
if (op == 1) {
int p, h;
scanf("%d%d", &p, &h);
P[q] = p;
id[p] = q;
tree.insert(p);
H[p] = h - delta;
f[p] = 1;
for (int q0 = (q - 11); q0 <= (q - 1); q0++)
if (q0 > 0 && P[q0] != -1) {
int p0 = P[q0];
if (p < p0 && H[p] < H[p0]) f[p] = max(f[p], f[p0] + 1);
}
f[p] = max(f[p], dfs(g2, 1, 1, n, p) + 1);
ins1(p);
vector<int> K;
for (int q0 = (q); q0 >= (q - 11); q0--)
if (q0 > 0 && P[q0] != -1) K.push_back(P[q0]);
sort((K).begin(), (K).end(), greater<int>());
for (auto p0 : K) {
del1(p0);
if (id[p0] <= q - 10) del2(p0);
for (auto p1 : K)
if (p0 < p1 && H[p0] < H[p1]) f[p0] = max(f[p0], f[p1] + 1);
ins1(p0);
if (id[p0] <= q - 10) ins2(p0);
}
} else {
int x;
scanf("%d", &x);
P[q] = -1;
auto it = tree.begin();
static int List[20];
for (int i = (1); i <= (x - 1); i++) {
List[i] = *it;
it++;
}
int p = *it;
P[id[p]] = -1;
tree.erase(it);
del1(p);
if (id[p] <= q - 10) del2(p);
for (int i = (1); i <= (x - 1); i++) {
del1(List[i]);
if (id[List[i]] <= q - 10) del2(List[i]);
}
for (int i = (x - 1); i >= (1); i--) {
int p = List[i];
f[p] = dfs(g, 1, 1, M + 10, H[p] + M) + 1;
ins1(p);
if (id[p] <= q - 10) ins2(p);
}
}
cout << g[1] << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int const N = 40;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long t, n, a, num, rem, rem1, rem3;
cout << endl;
cin >> t;
while (t--) {
cin >> n;
long long v[100009];
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
long long ans = 0, rem;
for (int i = 0; i < n - 1; ++i) {
int v1 = v[i + 1], v2 = v[i];
if (v[i + 1] < v[i]) {
rem = v[i] - v[i + 1];
v[i + 1] = v[i];
ans = max(ans, rem);
}
}
cout << ceil((double)log2(ans + 1)) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n, b, m, t, k;
int d[((int)1e5 + 5)];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> b >> k;
int ans = 0;
for (int i = 0; i < k; ++i) {
cin >> d[i];
ans += (d[i] % 2) * ((i == (k - 1)) ? 1 : (b % 2));
}
if (ans % 2)
cout << "odd\n";
else
cout << "even\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[101], b[101];
long long get(long long now, long long len) {
if (now <= len * 2) return 0;
long long sum = 0;
a[0] = 1;
a[1] = 0;
b[0] = now;
b[1] = now - 1;
while (b[1] >= len * 2) {
if (b[1] == len * 2) return a[0] + sum;
sum += a[1] + a[0];
if (b[0] % 2 == 1) {
b[1] = b[0] / 2 - 1;
b[0] = b[0] / 2;
a[0] = a[0] * 2 + a[1];
} else {
b[1] = b[0] / 2 - 1;
b[0] = b[0] / 2;
a[1] = a[1] * 2 + a[0];
}
}
return sum;
}
long long solve(long long l, long long r, long long p, long long sz) {
long long mid = (l + r) / 2, le = get(mid - l, p), re = get(r - mid, p + 1);
if (sz == 1) return mid;
if (sz > le + re + 1) return solve(mid + 1, r, p, sz - 1 - le);
return solve(l, mid - 1, p, sz - 1 - re);
}
int main() {
long long l, r, mid, mn;
scanf("%lld%lld", &n, &m);
if (m <= 2) {
if (m == 1) puts("1");
if (m == 2) printf("%lld", n);
return 0;
}
n -= 2;
m -= 2;
l = 0;
r = n / 2 + 1;
mn = 0;
while (l <= r) {
mid = (l + r) / 2;
if (get(n, mid) < m)
r = mid - 1;
else
l = mid + 1, mn = mid;
}
printf("%lld", solve(1, n, mn, m) + 1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
ans += (a - 1) * i + a;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
inline int getint() {
int x;
scanf("%d", &x);
return x;
}
char s[512];
int len;
int k;
int cc[512][512];
int cache[512][512];
inline int cost(int a, int b) {
int &ret = cc[a][b];
if (ret >= 0) return ret;
ret = 0;
while (a < b) {
if (s[a] != s[b]) ret++;
a++;
b--;
}
return ret;
}
int calc(int idx, int k) {
if (k < 0) return INF;
if (idx == len) return 0;
int &ret = cache[idx][k];
if (ret >= 0) return ret;
ret = INF;
for (int next = (idx + 1), _b = (len); next <= _b; ++next) {
ret = min(ret, calc(next, k - 1) + cost(idx, next - 1));
}
return ret;
}
inline string gen(int a, int b) {
string ret = "";
int ca = a;
int cb = b;
while (a < b) {
if (s[a] != s[b]) s[b] = s[a];
a++;
b--;
}
for (int i = (ca), _b = (cb); i <= _b; ++i) ret.push_back(s[i]);
return ret;
}
string generate(int idx, int k) {
if (idx == len) return "";
string ret = idx == 0 ? "" : "+";
for (int next = (idx + 1), _b = (len); next <= _b; ++next) {
if (calc(next, k - 1) + cost(idx, next - 1) == calc(idx, k)) {
ret += gen(idx, next - 1);
ret += generate(next, k - 1);
break;
}
}
return ret;
}
int main() {
while (scanf("%s", s) == 1) {
memset(cc, -1, sizeof(cc));
memset(cache, -1, sizeof(cache));
len = strlen(s);
k = getint();
cout << calc(0, k) << endl;
cout << generate(0, k) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 7;
const long long MAXN = 1e6 + 7;
int t, n, m;
char s[MAXN];
int dp[MAXN], pd[MAXN];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s + 1;
n = strlen(s + 1);
m = 0;
for (int i = n; i > 0; i--) {
if (s[i] == '0') {
if (s[i + 1] == '1')
m += 1;
else
m++;
} else {
if (m == 0) {
if (s[i] == '1') pd[i] = 1;
} else {
m--;
}
}
}
m = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '1') {
if (m >= 0)
dp[i] = 1, m++;
else
m--;
} else {
m++;
}
}
for (int i = 1; i <= n; i++) {
if (dp[i] + pd[i] == 2) s[i] = '0';
}
cout << s + 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n == 1 || n == 2) {
puts("1");
return 0;
}
int x = 4, y = 5;
int nx, ny;
while (y < n) {
if (x & 1) {
nx = x + y + 1;
ny = y + y + 1;
} else {
nx = x + y + 1;
ny = x + x + 1;
}
if (nx > ny) {
nx ^= ny ^= nx ^= ny;
}
x = nx;
y = ny;
}
if (x == n || y == n) {
puts("1");
} else {
puts("0");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, A, f[100100], M = 1e9 + 7, S = 1, T = 0, i, j;
string s, t;
int C(int a) {
for (j = n; j--;)
if (s[j] != t[(j - a + n) % n]) return 0;
return 1;
}
int main() {
cin >> s >> t >> k;
n = s.size();
f[0] = 1;
for (; k--; S = T, T = 0)
for (j = n; j--;) f[j] = ((S - f[j]) % M + M) % M, T = (T + f[j]) % M;
for (i = n; i--;) A = (A + f[i] * C(i)) % M;
cout << A;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int pow1(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b = b >> 1;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<int> v[200005];
int sz[200005];
long long int dp[200005];
long long int ans = 0;
void size(int node, int p) {
sz[node] = 1;
for (int i = 0; i < v[node].size(); i++) {
if (v[node][i] == p) continue;
size(v[node][i], node);
sz[node] += sz[v[node][i]];
}
}
void init(int node, int p) {
dp[node] = sz[node];
for (int i = 0; i < v[node].size(); i++) {
if (v[node][i] == p) continue;
init(v[node][i], node);
dp[node] += dp[v[node][i]];
}
}
void dfs(int node, int p) {
ans = max(ans, dp[node]);
for (int i = 0; i < v[node].size(); i++) {
if (v[node][i] == p) continue;
dp[node] -= dp[v[node][i]];
dp[node] -= sz[v[node][i]];
sz[node] -= sz[v[node][i]];
sz[v[node][i]] += sz[node];
dp[v[node][i]] += sz[node];
dp[v[node][i]] += dp[node];
dfs(v[node][i], node);
dp[v[node][i]] -= dp[node];
dp[v[node][i]] -= sz[node];
sz[v[node][i]] -= sz[node];
sz[node] += sz[v[node][i]];
dp[node] += sz[v[node][i]];
dp[node] += dp[v[node][i]];
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
size(1, 0);
init(1, 0);
dfs(1, 0);
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 100, MMax = 4;
int N, ans[NMax];
long long K, dp[NMax][MMax][MMax];
long long calc(int m) {
memset(dp, 0, sizeof(dp));
dp[0][1][1] = 1LL;
for (int i = 0; i <= (N - 1) / 2; i++) {
int j, k, first, second;
for (j = 0; j < 2; j++)
for (k = 0; k < 2; k++) {
for (first = 0; first < 2; first++)
if (i + 1 > m || first == ans[i + 1]) {
for (second = 0; second < 2; second++)
if (N - i > m || second == ans[N - i]) {
if (i * 2 + 1 == N && first != second) continue;
if (j && first > second) continue;
if (k && (first & second)) continue;
int ax = j, ay = k;
if (first != second) ax = 0;
if (first == second) ay = 0;
dp[i + 1][ax][ay] += dp[i][j][k];
}
}
}
}
return dp[(N + 1) / 2][0][0] + dp[(N + 1) / 2][0][1] + dp[(N + 1) / 2][1][0] +
dp[(N + 1) / 2][1][1];
}
int main() {
scanf("%d%I64d", &N, &K);
K++;
if (calc(0) < K) {
puts("-1");
return 0;
}
memset(ans, -1, sizeof(ans));
ans[1] = 0;
for (int i = 2; i <= N; i++) {
ans[i] = 0;
long long tmp = calc(i);
if (tmp < K) K -= tmp, ans[i] = 1;
}
for (int i = 1; i <= N; i++) printf("%d", ans[i]);
puts("");
getchar();
getchar();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int a;
scanf("%d%d", &n, &a);
if (n == 1) {
cout << 0;
return 0;
}
int pts[n];
for (int i = 0; i < n; ++i) {
scanf("%d", &pts[i]);
}
sort(pts, pts + n);
int ans = 1e9;
if (a <= pts[0]) {
ans = pts[n - 2] - a;
cout << ans;
return 0;
}
if (a >= pts[n - 1]) {
ans = a - pts[1];
cout << ans;
return 0;
}
int t1;
if (a < pts[1]) {
t1 = pts[n - 1] - a;
} else {
t1 = pts[n - 1] - a + 2 * abs(a - pts[1]);
t1 = min(t1, abs(pts[n - 1] - a) * 2 + abs(a - pts[1]));
}
ans = min(ans, t1);
int t2;
if (a > pts[n - 2]) {
t2 = abs(pts[0] - a);
} else {
t2 = abs(pts[0] - a) + 2 * abs(a - pts[n - 2]);
t2 = min(t2, abs(pts[0] - a) * 2 + abs(a - pts[n - 2]));
}
ans = min(t2, ans);
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char A[110][10010];
int dp[110][10010];
int cnt(int m, int n) {
for (int i = 0; i < (m); ++i) {
bool fg = 0;
for (int j = 0; j < (n); ++j) {
dp[i][j] = ((A[i][j] - '0') % 2 == 1 ? 0 : 20000);
if (dp[i][j] == 0) fg = 1;
}
if (!fg) return -1;
for (int j = 0; j < (n + n / 2 + 1); ++j)
dp[i][j % n] = min(dp[i][j % n], dp[i][(j - 1 + n) % n] + 1);
for (int j = (n + n / 2 + 1); j >= 0; --j)
dp[i][j % n] = min(dp[i][j % n], dp[i][(j + 1) % n] + 1);
}
int ans = m * 20000;
for (int j = 0; j < (n); ++j) {
int tmp = 0;
for (int i = 0; i < (m); ++i) tmp += dp[i][j];
ans = min(ans, tmp);
}
return ans;
}
int main() {
int m, n;
while (~scanf("%d%d", &m, &n)) {
for (int i = 0; i < (m); ++i) scanf("%s", A[i]);
printf("%d\n", cnt(m, n));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int s[5][5];
int main() {
int n, m, i, j;
for (i = 1; i <= 2; i++)
for (j = 1; j <= 2; j++) s[i][j] = 0;
s[1][3] = s[3][1] = 0;
s[2][3] = s[3][2] = 4;
s[3][3] = 8;
scanf("%d %d", &n, &m);
if (n <= 3 && m <= 3) {
printf("%d\n", s[n][m]);
return 0;
}
if (n > m) swap(n, m);
if (n == 1)
printf("%d\n", m + max(m % 6 - 3, 3 - m % 6) - 3);
else if (n == 2) {
if (m == 7)
printf("%d\n", 2 * m - 2);
else
printf("%d\n", 2 * m);
} else if (n % 2 == 0 || m % 2 == 0)
printf("%lld\n", (long long)n * m);
else
printf("%lld\n", (long long)n * m - 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long nn[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n * 2; i++) {
scanf("%lld", &nn[i]);
}
sort(nn, nn + 2 * n);
long long rc = nn[n - 1] - nn[0];
long long cc = nn[n * 2 - 1] - nn[n];
long long re = rc * cc;
rc = nn[2 * n - 1] - nn[0];
for (int i = 1; i < n; i++) {
cc = nn[i + n - 1] - nn[i];
re = min(re, rc * cc);
}
printf("%lld\n", re);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, counti = 0, counti2 = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '-') {
for (int j = i; j < s.size(); j++) {
if (s[j] == '+')
counti++;
else
counti2++;
if (counti2 > counti) {
counti = 0;
counti2 = 0;
} else
counti = counti - counti2;
counti2 = 0;
i++;
}
}
}
cout << counti << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
int n, k, a, b, x, y, z[300010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", z + i);
sort(z + 1, z + n + 1);
x = n / k;
y = n / k + 1;
b = n % k;
a = k - b;
dp[1][0] = z[y] - z[1];
dp[1][1] = z[x] - z[1];
for (int i = 2; i <= k; i++) {
for (int j = 0; j <= min(a, i); j++)
if (i == j)
dp[i][j] = dp[i - 1][j - 1] + 1ll * z[i * x] - z[(i - 1) * x + 1];
else {
int tmp = j * x + (i - 1 - j) * y;
if (tmp + y <= n)
dp[i][j] = dp[i - 1][j] + 1ll * z[tmp + y] - z[tmp + 1];
else
dp[i][j] = 1000000000000000000LL;
if (j > 0) {
tmp = (j - 1) * x + (i - j) * y;
if (tmp + x <= n)
dp[i][j] =
min(dp[i][j], dp[i - 1][j - 1] + 1ll * z[tmp + x] - z[tmp + 1]);
}
}
}
printf("%I64d", dp[k][a]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return (int)(((long long)a * b) % MOD); }
const int MAX = 5005, A = 30;
int dp[MAX][MAX];
int pref[MAX][MAX];
int pros[MAX];
char s[MAX];
int n;
vector<int> V[A];
int main() {
scanf("%d", &n);
scanf(" %s", s + 1);
for (int i = 0; i < A; i++) V[i].push_back(-1);
for (int i = (1); i < (n + 1); i++) {
pros[i] = V[s[i] - 'a'].back();
V[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < A; i++) V[i].push_back(MAX - 1);
dp[1][1] = 1;
pref[1][1] = 1;
for (int dokle = (1); dokle < (n + 1); dokle++) {
for (int i = (1); i < (n + 1); i++) {
int nacin = sub(pref[dokle][i], pref[dokle][pros[i] + 1]);
if (dokle == 1 && pros[i] == -1) nacin = 1;
dp[dokle + 1][i + 1] = add(dp[dokle + 1][i + 1], nacin);
}
if (dokle > 1)
for (int i = 0; i < MAX; i++)
dp[dokle + 1][i] = add(dp[dokle + 1][i], dp[dokle][i]);
for (int i = 0; i < MAX; i++)
pref[dokle + 1][i] =
add(dp[dokle + 1][i], (i ? pref[dokle + 1][i - 1] : 0));
}
int rje = pref[n + 1][MAX - 2];
printf("%d\n", rje);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long memo[51][2][2][2];
char grid[51][51];
long long n, m;
long long solve(long long i, long long symp, long long alpha, long long digit) {
if (i == n) {
if (symp == 1 && alpha == 1 && digit == 1) {
return 0;
} else {
return 1e18;
}
}
long long &ret = memo[i][symp][alpha][digit];
if (ret != -1) return ret;
long long C1 = 1e18, C2 = 1e18, C3 = 1e18, C = 1e18;
for (long long j = 0; j < m; j++) {
if (grid[i][j] == '*' || grid[i][j] == '&' || grid[i][j] == '#')
C1 = min(j, m - j) + solve(i + 1, 1, alpha, digit);
else if (isalpha(grid[i][j]))
C2 = min(j, m - j) + solve(i + 1, symp, 1, digit);
else
C3 = min(j, m - j) + solve(i + 1, symp, alpha, 1);
C = min(C, min(C1, min(C2, C3)));
}
return ret = C;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> grid[i][j];
memset(memo, -1, sizeof memo);
cout << solve(0, 0, 0, 0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph(200001);
int parent[200001], open[200001], close[200001], euler[200001], level[200001],
counter = 1, n, q, a, b, m, rminq[200001][20], subt[200001], ans;
int go_up[200001][20];
int traverse(int index, int par, int l) {
parent[index] = par;
euler[counter] = index;
level[index] = l;
open[index] = counter++;
subt[index] = 0;
for (int i = 0; i < graph[index].size(); i++) {
int node = graph[index][i];
if (node != par) {
subt[index] += traverse(node, index, l + 1);
euler[counter++] = index;
}
}
close[index] = counter - 1;
subt[index]++;
return subt[index];
}
void build() {
for (int j = 0; (1 << j) <= counter - 1; j++) {
for (int i = 1; i <= counter - 1; i++) {
if (j == 0) {
rminq[i][j] = euler[i];
} else if (i + (1 << j) - 1 > counter)
rminq[i][j] = -1;
else {
if (level[rminq[i][j - 1]] <= level[rminq[i + (1 << (j - 1))][j - 1]])
rminq[i][j] = rminq[i][j - 1];
else
rminq[i][j] = rminq[i + (1 << (j - 1))][j - 1];
}
}
}
}
int lca(int l, int r) {
int diff = r - l + 1, j, minlevel = n + 1, ans = -1;
while (diff > 0) {
for (j = 0; (1 << j) <= diff; j++)
;
j--;
if (minlevel > level[rminq[l][j]]) {
minlevel = level[rminq[l][j]];
ans = rminq[l][j];
}
l += (1 << j);
diff = r - l + 1;
}
return ans;
}
void build2(int index) {
go_up[index][0] = parent[index];
int prev = go_up[index][0];
for (int i = 1; i < 20; i++) {
if (prev == 0) break;
go_up[index][i] = go_up[prev][i - 1];
prev = go_up[index][i];
}
for (int i = 0; i < graph[index].size(); i++) {
int node = graph[index][i];
if (node != parent[index]) build2(node);
}
}
int query(int index, int dist) {
if (dist == 0) return index;
int j;
for (j = 0; (1 << j) <= dist; j++)
;
j--;
index = go_up[index][j];
dist -= (1 << j);
if (dist == 0) return index;
return query(index, dist);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
traverse(1, 0, 1);
build();
build2(1);
cin >> q;
for (int i = 0; i < q; i++) {
cin >> a >> b;
if (open[a] > open[b]) {
int c = a;
a = b;
b = c;
}
int anc = lca(open[a], open[b]);
int dist1 = level[a] - level[anc], dist2 = level[b] - level[anc];
if (dist1 == dist2) {
ans = n;
if (dist1 == 0)
cout << ans << "\n";
else if (dist1 == 1) {
ans -= subt[a];
ans -= subt[b];
cout << ans << "\n";
} else {
ans -= subt[query(a, dist1 - 1)];
ans -= subt[query(b, dist2 - 1)];
cout << ans << "\n";
}
} else if ((dist1 + dist2) % 2 == 1)
cout << 0 << "\n";
else {
if (dist1 > dist2) {
anc = query(a, (dist1 + dist2) / 2);
int mid = (dist1 + dist2) / 2;
dist1 = dist2 = mid;
ans = subt[anc];
ans -= subt[query(a, dist1 - 1)];
} else {
anc = query(b, (dist1 + dist2) / 2);
int mid = (dist1 + dist2) / 2;
dist1 = dist2 = mid;
ans = subt[anc];
ans -= subt[query(b, dist2 - 1)];
}
cout << ans << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
template <typename T = int>
T yh() {
T ret = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == EOF) return -1;
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) ret = (ret << 3) + (ret << 1) + (c ^ 48), c = getchar();
return f ? -ret : ret;
}
template <typename T>
void yh(T &ret) {
ret = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == EOF) return ret = -1, void();
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) ret = (ret << 3) + (ret << 1) + (c ^ 48), c = getchar();
ret = f ? -ret : ret;
}
const int maxn = 50005;
int n, m;
int c[maxn], r[maxn];
struct edge {
int to, nxt;
int w;
};
vector<edge> E(maxn << 4);
int h[maxn], en = 1;
void addedge(int x, int y, int w) {
if (++en == (int)E.size()) E.push_back((edge){0, 0, 0});
E[en].to = y;
E[en].nxt = h[x];
E[en].w = w;
h[x] = en;
}
void link(int x, int y, int w) {
addedge(x, y, w);
addedge(y, x, 0);
}
int S = 0;
int dep[maxn];
int cur[maxn];
queue<int> q;
bool bfs() {
while (!q.empty()) q.pop();
for (int i = 0; i <= ((n << 1) + 10); i++) dep[i] = inf;
dep[S] = 0;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int e = h[x]; e; e = E[e].nxt) {
int y = E[e].to;
if (E[e].w && dep[y] > dep[x] + 1) {
dep[y] = dep[x] + 1;
q.push(y);
}
}
}
return dep[((n << 1) + 10)] < inf;
}
int dfs(int x, int flow) {
if (x == ((n << 1) + 10)) return flow;
int delta = 0;
for (int &e = cur[x]; e; e = E[e].nxt) {
int y = E[e].to;
if (E[e].w && dep[y] == dep[x] + 1) {
delta = dfs(y, min(flow, E[e].w));
if (delta) {
E[e].w -= delta;
E[e ^ 1].w += delta;
return delta;
}
}
}
return 0;
}
int calc() {
int ans = 0;
while (bfs()) {
for (register int i = (0); i <= (((n << 1) + 10)); i++) cur[i] = h[i];
while (int path = dfs(S, inf)) ans += path;
}
return ans;
}
bool mp[505][505];
int main() {
n = yh(), m = yh();
for (register int i = (1); i <= (m); i++) {
int x = yh(), y = yh();
c[++*c] = x, r[++*r] = y;
mp[x][y] = 1;
}
int ANS = 0x7fffffff;
for (register int center = (1); center <= (n); center++) {
en = 1;
for (register int i = (0); i <= (((n << 1) + 10)); i++) h[i] = 0;
int ans = 0;
for (register int i = (1); i <= (n); i++) {
if (!mp[i][center]) ans++;
if (!mp[center][i]) ans++;
}
ans -= !mp[center][center];
for (register int i = (1); i <= (n); i++) link(S, i, 1);
for (register int i = (1); i <= (n); i++) link(i + n, ((n << 1) + 10), 1);
for (register int i = (1); i <= (m); i++)
if (c[i] != center && r[i] != center) link(c[i], r[i] + n, 1), ans++;
int tmp = calc();
ANS = min(ans + n - 1 - (tmp << 1), ANS);
}
cout << ANS << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int main() {
scanf("%d %d", &n, &t);
int met = 1e6, ans = -1;
for (int i = 0; i < n; i++) {
int s, d;
scanf("%d %d", &s, &d);
int tmp;
if (t <= s) {
tmp = s;
} else {
int k = (t - s + d - 1) / d;
tmp = s + k * d;
}
if (tmp < met) met = tmp, ans = i;
}
printf("%d\n", ans + 1);
}
| 1 |
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
int a[100010];
int s1[100010];
int s2[100010];
int can[100010];
int main() {
int n, i, j;
scanf("%d", &n);
a[0] = 0;
a[n + 1] = 0;
memset(can, 0, sizeof(can));
can[0] = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
s1[0] = 0;
s2[n + 1] = 0;
for (i = 1; i <= n; i++) {
s1[i] = s1[i - 1] + a[i];
}
for (i = n; i >= 1; i--) {
s2[i] = s2[i + 1] + a[i];
}
int ans = 0;
for (i = 1; i < n; i++) {
if (s1[i] == s2[i + 1]) ans++;
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 29645310968948039;
long long add(long long a, long long b) {
if (a + b >= MOD) return a + b - MOD;
return a + b;
}
long long mul(long long a, long long b) {
if (b == 0) return 0;
long long ans = mul(add(a, a), b / 2);
if (b % 2 == 1) ans = add(ans, a);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<long long> pw(n + 1);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = mul(pw[i - 1], 2);
vector<long long> a(n + 1, 0);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
a[u] = add(a[u], pw[v]);
a[v] = add(a[v], pw[u]);
}
map<long long, int> mp;
for (int i = 1; i <= n; i++) mp[a[i]]++;
long long ans = 0;
for (auto& p : mp) ans += (long long)p.second * (p.second - 1) / 2;
for (int i = 1; i <= n; i++) a[i] = add(a[i], pw[i]);
mp.clear();
for (int i = 1; i <= n; i++) mp[a[i]]++;
for (auto& p : mp) ans += (long long)p.second * (p.second - 1) / 2;
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long modpow(long long a, long long p, long long mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
p /= 2;
}
return ret;
}
long long power(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a);
a = (a * a);
p /= 2;
}
return ret;
}
long long fib(long long n, long long mod = LLONG_MAX) {
long long fib[2][2] = {{1, 1}, {1, 0}}, ret[2][2] = {{1, 0}, {0, 1}},
tmp[2][2] = {{0, 0}, {0, 0}};
long long i, j, k;
while (n) {
if (n & 1) {
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
tmp[i][j] = (tmp[i][j] + (ret[i][k] * fib[k][j]) % mod) % mod;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) ret[i][j] = tmp[i][j];
}
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
tmp[i][j] = (tmp[i][j] + (fib[i][k] * fib[k][j]) % mod) % mod;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) fib[i][j] = tmp[i][j];
n /= 2;
}
return (ret[0][1]);
}
int main() {
FastIO();
long long n, k, l, m;
cin >> n >> k >> l >> m;
long long ans = 1;
long long f = fib(n + 2, m);
long long p = (modpow(2LL, n, m) - f + m) % m;
if (l < 63 && (1LL << l) <= k) {
cout << 0 << '\n';
return 0;
}
ans %= m;
for (int i = 0; i < l; i++) {
if ((k >> i) & 1LL)
ans = (ans * p) % m;
else
ans = (ans * f) % m;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline bool mina(A &x, B y) {
return (x > y) ? (x = y, 1) : 0;
}
template <typename A, typename B>
inline bool maxa(A &x, B y) {
return (x < y) ? (x = y, 1) : 0;
}
int N;
int B[(104)][(104)];
int S[(104)];
int main() {
cin >> N;
for (int _b = (N), i = (0); i < _b; ++i)
for (int _b = (N), j = (0); j < _b; ++j) scanf("%d", &B[i][j]);
int sol = 0;
for (int _b = (N), i = (0); i < _b; ++i) {
int good = 1;
for (int _b = (N), j = (0); j < _b; ++j)
if (i != j && (B[i][j] & 1)) {
good = 0;
break;
}
if (good) S[sol++] = i + 1;
}
printf("%d\n", sol);
if (sol > 0) {
for (int _b = (sol), i = (0); i < _b; ++i) printf("%d ", S[i]);
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAX_N = (int)1e6 + 123;
const double eps = 1e-6;
const int mod = (int)1e6 + 3;
using namespace std;
int n;
int a[MAX_N];
vector<int> st;
bool bad[MAX_N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int t;
scanf("%d", &t);
while (t--) {
int x;
scanf("%d", &x);
bad[x] = 1;
}
for (int i = n; i > 0; i--) {
st.push_back(i);
if (bad[i]) continue;
if ((int)((st).size()) > 1 && a[i] == a[st[(int)((st).size()) - 2]]) {
a[st[(int)((st).size()) - 2]] *= -1;
st.pop_back(), st.pop_back();
}
}
if (!st.empty()) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define eb emplace_back
#define mp make_pair
#define nl cout << "\n";
#define ff first
#define ss second
#define rp(i, a, b) for (long long int i = a; i < b; i++)
#define inp(A) rp(i, 0, sizeof(A) / sizeof(A[0])) cin >> A[i];
#define outp(A) \
rp(i, 0, sizeof(A) / sizeof(A[0])) cout << A[i] << " "; \
nl;
#define pr(x) cout << (#x) << " " << (x) << endl;
#define all(v) v.begin(), v.end()
#define MOD 1000000007
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
void solve()
{
ll n; cin >> n;
vector<ll> A(2*n);
set<ll> s;
rp(i, 0, n*2) {
cin >> A[i];
s.insert(A[i]);
}
if(s.size() != n) {
cout << "NO\n";
return;
}
unordered_map<ll, bool> mp;
ll x = 0, sum = 0, val;
bool res = true;
for(auto it=s.rbegin(); it!=s.rend(); it++) {
val = ((*it) - 2*sum)/(2*n - x*2);
if(mp.find(val) != mp.end() || ((*it) - 2*sum)%(2*n - x*2) || val <= 0) {
res = false;
break;
}
x++;
sum += val;
mp[val] = true;
// cout << val << " ";
}
if(res) {
cout << "YES";
}else {
cout << "NO";
}
nl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS;
int T = 1;
cin >> T;
while (T--)
{
solve();
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
int c1, c2, c3;
c1 = ((k * l) / n) / nl;
int min = c1;
c2 = (c * d) / n;
if (c2 < min) {
min = c2;
}
c3 = (p / n) / np;
if (c3 < min) {
min = c3;
}
cout << min << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, cnt, ans, a[200010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i)
if (a[i] == a[i - 1])
++cnt;
else if (a[i] <= a[i - 1] + k)
cnt = 1;
else
ans += cnt, cnt = 1;
printf("%d\n", ans + cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, m, a, cnt, z = -1, flag = 1, ans, p[10005], x[10005], y[10005];
char s[10005];
bool cmp(const int i, const int j) { return x[i] < x[j]; }
int main() {
scanf("%d%s", &a, s), n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '-')
flag = -flag;
else if (s[i] == '+')
cnt++;
else if (s[i] == 'a')
cnt = cnt < 2, p[m] = m, x[m] = (z < 0 ? 1 : z) * flag, y[m++] = cnt,
i += cnt * 2, flag = 1, z = -1, cnt = 0;
else if (s[i] - '*')
z += z < 0, z = z * 10 + s[i] - 48;
std::sort(p, p + m, cmp);
for (int k = 0; k < m; k++) {
int i = p[k];
if (y[i])
ans += x[i] * a++;
else
ans += x[i] * ++a;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[200005];
int n, m, ss, tt, vis[200005], opt[200005];
void add(int x, int y) { a[x].push_back(y); }
void bfs(int s, int t) {
queue<int> q;
vis[s] = 1;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
if (v == t) continue;
for (int i = 0; i < a[v].size(); i++) {
int u = a[v][i];
if (!vis[u]) vis[u] = 1, q.push(u);
}
}
}
int main() {
scanf("%d%d", &n, &m);
ss = n * 2 + 1;
tt = n * 2 + 2;
for (int i = 1; i <= n; i++) {
scanf("%d", &opt[i]);
if (opt[i] == 1) add(ss, i), add(i + n, tt);
if (opt[i] == 2) add(i, tt), add(ss, i + n);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (opt[y] != 1) add(x, y), add(y + n, x + n);
}
bfs(ss, tt);
bfs(tt, ss);
for (int i = 1; i <= n; i++) printf("%d\n", vis[i] && vis[i + n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[100100], vis[100100];
long long i, j, k, l, n, m, last, num, sz, p;
int main() {
cin >> n;
if (n < 4) {
if (n == 1)
cout << 1 << endl;
else {
if (n == 2)
cout << 1 << ' ' << 2 << endl;
else {
cout << 1 << ' ' << 2 << ' ' << 3 << endl;
}
}
return 0;
}
p = sqrt(n);
num = p;
last = num;
for (i = 1; i <= min(n, p); i++) {
a[i] = last;
last--;
vis[last] = 1;
}
if (n > p) {
for (i = p + 1; i <= n; i++) {
if (i % p == 1) {
num += p;
num = min(num, n);
last = num;
}
a[i] = last;
last--;
}
}
for (i = 1; i <= n; i++) cout << a[i] << ' ';
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& x) {
return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-11;
char TEMPORARY_CHAR;
const int INF = 0x3f3f3f3f;
const int N = 1 << 16;
inline void input(int& a) {
a = 0;
while ((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') {
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
}
const long long p = 1003001;
long long has(vector<int>& a) {
long long ans = 0;
for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++) {
ans = ans * p + (long long)(*it);
}
return ans;
}
int main() {
int(n);
input((n));
;
int(m);
input((m));
;
vector<vector<int> > g(n);
for (int i = 0; i < (int)(m); i++) {
int(a);
input((a));
;
int(b);
input((b));
;
g[a - 1].push_back(b);
g[b - 1].push_back(a);
}
vector<long long> h(n);
for (int i = 0; i < (int)(n); i++) {
sort((g[i]).begin(), (g[i]).end());
h[i] = has(g[i]);
}
sort((h).begin(), (h).end());
long long ans = 0;
for (int i = 0; i < (int)(n); i++) {
int cnt = 0;
while (i + cnt < n && h[i] == h[i + cnt]) cnt++;
i = i + cnt - 1;
ans += ((long long)cnt * (long long)(cnt - 1)) >> 1;
}
for (int i = 0; i < (int)(n); i++) {
g[i].push_back(i + 1);
sort((g[i]).begin(), (g[i]).end());
h[i] = has(g[i]);
}
sort((h).begin(), (h).end());
for (int i = 0; i < (int)(n); i++) {
int cnt = 0;
while (i + cnt < n && h[i] == h[i + cnt]) cnt++;
i = i + cnt - 1;
ans += ((long long)cnt * (long long)(cnt - 1)) >> 1;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r, min1 = 0, x = 1, y = 1, max1 = 0;
cin >> n >> l >> r;
min1 += n - l + 1;
y = y << (r - 1);
max1 = (n - r + 1) * y;
while (l > 1) {
x = x << 1;
min1 += x;
l--;
}
x = 1;
while (r > 1) {
max1 += x;
x = x << 1;
r--;
}
cout << min1 << " " << max1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long read() {
long long x = 0;
bool f = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + (c - '0'), c = getchar();
return f ? -x : x;
}
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
template <typename T>
inline bool umin(T& a, T b) {
if (b < a) return a = b, 1;
return 0;
}
template <typename T>
inline bool umax(T& a, T b) {
if (b > a) return a = b, 1;
return 0;
}
const int MAXN = 300011, INF = 1.233e9;
int n, L;
int a[MAXN], b[MAXN];
struct Segment_Tree_Min {
int t[MAXN << 2 | 1];
void init(int* a, unsigned l = 1, unsigned r = n, unsigned num = 1) {
if (l == r) {
t[num] = a[l];
return;
}
unsigned mid = (l + r) >> 1;
init(a, l, mid, num << 1), init(a, mid + 1, r, num << 1 | 1);
t[num] = min(t[num << 1], t[num << 1 | 1]);
}
int Qmin(unsigned ql, unsigned qr, unsigned l = 1, unsigned r = n,
unsigned num = 1) {
if (ql <= l && r <= qr) return t[num];
unsigned mid = (l + r) >> 1;
int res = INF;
if (ql <= mid) umin(res, Qmin(ql, qr, l, mid, num << 1));
if (qr > mid) umin(res, Qmin(ql, qr, mid + 1, r, num << 1 | 1));
return res;
}
} Tmin;
struct Segment_Tree_Sum {
struct node {
long long sum, tag;
} t[MAXN << 2 | 1];
void pushdown(unsigned l, unsigned r, unsigned num) {
if (t[num].tag == 0) return;
unsigned mid = (l + r) >> 1;
t[num << 1].sum = (mid - l + 1) * t[num].tag, t[num << 1].tag = t[num].tag;
t[num << 1 | 1].sum = (r - mid) * t[num].tag,
t[num << 1 | 1].tag = t[num].tag;
t[num].tag = 0;
}
void init(unsigned l = 1, unsigned r = L, unsigned num = 1) {
t[num].sum = t[num].tag = 0;
if (l == r) return;
unsigned mid = (l + r) >> 1;
init(l, mid, num << 1), init(mid + 1, r, num << 1 | 1);
}
void Cover(unsigned ql, unsigned qr, long long k, unsigned l = 1,
unsigned r = L, unsigned num = 1) {
if (ql <= l && r <= qr) {
t[num].sum = (r - l + 1) * k, t[num].tag = k;
return;
}
pushdown(l, r, num);
unsigned mid = (l + r) >> 1;
if (ql <= mid) Cover(ql, qr, k, l, mid, num << 1);
if (qr > mid) Cover(ql, qr, k, mid + 1, r, num << 1 | 1);
t[num].sum = t[num << 1].sum + t[num << 1 | 1].sum;
}
long long Qsum(unsigned ql, unsigned qr, unsigned l = 1, unsigned r = L,
unsigned num = 1) {
if (ql <= l && r <= qr) return t[num].sum;
pushdown(l, r, num);
unsigned mid = (l + r) >> 1;
long long res = 0;
if (ql <= mid) res += Qsum(ql, qr, l, mid, num << 1);
if (qr > mid) res += Qsum(ql, qr, mid + 1, r, num << 1 | 1);
return res;
}
} Tsum;
struct one {
int l, r, dex;
};
std::vector<one> Q1[MAXN];
std::vector<std::pair<int, int> > Q2[MAXN];
int s[MAXN], val[MAXN], top;
long long res[MAXN];
int main() {
n = read();
int m = read(), k = read();
for (int i = 1; i <= n; ++i) a[i] = read();
Tmin.init(a);
for (int i = 1; i <= m; ++i) {
int l = read(), r = read();
Q1[l % k].emplace_back(
one{(l - 1) / k + 1, (l - 1) / k + 1 + (r - l) / k, i});
}
for (int r = 0; r < k; ++r) {
L = 0;
for (int i = r ? r : k; i <= n; i += k) b[++L] = i, Q2[L].clear();
for (auto x : Q1[r]) {
Q2[x.l].emplace_back(std::pair<int, int>(x.r, x.dex));
}
top = 0;
s[0] = L + 1;
for (int i = L; i; --i) {
int v = Tmin.Qmin(b[i], min(b[i] + k - 1, n)), flag = 0;
while (top && val[top] > v) {
Tsum.Cover(i + 1, s[top - 1] - 1, v), --top;
flag = 1;
}
Tsum.Cover(i, i, a[b[i]]);
if (flag) s[++top] = i + 1, val[top] = v;
s[++top] = i, val[top] = a[b[i]];
for (auto x : Q2[i]) res[x.second] = Tsum.Qsum(i, x.first);
}
}
for (int i = 1; i <= m; ++i) printf("%lld\n", res[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char a[1000005], b[1000005], s[1000005];
int k, T, tmp[27], vis[27], p, n, tt[27], vv[27];
bool check(int x, int cas) {
memcpy(tt, tmp, sizeof(tt));
memcpy(vv, vis, sizeof(vv));
if (cas == 1) {
for (int i = x; i <= n; i++) {
if (tt[s[i] - 'a'] != -1) {
if (tt[s[i] - 'a'] > a[i]) return 1;
if (tt[s[i] - 'a'] < a[i]) return 0;
continue;
}
for (int j = a[i] + 1; j <= k + 'a' - 1; j++)
if (!vv[j - 'a']) return 1;
if (!vv[a[i] - 'a'])
vv[a[i] - 'a'] = 1, tt[s[i] - 'a'] = a[i];
else
return 0;
}
return 1;
} else {
for (int i = x; i <= n; i++) {
if (tt[s[i] - 'a'] != -1) {
if (tt[s[i] - 'a'] > b[i]) return 0;
if (tt[s[i] - 'a'] < b[i]) return 1;
continue;
}
for (int j = 'a'; j < b[i]; j++)
if (!vv[j - 'a']) return 1;
if (!vv[b[i] - 'a'])
vv[b[i] - 'a'] = 1, tt[s[i] - 'a'] = b[i];
else
return 0;
}
return 1;
}
}
void solve() {
scanf("%d%s%s%s", &k, s + 1, a + 1, b + 1);
n = strlen(s + 1);
memset(tmp, -1, sizeof(tmp));
p = n + 1;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (a[i] == b[i]) {
if (tmp[s[i] - 'a'] == a[i]) continue;
if (tmp[s[i] - 'a'] == -1 && !vis[a[i] - 'a'])
tmp[s[i] - 'a'] = a[i], vis[a[i] - 'a'] = 1;
else {
puts("NO");
return;
}
} else {
p = i;
break;
}
int flag = 0;
for (int i = p; i <= n; i++) {
if (!flag && a[i] > b[i]) {
puts("NO");
return;
}
if (tmp[s[i] - 'a'] != -1) {
if ((((flag & 2) == 0) && tmp[s[i] - 'a'] < a[i]) ||
(((flag & 4) == 0) && tmp[s[i] - 'a'] > b[i])) {
puts("NO");
return;
}
if ((flag & 2) == 0 && tmp[s[i] - 'a'] > a[i]) flag |= 2;
if ((flag & 4) == 0 && tmp[s[i] - 'a'] < b[i]) flag |= 4;
} else if ((flag & 6) == 0) {
bool used = 0;
for (int j = a[i] + 1; j < b[i]; j++)
if (!vis[j - 'a']) {
tmp[s[i] - 'a'] = j;
vis[j - 'a'] = 1;
flag |= 6;
used = 1;
break;
}
if (!used) {
if (!used && !vis[b[i] - 'a']) {
vis[b[i] - 'a'] = 1, tmp[s[i] - 'a'] = b[i];
if (!check(i + 1, 2))
vis[b[i] - 'a'] = 0, tmp[s[i] - 'a'] = -1;
else
flag |= 2, used = 1;
}
if (!used && !vis[a[i] - 'a']) {
vis[a[i] - 'a'] = 1, tmp[s[i] - 'a'] = a[i];
if (check(i + 1, 1)) flag |= 4, used = 1;
}
if (!used) {
puts("NO");
return;
}
}
} else if ((flag & 2) == 0) {
bool used = 0;
for (int j = a[i] + 1; j <= k + 'a' - 1; j++)
if (!vis[j - 'a']) {
tmp[s[i] - 'a'] = j;
vis[j - 'a'] = 1;
flag |= 2;
used = 1;
break;
}
if (!used) {
if (!vis[a[i] - 'a'])
vis[a[i] - 'a'] = 1, tmp[s[i] - 'a'] = a[i];
else {
puts("NO");
return;
}
}
} else if ((flag & 4) == 0) {
bool used = 0;
for (int j = 'a'; j < b[i]; j++)
if (!vis[j - 'a']) {
tmp[s[i] - 'a'] = j;
vis[j - 'a'] = 1;
flag |= 4;
used = 1;
break;
}
if (!used) {
if (!vis[b[i] - 'a'])
vis[b[i] - 'a'] = 1, tmp[s[i] - 'a'] = b[i];
else {
puts("NO");
return;
}
}
}
flag |= 1;
if (flag == 7) break;
}
puts("YES");
int now = 0;
while (vis[now]) now++;
for (int i = 0; i < k; i++)
if (tmp[i] == -1) {
tmp[i] = 'a' + now;
vis[now] = 1;
while (vis[now]) now++;
}
for (int i = 0; i < k; i++) printf("%c", tmp[i]);
puts("");
}
int main() {
scanf("%d", &T);
while (T--) solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1000010;
const int INF = 1000000010;
long long num[SZ], sum[SZ];
map<long long, int> mp;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &num[i]), num[i + n] = num[i];
for (int i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + num[i];
for (int i = 2; i <= n + 1; i++) mp[sum[i]]++;
int ans = INF;
for (int i = 1; i <= n; i++) {
ans = min(ans, n - mp[sum[i]]);
mp[sum[i + 1]]--;
mp[sum[i + 1 + n]]++;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long int INF = 1e18;
const int N = 100005;
const int MOD = 1e9 + 7;
const double EPS = 1e-6;
const double PI = acos(-1.0);
int r = 1, o = 2, e = 3;
int cur = r;
int cost[5][5] = {0};
int main(int argc, char const *argv[]) {
int n;
cin >> n;
cin >> cost[r][o] >> cost[r][e] >> cost[o][e];
cost[o][r] = cost[r][o], cost[e][r] = cost[r][e], cost[e][o] = cost[o][e];
int ans = 0;
--n;
while (n--) {
if (cur == r) {
ans += min(cost[r][e], cost[r][o]);
(cost[r][e] < cost[r][o] ? cur = e : cur = o);
} else if (cur == e) {
ans += min(cost[e][o], cost[e][r]);
(cost[e][o] < cost[e][r] ? cur = o : cur = r);
} else {
ans += min(cost[o][r], cost[o][e]);
(cost[o][r] < cost[o][e] ? cur = r : cur = e);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<int> ans;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '-' && s[i + 1] == '.') {
ans.push_back(1);
i = i + 1;
} else if (s[i] == '.')
ans.push_back(0);
else if (s[i] == '-' && s[i + 1] == '-') {
ans.push_back(2);
i = i + 1;
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
void computeLPSArray(string pat, int M, int* lps);
int lastmatchJ = -1;
int KMPSearch(string pat, string txt, int flag) {
int M = pat.size();
int N = txt.size();
int lps[M];
computeLPSArray(pat, M, lps);
int i = 0;
int j = 0;
int endd = -1, lastmatchI = 0;
while (i < N) {
if (pat[j] == txt[i]) {
endd = max(endd, j);
lastmatchI = i + 1;
lastmatchJ = j + 1;
j++;
i++;
} else if (i < N && pat[j] != txt[i]) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
if (flag == 0)
return endd + 1;
else {
if (lastmatchI == N) return 1;
return 0;
}
}
void computeLPSArray(string pat, int M, int* lps) {
int len = 0;
lps[0] = 0;
int i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s1, s2;
cin >> s1;
long long x = s1.size();
s2 = s1.substr(1, x - 2);
int k = KMPSearch(s1, s2, 0);
if (k == 0) {
cout << "Just a legend";
return 0;
}
string s3 = s1.substr(0, k);
string s4 = s1.substr(x - k, k);
if (KMPSearch(s3, s4, 1)) {
cout << s1.substr(0, lastmatchJ);
} else {
cout << "Just a legend";
return 0;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> q[100005];
double dp[100005];
double cnt = 0;
void dfs(int x, int pre, int k) {
cnt += 1.0 / k;
for (int i = 0; i < q[x].size(); i++) {
int v = q[x][i];
if (v == pre) continue;
dfs(v, x, k + 1);
}
}
int main() {
int n;
scanf("%d", &n);
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
q[x].push_back(y);
q[y].push_back(x);
}
dfs(1, 0, 1);
printf("%.10f\n", cnt);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
float area(int x1, int y1, int x2, int y2, int x3, int y3) {
return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
bool inside_rectangle(int x1, int y1, int x2, int y2, int x3, int y3, int x4,
int y4, int x, int y) {
float A = area(x1, y1, x2, y2, x3, y3) + area(x1, y1, x4, y4, x3, y3);
float A1 = area(x, y, x1, y1, x2, y2);
float A2 = area(x, y, x2, y2, x3, y3);
float A3 = area(x, y, x3, y3, x4, y4);
float A4 = area(x, y, x1, y1, x4, y4);
return (A == A1 + A2 + A3 + A4);
}
int main() {
long long n, s, h, m, i;
std::vector<long long> v;
cin >> n >> s;
for (i = 0; i < n; ++i) {
cin >> h >> m;
v.push_back(60 * h + m);
}
if (v[0] >= s + 1)
cout << 0 << ' ' << 0;
else {
for (i = 1; i < n; ++i) {
if (v[i] - v[i - 1] >= 2 * (s + 1)) break;
}
i--;
cout << (v[i] + s + 1) / 60 << " " << (v[i] + s + 1) % 60;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, p, e;
int h[16];
int s[16 * 16];
int nbs = 0x7fffffff;
int bs[16 * 16];
bool is_ans() {
for (int i = 1; i <= n; i++)
if (h[i] >= 0) {
return false;
}
return true;
}
void dfs(int i) {
if (i >= nbs) {
return;
}
if (is_ans()) {
if (i < nbs) {
nbs = i;
for (int j = 0; j < i; j++) {
bs[j] = s[j];
}
}
return;
}
for (int j = (i > 0 ? s[i - 1] : 2); j < n; j++) {
if (h[j] >= 0 || h[j - 1] >= 0 || h[j + 1] >= 0) {
s[i] = j;
h[j] -= a;
h[j - 1] -= b;
h[j + 1] -= b;
dfs(i + 1);
h[j] += a;
h[j - 1] += b;
h[j + 1] += b;
}
}
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
while (h[0] > 0) {
p++;
h[0] -= b;
h[1] -= a;
h[2] -= b;
}
while (h[n] > 0) {
e++;
h[n] -= b;
h[n - 1] -= a;
h[n - 2] -= b;
}
dfs(0);
for (int i = 0; i < nbs; i++) {
bs[i + p] = bs[i];
}
for (int i = 0; i < p; i++) {
bs[i] = 2;
}
for (int i = 0; i < e; i++) {
bs[nbs + i] = n - 1;
}
nbs = nbs + p + e;
cout << nbs << endl;
cout << bs[0];
for (int i = 1; i < nbs; i++) {
cout << ' ' << bs[i];
}
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
string tostr(int n) {
stringstream rr;
rr << n;
return rr.str();
}
const int mod = 1e9 + 7;
const int mxn = 5e5 + 9;
const long double eps = 1e-9;
map<long long, long long> a;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long i, j, k, n, m, ans = 1e18;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> k;
if (i <= (n + 1) / 2)
a[k - i + 1]++;
else
a[k - (n - i)]++;
}
for (i = 1; i < mxn; i++) ans = min(ans, n - a[i]);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
char x = 'a';
int y;
set<int> arr[26];
for (int i = 0; i < s.length(); i++) {
y = s[i] - x;
arr[y].insert(i);
}
int q;
cin >> q;
int n, ans = 0;
for (int i = 0; i < q; i++) {
cin >> n;
if (n == 1) {
int pos;
char c;
cin >> pos >> c;
y = s[pos - 1] - x;
arr[y].erase(pos - 1);
s[pos - 1] = c;
y = c - x;
arr[y].insert(pos - 1);
}
if (n == 2) {
int l, r;
cin >> l >> r;
l--;
r--;
for (int i = 0; i < 26; i++) {
auto it = arr[i].lower_bound(l);
if (it == arr[i].end())
continue;
else if (*it <= r)
ans++;
}
cout << ans << endl;
ans = 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
int a[N], d[N];
double C[N][N], dp[N][N];
vector<int> v[N];
int main() {
int n, m, i, j, k, x, y, z, tt = 0;
scanf("%d%d", &m, &n);
C[0][0] = 1;
for (i = 1; i <= 1001; i++) {
C[i][0] = C[i][i] = 1;
for (j = 1; j < i; j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
for (i = 1; i <= n; i++) {
scanf("%d", &k);
while (k--) {
scanf("%d", &x);
v[i].push_back(x);
a[++tt] = x;
}
}
sort(a + 1, a + tt + 1);
x = a[tt - m + 1];
y = 0, z = 0;
for (i = 1; i <= tt; i++) y += (a[i] == x), z += (a[i] > x);
dp[0][0] = 1;
for (i = 1; i <= n; i++) {
int f = 0, ts = 0, yy, sz = v[i].size();
for (j = 0; j < v[i].size(); j++) {
yy = v[i][j];
if (yy == x) f = 1;
if (yy > x) ts++;
}
for (k = 1; k <= m - z; k++)
dp[i][k] =
dp[i - 1][k] / C[sz][ts] + (f ? dp[i - 1][k - 1] / C[sz][ts + 1] : 0);
dp[i][0] = dp[i - 1][0] / C[sz][ts];
}
double ans = dp[n][m - z] / C[y][m - z];
printf("%.9lf\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c;
scanf("%d", &c);
string s;
cin >> s;
int tam = s.size();
for (int i = 0; i < c - 1; i++) {
for (int j = 0; j < tam; j++) {
char c;
cin >> c;
if (c != '?' && c != s[j] && s[j] != '?') {
s[j] = '0';
} else if (c != '?' && s[j] == '?') {
s[j] = c;
}
}
}
for (int i = 0; i < tam; i++) {
if (s[i] == '?')
printf("l");
else if (s[i] == '0')
printf("?");
else
printf("%c", s[i]);
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
set<long long> g[N];
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << "(";
os << v.first << "," << v.second << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
long long sz = v.size();
for (long long i = 0; i < sz; ++i) {
os << v[i];
if (i != sz - 1) os << ",";
}
os << "]\n";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
T last = *v.rbegin();
os << "[";
for (auto it : v) {
os << it;
if (it != last) os << ",";
}
os << "]\n";
return os;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const map<T, S> &v) {
for (auto it : v) {
os << it.first << " : " << it.second << "\n";
}
return os;
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < (n - 1); i++) {
long long x, y;
cin >> x >> y;
--x;
--y;
g[x].insert(y);
g[y].insert(x);
}
vector<long long> a(n);
for (auto &x : a) {
cin >> x;
--x;
}
if (a[0] != 0) {
cout << "No\n";
return;
}
vector<bool> mark(n);
queue<long long> Q;
Q.push(0);
mark[0] = 1;
long long idx = 1;
while (!Q.empty()) {
long long f = Q.front();
Q.pop();
set<long long> nset;
while (idx < n && g[f].count(a[idx])) {
Q.push(a[idx]);
mark[a[idx]] = 1;
nset.insert(a[idx]);
idx++;
}
for (long long x : g[f]) {
if (!mark[x] && nset.find(x) == nset.end()) {
cout << "No\n";
return;
}
}
if (idx == n) break;
}
cout << "Yes\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printvec(vector<T>& vec) {
for (int i = 0; i < vec.size(); i++) cout << vec[i] << " ";
cout << '\n';
}
int main() {
std::ios::sync_with_stdio(false);
int i = 0, j = 0;
int ttt = 0;
cin >> ttt;
while (ttt--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < a.size(); i++) {
cin >> a[i];
};
sort(a.begin(), a.end());
int m = n / 2;
for (i = 1; i <= m; i++) {
cout << a[i] << " " << a[0] << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 3;
const double EPS = 1e-13;
const int64_t MOD = (int64_t)1e9 + 123;
struct Dsu {
unordered_map<int, int> leaders;
unordered_map<int, int> heights;
Dsu(size_t n = 0) {
leaders = unordered_map<int, int>(n);
heights = unordered_map<int, int>(n);
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
if (heights[a] < heights[b]) {
swap(a, b);
}
leaders[b] = a;
if (heights[a] == heights[b]) {
++heights[a];
}
}
}
int find(int a) {
if (leaders.count(a) == 0 or a == leaders[a]) {
return a;
}
return leaders[a] = find(leaders[a]);
}
};
void test0() {
Dsu dsu;
size_t n, m;
scanf("%zu %zu", &n, &m);
vector<vector<int>> ways(n, vector<int>(2, 0));
for (int i = 0; i < n; ++i) {
ways[i][1] = i;
}
for (int _ = 0; _ < m; ++_) {
int fir, sec;
scanf("%d %d", &fir, &sec);
--fir, --sec;
dsu.unite(fir, sec);
++ways[fir][0];
++ways[sec][0];
}
sort(ways.rbegin(), ways.rend());
int64_t max_danger = 1;
int prev = -1;
for (auto &&vertex : ways) {
if (dsu.find(prev) != dsu.find(vertex[1])) {
dsu.unite(prev, vertex[1]);
} else {
max_danger <<= 1;
}
}
printf("%" PRId64 "\n", max_danger);
}
int main() {
clock_t start = clock();
test0();
double time = (clock() - start) / (double)CLOCKS_PER_SEC * 1000;
fprintf(stderr, "Time: %f ms\n", time);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
auto start = high_resolution_clock::now();
int n, m, ans;
cin >> n >> m;
int power = pow(2, n);
if (n >= 27)
cout << m << "\n";
else if (pow(2, n) > m)
cout << m << "\n";
else if (pow(2, n) <= m) {
ans = m % power;
cout << ans;
}
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
void solve() {
int a, b;
cin >> a >> b;
int d = abs(a - b) / 2;
vector<int> ans;
if ((a + b) % 2) {
for (int i = d; i <= a + b - d; i++) {
ans.push_back(i);
}
} else {
for (int i = d; i <= a + b - d; i += 2) {
ans.push_back(i);
}
}
cout << ans.size() << '\n';
for (int i : ans) {
cout << i << ' ';
}
}
int main() {
int tc = 1;
cin >> tc;
while (tc--) {
solve();
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, k;
long long A, B;
int q;
long long tree[300000], tree1[300000];
long long a[300000], b[300000];
int MaxVal = 200005;
long long read(int idx) {
long long sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, long long val) {
while (idx <= MaxVal) {
tree[idx] += val;
idx += (idx & -idx);
}
}
long long read1(int idx) {
long long sum = 0;
while (idx > 0) {
sum += tree1[idx];
idx -= (idx & -idx);
}
return sum;
}
void update1(int idx, long long val) {
while (idx <= MaxVal) {
tree1[idx] += val;
idx += (idx & -idx);
}
}
int main() {
cin >> n >> k >> A >> B >> q;
for (i = 0; i < q; i++) {
int x, y, z;
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &x, &y);
int yy = y;
if (a[x] < A) {
if (a[x] + y > A) y = A - a[x];
a[x] += y;
update(x, y);
}
if (b[x] < B) {
if (b[x] + yy > B) yy = B - b[x];
b[x] += yy;
update1(x, yy);
}
} else {
scanf("%d", &y);
long long ans = 0;
if (y > 1) ans += read1(y - 1);
int last = y + k - 1;
if (last != n) ans += read(n) - read(last);
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <map>
using namespace std;
int main()
{
int t;
cin>>t;
while (t--)
{
int n;
cin>>n;
vector <int> vec(n);
int min=101;
for (int i=0;i<n;i++)
{
cin>>vec[i];
if (vec[i]<min)
min=vec[i];
}
int count=0;
for (int i=0;i<n;i++)
if (min==vec[i])
count++;
cout<<n-count<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void chkmax(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
inline void chkmin(T& x, U y) {
if (y < x) x = y;
}
const int MAXN = 510000;
int T;
int b[MAXN], d[MAXN], chk[MAXN], id[MAXN], st[MAXN], en[MAXN], f[19][MAXN],
par[MAXN];
pair<int, int> a[MAXN];
vector<int> adj[MAXN];
long long ans[MAXN], sz[MAXN];
void dfs(int u) {
d[u] = d[f[0][u]] + 1;
st[u] = ++T;
for (int i = 1; i < 19; i++) f[i][u] = f[i - 1][f[i - 1][u]];
for (int i = 0; i < ((int)(adj[u].size())); i++) dfs(adj[u][i]);
en[u] = T;
}
bool cmp(int u, int v) {
if (d[u] != d[v]) return d[u] < d[v];
return st[u] < st[v];
}
inline int lca(int u, int v) {
if (d[u] < d[v]) swap(u, v);
for (int i = 0, diff = d[u] - d[v]; (1 << i) <= diff; i++)
if (diff >> i & 1) u = f[i][u];
if (u == v) return u;
for (int i = 31 - __builtin_clz(d[u]); i >= 0; i--)
if (f[i][u] != f[i][v]) u = f[i][u], v = f[i][v];
return f[0][u];
}
int main() {
int n;
scanf("%d", &n);
int r = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &f[0][i]);
if (f[0][i])
adj[f[0][i]].push_back(i);
else
r = i;
}
dfs(r);
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
T = 0;
for (int i = 1, j; i <= n; i = j) {
T++;
int m = 0;
for (j = i; j <= n && d[id[i]] == d[id[j]]; j++) {
int u = id[j];
chk[u] = T, sz[u] = 1, a[++m] = make_pair(st[u], u);
if (j > i) {
int v = lca(u, id[j - 1]);
if (chk[v] != T) chk[v] = T, sz[v] = 0, a[++m] = make_pair(st[v], v);
}
}
sort(a + 1, a + m + 1);
int l = 0;
for (int k = 1; k <= m; k++) {
int u = a[k].second;
while (l > 0 && en[b[l]] < st[u]) l--;
par[u] = b[l];
b[++l] = u;
}
for (int k = m; k > 0; k--) {
int u = a[k].second;
if (par[u]) sz[par[u]] += sz[u];
}
for (int k = 1; k <= m; k++) {
int u = a[k].second;
sz[u] = sz[par[u]] + sz[u] * (d[u] - d[par[u]]);
if (d[u] == d[id[i]]) ans[u] = ans[f[0][u]] + sz[u] - 1;
}
}
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
map<int, bool> has;
int n, m, a[maxn], b[maxn];
int qpow(int x, int a) {
int ret = 1;
while (a) {
if (a & 1) ret = 1LL * ret * x % m;
x = 1LL * x * x % m;
a >>= 1;
}
return ret;
}
pair<int, int> Solve(int* a, int n) {
if (n == 0) return pair<int, int>(0, 1);
if (n == 1) return pair<int, int>(a[0], 1);
int x = (a[1] - a[0] + m) % m, cnt = 0;
for (int i = 0; i < n; i++)
if (has[(a[i] + x) % m]) cnt++;
int k = n - cnt, d = 1LL * x * qpow(k, m - 2) % m;
int cnt1 = 0, cnt2 = 0;
for (int i = 1; cnt1 + cnt2 + 1 < n; i++, cnt1++) {
if (!has[(a[0] + (long long)i * d) % m]) break;
}
for (int i = 1; cnt1 + cnt2 + 1 < n; i++, cnt2++) {
int t = (a[0] - (long long)i * d) % m;
if (t < 0) t += m;
if (!has[t]) break;
}
if (cnt1 + cnt2 + 1 == n) {
int t = (a[0] - (long long)cnt2 * d) % m;
if (t < 0) t += m;
return pair<int, int>(t, d);
} else {
return pair<int, int>(-1, -1);
}
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), has[a[i]] = true;
if (2 * n < m) {
pair<int, int> ans = Solve(a, n);
printf("%d ", ans.first);
if (ans.first != -1) printf("%d ", ans.second);
} else {
int cnt = 0;
for (int i = 0; i < m; i++)
if (!has[i]) b[cnt++] = i;
has.clear();
for (int i = 0; i < cnt; i++) has[b[i]] = true;
pair<int, int> ans = Solve(b, cnt);
if (ans.first == -1)
printf("-1");
else
cout << (ans.first + ((long long)m - n) * ans.second % m) % m << " "
<< ans.second;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char A[200];
cin >> A;
for (int i = 0; A[i] != '\0'; i++) {
if (A[i] == '.')
cout << "0";
else if (A[i] == '-' && A[i + 1] == '.') {
cout << "1";
i++;
} else if (A[i] == '-' && A[i + 1] == '-') {
cout << "2";
i++;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ans;
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= sqrt(n); i++)
if (n % i == 0) {
ans.push_back((n + 2 - i) * n / i / 2);
if (i * i != n) ans.push_back((i * n + 2 * i - n) / 2);
}
sort(ans.begin(), ans.end());
for (unsigned int i = 0; i < ans.size(); i++) printf("%lld ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool IsPrime(int N) {
for (int i = 2; i * i <= N; ++i) {
if (N % i == 0) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
vector<char> is_prime(101, false);
for (int i = 1; i < is_prime.size(); ++i) {
is_prime[i] = IsPrime(i);
}
vector<int> dp(is_prime.size(), 0);
for (int i = 1; i < dp.size(); ++i) {
dp[i] = is_prime[i] ? -1 : 1;
for (int j = 1; i - j > 0; ++j) {
if (dp[j] != -1 && dp[i - j] != -1) {
dp[i] = max(dp[i], dp[j] + dp[i - j]);
}
}
}
int Q;
cin >> Q;
for (int q = 0; q < Q; ++q) {
int a;
cin >> a;
if (a < dp.size()) {
cout << dp[a] << '\n';
continue;
}
switch (a % 4) {
case 0: {
case 2:
cout << a / 4 << '\n';
break;
}
default: {
cout << a / 4 - 1 << '\n';
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long cnt[32][2][2][2];
long long sum[32][2][2][2];
vector<int> A, B, C;
long long solve(int x, int y, int k) {
if (x < 0 || y < 0 || k < 0) {
return 0;
}
memset(cnt, 0, sizeof(cnt));
memset(sum, 0, sizeof(sum));
A.clear(), B.clear(), C.clear();
for (int i = 0; i <= 30; i++) {
A.push_back(x % 2);
x /= 2;
B.push_back(y % 2);
y /= 2;
C.push_back(k % 2);
k /= 2;
}
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
reverse(C.begin(), C.end());
cnt[0][1][1][1] = 1;
sum[0][1][1][1] = 0;
for (int i = 0; i <= 30; i++) {
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
for (int c = 0; c < 2; c++) {
for (int b1 = 0; b1 < 2; b1++) {
for (int b2 = 0; b2 < 2; b2++) {
int z = b1 ^ b2;
if (a == 1 && A[i] == 0 && b1 == 1) {
continue;
}
if (b == 1 && B[i] == 0 && b2 == 1) {
continue;
}
if (z == 1 && C[i] == 0 && c == 1) {
continue;
}
cnt[i + 1][a & (A[i] == b1)][b & (B[i] == b2)][c & (z == C[i])] +=
cnt[i][a][b][c];
cnt[i + 1][a & (A[i] == b1)][b & (B[i] == b2)][c & (z == C[i])] %=
MOD;
sum[i + 1][a & (A[i] == b1)][b & (B[i] == b2)][c & (z == C[i])] +=
sum[i][a][b][c];
sum[i + 1][a & (A[i] == b1)][b & (B[i] == b2)][c & (z == C[i])] %=
MOD;
sum[i + 1][a & (A[i] == b1)][b & (B[i] == b2)][c & (z == C[i])] +=
(cnt[i][a][b][c] * z * (1ll << (30 - i))) % MOD;
sum[i + 1][a & (A[i] == b1)][b & (B[i] == b2)][c & (z == C[i])] %=
MOD;
}
}
}
}
}
}
long long ans = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ans += sum[31][i][j][k];
ans %= MOD;
ans += cnt[31][i][j][k];
ans %= MOD;
}
}
}
return ans;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int x1, x2, y1, y2, k;
scanf("%d %d %d %d %d", &x1, &y1, &x2, &y2, &k);
x1--, x2--, y1--, y2--;
k--;
long long ans = 0;
ans += solve(x1 - 1, y1 - 1, k);
ans %= MOD;
ans -= solve(x1 - 1, y2, k);
while (ans < 0) {
ans += MOD;
}
ans %= MOD;
ans -= solve(x2, y1 - 1, k);
while (ans < 0) {
ans += MOD;
}
ans %= MOD;
ans += solve(x2, y2, k);
ans %= MOD;
printf("%lld\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100007;
int a[MAX], b[MAX], c[MAX];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) cin >> b[i];
for (int i = 0; i < n - 2; ++i) cin >> c[i];
sort(a, a + n);
sort(b, b + n - 1);
sort(c, c + n - 2);
for (int i = 0; i < n - 1; ++i) {
if (a[i] != b[i]) {
cout << a[i] << endl;
break;
}
if (i == n - 2) {
cout << a[n - 1] << endl;
}
}
for (int i = 0; i < n - 2; ++i) {
if (b[i] != c[i]) {
cout << b[i] << endl;
break;
}
if (i == n - 3) {
cout << b[n - 2] << endl;
}
}
}
| 1 |
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int n;
int arr[2001];
int main(){
int t;
cin >> t;
while(t--){
cin >> n;
for(int i = 0; i < n; i++){
cin >> arr[i];
}
for(int i = 0; i < n; i++){
if(arr[i] % 2 == 0) cout << arr[i] << " ";
}
for(int i = 0; i < n; i++){
if(arr[i] % 2 == 1) cout << arr[i] << " ";
}
cout << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, x1, y1, x2, y2, tempx, tempy, ans;
while (scanf("%d%d", &x, &y) == 2) {
if (x < 0)
tempx = -x;
else
tempx = x;
if (y < 0)
tempy = -y;
else
tempy = y;
ans = tempx + tempy;
if (x > 0 && y > 0) printf("%d %d %d %d\n", 0, ans, ans, 0);
if (x > 0 && y < 0) printf("%d %d %d %d\n", 0, -ans, ans, 0);
if (x < 0 && y > 0) printf("%d %d %d %d\n", -ans, 0, 0, ans);
if (x < 0 && y < 0) printf("%d %d %d %d\n", -ans, 0, 0, -ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ss;
cin >> ss;
int i = 0;
for (; i < ss.size(); i++) {
if (ss[i] != 'a') break;
}
if (i == ss.size()) {
ss[ss.size() - 1] = 'z';
cout << ss << endl;
return 0;
}
for (int j = i; j < ss.size(); j++) {
if (ss[j] == 'a')
break;
else
ss[j]--;
}
cout << ss << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
long long read() {
long long a = 0, b = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') b = -1;
c = getchar();
}
while (c >= '0' && c <= '9') a = a * 10 + c - 48, c = getchar();
return a * b;
}
char s[200005];
int n;
inline int nxt(int i) {
i++;
while (!s[i] && i <= n) i++;
return i;
}
int main() {
int t = read();
while (t--) {
scanf("%s", s);
n = strlen(s);
int k = 0, g = 0, ans = n;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
k++;
else {
if (k > 0) {
k--;
ans -= 2;
} else {
g++;
if (g >= 2) {
g -= 2;
ans -= 2;
}
}
}
}
cout << ans << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXA = 1000005;
int N, C[MAXN], SZ[MAXN], CCNT[MAXN], HCH[MAXN];
map<int, int>* countMap[MAXN];
long long domCount[MAXN], domSum[MAXN];
vector<int> G[MAXN];
void find_subtree_size(int cur, int prev) {
SZ[cur] = 1;
HCH[cur] = -1;
int heavySize = -1;
for (int v : G[cur]) {
if (v != prev) {
find_subtree_size(v, cur);
SZ[cur] += SZ[v];
if (heavySize < SZ[v]) {
heavySize = SZ[v];
HCH[cur] = v;
}
}
}
}
void find_dominating_color_sum(int cur, int prev) {
for (int u : G[cur])
if (u != prev && u != HCH[cur]) find_dominating_color_sum(u, cur);
if (HCH[cur] != -1) {
find_dominating_color_sum(HCH[cur], cur);
countMap[cur] = countMap[HCH[cur]];
domCount[cur] = domCount[HCH[cur]];
domSum[cur] = domSum[HCH[cur]];
} else {
countMap[cur] = new map<int, int>();
domCount[cur] = domSum[cur] = 0;
}
(*countMap[cur])[C[cur]]++;
if ((*countMap[cur])[C[cur]] > domCount[cur]) {
domCount[cur] = (*countMap[cur])[C[cur]];
domSum[cur] = C[cur];
} else if ((*countMap[cur])[C[cur]] == domCount[cur]) {
domSum[cur] += (0ll + C[cur]);
}
for (int u : G[cur]) {
if (u != prev && u != HCH[cur]) {
for (pair<const int, int>& kv : *countMap[u]) {
(*countMap[cur])[kv.first] += kv.second;
int curCount = (*countMap[cur])[kv.first];
if (curCount > domCount[cur]) {
domCount[cur] = curCount;
domSum[cur] = kv.first;
} else if (curCount == domCount[cur]) {
domSum[cur] += (0ll + kv.first);
}
}
}
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", &C[i]);
for (int i = 1; i <= N - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
find_subtree_size(1, 0);
find_dominating_color_sum(1, 0);
for (int i = 1; i <= N; ++i) printf("%lld ", domSum[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct info {
int sum, index;
};
int cmpr(info a, info b) { return (a.sum < b.sum); }
int main() {
int n, e, g, m, h, i;
cin >> n;
info p[n], temp;
for (i = 0; i < n; i++) {
cin >> e >> m >> g >> h;
p[i].sum = e + m + g + h;
p[i].index = i + 1;
}
sort(p, p + n, cmpr);
for (i = 0; i < n - 1; i++) {
if (p[i].index == 1)
if (p[i].sum == p[i + 1].sum) {
temp = p[i];
p[i] = p[i + 1];
p[i + 1] = temp;
}
}
for (i = 0; i < n; i++) {
if (p[i].index == 1) {
cout << n - i;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> mp;
mp['0'] = 2;
mp['1'] = 7;
mp['2'] = 2;
mp['3'] = 3;
mp['4'] = 3;
mp['5'] = 4;
mp['6'] = 2;
mp['7'] = 5;
mp['8'] = 1;
mp['9'] = 2;
char x, y;
scanf("%ch", &x);
scanf("%ch", &y);
int res = mp[x] * mp[y];
printf("%d\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
while (a != 0) {
T temp = a;
a = b % a;
b = temp;
}
return b;
}
template <class T>
T egcd(T a, T b, T &x, T &y) {
T gcd, xt, yt;
if (a == 0) {
gcd = b;
x = 0, y = 1;
} else {
gcd = egcd(b % a, a, xt, yt);
x = yt - (b / a) * xt;
y = xt;
}
return gcd;
}
template <class T>
T expo(T base, T exp, T mod) {
T res = 1;
base = base % mod;
while (exp > 0) {
if (exp & 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
template <class T>
T modinv(T a, T mod) {
T x, y;
egcd<T>(a, mod, x, y);
while (x < 0) x += mod;
while (x >= mod) x -= mod;
return x;
}
template <class T>
T modinvfermat(T a, T mod) {
return expo<T>(a, mod - 2, mod);
}
template <class T>
bool rev(T a, T b) {
return a > b;
}
template <class T>
long long maxpower(T a, T b) {
long long ans = 0;
while (a > 0 && a % b == 0) {
ans++;
a /= b;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (auto i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v[i] = make_pair(a, b);
}
int flag = 0;
if (v[0].first < v[0].second) {
cout << "NO" << endl;
} else {
for (auto i = 1; i < n; i++) {
if (v[i].first - v[i - 1].first >= v[i].second - v[i - 1].second) {
if (v[i].first - v[i - 1].first >= 0 &&
v[i].second - v[i - 1].second >= 0) {
} else {
cout << "NO" << endl;
flag = 1;
break;
}
} else {
cout << "NO" << endl;
flag = 1;
break;
}
}
if (flag == 0) cout << "YES" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
int n;
cin >> n;
cout << "? " << 1 << ' ' << 2 << endl;
fflush(stdout);
int c1, c2, c3;
cin >> c1;
cout << "? " << 1 << ' ' << 3 << endl;
fflush(stdout);
cin >> c2;
cout << "? " << 2 << ' ' << 3 << endl;
fflush(stdout);
cin >> c3;
a[1] = (c1 + c2 - c3) / 2;
a[2] = (c1 + c3 - c2) / 2;
a[3] = (c2 + c3 - c1) / 2;
for (int i = 4; i <= n; i++) {
cout << "? " << 1 << ' ' << i << endl;
fflush(stdout);
int ans;
cin >> ans;
a[i] = ans - a[1];
}
cout << "! ";
for (int i = 1; i <= n; i++) {
cout << a[i] << ' ';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, arr[100005], flag, maxx;
int main() {
cin >> n >> m;
int maxx = 0, falg;
int tmp1 = 0, sumoff = 0, sumon = 0;
arr[0] = 0;
arr[n + 1] = m;
n++;
for (int i = 1; i < n; i++) {
scanf("%d", &arr[i]);
if (i % 2 == 1) maxx += arr[i] - arr[i - 1];
}
if (n % 2 == 1) maxx += m - arr[n - 1];
int maxxx = maxx;
for (int i = n; i >= 1; i--) {
flag = 0;
if (i % 2 == 0) {
if (arr[i] - arr[i - 1] > 1)
flag += sumoff - sumon + arr[i] - arr[i - 1] - 1;
sumoff += arr[i] - arr[i - 1];
if (maxx + flag > maxxx) {
maxxx = maxx + flag;
}
} else {
if (arr[i] - arr[i - 1] > 1) flag += sumoff - sumon - 1;
if (flag + maxx > maxxx) {
maxxx = maxx + flag;
}
sumon += arr[i] - arr[i - 1];
}
}
cout << maxxx << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 100;
int n, a[N], kind[N], p[N];
char s[N];
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
void print(int i) { printf("%d %c\n", a[i], (kind[i] == 1) ? 'R' : 'L'); }
signed main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
scanf("%s", s + 1);
sort(a + 1, a + 1 + n);
if (s[n] == 'R')
for (int i = 1; i <= n; i++) kind[i] = ((n - i + 1) & 1);
else
for (int i = 1; i <= n; i++) kind[i] = !((n - i + 1) & 1);
int l = 1, r = n;
for (int i = n; i >= 2; i--) {
int op = (s[i - 1] == 'R');
p[i] = (kind[r] == op) ? l++ : r--;
}
p[1] = l;
for (int i = 1; i <= n; i++) print(p[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a[110000], b[110000], dp[110000][5];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, j, k;
vector<long long> v;
cin >> n;
for (i = 1; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n; i++) {
cin >> b[i];
}
for (i = 2; i <= n; i++) {
for (j = 0; j < 4; j++) {
dp[i][j] = -1;
for (k = 0; k <= 3; k++) {
if (dp[i - 1][k] != -1) {
if (((j & k) == b[i - 1]) && ((j | k) == a[i - 1])) dp[i][j] = k;
}
}
}
}
long long fl = 0;
for (i = 0; i < 4; i++) {
if (dp[n][i] != -1) {
cout << "YES\n";
for (j = n; j > 0; j--) {
v.push_back(i);
i = dp[j][i];
}
fl = 1;
break;
}
}
if (fl == 0)
cout << "NO";
else {
for (i = 0; i < v.size(); i++) cout << v[v.size() - i - 1] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 50 * 1000 + 100;
long long a[M];
vector<int> v;
long long n, k, ans, p;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
k += a[i];
}
for (int i = 0; i < n; i++)
if (a[i] > k / n) v.push_back(i);
for (int i = 0; i < n; i++)
if (a[i] > k / n) {
if (v[p] == i) p++;
a[i + 1] += a[i] - k / n;
ans += a[i] - k / n;
a[i] = k / n;
} else if (a[i] < k / n) {
int h = v[p];
ans += (k / n - a[i]) * (h - i);
a[h] -= k / n - a[i];
a[i] = k / n;
if (a[h] <= k / n) p++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 2e6 + 6;
int n, k;
vector<int> g[N];
int h[N];
vector<pair<int, int> > c[N];
inline void merge(int v, int to) {
pair<int, int> mx1 = {1e9, 0}, mx2 = {1e9, 0};
for (auto &x : c[v]) {
if (x.first - h[v] <= k) {
mx1.first = min(mx1.first, x.first);
mx1.second += x.second;
} else {
if (x.second > mx2.second) mx2 = x;
}
}
int vg = 0, vh = 1e9;
for (auto &x : c[to]) {
if (x.first - h[v] <= k) {
mx1.first = min(mx1.first, x.first);
mx1.second += x.second;
} else {
vg += x.second;
vh = x.first;
if (x.second > mx2.second) mx2 = x;
}
}
if (vg > mx2.second) mx2 = {vh, vg};
c[v].clear();
c[v].push_back(mx1);
c[v].push_back(mx2);
}
inline void dfs(int v) {
if (g[v].size() == 0) {
c[v].push_back({h[v], 1});
}
for (int to : g[v]) {
h[to] = h[v] + 1;
dfs(to);
merge(v, to);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
int x;
cin >> x;
g[x].push_back(i);
}
dfs(1);
int ans = 0;
for (auto &x : c[1]) ans += x.second;
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void print() { cerr << endl; }
template <typename Head, typename... Tail>
void print(Head H, Tail... T) {
cerr << " " << to_string(H);
print(T...);
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int r, c;
cin >> r >> c;
r--, c--;
int lm, rm;
cin >> lm >> rm;
vector<string> s(n, "");
for (auto &x : s) cin >> x;
vector<vector<bool>> vis(n, vector<bool>(m, false));
deque<pair<pair<int, int>, pair<int, int>>> Q;
Q.push_back({{r, c}, {lm, rm}});
int ans = 0;
while (!Q.empty()) {
auto z = Q.front();
Q.pop_front();
int x = z.first.first, y = z.first.second, rx = z.second.first,
ry = z.second.second;
if (vis[x][y]) continue;
vis[x][y] = true;
ans++;
if (x >= 1 && s[x - 1][y] == '.') Q.push_front({{x - 1, y}, {rx, ry}});
if (x < n - 1 && s[x + 1][y] == '.') Q.push_front({{x + 1, y}, {rx, ry}});
if (y >= 1 && s[x][y - 1] == '.' && rx)
Q.push_back({{x, y - 1}, {rx - 1, ry}});
if (y < m - 1 && s[x][y + 1] == '.' && ry)
Q.push_back({{x, y + 1}, {rx, ry - 1}});
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 1;
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << int(((a ^ b) && (c || d)) ^ ((b && c) || (a ^ d))) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 7;
long long n, q;
long long a[maxn];
long long m;
map<long long, long long> ma;
long long Mod(long long x, long long mod) {
if (x < mod) return x;
return x % mod + mod;
}
long long fp(long long a, long long b, long long mod) {
long long tmp = 1;
while (b) {
if (b & 1) tmp = Mod(tmp * a, mod);
b >>= 1, a = Mod(a * a, mod);
}
return tmp;
}
long long phi(long long k) {
long long s = k, kk = k;
if (ma.count(k)) return ma[k];
for (long long i = 2; i * i <= k; i++) {
if (k % i == 0) s = s / i * (i - 1);
while (k % i == 0) k /= i;
}
if (k > 1) s = s / k * (k - 1);
return ma[kk] = s;
}
long long solve(long long l, long long r, long long mod) {
if (l == r || mod == 1) return Mod(a[l], mod);
return fp(a[l], solve(l + 1, r, phi(mod)), mod);
}
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
scanf("%d", &q);
while (q--) {
long long l, r;
scanf("%lld%lld", &l, &r);
printf("%lld\n", solve(l, r, m) % m);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long double resnum, resden;
int e = 1;
long long A[5000], Deg[20];
int main() {
int k, i, j, l;
long long c, pl, pr, vl, vr;
scanf("%I64d%I64d%I64d%I64d%d", &pl, &pr, &vl, &vr, &k);
Deg[0] = 1ll, k--;
for (i = 1; i <= 9; i++) {
Deg[i] = Deg[i - 1] * 10ll;
for (j = 0; j < (1 << i); j++) {
c = 0;
for (l = 0; l < i; l++) {
if (j & (1 << l))
c += 4ll * Deg[l];
else
c += 7ll * Deg[l];
}
A[e] = c, e++;
}
}
sort(A, A + e);
A[e] = 1234567890ll;
for (i = 0; i + k < e; i++) {
if (vl <= A[i] && pr >= A[i + k] && vr > A[i - 1] && pl < A[i + k + 1]) {
resnum += (long double)((min(A[i], vr) - max(A[i - 1] + 1ll, vl) + 1ll) *
(min(A[i + k + 1] - 1ll, pr) - max(A[i + k], pl) +
1ll));
}
if (pl <= A[i] && vr >= A[i + k] && pr > A[i - 1] && vl < A[i + k + 1]) {
resnum += (long double)((min(A[i], pr) - max(A[i - 1] + 1ll, pl) + 1ll) *
(min(A[i + k + 1] - 1ll, vr) - max(A[i + k], vl) +
1ll));
}
if (k == 0 && A[i] >= vl && A[i] <= vr && A[i] >= pl && A[i] <= pr)
resnum -= (long double)(1.0);
}
resden = (long double)((pr - pl + 1ll) * (vr - vl + 1ll));
printf("%.10lf\n", (double)(resnum / resden));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
bool ar[10000];
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
ar[a] = true;
ar[b] = true;
}
int j;
for (int i = 1; ar[i]; i++) j = i;
j++;
printf("%d\n", n - 1);
for (int i = 1; i <= n; i++)
if (i != j) printf("%d %d\n", i, j);
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const double eps = 1E-9;
const double Exp = 2.718281828459045;
const double Pi = 3.1415926535897932;
const int NMAX = 100000 + 10;
const int MMAX = 100000 + 10;
const int INF = 1000000000;
template <typename T>
inline T abs(const T& a) {
if (a < 0) a = -a;
return a;
}
template <typename T>
inline T sqr(const T& a) {
return a * a;
}
int main() {
ios::sync_with_stdio(false);
pair<int, int> corn[4], cur;
int n, m;
int a, b;
int x, y;
int i, mx;
cin >> n >> m >> cur.first >> cur.second >> a >> b;
corn[0] = make_pair(1, 1);
corn[1] = make_pair(n, 1);
corn[2] = make_pair(1, m);
corn[3] = make_pair(n, m);
for (i = 0; i < 4; i++) {
if (corn[i] == cur) {
cout << 0 << endl;
return 0;
}
}
mx = INF;
for (i = 0; i < 4; i++) {
x = abs(cur.first - corn[i].first);
y = abs(cur.second - corn[i].second);
if (x % a != 0 || y % b != 0) continue;
if ((x / a) % 2 != (y / b) % 2) continue;
if (x / a > y / b) {
if (cur.second + b <= m || cur.second - b >= 1)
mx = min(mx, x / a);
else
continue;
} else {
if (cur.first + a <= n || cur.first - a >= 1)
mx = min(mx, y / b);
else
continue;
}
}
if (INF == mx)
cout << "Poor Inna and pony!" << endl;
else
cout << mx << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> itRS) {}
template <typename T, typename... Args>
void err(istream_iterator<string> itRS, T a, Args... args) {
cerr << *itRS << " = " << a << '\n';
err(++itRS, args...);
}
const int MOD = 1000000007;
bool sortbysec(
const pair<pair<long long int, long long int>, long long int> &a,
const pair<pair<long long int, long long int>, long long int> &b) {
return (a.second > b.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
string s1, s2;
vector<int> a(58, 0), b(58, 0);
getline(cin, s1);
getline(cin, s2);
for (int i = 0; s1[i]; i++) {
if (s1[i] == ' ') {
continue;
}
a[s1[i] - 65] += 1;
}
for (int i = 0; s2[i]; i++) {
if (s2[i] == ' ') {
continue;
}
b[s2[i] - 65] += 1;
}
int count = 0;
for (int i = 0; i < 58; i++) {
if (b[i] > 0) {
if (a[i] < b[i]) {
count++;
break;
}
}
}
if (count > 0)
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t[8] = {1, 3, 15, 133, 2025, 37851, 1030367, 36362925}, n;
scanf("%d", &n);
if ((n & 1) == 0) {
puts("0");
return 0;
}
long long ans = 1, mod = 1000000007;
for (int i = 2; i <= n; ++i) ans = (ans * i) % mod;
ans = (ans * t[n / 2]) % mod;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100001], b[100001], ans1, ans2, sum1, sum2;
int main() {
int m, n;
while (cin >> m >> n) {
sum1 = sum2 = 0;
for (int i = 0; i < m; i++) {
scanf("%lld", &a[i]);
sum1 += a[i];
}
for (int j = 0; j < n; j++) {
scanf("%lld", &b[j]);
sum2 += b[j];
}
sort(a, a + m);
sort(b, b + n);
ans1 = sum2;
ans2 = sum1;
for (int i = 0; i < m - 1; i++) ans1 += min(sum2, a[i]);
for (int i = 0; i < n - 1; i++) ans2 += min(sum1, b[i]);
cout << min(ans1, ans2) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
int A, B;
std::cin >> A >> B;
int g = gcd(A, B);
if ((A - B == g) || (B - A == g)) {
std::cout << "Equal" << std::endl;
} else if (A > B) {
std::cout << "Masha" << std::endl;
} else {
std::cout << "Dasha" << std::endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const char nl = '\n';
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int tt;
cin >> tt;
while (tt--) {
int a, b;
cin >> a >> b;
int ans = 0;
while (a != 0 && b != 0) {
if (a < b) swap(a, b);
ans += a / b;
a %= b;
}
cout << ans << nl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 2) {
cout << 2 << endl;
return 0;
} else {
cout << 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> groups(n);
for (auto &x : groups) cin >> x;
sort(groups.begin(), groups.end());
cout << groups[n / 2] << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
vector<int> best;
int bestsz = 1010;
for (int pos = 0; pos + s.length() - 1 < t.length(); pos++) {
vector<int> cur;
for (int i = 0; i < s.length(); i++) {
if (s[i] != t[pos + i]) cur.push_back(i);
}
if (cur.size() < bestsz) {
bestsz = cur.size();
best = cur;
}
}
printf("%d\n", best.size());
for (auto x : best) printf("%d ", x + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxf = 7;
const int maxn = 4;
int cb[maxf][maxn];
int cb2[maxf][maxn];
int cnt[maxf];
bool chk() {
bool ok = true;
for (int i = 1; i <= 6; i++) {
int c = cb2[i][0];
for (int j = 0; j < 4; j++) {
if (cb2[i][j] != c) ok = false;
}
}
return ok;
}
void rst() {
for (int i = 1; i <= 6; i++) {
for (int j = 0; j < 4; j++) cb2[i][j] = cb[i][j];
}
}
void prnt() {
for (int i = 1; i <= 6; i++) {
cout << cb2[i][0] << " " << cb2[i][1] << "\n";
cout << cb2[i][2] << " " << cb2[i][3] << "\n";
cout << "\n";
}
}
int main() {
for (int i = 1; i <= 6; i++) {
for (int j = 0; j < 4; j++) {
cin >> cb[i][j];
cnt[cb[i][j]]++;
}
}
for (int i = 1; i <= 6; i++) {
if (cnt[i] != 4) {
cout << "NO"
<< "\n";
return 0;
}
}
rst();
swap(cb2[1][0], cb2[2][0]);
swap(cb2[2][0], cb2[3][0]);
swap(cb2[3][0], cb2[6][3]);
swap(cb2[1][2], cb2[2][2]);
swap(cb2[2][2], cb2[3][2]);
swap(cb2[3][2], cb2[6][1]);
if (chk()) {
cout << "YES"
<< "\n";
return 0;
}
rst();
swap(cb2[3][0], cb2[6][3]);
swap(cb2[2][0], cb2[3][0]);
swap(cb2[1][0], cb2[2][0]);
swap(cb2[3][2], cb2[6][1]);
swap(cb2[2][2], cb2[3][2]);
swap(cb2[1][2], cb2[2][2]);
if (chk()) {
cout << "YES"
<< "\n";
return 0;
}
rst();
swap(cb2[2][0], cb2[5][0]);
swap(cb2[5][0], cb2[6][0]);
swap(cb2[6][0], cb2[4][0]);
swap(cb2[2][1], cb2[5][1]);
swap(cb2[5][1], cb2[6][1]);
swap(cb2[6][1], cb2[4][1]);
if (chk()) {
cout << "YES"
<< "\n";
return 0;
}
rst();
swap(cb2[6][0], cb2[4][0]);
swap(cb2[5][0], cb2[6][0]);
swap(cb2[2][0], cb2[5][0]);
swap(cb2[6][1], cb2[4][1]);
swap(cb2[5][1], cb2[6][1]);
swap(cb2[2][1], cb2[5][1]);
if (chk()) {
cout << "YES"
<< "\n";
return 0;
}
rst();
swap(cb2[1][2], cb2[5][0]);
swap(cb2[5][0], cb2[3][1]);
swap(cb2[3][1], cb2[4][3]);
swap(cb2[1][3], cb2[5][2]);
swap(cb2[5][2], cb2[3][0]);
swap(cb2[3][0], cb2[4][1]);
if (chk()) {
cout << "YES"
<< "\n";
return 0;
}
rst();
swap(cb2[3][1], cb2[4][3]);
swap(cb2[5][0], cb2[3][1]);
swap(cb2[1][2], cb2[5][0]);
swap(cb2[3][0], cb2[4][1]);
swap(cb2[5][2], cb2[3][0]);
swap(cb2[1][3], cb2[5][2]);
if (chk()) {
cout << "YES"
<< "\n";
return 0;
}
cout << "NO"
<< "\n";
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.