solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
const long double PI(acosl(-1.0));
long double eps = 1e-9;
using namespace std;
const int N = 2 * 1e5;
vector<set<int>> bitSt(23);
set<int> st;
int a[N];
int m = 20;
int find(int x) {
int zn = (int)(1e9 + 7);
for (int j(0); j < m; j++) {
int y = 1 << j;
if ((x & y) != 0) continue;
if (bitSt[j].size() == 0) continue;
zn = min(zn, *bitSt[j].begin());
}
if (zn == (int)(1e9 + 7)) return -1;
return zn;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(unsigned(time(NULL)));
int n;
cin >> n;
for (int i(0); i < n; i++) {
int x;
cin >> x;
st.insert(x);
for (int j(0); j < m; j++) {
int y = 1 << j;
if ((x & y) == 0) continue;
bitSt[j].insert(i);
}
a[i] = x;
}
for (int i(0); i < n; i++) {
int z = a[i];
int pz = find(z);
while (pz != -1) {
z = z | a[pz];
st.insert(z);
pz = find(z);
}
int x = a[i];
for (int j(0); j < m; j++) {
int y = 1 << j;
if ((x & y) == 0) continue;
bitSt[j].erase(i);
}
}
cout << st.size();
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m, k, i, j, num = 0;
scanf("%d %d %d", &n, &m, &k);
getchar();
char grid[n][m];
int a[m];
for (i = 0; i < m; i++) {
a[i] = 0;
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
grid[i][j] = getchar();
}
getchar();
}
for (i = 0; i < m; i++) {
for (j = 1; j < n; j++) {
if (i + j < m && grid[j][i + j] == 'L') num++;
if (i - j >= 0 && grid[j][i - j] == 'R') num++;
if (j + j < n && grid[j + j][i] == 'U') num++;
}
a[i] = num;
num = 0;
}
for (i = 0; i < m; i++) {
printf("%d%s", a[i], (i == m - 1) ? "\n" : " ");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool trace;
struct SegmentTreeNode {
long long sum;
long long delay_count;
SegmentTreeNode() : sum(0), delay_count(0) {}
};
class SegmentTree {
int N;
void _update(int p, int q, int node, int L, int R);
int _count(int p, int q, int node, int L, int R);
public:
vector<SegmentTreeNode> tree;
SegmentTree(int _N) : N(_N) {
int M =
N > 1 ? 2 * (1 << ((sizeof(int) * 8 - 1 - __builtin_clz((N - 1))) + 1))
: 2;
tree = vector<SegmentTreeNode>(M);
}
void update(int p, int q) { _update(p, q, 1, 0, N - 1); }
int count(int p, int q) { return _count(p, q, 1, 0, N - 1); }
};
void SegmentTree::_update(int p, int q, int node, int L, int R) {
if (q < L || p > R) return;
if (p <= L && R <= q) {
tree[node].sum += R - L + 1;
tree[node].delay_count++;
return;
}
int cL = node * 2;
int cR = node * 2 + 1;
if (tree[node].delay_count > 0) {
tree[cL].delay_count += tree[node].delay_count;
tree[cL].sum += ((L + R) / 2 - L + 1) * tree[node].delay_count;
tree[cR].delay_count += tree[node].delay_count;
tree[cR].sum += (R - ((L + R) / 2 + 1) + 1) * tree[node].delay_count;
tree[node].delay_count = 0;
}
_update(p, q, cL, L, (L + R) / 2);
_update(p, q, cR, (L + R) / 2 + 1, R);
tree[node].sum = tree[cL].sum + tree[cR].sum;
}
int SegmentTree::_count(int p, int q, int node, int L, int R) {
if (q < L || p > R) return 0;
if (p <= L && R <= q) return tree[node].sum;
int cL = node * 2;
int cR = node * 2 + 1;
if (tree[node].delay_count > 0) {
tree[cL].delay_count += tree[node].delay_count;
tree[cL].sum += ((L + R) / 2 - L + 1) * tree[node].delay_count;
tree[cR].delay_count += tree[node].delay_count;
tree[cR].sum += (R - ((L + R) / 2 + 1) + 1) * tree[node].delay_count;
tree[node].delay_count = 0;
}
return _count(p, q, cL, L, (L + R) / 2) +
_count(p, q, cR, (L + R) / 2 + 1, R);
}
vector<SegmentTree> segm_trees;
class TreeDecomposition {
int root;
vector<int> vis;
vector<int> par;
vector<int> Td, Tf;
vector<int> subtree_size;
vector<int> prefix_walk;
void _dfs();
public:
vector<vector<int> > adj;
vector<vector<int> > chains;
vector<pair<int, int> > node_chain_pos;
TreeDecomposition(int _N) : adj(_N) {}
void decompose();
bool is_ancestor(int u, int v) const;
};
void TreeDecomposition::_dfs() {
int N = adj.size();
vis = vector<int>(N);
par = vector<int>(N, -1);
Td = vector<int>(N);
Tf = vector<int>(N);
subtree_size = vector<int>(N);
root = 0;
stack<pair<int, int> > S;
S.push(pair<int, int>(root, 0));
par[root] = root;
for (int t = 1; !S.empty(); ++t) {
int u = S.top().first, e = S.top().second;
if (e == 0) {
vis[u] = 2;
Td[u] = t;
}
if (e == int(adj[u].size())) {
Tf[u] = t;
subtree_size[u] = 1;
for (int j = 0; j < int(adj[u].size()); ++j) {
int v = adj[u][j];
if (v == par[u]) continue;
subtree_size[u] += subtree_size[v];
}
prefix_walk.push_back(u);
S.pop();
} else {
++S.top().second;
int v = adj[u][e];
if (!vis[v]) {
vis[v] = 1;
par[v] = u;
S.push(pair<int, int>(v, 0));
}
}
}
}
void TreeDecomposition::decompose() {
_dfs();
int N = adj.size();
vector<bool> par_edge_processed(N);
par_edge_processed[root] = true;
for (int k = 0; k < (int)prefix_walk.size(); ++k) {
int v = prefix_walk[k];
if (par_edge_processed[v]) continue;
vector<int> cur_path;
cur_path.push_back(v);
do {
int u = par[v];
cur_path.push_back(u);
par_edge_processed[v] = true;
if (2 * subtree_size[v] < subtree_size[u]) break;
v = u;
} while (!par_edge_processed[v]);
chains.push_back(cur_path);
}
node_chain_pos = vector<pair<int, int> >(N);
node_chain_pos[0].first = -1;
for (int i = 0; i < (int)chains.size(); ++i) {
for (int j = 0; j < int(chains[i].size()) - 1; ++j) {
int u = chains[i][j];
node_chain_pos[u] = pair<int, int>(i, j);
}
}
}
inline bool TreeDecomposition::is_ancestor(int u, int v) const {
return Td[u] <= Td[v] && Tf[v] <= Tf[u];
}
void update(const TreeDecomposition& td, int u, int v) {
while (u != v) {
if (td.is_ancestor(u, v)) swap(u, v);
int p = td.node_chain_pos[u].first;
int lo = td.node_chain_pos[u].second, hi = int(td.chains[p].size()) - 1;
if (td.is_ancestor(td.chains[p][hi], v)) {
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (td.is_ancestor(td.chains[p][mid], v))
hi = mid;
else
lo = mid + 1;
}
hi = lo;
lo = td.node_chain_pos[u].second;
}
segm_trees[p].update(lo, hi - 1);
u = td.chains[p][hi];
}
}
long long query(const TreeDecomposition& td, int u, int v) {
long long res = 0;
while (u != v) {
if (td.is_ancestor(u, v)) swap(u, v);
int p = td.node_chain_pos[u].first;
int lo = td.node_chain_pos[u].second, hi = int(td.chains[p].size()) - 1;
if (td.is_ancestor(td.chains[p][hi], v)) {
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (td.is_ancestor(td.chains[p][mid], v))
hi = mid;
else
lo = mid + 1;
}
hi = lo;
lo = td.node_chain_pos[u].second;
}
res += segm_trees[p].count(lo, hi - 1);
u = td.chains[p][hi];
}
return res;
}
struct Road {
int u, v;
};
Road roads[100004];
int main(int argc, char* argv[]) {
cin.sync_with_stdio(false);
int N;
cin >> N;
TreeDecomposition td(N);
for (int j = 1; j < N; ++j) {
int u, v;
cin >> u >> v;
--u, --v;
roads[j].u = u;
roads[j].v = v;
td.adj[u].push_back(v);
td.adj[v].push_back(u);
}
td.decompose();
segm_trees.clear();
for (int i = 0; i < int(td.chains.size()); ++i)
segm_trees.push_back(SegmentTree(int(td.chains[i].size()) - 1));
int Q;
cin >> Q;
for (int q = 1; q <= Q; ++q) {
int u, v;
cin >> u >> v;
if (u == v) continue;
--u, --v;
update(td, u, v);
}
for (int j = 1; j < N; ++j) {
long long res = query(td, roads[j].u, roads[j].v);
if (j > 1) cout << ' ';
cout << res;
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long lcm(long long a, long long b);
long long gcd(long long a, long long b);
long long cross_prod(long long ax, long long ay, long long bx, long long by,
long long cx, long long cy);
long long sum_digit(long long A);
long long get_mask(long long x);
long long get_nr(string &S, int &pos, int lg);
bool cmp_pair_ii1(pair<int, int> A, pair<int, int> B);
bool cmp_i2(int A, int B);
string next_word(string &S, int &pos);
long long rise(long long x, long long p);
double dist(int a, int b, int x, int y);
long long inv(long long x);
class SegmentTree {
public:
vector<int> V;
void init(int dim);
int query(int start, int end, int pos, int node);
void build(int start, int end, int node);
};
inline int getInt();
inline long long getLL();
int N, M, c;
vector<int> V1, V2, ps;
int main() {
int i, _min, dif;
N = getInt();
M = getInt();
c = getInt();
V1.resize(N + 1);
V2.resize(M + 1);
ps.resize(M + 1);
for (i = 1; i <= N; ++i) {
V1[i] = getInt();
}
for (i = 1; i <= M; ++i) {
ps[i] = getInt();
ps[i] += ps[i - 1];
}
dif = N - M;
for (i = 1; i <= M; ++i) {
_min = min(i - 1, dif);
V1[i] += ps[i] - ps[i - _min - 1];
}
for (i = N; i > M && i >= N - M + 1; --i) {
_min = min(N - i, dif);
V1[i] += ps[M] - ps[M - _min - 1];
}
for (i = N - M; i > M; --i) {
V1[i] += ps[M];
}
for (i = 1; i <= N; ++i) {
printf("%d ", V1[i] % c);
}
return 0;
}
inline int getInt() {
int res = 0, pos = 1;
char ch;
ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) pos = (ch == '-' ? 0 : 1);
for (; ch >= '0' && ch <= '9'; ch = getchar()) res = res * 10 + (ch - '0');
if (pos == 0) res *= -1;
return res;
}
inline long long getLL() {
long long res = 0, pos = 1;
char ch;
ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) pos = (ch == '-' ? 0 : 1);
for (; ch >= '0' && ch <= '9'; ch = getchar()) res = res * 10 + (ch - '0');
if (!pos) res *= -1;
return res;
}
long long inv(long long x) { return rise(x, 1073676287 - 2); }
double dist(int a, int b, int x, int y) {
double t1, t2;
t1 = a - x;
t1 *= t1;
t2 = b - y;
t2 *= t2;
return sqrt(t1 + t2);
}
bool cmp_pair_ii1(pair<int, int> A, pair<int, int> B) {
return A.first < B.first;
}
bool cmp_i2(int A, int B) { return A > B; }
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
long long cross_prod(long long ax, long long ay, long long bx, long long by,
long long cx, long long cy) {
return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
}
long long sum_digit(long long A) {
long long sum = 0;
do {
sum += A % 10;
A /= 10;
} while (A);
return sum;
}
long long get_mask(long long x) {
long long mask = 0, c;
while (x) {
c = x % 10;
x /= 10;
if (c == 4 || c == 7) {
mask = mask * 10 + c;
}
}
return mask;
}
void SegmentTree::init(int dim) { V.resize((dim + 1) << 2); }
void SegmentTree::build(int start, int end, int node) {
V[node] = end - start + 1;
if (start == end) {
return;
}
int mid;
mid = (start + end) >> 1;
build(start, mid, (node << 1));
build(mid + 1, end, ((node << 1) | 1));
}
int SegmentTree::query(int start, int end, int pos, int node) {
--V[node];
if (start == end) return end;
int L, R;
L = node << 1;
R = L | 1;
int mid;
mid = (start + end) >> 1;
if (pos <= V[L]) {
return query(start, mid, pos, L);
} else {
return query(mid + 1, end, pos - V[L], R);
}
}
long long get_nr(string &S, int &pos, int lg) {
long long nr = 0;
while (pos < lg && S[pos] != ',') {
nr = nr * 10 + (S[pos] - '0');
++pos;
}
return nr;
}
string next_word(string &S, int &pos) {
int pos_l, pos_sp;
if (S[S.length() - 1] != ' ') {
S += ' ';
}
pos_l = S.find_first_not_of(" ", pos);
if (pos_l == -1) {
pos = -1;
return "";
}
pos_sp = S.find_first_of(" ", pos_l);
pos = pos_sp;
return S.substr(pos_l, pos_sp - pos_l);
}
long long rise(long long x, long long p) {
if (p == 1) {
return x;
}
long long res = rise(x, p / 2);
res %= 1073676287;
if (p & 1) {
return (((res * res) % 1073676287) * x) % 1073676287;
} else {
return ((res * res) % 1073676287);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 800;
int n, a[maxn + 3], b[maxn + 3], tmp[maxn + 3], res[maxn + 3];
int get() {
int x;
scanf("%d", &x);
return x;
}
int main() {
srand(time(0));
scanf("%d", &n);
int t = 0;
for (int i = 1; i <= n; i++) {
printf("? %d", n - 1);
for (int k = 1; k <= n; k++)
if (k != i) printf(" %d", k);
puts(""), fflush(stdout);
if (get()) {
b[i] = -1;
if (++t == 1) a[1] = i;
if (t == 2) {
a[n] = i;
break;
}
}
}
for (int l = 1, r = n, k = 0; l + 1 <= r - 1; l <<= 1, r = n - l + 1, k++) {
int s = 0, mod = l << 1;
for (int i = 1; i <= l; i++) s = (s + i) % mod;
for (int i = r; i <= n; i++) s = (s + i) % mod;
for (int i = 1; i <= n; i++)
if (b[i] != -1) {
printf("? %d", 1 << (k + 1));
int p = 0;
for (int j = 1; j <= l; j++)
if ((s - j + b[i] + l) % l)
printf(" %d", a[j]);
else
p = j;
for (int j = r; j <= n; j++) printf(" %d", a[j]);
printf(" %d\n", i), fflush(stdout);
if (((s - p + b[i] + l) % mod == 0) == get()) b[i] |= 1 << k;
}
for (int i = 1; i <= l && l + i < r - i; i++) {
int m = 0, x = 0;
for (int j = 1; j <= n; j++)
if (b[j] != -1) tmp[++m] = j;
x = l + i;
for (int j = 1; j <= n; j++)
if (b[j] == x % mod) {
printf("? %d", m - 1);
for (int k = 1; k <= m; k++)
if (tmp[k] != j) printf(" %d", tmp[k]);
puts(""), fflush(stdout);
if (get()) {
a[x] = j;
b[j] = -1;
break;
}
}
x = r - i;
for (int j = 1; j <= n; j++)
if (b[j] == x % mod) {
printf("? %d", m - 1);
for (int k = 1; k <= m; k++)
if (tmp[k] != j) printf(" %d", tmp[k]);
puts(""), fflush(stdout);
if (get()) {
a[x] = j;
b[j] = -1;
break;
}
}
}
}
for (int i = 1; i <= n; i++) res[a[i]] = i;
if (res[1] > n / 2)
for (int i = 1; i <= n; i++) res[i] = n + 1 - res[i];
printf("! ");
for (int i = 1; i <= n; i++) printf("%d%c", res[i], " \n"[i == n]);
fflush(stdout);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct Timer {
int hour, minute, inteval;
void forced(int x) {
minute -= x;
if (minute < 0) {
minute += 60;
hour -= 1;
if (hour < 0) hour = 23;
}
}
bool check() {
char temp[10];
sprintf(temp, "%2d%2d", hour, minute);
for (int i = 0; i < 4; i++) {
if (temp[i] == '7') return true;
}
return false;
}
};
int main() {
long long int x, h, m;
cin >> x >> h >> m;
struct Timer ter;
ter.hour = h;
ter.minute = m;
ter.inteval = x;
int cnt = 0;
while (!ter.check()) {
ter.forced(ter.inteval);
cnt++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 123456789;
int n, m;
vector<int> pref, suff;
int be[N], en[N];
int bel[N];
int lis[N], lds[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
++be[l];
++en[r];
}
int cur = 0;
for (int i = 1; i <= m; ++i) {
cur += be[i];
bel[i] = cur;
cur -= en[i];
}
pref.assign(N, INF);
pref[1] = bel[1];
lis[1] = 1;
for (int i = 2; i <= m; ++i) {
int pos = upper_bound(pref.begin(), pref.end(), bel[i]) - pref.begin();
pref[pos] = bel[i];
lis[i] = pos;
}
suff.assign(N, INF);
suff[1] = bel[m];
lds[m] = 1;
for (int i = m - 1; i >= 1; --i) {
int pos = upper_bound(suff.begin(), suff.end(), bel[i]) - suff.begin();
suff[pos] = bel[i];
lds[i] = pos;
}
int ans = 0;
for (int i = 1; i <= m; ++i) ans = max(ans, lis[i] + lds[i] - 1);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, y[1000001], k = -1, z[2000001], c, t, h;
long long ans = 1;
string second, p;
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
cin >> p;
for (int i = 1; i <= m; i++) cin >> y[i], y[i]--;
for (int i = 1; i <= n; i++) second += '0';
for (int i = 1; i <= m; i++) {
if (y[i] <= k) {
int z = k - y[i] + 1;
for (int j = z; j < p.length(); j++) second[++k] = p[j];
} else {
k = y[i] - 1;
for (int j = 0; j < p.length(); j++) second[++k] = p[j];
}
}
h = p.length();
p += second;
int l = 0, r = 0;
for (int i = 1; i < p.length(); i++)
if (i > r) {
l = r = i;
while (r < p.length() && p[r] == p[r - l]) r++;
z[i] = r - l;
r--;
} else {
k = z[i - l];
if (k < r - i + 1)
z[i] = k;
else {
l = i;
while (r < p.length() && p[r] == p[r - l]) r++;
z[i] = r - l;
r--;
}
}
for (int i = 1; i <= m; i++)
if (z[y[i] + h] < h) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < second.length(); i++)
if (second[i] == '0') ans = (ans * 26) % 1000000007;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 200002;
long long f[NMAX], sp[NMAX];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, d, m;
cin >> n >> d >> m;
for (int i = 1; i <= n; i++) cin >> f[i];
sort(f + 1, f + n + 1);
long long pass = 0;
for (int i = 1; i <= n; i++) {
if (f[i] <= m) pass = i;
sp[i] = sp[i - 1] + f[i];
}
long long ans = 0;
for (int i = 0; i <= pass; i++) {
long long days;
long long funny = sp[pass] - sp[pass - i];
days = n - i;
long long cat = days / (d + 1);
if (days % (d + 1) != 0) cat++;
funny += sp[n] - sp[max(n - cat, pass)];
ans = max(ans, funny);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 800008;
const long long M = 1000000007;
int dp[20][N];
void init() {
for (int i = 1; i <= 200000; i++) {
for (int j = 0; j < 20; j++) {
if ((i & (1 << j)) > 0) {
dp[j][i] = dp[j][i - 1] + 1;
} else {
dp[j][i] = dp[j][i - 1];
}
}
}
}
void solve() {
int l, r;
cin >> l >> r;
int ans = r - l;
for (int i = 0; i < 20; i++) {
int cnt = dp[i][r] - dp[i][l - 1];
ans = min(ans, r - l + 1 - cnt);
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init();
int tc = 1;
cin >> tc;
for (int qq = 1; qq <= tc; qq++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return (b ? gcd(b, a % b) : a); }
void fun(vector<long long int>& ap, vector<long long int>& kf, int n, int mia,
int mik) {
long long int ans = 0;
for (int i = 0; i < n; ++i) {
if (ap[i] > mia) {
if (kf[i] > mik) {
ans += max((ap[i] - mia), (kf[i] - mik));
ap[i] = mia;
kf[i] = mik;
}
ans += ap[i] - mia;
ap[i] = mia;
continue;
}
if (kf[i] > mik) {
ans += kf[i] - mik;
kf[i] = mik;
}
}
cout << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 0;
cin >> t;
for (int j = 0; j < t; j++) {
int n = 0;
cin >> n;
vector<long long int> ap(n);
int mia = 1e+9 + 1;
for (int i = 0; i < n; ++i) {
cin >> ap[i];
if (ap[i] < mia) mia = ap[i];
}
vector<long long int> kf(n);
int mik = 1e+9 + 1;
for (int i = 0; i < n; ++i) {
cin >> kf[i];
if (kf[i] < mik) mik = kf[i];
}
fun(ap, kf, n, mia, mik);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < s.size(); i++) ans = max(ans, s[i] - '0');
cout << ans << endl;
for (int i = 0; i < ans; i++) {
bool first = false;
for (int j = 0; j < s.size(); j++)
if (s[j] - '0') {
cout << 1;
s[j]--;
first = true;
} else if (first)
cout << 0;
cout << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct crew {
string name;
string gender;
int key;
int ro;
};
bool serial(crew a, crew b) {
if (a.key != b.key) {
return a.key < b.key;
}
return (a.ro < b.ro);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t, r = 1, r1 = 0, r2 = 0, k = 0, a, b, c = 1, m, d = 0, n, e, f,
x = 0, g, p = 0, q = 0, y = 0, z = 0;
vector<long long> v;
vector<long long> u;
set<long long> s;
std::vector<int>::iterator it;
string s1, s2, s3, s4;
cin >> n;
crew oop[n];
for (int i = 0; i < n; i++) {
cin >> oop[i].name >> oop[i].gender;
s1 = oop[i].gender;
;
if (s1 == "rat") {
oop[i].key = 1;
}
if (s1 == "woman") {
oop[i].key = 2;
}
if (s1 == "child") {
oop[i].key = 2;
}
if (s1 == "man") {
oop[i].key = 3;
}
if (s1 == "captain") {
oop[i].key = 4;
}
oop[i].ro = i;
}
sort(oop, oop + n, serial);
for (int i = 0; i < n; i++) {
cout << oop[i].name << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cond = 1;
const int Q = (int(1e9)) + 7;
const int M = 1001013;
int sil[M], od[M];
inline int odwrot(int x, long long ret) { return ret * od[x] % Q; }
int odwr(int x, int ret) {
int n = Q - 2;
while (n) {
if (n % 2) ret = ((long long)ret) * x % Q;
x = ((long long)x) * x % Q;
n /= 2;
}
return ret;
}
int ff(int k, int n, int x) {
int ret = odwrot(k - x, sil[k]);
ret = ((long long)ret) * ret % Q;
n -= x;
while (n) {
if (n % 2) ret = ((long long)ret) * k % Q;
k = ((long long)k) * k % Q;
n /= 2;
}
return ret;
}
int f(int k, int n, int x) {
int ret = odwrot(k - x, sil[k]);
ret = ((long long)ret) * ret % Q;
return ret;
}
int main() {
int k, w;
scanf("%d %d", &k, &w);
sil[0] = 1;
for (typeof(1) i = (1); i <= (k + 5); ++i)
sil[i] = ((long long)i) * sil[i - 1] % Q;
od[k + 4] = odwr(sil[k + 4], 1);
for (typeof(k + 3) i = (k + 3); i >= (0); --i)
od[i] = ((long long)(i + 1)) * od[i + 1] % Q;
int ret = 0;
int potk = 1, kk = k;
int uu = w - 3;
while (uu) {
if (uu % 2) potk = ((long long)potk) * kk % Q;
kk = ((long long)kk) * kk % Q;
uu /= 2;
}
int odk = odwr(k, 1);
for (typeof(1) x = (1); x <= (min(k, w - 2)); ++x) {
ret += (f(k, w, x) * ((long long)k) % Q * ((long long)k) % Q -
f(k, w - 1, x + 1) + Q) %
Q * ((long long)potk) % Q;
potk = ((long long)potk) * odk % Q;
ret = (ret % Q + Q) % Q;
}
if (w - 1 <= k) {
ret += ff(k, w, w - 1) - odwr(k, ff(k, w, w));
ret = (ret % Q + Q) % Q;
}
for (typeof(w) x = (w); x <= (k); ++x) {
int u = ((long long)(((long long)odwrot(k - x, sil[k])) * w % Q)) *
odwrot(k - x, sil[k - x + w - 1]) % Q;
ret = (ret + u) % Q;
if (x < k) {
u = ((long long)odwrot(k - x - 1, sil[k])) *
odwrot(k - x, sil[k - x + w - 2]) % Q * ((long long)(w - 1)) % Q;
ret = (ret + u) % Q;
}
}
printf("%d\n", ret);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 1e9 + 7;
const long long N = 3e5 + 10;
const long long inf = 1e17 + 10;
long long __gcd(long long a, long long b) { return b ? __gcd(b, a % b) : a; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
unordered_map<long long, long long> mp;
long long c = 0;
for (long long i = 0; i < 9; i++)
for (long long j = 0; j < 9; j++) {
if (i >= 1 && j >= 5) continue;
c += max(0LL, n - i - j + 1);
}
cout << c << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long fac[11];
fac[0] = 1;
for (int i = 0; i < 10; i++) fac[i + 1] = (i + 1) * fac[i];
int len;
long long n;
cin >> len >> n;
int cnt2 = 0, cnt3 = 0, cnt5 = 0, cnt7 = 0;
for (; n; n /= 10) {
long long f = fac[n % 10];
for (; f % 7 == 0; f /= 7) cnt7++;
for (; f % 5 == 0; f /= 5) cnt5++;
for (; f % 3 == 0; f /= 3) cnt3++;
for (; f % 2 == 0; f /= 2) cnt2++;
}
vector<int> ans;
while (cnt7) {
ans.push_back(7);
long long f = fac[7];
for (; f % 7 == 0; f /= 7) cnt7--;
for (; f % 5 == 0; f /= 5) cnt5--;
for (; f % 3 == 0; f /= 3) cnt3--;
for (; f % 2 == 0; f /= 2) cnt2--;
}
while (cnt5) {
ans.push_back(5);
long long f = fac[5];
for (; f % 5 == 0; f /= 5) cnt5--;
for (; f % 3 == 0; f /= 3) cnt3--;
for (; f % 2 == 0; f /= 2) cnt2--;
}
while (cnt3) {
ans.push_back(3);
long long f = fac[3];
for (; f % 3 == 0; f /= 3) cnt3--;
for (; f % 2 == 0; f /= 2) cnt2--;
}
while (cnt2) {
ans.push_back(2);
long long f = fac[2];
for (; f % 2 == 0; f /= 2) cnt2--;
}
for (int i = 0; i < ans.size(); i++) cout << ans[i];
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int f[1 << 20];
int pow(int a, int b, int mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (1ll * ans * a) % mod;
a = (1ll * a * a) % mod;
b /= 2;
}
return ans;
}
int c[1 << 20];
int cnt[1 << 20];
int st[1 << 20];
int dr[1 << 20];
int fin[1 << 20];
int main(void) {
int n;
cin >> n;
f[0] = c[0] = 1;
for (int i = 1; i <= 1e6; ++i)
f[i] = (f[i - 1] * 1ll * i) % mod, c[i] = pow(f[i], mod - 2, mod);
long long ans = 1;
while (n--) {
int p;
cin >> p;
++cnt[p];
}
n = 2e5;
st[1] = dr[n + 1] = 1;
for (int i = 2; i <= n; ++i)
st[i] = (1ll * st[i - 1] * (cnt[i] + 1)) % (mod - 1);
for (int i = n; i; --i) dr[i] = (1ll * dr[i + 1] * (cnt[i] + 1)) % (mod - 1);
for (int i = 1; i <= n; ++i)
if (cnt[i]) {
int our = (1ll * cnt[i] * (cnt[i] + 1) / 2) % (mod - 1);
fin[i] = (1ll * our * st[i - 1]) % (mod - 1);
fin[i] = (1ll * fin[i] * dr[i + 1]) % (mod - 1);
}
for (int i = 1; i <= n; ++i) ans = (1ll * ans * pow(i, fin[i], mod)) % mod;
return cout << ans << '\n', 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, a = 0, b = 1, c = 0, d, t, n, e = 0;
string s;
vector<int> v;
vector<int> u;
cin >> t;
cin >> s;
for (i = 5; i >= 0; i--) {
b = pow(10, i) + .5;
a = t / b;
if (a > 0) e = 1;
if (e == 1) {
if (a == 5) a = 2;
if (a == 9) a = 6;
v.push_back(a);
t = t % b;
}
}
int l = v.size();
u = v;
for (i = 0; i <= v.size() - 1; i++) {
for (j = i + 1; j <= v.size() - 1; j++) {
if (v[i] == v[j]) {
v.erase(v.begin() + j);
j--;
}
}
}
n = v.size();
int r[n];
int p[n];
int m[n];
for (i = 0; i <= n - 1; i++) {
for (j = 0; j <= l - 1; j++) {
if (v[i] == u[j]) {
c++;
}
}
r[i] = c;
c = 0;
}
for (i = 0; i <= s.length() - 1; i++) {
if (s[i] == '9') {
s[i] = '6';
}
if (s[i] == '5') {
s[i] = '2';
}
}
for (i = 0; i <= n - 1; i++) {
for (j = 0; j <= s.length() - 1; j++) {
if ('0' + v[i] == s[j]) {
c++;
}
}
p[i] = c;
c = 0;
}
for (i = 0; i <= n - 1; i++) {
a = p[i] / r[i];
m[i] = a;
}
b = m[0];
for (i = 0; i <= n - 1; i++) {
if (m[i] < b) b = m[i];
}
cout << b;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define range(a) a.begin(), a.end()
#define endl "\n"
#define YES() cout << "YES" << endl
#define NO() cout << "NO" << endl
#define MP make_pair
using P = pair<int, int>;
const long long INF = 1LL<<60;
void chmin(long long &a, long long b) { if (a > b) a = b; }
void chmax(long long &a, long long b) { if (a < b) a = b; }
template<typename T>
T gcd(T a, T b){
if (a%b == 0){
return b;
}else{
return gcd(b, a % b);
}
}
template<typename T>
T lcm(T a, T b){
return a * b / gcd(a, b);
}
void solve(){
int N;
cin >> N;
vector<int> A(N);
FOR(i,0,N){
cin >> A[i];
}
vector<int> I, J, X, Y;
FOR(i,0,N-1){
if(gcd(A[i], A[i+1]) != 1){
int m = min(A[i], A[i + 1]);
if(m == A[i]){
A[i + 1] = m + 1;
}else{
if(i == 0){
A[i] = A[i + 1] + 1;
}else{
//A[i] = lcm(A[i - 1], A[i + 1]) + 1;
int u = m + 1;
while(1){
if(gcd(A[i-1], u) == 1 && gcd(A[i+1], u) == 1){
A[i] = u;
break;
}else{
++u;
}
}
}
}
I.push_back(i + 1);
J.push_back(i + 2);
X.push_back(A[i]);
Y.push_back(A[i + 1]);
}
}
/*
for(auto x: A){
cout << x << " ";
}
cout << endl << endl;
*/
int k = I.size();
cout << k << endl;
FOR(i,0,k){
cout << I[i] << " " << J[i] << " " << X[i] << " " << Y[i] << endl;
}
return;
}
int main(void){
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while(T--){
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
bool v = 0;
int words, prefixes;
Node* ch[2] = {0};
Node() { words = prefixes = 0; }
Node(bool nv) {
words = prefixes = 0;
v = nv;
}
};
Node* trie = new Node();
void getBits(long long x, vector<bool>& bits) {
while (x) {
bits.push_back(x & 1);
x >>= 1;
}
while (bits.size() < 40) bits.push_back(0);
}
void add(long long x) {
vector<bool> bits;
getBits(x, bits);
Node* h = trie;
for (int i = bits.size() - 1; i >= 0; i--) {
h->prefixes++;
if (!h->ch[bits[i]]) h->ch[bits[i]] = new Node(bits[i]);
h = h->ch[bits[i]];
}
h->words++;
h->prefixes++;
}
long long query(long long x) {
vector<bool> bits, bits2;
getBits(x, bits);
Node* h = trie;
bool v;
for (int i = bits.size() - 1; i >= 0; i--) {
v = !bits[i];
if (h->ch[v])
h = h->ch[v], bits2.push_back(v);
else if (h->ch[!v])
h = h->ch[!v], bits2.push_back(!v);
else
break;
}
long long val = 0;
for (unsigned int i = 0; i < bits2.size(); i++) {
val = (val << 1) + (long long)bits2[i];
}
return x ^ val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
long long leftXor = 0, rightXor = 0, maxXor = 0;
add(0);
cin >> n;
long long s[100001] = {0};
for (int i = 1; i <= n; i++) {
cin >> s[i];
leftXor ^= s[i];
}
for (int i = n; i >= 0; i--) {
maxXor = max(maxXor, query(leftXor));
rightXor ^= s[i];
add(rightXor);
leftXor ^= s[i];
}
cout << maxXor << '\n';
flush(cout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m;
vector<int> g[1000005];
int roads[1000005];
bool interior(int x, int y) { return (x < n && y < m && x >= 0 && y >= 0); }
void dfs(int x, int y, int way) {
if (way == -1 && g[x][y] == 2) roads[x + y]++;
g[x][y] = ((way == 1) ? 2 : 3);
if (interior(x + way, y))
if (way == 1 && g[x + way][y] == 0)
dfs(x + way, y, way);
else if (way == -1 && g[x + way][y] == 2)
dfs(x + way, y, way);
if (interior(x, y + way))
if (way == 1 && g[x][y + way] == 0)
dfs(x, y + way, way);
else if (way == -1 && g[x][y + way] == 2)
dfs(x, y + way, way);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
char x;
cin >> n >> m;
for (int i = (0); i < (n); ++i) {
g[i].resize(m);
for (int j = (0); j < (m); ++j) {
cin >> x;
g[i][j] = ((x == '.') ? 0 : 1);
}
}
dfs(0, 0, 1);
if (g[n - 1][m - 1] == 0) return cout << 0, 0;
dfs(n - 1, m - 1, -1);
for (int i = (1); i < (n + m - 2); ++i)
if (roads[i] == 1) return cout << 1, 0;
return cout << 2, 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int f, n, t;
cin >> f >> n >> t;
vector<int> cnt(n, 0);
int ans = 0;
for (int i = 0; i < f; i++) {
string str;
cin >> str;
for (int j = 0; j < n; j++) {
if (str[j] == 'Y') cnt[j]++;
}
}
ans = count_if(cnt.begin(), cnt.end(), [&t](const int i) { return i >= t; });
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, i;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
int p = 0;
for (i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
p++;
break;
}
}
if (p == 0) {
cout << n << "\n";
} else {
cout << "1\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 202;
int n, m;
int a[maxN][maxN];
int adj[maxN], deg[maxN];
bool marked[maxN];
vector<int> odd, EC;
stack<int> S;
void DFS(int u) {
marked[u] = true;
if (deg[u] & 1) odd.push_back(u);
for (int v = 1; v <= n; ++v)
if (a[u][v] == 1 && !marked[v]) DFS(v);
}
int hasPath(int u) {
for (int v = 1; v <= n; ++v)
if (a[u][v] == 1) {
a[u][v] = 2;
a[v][u] = 3;
return v;
}
if (adj[u] > 0) {
int v = adj[u];
adj[v] = 0;
adj[u] = 0;
return v;
}
return 0;
}
int main() {
int nTests;
scanf("%d", &nTests);
while (nTests--) {
scanf("%d %d", &n, &m);
memset(a, 0, sizeof(a));
memset(deg, 0, sizeof(deg));
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
a[u][v] = a[v][u] = 1;
++deg[u];
++deg[v];
}
int res = 0;
for (int u = 1; u <= n; ++u)
if (!(deg[u] & 1)) ++res;
printf("%d\n", res);
memset(marked, false, sizeof(marked));
for (int u = 1; u <= n; ++u)
if (!marked[u]) {
odd.clear();
DFS(u);
for (int i = 0, sz = odd.size(); i < sz; i += 2) {
adj[odd[i]] = odd[i + 1];
adj[odd[i + 1]] = odd[i];
}
while (!S.empty()) S.pop();
EC.clear();
S.push(u);
while (!S.empty()) {
int u = S.top();
int v = hasPath(u);
if (v > 0)
S.push(v);
else {
S.pop();
EC.push_back(u);
}
}
}
for (int u = 1; u <= n; ++u)
for (int v = 1; v <= n; ++v)
if (a[u][v] == 2) printf("%d %d\n", u, v);
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
#define F first
#define S second
#define PB push_back
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
const int maxn = 1e5 + 10;
bool mark[maxn], mark2[maxn];
vector<int> v[maxn];
int n, m;
void to_graph(vector<pii> ed){
for(int i = 0; i <= n; i++)
v[i].clear();
for(int i = 0; i <= n; i++)
mark[i] = mark2[i] = false;
for(pii p : ed){
v[p.first].push_back(p.second);
v[p.second].push_back(p.first);
}
}
int h[maxn], bsth[maxn];
void dfs_cut(int u, int par, vector<pii> &ret){
// h not initailized!
mark[u] = 1;
bsth[u] = h[u];
for(int y : v[u]){
if(!mark[y]){
h[y] = h[u] + 1;
dfs_cut(y, u, ret);
bsth[u] = min(bsth[u], bsth[y]);
}
else if(y != par){
bsth[u] = min(bsth[u], h[y]);
}
}
if(par != -1 && bsth[u] == h[u]){
ret.push_back({u, par});
}
}
vector<pii> get_cut_edges(vector<pii> ed){
to_graph(ed);
vector<pii> ans;
for(int i = 1; i <= n; i++){
if(mark[i] == false)
dfs_cut(i, -1, ans);
}
return ans;
}
void dfs_match(int u, vector<pii> &ret){
mark[u] = 1;
for(int y : v[u]){
if(!mark[y]){
dfs_match(y, ret);
bool matched = false;
if(!mark2[u] && !mark2[y] && (v[u].size()&1) && (v[y].size()&1)){
mark2[u] = mark2[y] = true;
matched = true;
}
if(!matched){
ret.push_back({u, y});
}
}
}
}
vector<pii> get_not_matching_edges(vector<pii> ed){
to_graph(ed);
vector<pii> ans;
for(int i = 1; i <= n; i++){
if(mark[i] == false)
dfs_match(i, ans);
}
return ans;
}
int dfs_partition(int u, vector<pii> &ret){
mark[u] = 1;
int lst = u;
for(int y : v[u]){
if(!mark[y]){
int w = dfs_partition(y, ret);
if(lst == u){
lst = w;
}
else{
ret.push_back({lst, w});
lst = u;
}
}
}
return lst;
}
vector<pii> get_partition(vector<pii> ed){
to_graph(ed);
vector<pii> ans;
for(int i = 1; i <= n; i++){
if(mark[i] == false){
int x = dfs_partition(i, ans);
if(x != i)
ans.push_back({x, i});
}
}
return ans;
}
int main(){
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
while(cin >> n >> m){
if(n == 0 && m == 0)
return 0;
vector<pii> ed;
while(m--){
int s;
cin >> s;
int bef;
cin >> bef;
for(int i = 0; i < s-1; i++){
int nw;
cin >> nw;
ed.push_back({bef, nw});
bef = nw;
}
}
ed = get_cut_edges(ed);
ed = get_not_matching_edges(ed);
ed = get_partition(ed);
cout << ed.size() << "\n";
for(pii p : ed){
cout << p.first << " " << p.second << "\n";
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long a[1024][1024], d1[1024][1024], d2[1024][1024], d3[1024][1024],
d4[1024][1024], d[1024][1024];
long long ans, curr;
int i, n, j, m;
long long compute(int i, int j) {
long long A, B;
A = d1[i - 1][j] + d2[i + 1][j] + d3[i][j - 1] + d4[i][j + 1];
B = d1[i][j - 1] + d2[i][j + 1] + d3[i + 1][j] + d4[i - 1][j];
return max(A, B);
}
int main() {
cin >> n >> m;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) cin >> a[i][j];
d1[0][0] = a[0][0];
d2[n - 1][m - 1] = a[n - 1][m - 1];
d3[n - 1][0] = a[n - 1][0];
d4[0][m - 1] = a[0][m - 1];
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
if (i + j == 0) continue;
if (i * j == 0) {
if (!i)
d1[i][j] = d1[i][j - 1] + a[i][j];
else
d1[i][j] = d1[i - 1][j] + a[i][j];
} else {
d1[i][j] = a[i][j] + max(d1[i - 1][j], d1[i][j - 1]);
}
}
for (i = n - 1; i > -1; --i)
for (j = m - 1; j > -1; --j) {
if (i == n - 1 && j == m - 1) continue;
if (i == n - 1 || j == m - 1) {
if (i == n - 1)
d2[i][j] = d2[i][j + 1] + a[i][j];
else
d2[i][j] = d2[i + 1][j] + a[i][j];
} else {
d2[i][j] = a[i][j] + max(d2[i + 1][j], d2[i][j + 1]);
}
}
for (i = n - 1; i > -1; --i)
for (j = 0; j < m; ++j) {
if (i == n - 1 && j == 0) continue;
if (i == n - 1 || j == 0) {
if (i == n - 1)
d3[i][j] = d3[i][j - 1] + a[i][j];
else
d3[i][j] = d3[i + 1][j] + a[i][j];
} else {
d3[i][j] = a[i][j] + max(d3[i + 1][j], d3[i][j - 1]);
}
}
for (i = 0; i < n; ++i)
for (j = m - 1; j > -1; --j) {
if (i == 0 && j == m - 1) continue;
if (i == 0 || j == m - 1) {
if (i == 0)
d4[i][j] = d4[i][j + 1] + a[i][j];
else
d4[i][j] = d4[i - 1][j] + a[i][j];
} else {
d4[i][j] = a[i][j] + max(d4[i - 1][j], d4[i][j + 1]);
}
}
for (i = 1; i < n - 1; ++i)
for (j = 1; j < m - 1; ++j) {
curr = compute(i, j);
ans = max(ans, curr);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001];
int main() {
int n;
cin >> n;
int k = (1 << (n + 1)) - 1;
for (int j = 2; j <= k; j++) scanf("%d", a + j);
long long int t = (1 << n) - 1;
long long int ans = 0;
for (; t >= 1; t--) {
int x = a[t * 2];
int y = a[t * 2 + 1];
a[t] += max(x, y);
ans += 2 * max(x, y) - x - y;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
int cross(int a1, int b1, int a2, int b2) { return (a1 * b2 - a2 * b1); }
int ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
return cross(b.first - a.first, b.second - a.second, c.first - a.first,
c.second - a.second);
}
void hi() { printf("hi\n"); }
int parents[100010];
int myrank[100010];
void init() { memset(parents, -1, sizeof(parents)); }
int ancestor(int a) {
if (parents[a] == -1) {
return a;
}
parents[a] = ancestor(parents[a]);
return parents[a];
}
bool merge(int a, int b) {
a = ancestor(a);
b = ancestor(b);
if (a == b) return false;
if (myrank[a] > myrank[b]) {
parents[b] = a;
} else if (myrank[a] == myrank[b]) {
parents[b] = a;
myrank[a]++;
} else {
parents[a] = b;
}
return true;
}
int n, x;
bool dp[1010][1010];
vector<int> sizes;
int goesto[1010];
int xplace = 1;
int main() {
init();
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> goesto[i];
goesto[i]--;
if (goesto[i] != -1) {
merge(goesto[i], i);
}
}
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (ancestor(j) == i) {
if (j == x - 1) {
cnt = 0;
break;
}
cnt++;
}
}
if (cnt) {
sizes.push_back(cnt);
}
}
int xcpy = x - 1;
while (goesto[xcpy] != -1) {
xplace++;
xcpy = goesto[xcpy];
}
dp[0][xplace] = 1;
for (int i = 1; i <= sizes.size(); i++) {
for (int p = 1; p <= n; p++) {
dp[i][p] = dp[i - 1][p];
if (p > sizes[i - 1]) {
dp[i][p] = dp[i][p] || dp[i - 1][p - sizes[i - 1]];
}
}
}
for (int i = 1; i <= n; i++) {
if (dp[sizes.size()][i]) {
cout << i << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
long long n, cp = 0, cn = 0;
cin >> n;
long long a[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] % 2)
cn++;
else
cp++;
}
if (cn % 2 == 0) {
cout << "YES\n";
continue;
}
sort(a + 1, a + n + 1);
long long f = 0;
for (long long i = 1; i < n; i++) {
if (abs(a[i] - a[i + 1]) == 1) {
f = 1;
break;
}
}
if (f)
cout << "YES\n";
else {
cout << "NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long t1, t2, k;
double cal(long long u, long long v) {
return (u * t1) - (u * t1) * double(k / 100.0) + (v * t2);
}
vector<pair<double, int> > p;
bool cmp(pair<double, int>& x, pair<double, int>& y) {
if (x.first != y.first) return x.first > y.first;
return x.second < y.second;
}
int main() {
long long n, u, v;
cin >> n >> t1 >> t2 >> k;
for (int i = 0; i < n; ++i) {
cin >> u >> v;
double x = cal(u, v);
double y = cal(v, u);
p.push_back({max(x, y), i});
}
sort(p.begin(), p.end(), cmp);
for (auto it : p) printf("%d %.2lf\n", it.second + 1, it.first);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void Heavy_Gaurav_Singh() {
long long n;
cin >> n;
pair<long long, long long> dt[n];
long long deg[n], xr[n];
for (int i = 0; i < n; i++) {
cin >> deg[i];
cin >> xr[i];
dt[i] = {deg[i], i};
}
sort(dt, dt + n);
vector<pair<long long, long long> > ans;
for (auto x : dt) {
long long n = x.second, dg = x.first;
while (deg[n] == 1) {
long long par = xr[n];
ans.push_back({n, par});
deg[par]--;
deg[n]--;
xr[par] ^= n;
n = par;
}
}
cout << (long long)ans.size() << endl;
for (auto x : ans) cout << x.first << " " << x.second << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int test = 1;
while (test--) {
Heavy_Gaurav_Singh();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> seg[1010];
int ans[1010];
int nans;
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d %d", &seg[i].first, &seg[i].second);
for (int i = 0; i < N; i++)
seg[i] = make_pair(max(seg[i].first, seg[i].second),
min(seg[i].first, seg[i].second));
nans = 0;
int ult = -1000000000;
sort(seg, seg + N);
for (int i = 0; i < N; i++) {
if (seg[i].second > ult) {
ult = seg[i].first;
ans[nans++] = seg[i].first;
}
}
printf("%d\n", nans);
for (int i = 0; i < nans; i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> v, a;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
v.push_back(x);
}
reverse(v.begin(), v.end());
a.push_back(v[0]);
a.push_back(v[1] + a[0]);
long long int c = a[1] - a[0];
for (long long int i = 2; i < v.size(); i++) {
a.push_back(v[i] + c);
c *= -1;
c += a[i];
}
for (long long int i = n - 1; i >= 0; i--) cout << a[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1000050];
vector<int> r[1000050];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
r[v].push_back(u);
}
vector<bool> ans(n + 1);
vector<bool> vis(n + 1);
int c = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
c++;
ans[i] = true;
for (int v : g[i]) {
vis[v] = true;
}
}
}
for (int i = n; i > 0; i--) {
if (ans[i]) {
for (int u : r[i]) {
if (ans[u]) {
c--;
ans[i] = false;
break;
}
}
}
}
cout << c << '\n';
for (int i = 1; i <= n; i++) {
if (ans[i]) cout << i << " ";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long pos) { return N = N | (1 << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
void CI(int &_x) { scanf("%d", &_x); }
void CO(long long &_x) { cout << _x; }
template <typename T>
void getarray(T a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void prLLIarray(T a[], long long n) {
for (long long i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const long long INF = 0x7f7f7f7f;
long long dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
long long dr4[4] = {0, 0, 1, -1};
long long dc4[4] = {-1, 1, 0, 0};
long long kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
long long kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
int main() {
int d1, d2, d3;
cin >> d1 >> d2 >> d3;
int ans1 = 0;
ans1 += d1;
ans1 += min(d1 + d2, d3);
ans1 += min(d2, d3 + d1);
int ans2 = 0;
ans2 += d2;
ans2 += min(d1 + d2, d3);
ans2 += min(d1, d2 + d3);
cout << min(ans1, ans2) << "\n";
}
| 0 |
#include <bits/stdc++.h>
const int max_N = 2000005;
int n, m;
std::vector<int> Edge[max_N];
int read() {
char c = getchar();
int ans = 0;
bool flag = true;
while (!isdigit(c)) flag &= (c != '-'), c = getchar();
while (isdigit(c)) ans = ans * 10 + c - '0', c = getchar();
return flag ? ans : -ans;
}
int read_char() {
char c = getchar();
while (c != 'N' && c != 'W') c = getchar();
return c == 'W';
}
void Write(int x) {
if (x < 10)
putchar(x + '0');
else
Write(x / 10), putchar(x % 10 + '0');
}
bool check() {
for (int i = 1; i <= m; i++)
if (Edge[i].size() >= 4) return true;
for (int i = 1; i <= m; i++) {
if (Edge[i].size() != 3) continue;
int cnt = 0;
for (auto j : Edge[i]) cnt += (Edge[j].size() > 1);
if (cnt >= 2) return true;
}
int cnt = 0;
for (int i = 1; i <= m; i++) cnt += (Edge[i].size() == 3);
return cnt == 2 && (m & 1);
}
void Clear() {
for (int i = 1; i <= m; i++) std::vector<int>().swap(Edge[i]);
}
int main() {
int t = read();
while (t--) {
n = read(), m = n;
for (int i = 1, u, v; i < n; i++)
u = read(), v = read(), Edge[u].push_back(v), Edge[v].push_back(u);
for (int i = 1; i <= n; i++)
if (read_char())
Edge[i].push_back(m + 1), Edge[m + 1].push_back(i),
Edge[m + 1].push_back(m + 2), Edge[m + 2].push_back(m + 1),
Edge[m + 1].push_back(m + 3), Edge[m + 3].push_back(m + 1), m += 3;
if (check())
putchar('W'), putchar('h'), putchar('i'), putchar('t'), putchar('e');
else
putchar('D'), putchar('r'), putchar('a'), putchar('w');
putchar('\n'), Clear();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long ans, a, b, c, d;
int n, m, r, sz[201000], x[201000], y[201000], s, t, u, v, e[3];
vector<int> h[201000], g[201000];
unsigned long long calc(int o, int p, int q) {
e[0] = o;
e[1] = p;
e[2] = q;
sort(e, e + 3);
return a * e[0] + b * e[1] + c * e[2];
}
int main() {
cin >> n >> m;
cin >> a >> b >> c;
for (int i = 0; i < n; i++) {
ans += a * i * ((unsigned long long)(n - i - 1) * (n - i - 2) / 2);
ans += b * i * (n - i - 1) * i;
ans += c * i * ((unsigned long long)i * (i - 1) / 2);
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
x[i] = u;
y[i] = v;
h[u].push_back(v);
h[v].push_back(u);
if (u > v) swap(u, v);
ans -= (b * u + c * v) * u + a * ((unsigned long long)u * (u - 1) / 2);
ans -= (a * u + c * v) * (v - u - 1) +
b * ((unsigned long long)(u + v) * (v - u - 1) / 2);
ans -= (a * u + b * v) * (n - v - 1) +
c * ((unsigned long long)(v + n) * (n - v - 1) / 2);
}
for (int i = 0; i < n; i++) {
sz[i] = h[i].size();
r = 0;
sort(h[i].begin(), h[i].end());
for (int j = 0; j < h[i].size(); j++) {
d = h[i][j];
if (d < i)
ans += a * d * (sz[i] - j - 1) + b * d * j, r++;
else
ans += b * d * (sz[i] - j - 1) + c * d * j;
}
ans += c * i * ((unsigned long long)(r * (r - 1) / 2)) +
b * i * r * (sz[i] - r) +
a * i * ((unsigned long long)(sz[i] - r) * (sz[i] - r - 1) / 2);
}
for (int i = 0; i < m; i++) {
u = x[i];
v = y[i];
if (sz[u] < sz[v] || sz[u] == sz[v] && u < v) swap(u, v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++) sort(g[i].begin(), g[i].end());
for (int i = 0; i < m; i++) {
u = x[i];
v = y[i];
s = 0;
t = 0;
while (s < g[u].size() && t < g[v].size()) {
if (g[u][s] == g[v][t])
ans -= calc(u, v, g[u][s]), s++, t++;
else if (g[u][s] > g[v][t])
t++;
else
s++;
}
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char a[5010], tmp[5010];
int main() {
scanf("%s", a);
int len = strlen(a);
bool ok = false;
for (int i = 0; i < (len >> 1) - 1; i++) {
if (a[i] != a[i + 1]) {
ok = true;
break;
}
}
if (ok) {
bool flag = false;
for (int i = 1; i <= (len + 1) >> 1; i++) {
bool ok1 = true;
for (int j = 0; j < len; j++) {
tmp[j] = a[(i + j) % len];
}
for (int j = 0; j < len >> 1; j++) {
if (tmp[j] != tmp[len - j - 1]) {
ok1 = false;
break;
}
}
bool ok2 = false;
for (int j = 0; j < len; j++) {
if (a[j] != tmp[j]) {
ok2 = true;
}
}
if (ok1 && ok2) {
flag = true;
break;
}
}
if (flag) {
printf("1\n");
} else {
printf("2\n");
}
} else {
printf("Impossible\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, T;
vector<int> dat;
vector<int> ans;
int main() {
scanf("%d%d%d", &n, &m, &T);
T--;
for (int i = 0; i < n; i++) {
int h, m, s;
scanf("%d:%d:%d", &h, &m, &s);
dat.push_back(h * 3600 + m * 60 + s);
}
int usercnt = 0;
multimap<int, int> users;
int reached_max = 0;
for (int i = 0; i < n; i++) {
while (!users.empty() && users.begin()->first + T < dat[i]) {
users.erase(users.begin());
}
if (users.size() < m) {
users.insert(make_pair(dat[i], usercnt));
ans.push_back(usercnt);
usercnt++;
} else {
auto I = users.end();
--I;
auto fval = *I;
users.erase(I);
users.insert(make_pair(dat[i], fval.second));
ans.push_back(fval.second);
}
reached_max = max(reached_max, (int)users.size());
}
if (reached_max != m) {
printf("No solution\n");
return 0;
}
printf("%d\n", usercnt);
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i] + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int d, n, m;
long long ans;
int k[1000006];
int T[4 * 1000006];
int ind[1000006];
pair<int, int> p[1000006];
void upd(int x, int y, int l, int r, int node) {
if (l == r) {
T[node] = y;
return;
}
if (x <= (l + r) / 2)
upd(x, y, l, (l + r) / 2, node * 2);
else
upd(x, y, (l + r) / 2 + 1, r, node * 2 + 1);
T[node] = min(T[node * 2], T[node * 2 + 1]);
}
int get(int x, int l, int r, int node) {
if (x < l) return m + 1;
if (x >= r) return T[node];
return min(get(x, l, (l + r) / 2, node * 2),
get(x, (l + r) / 2 + 1, r, node * 2 + 1));
}
int main() {
scanf("%d%d%d", &d, &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p + 1, p + 1 + m);
for (int i = 0; i < 4 * 1000006; i++) T[i] = m + 1;
for (int i = m; i > 0; i--)
k[i] = get(p[i].second, 1, 1000006, 1), upd(p[i].second, i, 1, 1000006, 1);
p[m + 1] = {d, 0};
int pr = 0, j = n;
for (int i = 1; i <= m; i++) {
n -= p[i].first - pr;
if (n < 0) {
printf("-1");
return 0;
}
pr = p[i].first;
ans +=
min(j - n, max(0, p[k[i]].first - p[i].first - n)) * 1LL * p[i].second;
n += min(j - n, max(0, p[k[i]].first - p[i].first - n));
}
n -= d - pr;
if (n < 0) ans = -1;
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> g[100001];
int col[100001];
bool dfs(int v, int color = 2) {
if (col[v]) return col[v] == color;
col[v] = color;
for (auto u : g[v])
if (!dfs(u.first, color ^ u.second)) return false;
return true;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
while (m--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
c = 1 - c;
g[a].emplace_back(b, c);
g[b].emplace_back(a, c);
}
int ans = 1;
for (int i = 1; i <= n; i++)
if (col[i] == 0)
if (dfs(i)) {
if (i != 1) ans = (ans + ans) % 1000000007;
} else
ans = 0;
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int cnt = 0;
for (int i = 0; i < n; i++) {
while (a[i] > k * 2) {
k *= 2;
cnt++;
}
k = max(k, a[i]);
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101010 * 4;
struct ACMachine {
int tr[maxn][26];
int fail[maxn];
int nume;
int cnt[maxn];
vector<int> vec[maxn];
queue<int> q;
void init() {
while (!q.empty()) q.pop();
nume = 0;
}
int addnode() {
++nume;
for (int i = 0; i < 26; i++) {
tr[nume][i] = 0;
}
cnt[nume] = fail[nume] = 0;
return nume;
}
int insert(int x, int c) {
c -= 'a';
if (!tr[x][c]) {
tr[x][c] = addnode();
}
return tr[x][c];
}
void build() {
for (int i = 0; i < 26; i++)
if (tr[0][i]) {
q.push(tr[0][i]);
vec[0].push_back(tr[0][i]);
}
while (q.size()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
if (tr[u][i]) {
fail[tr[u][i]] = tr[fail[u]][i];
q.push(tr[u][i]);
vec[fail[tr[u][i]]].push_back(tr[u][i]);
} else
tr[u][i] = tr[fail[u]][i];
}
}
}
void dfs(int x, int val) {
int siz = vec[x].size();
cnt[x] += val;
for (int i = 0; i < siz; i++) {
dfs(vec[x][i], cnt[x]);
}
}
} ac1, ac2;
char ch[maxn];
char temv[maxn];
int main() {
int n;
scanf("%s%d", ch, &n);
int pos1 = 0, pos2 = 0, len = strlen(ch);
ac1.init();
ac2.init();
for (int j = 0; j < len; j++) pos1 = ac1.insert(pos1, ch[j]);
for (int j = len - 1; j >= 0; j--) pos2 = ac2.insert(pos2, ch[j]);
for (int i = 1; i <= n; i++) {
scanf("%s", temv);
len = strlen(temv);
pos1 = 0;
pos2 = 0;
for (int j = 0; j < len; j++) pos1 = ac1.insert(pos1, temv[j]);
for (int j = len - 1; j >= 0; j--) pos2 = ac2.insert(pos2, temv[j]);
ac1.cnt[pos1]++;
ac2.cnt[pos2]++;
}
len = strlen(ch);
ac1.build();
ac2.build();
ac1.dfs(0, 0);
ac2.dfs(0, 0);
len = strlen(ch);
long long ans = 0;
for (int i = 1; i < len; i++) {
ans += (long long)ac1.cnt[i] * ac2.cnt[len - i];
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int T, n, k;
long long inf = 1e18;
vector<int> v;
void _clear() { v.clear(); }
long long po(long long x, long long os) {
if (os == 0) return 1;
long long z = po(x, os / 2);
if (os & 1) return z * z * x;
return z * z;
}
long long calc(int k) {
long long ret = 0;
long long num = 0;
for (int i = 0; i <= n - 2; i++) {
long long moves = min(1LL * v[i + 1] / v[i] - 1, 1LL * k - num);
ret += moves * v[i];
num += moves;
}
ret += (k - num) * v.back();
return ret;
}
int main() {
scanf("%d", &T);
while (T--) {
_clear();
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
v.push_back(po(10, x));
}
sort(v.begin(), v.end());
printf("%lld\n", calc(k + 1));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << 2 - n % 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int mod = (int)1e9 + 7;
long long f[5001][5001];
long long d[5001][2];
long long getMod(long long n) {
if (n >= 0) return n % mod;
while (n < 0) n += mod;
return n;
}
long long getSum(int l, int r, int idx) {
if (l > r) return 0;
return getMod(d[r][idx] - d[l - 1][idx]);
}
int main(void) {
int n, a, b, k;
scanf("%i %i %i %i", &n, &a, &b, &k);
int i, j, c;
for (i = 1; i <= n; i++) {
f[i][0] = 1;
d[i][0] = d[i - 1][0] + 1;
}
for (j = 1; j <= k; j++)
for (i = 1; i <= n; i++) {
d[i][j & 01] = d[i - 1][j & 01];
if (i == b) continue;
int l = (1 > i - abs(i - b) + 1 ? 1 : i - abs(i - b) + 1),
r = (n < i + abs(i - b) - 1 ? n : i + abs(i - b) - 1);
f[i][j] = getSum(l, i - 1, (j - 1) & 01) + getSum(i + 1, r, (j - 1) & 01);
assert(f[i][j] >= 0);
if (f[i][j] >= mod) f[i][j] %= mod;
d[i][j & 01] += f[i][j];
assert(d[i][j & 01] >= 0);
if (d[i][j & 01] >= mod) d[i][j & 01] %= mod;
}
printf("%lld\n", f[a][k]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b;
vector<long long> v, v1;
long long s = 0, k;
for (long long i = 0; i < a; i++) {
cin >> k;
if (k < 0)
v1.push_back(k);
else {
v.push_back(k);
s += k;
}
}
long long ans = s;
long long r = 0;
if (v1.size() > 0 && v.size() > 0)
r = min(abs(v1[v1.size() - 1]), v[0]);
else if (v1.size() > 0)
r = (-1) * v1[v1.size() - 1];
if (v1.size() == 0 && b % 2 == 0)
ans = s;
else if (v1.size() == 0 && b % 2 == 1)
ans -= 2 * v[0];
else {
if ((v1.size() + b) % 2 == 0 || b < v1.size()) {
for (long long i = 0; i < v1.size(); i++) {
if (b > 0) {
ans += abs(v1[i]);
b--;
} else
ans += v1[i];
}
} else {
for (long long i = 0; i < v1.size(); i++) {
if (b > 0) {
ans += abs(v1[i]);
b--;
} else
ans += v1[i];
}
ans -= 2 * r;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535;
bool isMask(int a, int b) {
string mask;
while (a) {
if (a % 10 == 7 || a % 10 == 4) mask.push_back(a % 10 + '0');
a /= 10;
}
int res = 0;
for (int i = mask.size() - 1; i >= 0; i--) {
res = res * 10 + mask[i] - '0';
}
return res == b;
}
int main() {
int a, b;
cin >> a >> b;
if (b > a) {
cout << b << endl;
return 0;
}
int res = 0;
for (int i = a + 1; i <= 200001; i++) {
if (isMask(i, b)) {
res = i;
break;
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n;
long long x, s;
vector<long long> ans, v[63];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
v[63 - __builtin_clzll(x)].push_back(x);
}
for (int j = 0; j < 63; j++)
sort(v[j].begin(), v[j].end()), reverse(v[j].begin(), v[j].end());
for (int i = 0; i <= n; i++) {
if (ans.size() != i) {
printf("No\n");
return 0;
}
for (int j = 0; j < 63; j++) {
if (s & (1ll << j)) continue;
if (v[j].empty()) continue;
ans.push_back(v[j].back());
s ^= v[j].back();
v[j].pop_back();
break;
}
}
printf("Yes\n");
for (int i = 0; i < n; i++) printf("%lld%c", ans[i], i + 1 == n ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int field[8][8];
int main() {
string caballo, torre;
getline(cin, torre);
getline(cin, caballo);
memset(field, 0, sizeof(field));
field[torre[0] - 'a'][torre[1] - '0' - 1] = 1;
field[caballo[0] - 'a'][caballo[1] - '0' - 1] = 1;
for (int i = 0; i < 8; i++) {
field[torre[0] - 'a'][i] = 1;
field[i][torre[1] - '0' - 1] = 1;
}
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
if (((caballo[0] - 'a') - i) * ((caballo[0] - 'a') - i) +
((caballo[1] - '0' - 1) - j) * ((caballo[1] - '0' - 1) - j) ==
5) {
field[i][j] = 1;
}
if (((torre[0] - 'a') - i) * ((torre[0] - 'a') - i) +
((torre[1] - '0' - 1) - j) * ((torre[1] - '0' - 1) - j) ==
5) {
field[i][j] = 1;
}
}
int sum = 0;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (field[i][j] == 0) sum++;
printf("%d\n", sum);
getchar();
return 0;
}
| 2 |
#include <bits/stdc++.h>
namespace fast_IO {
const int IN_LEN = 10000000, OUT_LEN = 10000000;
char ibuf[IN_LEN], obuf[OUT_LEN], *ih = ibuf + IN_LEN, *oh = obuf,
*lastin = ibuf + IN_LEN,
*lastout = obuf + OUT_LEN - 1;
inline char getchar_() {
return (ih == lastin) &&
(lastin = (ih = ibuf) + fread(ibuf, 1, IN_LEN, stdin),
ih == lastin)
? EOF
: *ih++;
}
inline void putchar_(const char x) {
if (oh == lastout) fwrite(obuf, 1, oh - obuf, stdout), oh = obuf;
*oh++ = x;
}
inline void flush() { fwrite(obuf, 1, oh - obuf, stdout); }
} // namespace fast_IO
using namespace fast_IO;
template <typename T>
inline T max(const T a, const T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(const T a, const T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(const T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline void swap(T& a, T& b) {
T c = a;
a = b;
b = c;
}
template <typename T>
inline T gcd(const T a, const T b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
template <typename T>
inline T square(const T x) {
return x * x;
};
template <typename T>
inline void read(T& x) {
char cu = getchar();
x = 0;
bool fla = 0;
while (!isdigit(cu)) {
if (cu == '-') fla = 1;
cu = getchar();
}
while (isdigit(cu)) x = x * 10 + cu - '0', cu = getchar();
if (fla) x = -x;
}
template <typename T>
void printe(const T x) {
if (x >= 10) printe(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void print(const T x) {
if (x < 0)
putchar('-'), printe(-x);
else
printe(x);
}
int n, m, h;
int head[100001], nxt[200001], tow[200001], tmp, vau[100001];
int belo[100001], n_d = 0;
inline void addb(const int u, const int v) {
tmp++;
nxt[tmp] = head[u];
head[u] = tmp;
tow[tmp] = v;
}
int tot, DFN[100001], LOW[100001], beg;
int stack[100001], top, size[100001];
inline void push(const int x) { stack[++top] = x; }
inline int pop() { return stack[top--]; }
void DFS(const int u) {
DFN[u] = LOW[u] = ++tot;
push(u);
for (register int i = head[u]; i; i = nxt[i]) {
const int v = tow[i];
if (!DFN[v]) {
DFS(v);
LOW[u] = min(LOW[u], LOW[v]);
} else if (belo[v] == 0)
LOW[u] = min(LOW[u], DFN[v]);
}
if (LOW[u] == DFN[u]) {
n_d++;
register int cl = pop();
while (cl != u) {
belo[cl] = n_d;
size[n_d]++;
cl = pop();
}
belo[cl] = n_d;
size[n_d]++;
}
}
bool could[100001];
inline void addb_d(const int u, const int v) {
if (u == v) return;
could[u] = 0;
}
inline void draw() {
for (register int i = 1; i <= n; i++)
for (register int j = head[i]; j; j = nxt[j]) addb_d(belo[i], belo[tow[j]]);
}
int res = 0;
bool sign = 0;
int main() {
read(n), read(m), read(h);
for (register int i = 1; i <= n; i++) read(vau[i]);
for (register int i = 1; i <= m; i++) {
int u, v;
read(u), read(v);
if ((vau[u] + 1) % h == vau[v]) addb(u, v);
if ((vau[v] + 1) % h == vau[u]) addb(v, u);
}
for (beg = 1; beg <= n; beg++)
if (!DFN[beg]) DFS(beg);
memset(could, 1, sizeof(could));
draw();
size[0] = 0x7fffffff;
for (register int i = 1; i <= n_d; i++)
if (could[i] && size[res] > size[i]) res = i;
print(size[res]), putchar('\n');
for (register int i = 1; i <= n; i++)
if (belo[i] == res) {
if (sign)
putchar(' ');
else
sign = 1;
print(i);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, min1, min2, min3, max1, max2, max3;
cin >> n;
cin >> min1;
cin >> max1;
cin >> min2;
cin >> max2;
cin >> min3;
cin >> max3;
int pri = min1, se = min2, ter = min3;
if ((pri + se + ter) == n) {
cout << pri << " " << se << " " << ter;
} else {
while (pri + se + ter != n) {
if (pri < max1) {
pri++;
} else {
if (se < max2) {
se++;
} else {
if (ter < max3) {
ter++;
}
}
}
}
cout << pri << " " << se << " " << ter;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int n;
cin >> n;
map<string, int> m[2];
getchar();
for (int i = 0; i < n; ++i) {
string test;
getline(cin, test);
stringstream iss(test);
string split;
string t, team, id, col;
iss >> t;
iss >> team;
iss >> id;
iss >> col;
int in = (team == "a") ? 1 : 0;
if (m[in][id] == 1000) {
continue;
}
if (col == "y") {
m[in][id]++;
if (m[in][id] == 2) {
m[in][id] = 1000;
}
} else
m[in][id] = 1000;
if (m[in][id] == 1000) {
if (in == 1)
cout << b << " " << id << " " << t << "\n";
else
cout << a << " " << id << " " << t << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[200100];
int vis[200100];
long long gcd(long long a, long long b) {
if (a > b) gcd(b, a);
if (a == 0) return b;
return (gcd(b % a, a));
}
int main() {
long long a, b;
cin >> a >> b;
long long g = gcd(a, b);
int n;
cin >> n;
vector<long long> factors;
for (long long i = 1; i <= sqrt(g); i++) {
if (g % i == 0) {
factors.push_back(i);
if (i != g / i) factors.push_back(g / i);
}
}
sort(factors.begin(), factors.end());
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
if (x > g)
cout << -1 << endl;
else if (x <= g && y >= g)
cout << g << endl;
else {
int start = 0;
int end = factors.size() - 1;
int mid = 0;
long long ans = -1;
while (start <= end) {
mid = (start + end) / 2;
if (factors[mid] <= y) {
start = mid + 1;
if (factors[mid] >= x) ans = factors[mid];
} else
end = mid - 1;
}
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 200200;
const int mod = 998244353;
inline long long pow(long long a, int b, long long ans = 1) {
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ans = ans * a % mod;
return ans;
}
inline long long inverse(int x) { return pow(x, mod - 2); }
inline void reduce(int& x) { x += x >> 31 & mod; }
int n;
double ans[maxn << 2];
double min[maxn << 2];
double max[maxn << 2];
inline void update(int o) {
ans[o] = ans[o << 1] + ans[o << 1 | 1];
min[o] = std::min(min[o << 1], min[o << 1 | 1]);
max[o] = std::max(max[o << 1], max[o << 1 | 1]);
}
inline int find(int o, double* x, int l = 1, int r = n) {
if (l == r) return l;
int mid = l + r >> 1;
return x[o] == x[o << 1] ? find(o << 1, x, l, mid)
: find(o << 1 | 1, x, mid + 1, r);
}
inline double get(int l, int x) {
return x < 0 || x > l ? -1 / 0. : (double)x / (x + l);
}
inline double calc(int l, int x) {
return x > l ? -1. / 0 : get(l, x) - get(l, x - 1);
}
template <typename _Tp>
inline _Tp get() {
static _Tp x;
return std::cin >> x, x;
}
double p[maxn];
int cnt[maxn], l[maxn], t, q;
inline void mdf(int o, int pos, int l = 1, int r = n) {
if (l == r) {
max[o] = p[pos] * calc(::l[pos], cnt[pos] + 1);
min[o] = p[pos] * calc(::l[pos], cnt[pos]);
ans[o] = p[pos] * get(::l[pos], cnt[pos]);
return;
}
int mid = l + r >> 1;
if (pos <= mid)
mdf(o << 1, pos, l, mid);
else
mdf(o << 1 | 1, pos, mid + 1, r);
update(o);
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> t >> q;
for (int i = 1; i <= n; ++i) p[i] = get<int>();
for (int i = 1; i <= n; ++i) std::cin >> l[i];
l[++n] = 1e9, p[n] = 1e-20;
for (int i = 1; i <= n; ++i) mdf(1, i);
for (; t--;) {
int u = find(1, max);
++cnt[u], mdf(1, u);
}
for (int i = 1, t, k; i <= q; ++i) {
std::cin >> t >> k, l[k] += t == 1 ? 1 : -1;
mdf(1, k);
for (; max[1] > min[1];) {
int u = find(1, max), v = find(1, min);
++cnt[u], --cnt[v];
mdf(1, u), mdf(1, v);
}
printf("%.10lf\n", ans[1]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long a[1005], b[1005];
priority_queue<long long> q;
int main() {
long long n, k1, k2;
cin >> n >> k1 >> k2;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> b[i];
q.push(abs(a[i] - b[i]));
}
k1 += k2;
while (k1 > 0) {
long long x = q.top();
q.pop();
if (x == 0) break;
q.push(x - 1);
k1--;
}
long long ans = 0;
if (k1 & 1) ans = 1;
while (!q.empty()) {
long long tmp = q.top();
ans += tmp * tmp;
q.pop();
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
std::string solve(std::string s) {
int d = std::distance((s).begin(), (s).end());
if (d % 2 == 1) return s;
std::string s1 = solve(s.substr(0, d / 2)), s2 = solve(s.substr(d / 2, d));
return s1 < s2 ? s1 + s2 : s2 + s1;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
std::string a, b;
std::cin >> a >> b;
std::cout << (solve(a) == solve(b) ? "YES\n" : "NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long cdiv(long long a, long long b) {
return a / b + ((a ^ b) > 0 && a % b);
}
long long fdiv(long long a, long long b) {
return a / b - ((a ^ b) < 0 && a % b);
}
void solve() {
long long int n;
cin >> n;
long long int w, h, prev_h = 0;
cin >> w >> h;
long long int z = max(w, h);
for (long long int i = 1; i < n; i++) {
cin >> w >> h;
long long int d = min(w, h);
long long int l = max(w, h);
if (d > z) {
cout << "NO\n";
return;
}
if (z >= d and z >= l)
z = l;
else if (z >= d)
z = d;
else if (z >= l)
z = l;
}
cout << "YES\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = 50000000;
const int maxn = 100010;
const int maxk = 350;
int grundy[maxn], cut[maxn], prefxor[maxn];
int possible(int n, int k) {
int temp = 2 * n;
if (temp % k) return 0;
temp /= k;
temp = temp - 1 + k;
if (temp <= 0 || temp & 1)
return 0;
else {
int lst = (temp / 2) - (k - 1);
if (lst <= 0) return 0;
return temp / 2;
}
}
void precompute() {
int i, j, second;
for (i = 1; i < maxn; i++) {
set<int> mset;
cut[i] = inf;
for (j = 2; j <= min(maxk, i); j++) {
second = possible(i, j);
if (second) {
int x = prefxor[second] ^ prefxor[second - j];
mset.insert(x);
if (!x) cut[i] = min(cut[i], j);
}
}
int ret = 0;
while (mset.find(ret) != mset.end()) ret++;
grundy[i] = ret;
prefxor[i] = prefxor[i - 1] ^ ret;
}
}
int main() {
precompute();
int n;
scanf("%d", &n);
if (grundy[n]) {
printf("%d\n", cut[n]);
} else {
printf("-1\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int f(int x) { return a * x + b - d; }
int fa(int x) { return a * x + b; }
int main() {
cin >> a >> b >> c >> d;
for (int i = 0; i < 100000; ++i) {
if (f(i) >= 0 && f(i) % c == 0) {
cout << fa(i) << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 10;
struct node {
int a, o;
} s[MAX], st[MAX];
bool cmp(node i, node j) { return i.a > j.a; }
bool cnp(node i, node j) { return i.a < j.a; }
bool cpp(node i, node j) { return i.o < j.o; }
int main() {
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &st[i].a), st[i].o = i;
for (int i = 0; i < m; i++) scanf("%d", &s[i].a), s[i].o = i;
sort(st, st + m, cmp), sort(s, s + m, cnp);
for (int i = 0; i < m; i++) st[i].o = s[i].o;
sort(st, st + m, cpp);
for (int i = 0; i < m; i++) printf("%d ", st[i].a);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m, p;
struct NODE {
long long lazy;
long long sum;
NODE() : lazy(-1) {}
} it[3000000];
long long len[3000000];
int S;
vector<pair<int, int> > in[3000000];
vector<pair<int, int> > out[3000000];
set<pair<int, int> > s;
void recalc(int now) {
if (it[now].lazy >= 0)
it[now].sum = it[now].lazy * len[now] % 1000000007;
else
it[now].sum = (it[now * 2].sum + it[now * 2 + 1].sum) % 1000000007;
}
void pushdown(int now) {
if (it[now].lazy >= 0)
it[now * 2].lazy = it[now].lazy, it[now * 2 + 1].lazy = it[now].lazy,
it[now].lazy = -1;
recalc(now * 2), recalc(now * 2 + 1);
}
void update(int now, int x, int y, int s, int e, long long v) {
if (x > y) return;
if (x == s && y == e) {
it[now].lazy = v;
recalc(now);
return;
}
pushdown(now);
update(now * 2, x, min(y, (s + e) / 2), s, (s + e) / 2, v);
update(now * 2 + 1, max(x, (s + e) / 2 + 1), y, (s + e) / 2 + 1, e, v);
recalc(now);
}
long long getsum(int now, int x, int y, int s, int e) {
if (x > y) return 0;
if (x == s && y == e) return it[now].sum;
pushdown(now);
return (getsum(now * 2, x, min(y, (s + e) / 2), s, (s + e) / 2) +
getsum(now * 2 + 1, max(x, (s + e) / 2 + 1), y, (s + e) / 2 + 1, e)) %
1000000007;
}
int main() {
int i, j, k, l;
cin >> n >> m >> p;
for (i = 0; i < p; i++) {
int x, y, z, w;
scanf("%d%d%d%d", &x, &y, &z, &w);
in[y].emplace_back(x, z);
out[w + 1].emplace_back(x, z);
}
for (S = 1; S <= n + 2; S *= 2)
;
for (i = S; i < S * 2; i++) len[i] = 1, it[i].lazy = 0;
for (i = S - 1; i > 0; i--) len[i] = len[i * 2] + len[i * 2 + 1];
update(1, 1, 1, 0, S - 1, 1);
for (auto e : in[1]) s.insert(e);
for (i = 1; i <= m; i++) {
sort((in[i]).begin(), (in[i]).end());
reverse((in[i]).begin(), (in[i]).end());
for (auto e : in[i]) {
auto ix = s.lower_bound(make_pair(e.second + 2, -0x3f3f3f3f));
int tar = 1;
if (ix != s.begin()) tar = prev(ix)->second + 1;
long long res = getsum(1, tar, e.second + 1, 0, S - 1);
update(1, e.second + 1, e.second + 1, 0, S - 1, res);
}
for (auto e : out[i]) s.erase(e);
for (auto e : in[i]) update(1, e.first, e.second, 0, S - 1, 0), s.insert(e);
}
cout << getsum(1, s.size() ? prev(s.end())->second + 1 : 1, n, 0, S - 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, r1, r2, r3, d, a[1000001], dp[1000003];
signed main() {
scanf("%lld %lld %lld %lld %lld", &n, &r1, &r2, &r3, &d);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
dp[i] = 114514114514114514;
}
dp[n + 1] = dp[n + 2] = 112414114514114514;
dp[1] = 0;
for (int i = 1; i <= n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + a[i] * r1 + r3 + d);
dp[i + 1] = min(dp[i + 1], dp[i] + min((a[i] + 1) * r1, r2) + r1 + d * 3);
dp[i + 2] =
min(dp[i + 2], dp[i] + min((a[i] + 1) * r1, r2) +
min((a[i + 1] + 1) * r1, r2) + 2 * r1 + d * 4);
}
cout << min(dp[n + 1] - d, dp[n - 1] + min((a[n - 1] + 1) * r1, r2) +
r1 * a[n] + r3 + 2 * d + r1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define m_p make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
typedef long long ll;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 1003;
int gcd(int x, int y)
{
if (x == 0)
return y;
return gcd(y % x, x);
}
int qry(int h, int w, int i1, int j1, int i2, int j2)
{
if (h == 0 || w == 0)
return 1;
printf("? %d %d %d %d %d %d\n", h, w, i1, j1, i2, j2);
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
int c[N];
void dfs(int x)
{
for (int i = 1; i <= 1000; ++i)
{
if (c[i] != -1)
{
int h = gcd(i, x);
if (c[h] == -1)
{
c[h] = (c[x] & c[i]);
dfs(h);
}
}
}
}
void solv()
{
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= 1000; ++i)
c[i] = -1;
c[n] = 1;
for (int i = n; i >= 1; --i)
{
if (n % i != 0)
continue;
if (c[i] != -1)
continue;
if ((n % (i * 2)) == 0)
{
c[i] = (qry(i, m, 1, 1, i + 1, 1) & c[i * 2]);
}
else
{
if ((n / i) % 2 == 1)
c[i] = ((qry(i * (n / i / 2), m, 1, 1, i * (n / i / 2 + 1) + 1, 1) &
qry(i * (n / i / 2), m, i + 1, 1, i * (n / i / 2 + 1) + 1, 1)));
else
c[i] = ((qry(i * (n / i / 2), m, 1, 1, i * (n / i / 2) + 1, 1) &
qry(i * (n / i / 2 - 1), m, i + 1, 1, i * (n / i / 2) + 1, 1)));
}
dfs(i);
}
int qn = 0;
for (int i = 1; i <= n; ++i)
{
if (n % i != 0)
continue;
qn += c[i];
}
for (int i = 1; i <= 1000; ++i)
c[i] = -1;
c[m] = 1;
for (int i = m; i >= 1; --i)
{
if (m % i != 0)
continue;
if (c[i] != -1)
continue;
if ((m % (i * 2)) == 0)
{
c[i] = (qry(n, i, 1, 1, 1, i + 1) & c[i * 2]);
}
else
{
if ((m / i) % 2 == 1)
c[i] = (qry(n, i * (m / i / 2), 1, 1, 1, i * (m / i / 2 + 1) + 1) &
qry(n, i * (m / i / 2), 1, i + 1, 1, i * (m / i / 2 + 1) + 1));
else
c[i] = (qry(n, i * (m / i / 2), 1, 1, 1, i * (m / i / 2) + 1) &
qry(n, i * (m / i / 2 - 1), 1, i + 1, 1, i * (m / i / 2) + 1));
}
dfs(i);
}
int qm = 0;
for (int i = 1; i <= m; ++i)
{
if (m % i != 0)
continue;
qm += c[i];
}
printf("! %d\n", qn * qm);
fflush(stdout);
}
bool cc[1003];
void dfsp(int x)
{
if (cc[x])
return;
cc[x] = true;
for (int i = 1; i <= 1000; ++i)
{
if (cc[i])
dfsp(gcd(x, i));
}
}
int main()
{
#ifdef SOMETHING
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif // SOMETHING
//ios_base::sync_with_stdio(false), cin.tie(0);
/*int q[1003] = {};
for (int n = 1; n <= 1000; ++n)
{
memset(cc, false, sizeof cc);
cc[n] = true;
if (n == 512)
printf("");
for (int i = n; i >= 1; --i)
{
if (n % i != 0)
continue;
if (cc[i])
continue;
dfsp(i);
q[n] += 2;
if (n % (i * 2) == 0)
--q[n];
}
}
int minu = 100;
for (int n = 1; n <= 1000; ++n)
{
for (int m = 1; m <= 1000; ++m)
{
int l = 0;
while ((1 << (l + 1)) <= n + m)
++l;
minu = min(minu, 3 * l - q[n] - q[m]);
}
}
for (int n = 1; n <= 1000; ++n)
{
for (int m = 1; m <= 1000; ++m)
{
int l = 0;
while ((1 << (l + 1)) <= n + m)
++l;
if (3 * l - q[n] - q[m] == minu)
{
printf("%d %d\n", n, m);
}
}
}
printf("%d\n", minu);
return 0;*/
int tt = 1;
//scanf("%d", &tt);
while (tt--)
solv();
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, d, m, l, i;
long long sum = 0;
scanf("%d %d %d %d", &n, &d, &m, &l);
for (i = 0; i < n; i++) {
if ((sum + m - 1) / d * d > sum + l) {
printf("%I64d\n", ((sum + l) / d + 1) * d);
return 0;
}
sum += m;
}
printf("%I64d\n", ((sum - m + l) / d + 1) * d);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const long long MOD = 1e9 + 7;
long long n, m;
long long fact[MAXN + 10], invfact[MAXN + 10], ans;
long long mypow(long long x, long long y) {
if (y <= 0) return 1;
if (y % 2) return mypow(x, y - 1) * x % MOD;
long long t = mypow(x, y / 2);
return t * t % MOD;
}
long long comb(long long n, long long r) {
if (n < r) return 0;
return fact[n] * invfact[r] % MOD * invfact[n - r] % MOD;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long i, j;
scanf("%lld%lld%*d%*d", &n, &m);
fact[0] = 1;
for (i = 1; i <= MAXN; i++) fact[i] = fact[i - 1] * i % MOD;
invfact[MAXN] = mypow(fact[MAXN], MOD - 2);
for (i = MAXN - 1; i >= 0; i--) invfact[i] = invfact[i + 1] * (i + 1) % MOD;
for (i = 2; i <= n; i++) {
long long now = 1;
if (i != n) now = i * mypow(n, n - i - 1) % MOD;
now = now * fact[n - 2] % MOD * invfact[n - i] % MOD;
now = now * mypow(m, n - i) % MOD;
now = now * comb(m - 1, i - 2) % MOD;
ans += now;
ans %= MOD;
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int a[1005];
int N, M, H;
int s;
int C(int m, int k) {
if (k > m)
return 0;
else if (k == m)
return 1;
else if (k == m - 1 || k == 1)
return m;
int up, dn;
int min = m - k + 1;
int i;
int sum;
for (sum = m, i = m - 1; i >= min; i--) sum *= i;
up = sum;
for (sum = k, i = k - 1; i >= 2; i--) sum = sum * i;
dn = sum;
return up / dn;
}
int main() {
int i;
while (scanf("%d%d%d", &N, &M, &H) != EOF) {
s = 0;
for (i = 1; i <= M; i++) {
scanf("%d", &a[i]);
s += a[i];
}
if (s < N) {
printf("-1.0\n");
continue;
}
double p = 1.0;
int max, min;
max = s - 1;
min = s - 1 - N + 2;
for (i = max; i >= min; i--) p = p / i;
max = s - a[H];
min = s - a[H] - N + 2;
for (i = max; i >= min; i--) p *= i;
printf("%lf\n", 1 - p);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int lowbit(int x) { return x & -x; }
template <class T>
inline void read(T &re) {
re = 0;
T sign = 1;
char tmp;
while ((tmp = getchar()) && (tmp < '0' || tmp > '9'))
if (tmp == '-') sign = -1;
re = tmp - '0';
while ((tmp = getchar()) && (tmp >= '0' && tmp <= '9'))
re = re * 10 + (tmp - '0');
re *= sign;
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
int n, m;
int a[2], dp[1 << 24], dis[1 << 24];
int main() {
read(n);
for (register int i = 0; i < n; ++i) read(dis[1 << i]);
read(m);
for (register int i = 0; i < m; i++) read(a[i]);
dp[0] = 1;
for (register int i = 1; i < (1 << n); i++) {
int j = lowbit(i), k = i;
dis[i] = dis[i ^ j] + dis[j];
if (dis[i] == a[0] || dis[i] == a[1]) continue;
while (k) {
j = lowbit(k);
dp[i] += dp[i ^ j];
if (dp[i] >= 1000000007) dp[i] -= 1000000007;
k ^= j;
}
}
write(dp[(1 << n) - 1]);
putchar('\n');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, dfn[5000 + 5], low[5000 + 5], q[5000 + 5], top, d[5000 + 5],
head[5000 + 5], cnt, ans;
int dn, mn[5000 + 5], Mn[5000 + 5], cc, bel[5000 + 5], inq[5000 + 5],
flag[5000 + 5];
struct edge {
int to, next;
} e[5000 + 5];
inline void ins(int f, int t) {
e[++cnt] = (edge){t, head[f]};
head[f] = cnt;
}
int Solve(int x) {
memset(d, 40, sizeof(d));
d[q[top = 1] = x] = 0;
for (int i = 1; i <= top; ++i) {
for (int j = head[q[i]]; j; j = e[j].next)
if (d[q[i]] + 1 < d[e[j].to]) d[q[++top] = e[j].to] = d[q[i]] + 1;
if (i == 1) d[x] = 1e9;
}
return d[x];
}
void Tarjan(int x) {
dfn[x] = low[x] = ++dn;
inq[q[++top] = x] = 1;
for (int i = head[x]; i; i = e[i].next)
if (!dfn[e[i].to])
Tarjan(e[i].to), low[x] = min(low[x], low[e[i].to]);
else if (inq[e[i].to])
low[x] = min(low[x], dfn[e[i].to]);
if (low[x] == dfn[x]) {
for (q[top + 1] = 0, Mn[++cc] = 1e9; q[top + 1] != x; --top)
Mn[cc] = min(Mn[cc], mn[q[top]]), bel[q[top]] = cc, inq[q[top]] = 0;
}
}
int main() {
n = read();
m = read();
for (int i = 1, j; i <= m; ++i) j = read(), ins(j, read());
for (int i = 1; i <= n; ++i) mn[i] = head[i] ? Solve(i) : 0;
top = 0;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= n; ++i)
for (int j = head[i]; j; j = e[j].next)
if (bel[e[j].to] != bel[i]) flag[bel[i]] = 1;
for (int i = 1; i <= cc; ++i)
if (!flag[i]) ans += Mn[i] ? Mn[i] * 998 + 1 : 0;
cout << ans + n;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 110000;
int V;
vector<int> G[Max];
int match[Max];
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
map<int, int> g;
int n, a, b;
int num[Max];
int ina[Max];
int inb[Max];
int pass[Max];
pair<int, int> degree[Max];
bool build() {
memset(ina, 0, sizeof(ina));
memset(inb, 0, sizeof(inb));
memset(pass, 0, sizeof(pass));
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
g[num[i]] = i;
}
for (int i = 0; i < n; i++) {
if (ina[i] == 0) {
if (g.count(a - num[i])) {
int t = g[a - num[i]];
add_edge(i, t);
ina[t] = 1;
ina[i] = 1;
}
}
if (inb[i] == 0) {
if (g.count(b - num[i])) {
int t = g[b - num[i]];
add_edge(i, t);
inb[t] = 1;
inb[i] = 1;
}
}
degree[i].first = ina[i] + inb[i];
degree[i].second = i;
if (num[i] * 2 == a || num[i] * 2 == b) pass[i] = 1;
if (ina[i] == 0 && inb[i] == 0) return false;
}
return true;
}
int used[Max];
int answer[Max];
int dfs(int u, int a) {
answer[u] = a;
used[u] = 1;
if (pass[u] == 1) {
return -Max;
}
for (int i = 0; i < (int)G[u].size(); i++) {
if (!used[G[u][i]]) {
return dfs(G[u][i], a) + 1;
}
}
return 1;
}
bool solve() {
memset(used, 0, sizeof(used));
memset(answer, 0, sizeof(answer));
for (int i = 0; i < n; i++) {
if (!used[i] && degree[i].first == 1) {
int M;
if (ina[degree[i].second] == 1) {
M = 0;
} else
M = 1;
int temp = dfs(degree[i].second, M);
if (temp > 0 && temp % 2 == 1) return false;
} else if (degree[i].first == 0) {
return false;
}
}
return true;
}
int main() {
cin >> n >> a >> b;
if (build()) {
if (a == b) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("1");
}
cout << endl;
} else {
bool t;
t = solve();
if (t) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", answer[i]);
}
cout << endl;
} else {
cout << "NO" << endl;
}
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string a, b, c;
int T;
int main() {
cin >> T;
for (; T--;) {
cin >> a >> b >> c;
bool flag = true;
for (int i = 0; i < a.size(); i++) {
if (!(a[i] == c[i] || b[i] == c[i])) flag = false;
}
cout << (flag ? "YES" : "NO") << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
inline void read(int &x) { scanf("%d", &x); }
inline void read(long long &x) { scanf("%I64d", &x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void read(long double &x) {
double tmp;
read(tmp);
x = tmp;
}
template <class T>
inline void read(T *a, int n) {
for (int i = (0); i < (n); ++i) read(a[i]);
}
inline void write(int x) { printf("%d", x); }
inline void write(long long x) { printf("%I64d", x); }
inline void write(double x) { printf("%.10lf", x); }
inline void write(long double x) { printf("%.10lf", (double)x); }
template <class T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <class T>
inline void writeln(T *a, int n) {
for (int i = (0); i < (n); ++i) {
write(a[i]);
putchar(' ');
}
putchar('\n');
}
template <class T>
inline void writelnln(T *a, int n) {
for (int i = (0); i < (n); ++i) writeln(a[i]);
}
int A[5];
std::set<int> res[5][5];
inline void calc(int l, int r) {
std::set<int> &S = res[l][r];
S.clear();
if (l == r) {
S.insert(A[l]);
S.insert(-A[l]);
} else {
for (int m = (l); m < (r); ++m) {
std::set<int> &a = res[l][m], &b = res[m + 1][r];
for (__typeof(a.begin()) aa = a.begin(); aa != a.end(); ++aa)
for (__typeof(b.begin()) bb = b.begin(); bb != b.end(); ++bb) {
S.insert(*aa + *bb);
S.insert(*aa - *bb);
S.insert(*aa * *bb);
S.insert(-*aa + *bb);
S.insert(-*aa - *bb);
S.insert(-*aa * *bb);
}
}
}
}
std::set<int> ANS;
char buf[3000007], *cb = buf;
int main() {
int k, m;
read(k);
read(m);
for (int ls = (0); ls < (10000); ++ls) {
A[0] = ls / 1000;
A[1] = ls / 100 % 10;
A[2] = ls / 10 % 10;
A[3] = ls % 10;
calc(0, 0);
calc(1, 1);
calc(2, 2);
calc(3, 3);
calc(0, 1);
calc(1, 2);
calc(2, 3);
calc(0, 2);
calc(1, 3);
calc(0, 3);
std::set<int> &ans = res[0][3];
for (__typeof(ans.begin()) x = ans.begin(); x != ans.end(); ++x) {
int ttt = abs(k - *x);
if (ttt < 10000) {
ANS.insert(ls * 10000 + ttt);
if (ANS.size() == m) {
for (__typeof(ANS.begin()) it = ANS.begin(); it != ANS.end(); ++it) {
int x = *it;
*(cb++) = x / 10000000 + '0';
*(cb++) = x / 1000000 % 10 + '0';
*(cb++) = x / 100000 % 10 + '0';
*(cb++) = x / 10000 % 10 + '0';
*(cb++) = x / 1000 % 10 + '0';
*(cb++) = x / 100 % 10 + '0';
*(cb++) = x / 10 % 10 + '0';
*(cb++) = x % 10 + '0';
*(cb++) = '\n';
}
fwrite(buf, 1, cb - buf, stdout);
return 0;
}
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
string s;
int vis[104] = {0};
int main() {
int n, m;
cin >> n >> m >> s;
q.push(0);
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = 1; i <= m && p + i < n; i++)
if (s[p + i] == '1' && !vis[p + i]) {
vis[p + i] = vis[p] + 1;
q.push(p + i);
}
}
return cout << (vis[n - 1] ? vis[n - 1] : -1) << endl, 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
const int N = 55;
int n;
int f[N][N][N][N], d[N][N], a[N][N];
int tot(int x, int y, int u, int v) {
return d[u][v] - d[x - 1][v] - d[u][y - 1] + d[x - 1][y - 1];
}
int F(int x, int y, int u, int v) {
if (!tot(x, y, u, v)) return 0;
int &re = f[x][y][u][v];
if (re != -1) return re;
re = tot(x, y, u, v) > 0 ? max(u - x, v - y) + 1 : 0;
if (re == 0) return re;
for (int i = x; i <= u - 1; ++i) {
re = min(re, F(x, y, i, v) + F(i + 1, y, u, v));
}
for (int j = y; j <= v - 1; ++j) {
re = min(re, F(x, y, u, j) + F(x, j + 1, u, v));
}
return re;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
memset(f, -1, sizeof(f));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
char x;
cin >> x;
a[i][j] = (x == '#');
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
d[i][j] = d[i - 1][j] + d[i][j - 1] + a[i][j] - d[i - 1][j - 1];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
f[i][j][i][j] = a[i][j];
}
cout << F(1, 1, n, n);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
int main() {
int n, i, j, m, h;
cin >> n >> m >> h;
int front[m], left[n], top[n][m], ans[m][n];
for (i = 0; i < m; i++) {
cin >> front[i];
}
for (i = 0; i < n; i++) {
cin >> left[i];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> top[i][j];
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
int temp = min(front[j], left[i]);
if (top[i][j] == 1) {
cout << temp << " ";
} else {
cout << 0 << " ";
}
}
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> ans{1}, pr{2, 3, 5, 7, 11};
int main() {
cin >> n;
for (int p : pr) {
if (ans.size() > n) break;
for (int i = 0; i < (int)ans.size(); i++) {
if (ans[i] * p <= 2 * n * n) ans.emplace_back(ans[i] * p);
}
}
reverse(begin(ans), end(ans));
ans.resize(n);
for (int x : ans) cout << x << ' ';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int k = (n - m) / 2 + 1;
if (m == 1) {
for (int i = 0; i < n - 1; i++) {
cout << 1;
}
cout << 0;
return 0;
}
if (m == 2) {
for (int i = 0; i < n - 2; i++) {
cout << 1;
}
cout << 0;
cout << 0;
return 0;
}
string s = "10";
if (k == 1) {
s = "1";
} else {
for (int i = 2; i < k; i++) {
s += "1";
}
}
for (int i = 0; i < n; i++) {
cout << s[i % k];
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
class Debugger {
public:
Debugger(const std::string& _separator = ", ")
: first(true), separator(_separator) {}
template <typename ObjectType>
Debugger& operator,(const ObjectType& v) {
if (!first) cerr << separator;
cerr << v;
first = false;
return *this;
}
~Debugger() { cerr << "\n"; }
private:
bool first;
string separator;
};
template <typename T1, typename T2>
inline ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
bool first = true;
os << "[";
for (unsigned long long i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline ostream& operator<<(ostream& os, const set<T>& v) {
bool first = true;
os << "[";
for (typename set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const map<T1, T2>& v) {
bool first = true;
os << "[";
for (typename map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
long long xx = 1000000000, yy = 1;
set<long long> grid;
long long massiv[300000];
long long n;
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> massiv[i];
}
for (long long i = 1; i < n; i++) {
if (yy < abs(massiv[i + 1] - massiv[i])) {
yy = abs(massiv[i + 1] - massiv[i]);
}
}
for (long long i = 1; i < n; i++) {
if ((abs(massiv[i + 1] - massiv[i]) != yy &&
abs(massiv[i + 1] - massiv[i]) != 1) ||
(massiv[i] % yy == 0 && massiv[i + 1] - massiv[i] == 1 && yy != 1) ||
(massiv[i] % yy == 1 && massiv[i + 1] - massiv[i] == -1 && yy != 1)) {
cout << "NO"
<< "\n";
return 0;
}
}
cout << "YES"
<< "\n";
cout << xx << " " << yy << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
int a, b;
int p, q, r, s;
vector<pair<int, int> > u, v;
bool f;
int main() {
cin >> a >> b;
if (a > b) swap(a, b);
for (int i = 1; i < a; ++i) {
for (int j = 1; j < a; ++j) {
if (i * i + j * j == a * a) {
p = i;
q = j;
u.push_back(make_pair(p, q));
}
}
}
for (int i = -b; i < 0; ++i) {
for (int j = 1; j < b; ++j) {
if (i * i + j * j == b * b) {
r = i;
s = j;
v.push_back(make_pair(r, s));
}
}
}
for (int i = (0); i < (u.size()); ++i) {
for (int j = (0); j < (v.size()); ++j) {
if (u[i].first * v[j].first + u[i].second * v[j].second == 0 &&
u[i].second != v[j].second) {
cout << "YES" << endl;
cout << "0 0" << endl;
cout << u[i].first << " " << u[i].second << endl;
cout << v[j].first << " " << v[j].second << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string arr[505];
int dp1[505][505], cnt[505], val[505][505], dp2[505][505];
int main() {
int i, j, k;
int n, m, x;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &x);
for (i = 1; i <= n; i++) cin >> arr[i];
for (i = 0; i <= n; i++) {
for (j = 1; j <= m; j++) dp1[i][j] = 1e6;
for (j = 0; j <= x; j++) dp2[i][j] = 1e6;
}
dp2[0][0] = 0;
for (i = 1; i <= n; i++) {
if (arr[i][0] == '1') val[i][0] = 1;
for (j = 1; j < m; j++) {
if (arr[i][j] == '1')
val[i][j] = val[i][j - 1] + 1;
else
val[i][j] = val[i][j - 1];
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j < m; j++) {
for (k = j; k < m; k++) {
if (j == 0)
dp1[i][val[i][k]] = min(dp1[i][val[i][k]], k - j + 1);
else
dp1[i][val[i][k] - val[i][j - 1]] =
min(dp1[i][val[i][k] - val[i][j - 1]], k - j + 1);
}
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j <= x; j++) {
for (k = 0; k <= j; k++) {
int temp = val[i][m - 1] - (j - k);
if (temp < 0) continue;
dp2[i][j] = min(dp2[i][j], dp2[i - 1][k] + dp1[i][temp]);
}
}
}
int ans = 1e6;
for (i = 0; i <= x; i++) ans = min(ans, dp2[n][i]);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1 || n == 2) {
cout << "1" << endl;
cout << "1" << endl;
return 0;
}
if (n == 3) {
cout << "2" << endl;
cout << "1"
<< " "
<< "3" << endl;
return 0;
}
cout << n << endl;
for (int i = 2; i <= n; i += 2) {
cout << i << " ";
}
for (int i = 1; i <= n; i += 2) {
cout << i << " ";
}
cout << endl;
}
| 1 |
#define ll long long
#define lld float
#define M 202
#define f first
#define s second
#define pi 3.141592653589793238
#define vl vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define N 100002
#define Endl endl
#define maxx(a,b,c,d) max(max(a,b),max(d,c))
#define minn(a,b,c,d) min(min(a,b),min(d,c))
#define pb push_back
#define mod 1000000007
#define pp 31
#define ss(v) sort(v.begin(),v.end())
#define sr(v) sort(v.begin(),v.end(),greater<ll>())
#define rin(A, B, C) (((A)<=(B))&&((B)<=(C)))
#include <bits/stdc++.h>
using namespace std;
ll f[1001];
ll power(ll a, ll b)
{
if(!b)return 1LL;
ll aa=power(a,b/2);
if(b%2)return aa*aa%mod*a%mod;
return aa*aa%mod;
}
ll im(ll a)
{
return power(a,mod-2);
}
ll ncr(ll n,ll r)
{
return f[n]*im(f[r])%mod*im(f[n-r])%mod;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("output.txt", "w", stdout);
// freopen("input.txt", "r", stdin);
ll t;
cin>>t;
f[0]=1;
for(ll i=1;i<=1000;i++)
{
f[i] = (f[i-1]*i)%mod;
}
while(t--)
{
ll n,k;
cin>>n>>k;
map<ll,ll> m;
vl v(n);
for(ll i=0;i<n;i++)
{
cin>>v[i];
m[v[i]]++;
}
sr(v);
ll sum=0,prev=v[0];
ll num=v[k-1];
for(ll i=0;i<k;i++)
{
if(v[i]==num) sum++;
}
cout<<ncr(m[num],sum)<<endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int pre[1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n, r, p, q;
cin >> n >> r;
long long int a[1005];
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) {
p = max(1LL, i - r + 1);
pre[p] += 1;
q = min(n + 1, i + r);
pre[q] -= 1;
}
}
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + pre[i];
}
for (int i = 1; i <= n; i++) {
if (pre[i] < 1) {
cout << -1;
return 0;
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
p = max(1LL, i - r + 1);
q = min(n, i + r - 1);
long long int w = 0;
for (int j = p; j <= q; j++) {
if (pre[j] == 1) w = 1;
}
if (w == 1)
ans++;
else {
for (int j = p; j <= q; j++) pre[j] -= 1;
}
}
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500000 + 10, MAXT = MAXN * 8;
const long long LINF = 1LL << 60;
struct Seg {
int x, y, c;
bool operator<(const Seg &s1) const { return x < s1.x; }
} seg[MAXN];
int hashx[MAXT], cnt;
struct Segtree {
int l, r;
long long add, mx;
int pos;
} t[MAXT];
int val[MAXT];
void updatemx(long long &mx, int &pos, long long mx1, int pos1) {
if (mx1 > mx) {
mx = mx1;
pos = pos1;
}
}
void pushup(int p) {
t[p].mx = t[p << 1].mx;
t[p].pos = t[p << 1].pos;
updatemx(t[p].mx, t[p].pos, t[p << 1 | 1].mx, t[p << 1 | 1].pos);
}
void add_t(int p, long long d) {
t[p].add += d;
t[p].mx += d;
}
void pushdown(int p) {
if (t[p].add != 0) {
add_t(p << 1, t[p].add);
add_t(p << 1 | 1, t[p].add);
t[p].add = 0;
}
}
void buildtree(int p, int l, int r) {
t[p] = (Segtree){l, r, 0, 0, 0};
if (l == r) {
t[p].mx = (long long)val[l];
t[p].pos = l;
return;
}
int mid = (l + r) >> 1;
buildtree(p << 1, l, mid);
buildtree(p << 1 | 1, mid + 1, r);
pushup(p);
}
void change(int p, int l, int r, int ql, int qr, long long d) {
if (ql == l && qr == r) {
add_t(p, d);
return;
}
pushdown(p);
int mid = (l + r) >> 1;
if (ql <= mid) change(p << 1, l, mid, ql, min(qr, mid), d);
if (qr > mid) change(p << 1 | 1, mid + 1, r, max(ql, mid + 1), qr, d);
pushup(p);
}
long long que_mx(int p, int l, int r, int ql, int qr, int &pos) {
if (ql == l && qr == r) {
pos = t[p].pos;
return t[p].mx;
}
pushdown(p);
int mid = (l + r) >> 1;
long long res = -LINF, temp_res;
int temp_pos;
if (ql <= mid) {
temp_res = que_mx(p << 1, l, mid, ql, min(qr, mid), temp_pos);
updatemx(res, pos, temp_res, temp_pos);
}
if (qr > mid) {
temp_res = que_mx(p << 1 | 1, mid + 1, r, max(ql, mid + 1), qr, temp_pos);
updatemx(res, pos, temp_res, temp_pos);
}
pushup(p);
return res;
}
int findx(int key) {
int l = 1, r = cnt;
while (l < r) {
int mid = (l + r) >> 1;
if (hashx[mid] == key)
return mid;
else if (hashx[mid] < key)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
int main() {
int n;
scanf("%d", &n);
cnt = 0;
for (int i = 0; i < n; ++i) {
scanf("%d%d%d", &seg[i].x, &seg[i].y, &seg[i].c);
if (seg[i].x > seg[i].y) swap(seg[i].x, seg[i].y);
hashx[++cnt] = seg[i].x;
hashx[++cnt] = seg[i].y;
}
sort(hashx + 1, hashx + 1 + cnt);
cnt = 1;
for (int i = 2; i <= n * 2; ++i) {
if (hashx[i] != hashx[i - 1]) {
hashx[++cnt] = hashx[i];
}
}
for (int i = 0; i < n; ++i) {
seg[i].x = findx(seg[i].x);
seg[i].y = findx(seg[i].y);
}
sort(seg, seg + n);
memset(val, 0, sizeof(0));
for (int i = 1; i <= cnt; ++i) val[i] = hashx[1] - hashx[i];
buildtree(1, 1, cnt);
for (int i = 0; i < n; ++i)
change(1, 1, cnt, seg[i].y, cnt, (long long)seg[i].c);
long long ans = -LINF;
int ansl = -1, ansr = -1;
int pos = 0;
for (int l = 1; l <= cnt; ++l) {
int temp_pos;
long long que =
que_mx(1, 1, cnt, l, cnt, temp_pos) + (long long)(hashx[l] - hashx[1]);
if (que > ans) {
ans = que;
ansl = hashx[l];
ansr = hashx[temp_pos];
}
while (pos < n && seg[pos].x == l) {
change(1, 1, cnt, seg[pos].y, cnt, (long long)-seg[pos].c);
++pos;
}
}
if (ans < 0) {
ans = 0;
ansl = ansr = hashx[cnt] + 1;
}
cout << ans << endl;
cout << ansl << " " << ansl << " " << ansr << " " << ansr << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> a, b;
vector<int> ans;
int next(int x, map<int, int> &m) {
map<int, int>::iterator i = m.upper_bound(x);
if (i == m.end()) i = m.begin();
return i->first;
}
int prev(int x, map<int, int> &m) {
map<int, int>::iterator i = m.lower_bound(x);
if (i == m.begin()) i = m.end();
i--;
return i->first;
}
int main() {
ios::sync_with_stdio(0);
int n, m, tmp;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> tmp;
a[tmp]++;
}
for (int j = 0; j < n; ++j) {
cin >> tmp;
b[tmp]++;
}
int ai = a.begin()->first, bi = b.begin()->first;
while (n--) {
while (1) {
int aa = ai, bb = bi;
while ((((ai) + (bi)) % m) < (((prev(ai, a)) + (bi)) % m))
ai = prev(ai, a);
while ((((ai) + (bi)) % m) < (((next(ai, a)) + (bi)) % m))
ai = next(ai, a);
while ((((ai) + (prev(bi, b))) % m) > (((ai) + (bi)) % m))
bi = prev(bi, b);
while ((((ai) + (next(bi, b))) % m) > (((ai) + (bi)) % m))
bi = next(bi, b);
if (aa == ai and bb == bi) break;
}
ans.push_back((((ai) + (bi)) % m));
if (a[ai] > 1)
a[ai]--;
else {
int cp = ai;
ai = next(ai, a);
a.erase(cp);
}
if (b[bi] > 1)
b[bi]--;
else {
int cp = bi;
bi = prev(bi, b);
b.erase(cp);
}
}
sort(ans.begin(), ans.end(), greater<int>());
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
pair<int, int> query(int x, int y, int k, int m) {
if (x < 1 || y < 1 || m < 1 || k < 1) return make_pair(0, 0);
if (k <= max(x, y)) {
int a = min(k, min(x, y));
int b = min(k, m);
return make_pair((1LL * a * b) % MOD,
(1LL * a * ((1LL * b * (b + 1) / 2) % MOD)) % MOD);
} else if (k > 1) {
pair<int, int> q1 = query(x, y, k / 2, m),
q2 = query(x - k / 2, y, k / 2, m - k / 2),
q3 = query(x, y - k / 2, k / 2, m - k / 2),
q4 = query(x - k / 2, y - k / 2, k / 2, m);
return make_pair((0LL + q1.first + q2.first + q3.first + q4.first) % MOD,
(0LL + q1.second + q2.second + q3.second + q4.second +
1LL * (q2.first + q3.first) * (k / 2)) %
MOD);
}
return make_pair(0, 0);
}
int main(void) {
int q;
cin >> q;
while (q--) {
int x1, y1, x2, y2, m;
cin >> x1 >> y1 >> x2 >> y2 >> m;
int k = 1;
while (k <= max(x2, y2)) k *= 2;
cout << (2LL * MOD + query(x2, y2, k, m).second -
query(x1 - 1, y2, k, m).second - query(x2, y1 - 1, k, m).second +
query(x1 - 1, y1 - 1, k, m).second) %
MOD
<< "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long a[100010];
int main() {
int i, j;
cin >> n >> m >> k;
for (i = 1; i <= m; i++) {
cin >> a[i];
}
long long ans = 1, delta = 0, tmp = 1;
long long page = a[1] / k + (a[1] % k != 0);
for (i = 2; i < m; i++) {
if ((a[i] - delta) / k + ((a[i] - delta) % k != 0) != page) {
delta = tmp;
tmp++;
ans++;
page = (a[i] - delta) / k + ((a[i] - delta) % k != 0);
} else {
tmp++;
}
}
if (((a[m] - delta) / k + ((a[m] - delta) % k != 0)) != page) ans++;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct Point {
double x, y;
} data[maxn];
bool cmp(Point &a, Point &b) {
if (a.x == b.x) return a.y > b.y;
return a.x > b.x;
}
bool ccw(Point &a, Point &b, Point &c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x) < 0;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> data[i].x >> data[i].y;
data[i].y = data[i].y - data[i].x * data[i].x;
}
sort(data + 1, data + n + 1, cmp);
vector<Point> res(data + 1, data + 2);
for (int i = 2; i <= n; i++) {
if (data[i].x == res.back().x) continue;
for (int j = res.size() - 2; j >= 0 && !ccw(res[j + 1], res[j], data[i]);
j--) {
res.pop_back();
}
res.push_back(data[i]);
}
cout << res.size() - 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(){
# ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
# endif
int tt;cin>>tt;
while(tt--){
int n;
cin>>n;
for(int i = 1;i<=n;i++){
if(i==n){
cout << 1 <<"\n";
}else{
cout << i+1<<" ";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int inf_int = 2e9;
long long inf_ll = 2e18;
const double pi = 3.1415926535898;
template <typename T, typename T1>
void prin(vector<pair<T, T1> >& a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i].first << " " << a[i].second << "\n";
}
}
template <typename T>
void prin(vector<T>& a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i];
if (i < a.size() - 1)
cout << " ";
else
cout << "\n";
}
}
template <typename T>
void prin(set<T>& a) {
for (auto it = a.begin(); it != a.end(); it++) {
cout << *it << " ";
}
}
template <typename T>
void prin_new_line(vector<T>& a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i] << "\n";
}
}
template <typename T, typename T1>
void prin_new_line(vector<pair<T, T1> >& a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i].first << " " << a[i].second << "\n";
}
}
int sum_vec(vector<int>& a) {
int s = 0;
for (int i = 0; i < a.size(); i++) {
s += a[i];
}
return s;
}
template <typename T>
T max(vector<T>& a) {
T ans = a[0];
for (int i = 1; i < a.size(); i++) {
ans = max(ans, a[i]);
}
return ans;
}
template <typename T>
T min(vector<T>& a) {
T ans = a[0];
for (int i = 1; i < a.size(); i++) {
ans = min(ans, a[i]);
}
return ans;
}
template <typename T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <typename T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
double s_triangle(double x1, double y1, double x2, double y2, double x3,
double y3) {
return abs(((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2);
}
bool overflow(long long a, long long b) {
if (a * b / b != a) return true;
return false;
}
bool debug = 0;
const int maxn = 2e5 + 70;
set<int> s[maxn];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (y == 0) {
int ans = 0;
for (int e = 1; e * e <= x; e++) {
if (x % e == 0) {
if (x / e == e) {
s[e].insert(i);
ans++;
} else {
s[e].insert(i);
s[x / e].insert(i);
ans = ans + 2;
}
}
}
cout << ans << "\n";
} else {
int ans = 0;
for (int e = 1; e * e <= x; e++) {
if (x % e == 0) {
if (x / e == e) {
if (s[e].lower_bound(i - y) == s[e].end()) {
ans++;
}
s[e].insert(i);
} else {
if (s[e].lower_bound(i - y) == s[e].end()) {
ans++;
}
if (s[x / e].lower_bound(i - y) == s[x / e].end()) {
ans++;
}
s[e].insert(i);
s[x / e].insert(i);
}
}
}
cout << ans << "\n";
}
}
}
int main() {
if (!debug) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int pt(int a, int b, int c) {
printf("3 %d %d %d\n", a, b, c);
printf("3 %d %d %d\n", a, b, c);
}
int pt(int a, int b, int c, int d) {
printf("4 %d %d %d %d\n", a, b, c, d);
printf("4 %d %d %d %d\n", a, b, c, d);
}
int main() {
scanf("%d", &n);
if (n & 1) {
printf("%d\n", (n / 2) * (n / 2 - 1) + n - 1);
for (int i = 2; i <= n; i += 2)
for (int j = i + 2; j <= n; j += 2) pt(i, j, i + 1, j + 1);
for (int i = 2; i <= n; i += 2) pt(1, i, i + 1);
} else {
printf("%d\n", (n / 2 - 1) * (n / 2 + 1));
for (int i = 3; i <= n; i += 2)
for (int j = i + 2; j <= n; j += 2) pt(i, j, i + 1, j + 1);
printf("4 1 3 2 4\n4 1 2 3 4\n4 2 1 3 4\n");
for (int i = 5; i <= n; i += 2)
printf("3 %d %d %d\n", 1, i, i + 1), printf("3 %d %d %d\n", 2, i, i + 1),
printf("4 %d %d %d %d\n", 1, i, 2, i + 1);
}
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
const long long N = 1e6 + 5;
long long mod = 1e9 + 7;
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long pow1(long long n, long long p) {
if (p == 0) return 1;
long long x = pow1(n, p / 2);
x = (x * x) % mod;
if (p % 2 == 0)
return x;
else
return (x * n) % mod;
}
long long binarySearch(long long arr[], long long l, long long r, long long x) {
if (r >= l) {
long long mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
bool compare(const pair<long long, long long> &p1,
const pair<long long, long long> &p2) {
if (p1.first < p2.first) return true;
if (p1.first == p2.first) return p1.second < p2.second;
return false;
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long isPrime(long long n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long C(long long n, long long r) {
if (r > n - r) r = n - r;
long long ans = 1;
for (long long i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % mod;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % mod;
res %= mod;
}
return res;
}
long long modinv(long long k) { return pow1(k, mod - 2); }
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long d, m;
cin >> d >> m;
mod = m;
long long prod = 1;
if (m == 1)
cout << 0 << "\n";
else {
for (long long i = 0; i < 31; i++) {
if (d < (1LL << i)) break;
long long diff = (d < (1LL << (i + 1)) - 1 ? d : (1LL << (i + 1)) - 1) -
(1LL << i) + 2;
diff %= m;
prod *= diff;
prod %= m;
}
if (prod - 1 < 0) prod += m;
cout << prod - 1 << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n;
long long t;
long long a[200005];
int x[200005];
long long b[200005];
int pre[200005];
int pref[200005];
int main() {
scanf("%d%I64d", &n, &t);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
if (x[i] < i) {
printf("No\n");
return 0;
}
pre[i]++;
pre[x[i]]--;
}
for (int i = 1; i <= n; i++) {
pre[i] += pre[i - 1];
if (pre[i]) {
b[i] = a[i + 1] + t;
} else {
b[i] = a[i] + t;
}
}
for (int i = 1; i < n; i++) {
if (b[i] >= b[i + 1]) b[i + 1] = b[i] + 1;
}
for (int i = 2; i <= n; i++) {
pref[i] = pref[i - 1];
if (a[i] + t <= b[i - 1]) pref[i]++;
}
for (int i = 1; i <= n; i++) {
if (x[i] < n && pref[x[i] + 1] - pref[i] == x[i] + 1 - i) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
for (int i = 1; i <= n; i++) printf("%I64d ", b[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
if (p1 == p2) return EOF;
}
return *p1++;
}
inline int getint() {
int x;
char c = nc(), b = 1;
if (c == -1) return 0;
for (; !(c >= '0' && c <= '9'); c = nc())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= b;
return x;
}
int n, m, p;
int a[505050], s[505050];
int f[505050][111];
const int INF = 1e9;
int fnk_1[505050], fnk_2[505050];
void init() {
for (int r = 1; r <= p; r++) fnk_1[r] = INF, fnk_2[r] = INF;
}
void update(int x, int y) {
for (int r = x + 1; r <= p; r += r & -r) {
if (fnk_1[r] > y)
fnk_1[r] = y;
else
break;
}
for (int r = p - x; r <= p; r += r & -r) {
if (fnk_2[r] > y)
fnk_2[r] = y;
else
break;
}
}
int min_le(int x) {
int rlt = INF;
for (int r = x + 1; r; r -= r & -r) rlt = min(rlt, fnk_1[r]);
return rlt;
}
int min_ri(int x) {
int rlt = INF;
for (int r = p - x; r; r -= r & -r) rlt = min(rlt, fnk_2[r]);
return rlt;
}
int main() {
scanf("%d %d %d", &n, &m, &p);
for (int i = 1; i <= n; i++)
a[i] = getint(), a[i] %= p, s[i] = (s[i - 1] + a[i]) % p;
for (int i = 0; i < 505050; i++)
for (int j = 0; j < 111; j++) f[i][j] = INF;
f[0][0] = 0;
for (int i = 1; i <= n; i++) f[i][1] = 0;
for (int k = 2; k <= m; k++) {
init();
update(s[k - 1], f[k - 1][k - 1]);
for (int i = k; i <= n; i++) {
f[i][k] = min(min_le(s[i]), min_ri(s[i] + 1) + 1);
update(s[i], f[i][k - 1]);
}
}
printf("%d\n", s[n] + p * f[n][m]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int b[N], lv[N], ans[N], a[N], p[N][20], in[N], out[N], n, m, k;
int c[N][4], need[N], L[N], R[N], s[N];
vector<int> g[N], v[N];
queue<int> q[N];
int get(int x) {
int ans = 0;
while (x) {
ans += b[x];
x -= x & -x;
}
return ans;
}
void add(int x, int v) {
while (x <= n) {
b[x] += v;
x += x & -x;
}
}
void DFS(int x) {
static int top = 0;
in[x] = ++top;
lv[x] = lv[p[x][0]] + 1;
for (auto y : v[x])
if (y != p[x][0]) {
p[y][0] = x;
DFS(y);
}
out[x] = top;
}
int LCA(int x, int y) {
if (lv[x] < lv[y]) swap(x, y);
for (int i = 0, v = lv[x] - lv[y]; v; i++, v >>= 1)
if (v & 1) x = p[x][i];
if (x == y) return x;
for (int i = int(log2(lv[x])); i >= 0; i--)
if (p[x][i] != p[y][i]) x = p[x][i], y = p[y][i];
return p[x][0];
}
void prepare() {
scanf("%d%d%d", &n, &m, &k);
for (auto i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
DFS(1);
for (auto lv = 1; lv <= 18; lv++)
for (auto i = 1; i <= n; i++) p[i][lv] = p[p[i][lv - 1]][lv - 1];
for (auto i = 1; i <= m; i++) scanf("%d", a + i);
for (auto i = 1; i <= k; i++) {
scanf("%d%d%d", c[i], c[i] + 1, need + i);
c[i][2] = LCA(c[i][0], c[i][1]);
c[i][3] = p[c[i][2]][0];
}
}
void sweep(int phase) {
memset(b, 0, sizeof(b));
for (auto i = 1; i <= m; i++) {
add(in[a[i]], 1);
add(out[a[i]] + 1, -1);
while (!q[i].empty()) {
int idx = q[i].front();
q[i].pop();
int tmp[4];
for (auto i = 0; i <= 3; i++) tmp[i] = get(in[c[idx][i]]);
if (tmp[0] + tmp[1] - tmp[2] - tmp[3] >= phase)
R[idx] = i - 1;
else
L[idx] = i + 1;
}
}
}
void solve() {
for (auto phase = 1; phase <= 10; phase++) {
int top = 0;
for (auto i = 1; i <= k; i++)
if (!ans[i]) {
s[++top] = i;
L[i] = 1, R[i] = m;
}
while (top) {
for (auto j = top; j >= 1; j--) {
int i = s[j];
if (L[i] <= R[i]) {
int mid = (L[i] + R[i]) >> 1;
q[mid].push(i);
} else {
if (L[i] <= m) g[i].push_back(L[i]);
if (L[i] > m || need[i] == phase) ans[i] = 1;
swap(s[j], s[top--]);
}
}
sweep(phase);
}
}
for (auto i = 1; i <= k; i++) {
printf("%d ", int(g[i].size()));
for (auto x : g[i]) printf("%d ", x);
printf("\n");
}
}
int main() {
prepare();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long t, a, b;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long bcnn(long long a, long long b) { return a * b / gcd(a, b); }
long long calc() {
long long d = gcd(a, b);
long long tmp = a / d;
if (t / tmp < b) {
return min(t, min(a, b) - 1);
}
long long hang = tmp * b;
long long mod = t % hang;
long long g = t / hang;
long long base = min(a, b);
return base * g + min(base - 1, mod);
}
int main(int argc, const char* argv[]) {
if (0) freopen("../../input.txt", "r", stdin);
cin >> t >> a >> b;
long long tuso = calc();
long long mauso = t;
long long d = gcd(tuso, mauso);
tuso /= d;
mauso /= d;
cout << tuso << "/" << mauso << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct beacon {
long long x, p;
};
bool compare(beacon b1, beacon b2) { return b1.x < b2.x; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, cur;
cin >> n;
beacon a[n];
long long d[n], total[n];
for (i = 0; i < n; i++) {
cin >> a[i].x >> a[i].p;
}
sort(a, a + n, compare);
for (i = 0; i < n; i++) d[i] = a[i].x;
for (i = 0; i < n; i++) {
cur = i;
if (d[cur] - a[cur].p <= a[0].x) {
total[cur] = cur;
} else {
long long pos = lower_bound(d, d + n, d[cur] - a[cur].p) - d;
total[cur] = (cur - pos);
if (pos >= 1) total[cur] += (total[pos - 1]);
}
}
long long ans = n;
for (i = 1; i <= n; i++) {
ans = min(ans, (n - i) + total[i - 1]);
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
string s, t;
while (cin >> s >> t) {
vector<int> ind;
for (int i = 0; i < ((int)(s).size()); ++i)
if (s[i] != t[i]) ind.push_back(i);
if (((int)(ind).size()) & 1) {
cout << "impossible\n";
continue;
}
string r = s;
for (int i = 0; i < ((int)(ind).size()); ++i)
if (i & 1)
r[ind[i]] = s[ind[i]];
else
r[ind[i]] = t[ind[i]];
cout << r << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long multiply(unsigned long long n) {
unsigned long long minm = 9, maxm = 0;
while (n > 0) {
minm = min(minm, n % 10);
maxm = max(maxm, n % 10);
n /= 10;
}
return minm * maxm;
}
int main() {
int t;
cin >> t;
while (t--) {
unsigned long long a, n;
cin >> a >> n;
for (int i = 2; i <= n; i++) {
unsigned long long addMinMaxDigits = multiply(a);
if (addMinMaxDigits == 0) {
break;
} else
a += addMinMaxDigits;
}
cout << a << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long P;
long long inv[500005], s[500005];
int n, m;
int len[2], cnt[2];
void add(long long &x, long long y) {
x += y;
if (x >= P) x -= P;
if (x < 0) x += P;
}
void init() {
inv[0] = inv[1] = 1;
for (int i = 2; i <= n + m; i++) inv[i] = (P - P / i) * inv[P % i] % P;
for (int i = 1; i <= n + m; i++) s[i] = (s[i - 1] + inv[i]) % P;
}
long long calc(long long l1, long long l2) {
long long ans = l1 * l2 % P * inv[2] % P;
for (int i = 1; i <= l1; i++) add(ans, P - (s[i + l2] - s[i]) % P);
return ans;
}
long long sum(long long x) { return x * (x - 1) / 2 % P; }
void dfs(int l, int r, int h) {
if (h <= 1 || l == r) {
if (!len[0] || r - l + 1 == len[0])
len[0] = r - l + 1, cnt[0]++;
else if (!len[1] || r - l + 1 == len[1])
len[1] = r - l + 1, cnt[1]++;
return;
}
int mid = (l + r) >> 1;
dfs(l, mid, h - 1), dfs(mid + 1, r, h - 1);
}
int main() {
cin >> n >> m >> P;
init();
dfs(1, n, m);
long long ans = 0;
for (int i = 0; i <= 1; i++) {
add(ans, sum(len[i]) * inv[2] % P * cnt[i] % P);
add(ans, sum(cnt[i]) * calc(len[i], len[i]) % P);
}
add(ans, cnt[0] * cnt[1] % P * calc(len[0], len[1]) % P);
cout << ans << endl;
return 0;
}
| 12 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.