solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k = 0;
cin >> n >> m;
if (n % 2 == 0) {
int x = n / 2;
for (int i = 0; i < n; i++) {
if (x % m == 0 && x <= n) {
cout << x;
k = 1;
break;
}
x = x + 1;
}
}
if (n % 2 != 0) {
int x = n / 2 + 1;
for (int i = 0; i < n; i++) {
if (x % m == 0 && x <= n) {
cout << x;
k = 1;
break;
}
x = x + 1;
}
}
if (k == 0) cout << "-1";
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
inline int read() {
int r = 0, f = 1;
char ch = getchar();
while (ch < 48) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch > 47) r = r * 10 + (ch ^ 48), ch = getchar();
return r * f;
}
inline int max(const int &a, const int &b) { return a > b ? a : b; }
inline int min(const int &a, const int &b) { return a > b ? b : a; }
const int maxn = 3086;
int n, cnt;
struct EDge {
int to;
int next;
} e[maxn << 1];
int head[maxn];
void add(int a, int b) {
e[++cnt].to = b;
e[cnt].next = head[a];
head[a] = cnt;
}
int siz[maxn], fa[maxn], dep[maxn], arr[maxn];
int dfn[maxn], top[maxn], son[maxn], num;
void dfs1(int u) {
siz[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (siz[v]) continue;
dep[v] = dep[u] + 1;
fa[v] = u;
dfs1(v), siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int t) {
dfn[u] = ++num, arr[num] = u;
top[u] = t;
if (son[u]) dfs2(son[u], t);
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v != fa[u] && v != son[u]) dfs2(v, v);
}
}
inline int Lca(int a, int b) {
while (top[a] != top[b]) {
if (dep[top[a]] > dep[top[b]])
a = fa[top[a]];
else
b = fa[top[b]];
}
return dep[a] > dep[b] ? b : a;
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[Lca(x, y)]; }
long long dp[maxn][maxn];
bool vis[maxn][maxn];
queue<int> qx, qy;
int fak(int u, int k) {
int tar = dep[u] - k;
while (dep[top[u]] > tar) u = fa[top[u]];
return arr[dfn[u] - dep[u] + tar];
}
int calc(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
if (dfn[u] >= dfn[v] && dfn[u] < dfn[v] + siz[v])
return siz[u] * (n - siz[fak(u, dep[u] - dep[v] - 1)]);
else
return siz[u] * siz[v];
}
void work() {
n = read();
for (int i = 1; i < n; ++i) {
int x = read(), y = read();
add(x, y), add(y, x);
}
dfs1(1), dfs2(1, 1);
for (int i = 1; i <= n; ++i) {
vis[i][i] = 1;
qx.push(i), qy.push(i);
}
while (!qx.empty()) {
int x = qx.front();
qx.pop();
int y = qy.front();
qy.pop();
int now = dis(x, y);
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (dis(v, y) != now + 1) continue;
long long maxd = dp[x][y] + calc(v, y);
dp[v][y] = max(dp[v][y], maxd);
dp[y][v] = max(dp[y][v], maxd);
if (!vis[y][v]) {
vis[y][v] = vis[v][y] = 1;
qx.push(v);
qy.push(y);
}
}
for (int i = head[y]; i; i = e[i].next) {
int v = e[i].to;
if (dis(x, v) != now + 1) continue;
long long maxd = dp[x][y] + calc(x, v);
dp[x][v] = max(dp[x][v], maxd);
dp[v][x] = max(dp[v][x], maxd);
if (!vis[x][v]) {
vis[x][v] = vis[v][x] = 1;
qx.push(x);
qy.push(v);
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) ans = max(ans, dp[i][j]);
printf("%lld\n", ans);
}
signed main() { work(); }
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long grid[200][200];
int main() {
long long n, m, k, x, y;
cin >> n >> m >> k >> x >> y;
x--;
y--;
if (n == 1) {
long long per = m;
long long iters = k / per;
k %= per;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (k > 0) grid[i][j]++;
k--;
}
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
grid[i][j] += iters;
}
}
} else {
long long per = m * (n + n - 2);
long long iters = k / per;
k %= per;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (k > 0) grid[i][j]++;
k--;
}
}
for (int i = n - 2; i >= 1; i--) {
for (int j = (0); j < (m); j++) {
if (k > 0) grid[i][j]++;
k--;
}
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (i == 0 || i == n - 1)
grid[i][j] += iters;
else
grid[i][j] += 2 * iters;
}
}
}
long long min_ans = grid[0][0];
long long max_ans = grid[0][0];
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
min_ans = min(min_ans, grid[i][j]);
max_ans = max(max_ans, grid[i][j]);
}
}
cout << max_ans << " " << min_ans << " " << grid[x][y] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
cin.sync_with_stdio(false);
cout << setprecision(16);
string input, m[10], output;
int i, idx = 0, j;
cin >> input;
for (i = 0; i < (int)(10); i++) cin >> m[i];
while (idx != input.length()) {
for (i = 0; i < (int)(10); i++) {
bool good = true;
for (j = 0; j < (int)(m[i].length()); j++)
if (m[i][j] != input[idx + j]) {
good = false;
break;
}
if (good) {
output += (char)('0' + i);
idx += m[i].length();
}
}
}
cout << output << endl;
cout.flush();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int N = 2020;
struct trie {
trie *c[26];
int cnt;
} * root, *nil;
string s1, s2, s3;
int n, l, r, f[N][N], ans;
trie *new_node() {
trie *node = new (trie);
for (int i = 0; i < 26; i++) node->c[i] = nil;
node->cnt = 0;
return node;
}
void add(string s) {
trie *path;
path = root;
for (int i = 0; i < (int)s.size(); i++) {
int q = s[i] - 'a';
if (path->c[q] == nil) {
trie *nw = new_node();
path->c[q] = nw;
}
path = path->c[q];
if (i == s.size() - 1) path->cnt++;
}
}
int go(string s) {
int res = 0;
trie *path = root;
for (int i = 0; i < (int)s.size(); i++) {
int q = s[i] - 'a';
if (path->c[q] == nil) return 0;
path = path->c[q];
if (i == s.size() - 1) res += path->cnt;
}
return res;
}
void deleteTree(trie *root) {
for (int i = 0; i < 26; i++)
if (root->c[i] != nil) {
deleteTree(root->c[i]);
delete (root->c[i]);
}
}
int main() {
getline(cin, s1);
scanf("%d\n", &n);
nil = new (trie);
root = new_node();
for (int i = 1; i <= n; i++) {
deleteTree(root);
root = new_node();
cin >> s2 >> l >> r;
for (int u = 0; u < s2.size(); u++) {
s3 = "";
for (int v = u; v < s2.size(); v++) {
s3 += s2[v];
add(s3);
}
}
for (int u = 0; u < s1.size(); u++) {
s3 = "";
for (int v = u; v < s1.size(); v++) {
s3 += s1[v];
int q = go(s3);
if (q >= l && q <= r) f[u][v]++;
}
}
}
root = new_node();
for (int i = 0; i < s1.size(); i++) {
trie *path = root;
for (int j = i; j < s1.size(); j++) {
int q = s1[j] - 'a';
if (path->c[q] == nil) {
trie *nw = new_node();
path->c[q] = nw;
}
path = path->c[q];
if (f[i][j] == n && path->cnt == 0) ans++;
path->cnt++;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
printf("%d\n", n);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, m, a[401], f[1 << 15][71], g[1 << 15], fa[10001], in[1001],
c[201][201];
long long peach[1 << 15], ans = 1, hd = 0;
vector<long long> vec[101], Vec;
long long g_fa(long long x) {
if (fa[x] == x)
return x;
else
return g_fa(fa[x]);
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(1 + a, 1 + a + n);
for (long long i = 1; i <= n; i++) fa[i] = i;
for (long long i = 1; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
if (a[j] % a[i] == 0) {
long long t1 = g_fa(i), t2 = g_fa(j);
in[j]++;
if (t1 != t2) fa[t2] = t1;
}
}
}
c[0][0] = c[0][1] = c[1][1] = 1;
for (long long i = 2; i <= 2 * n; i++) {
c[0][i] = 1;
for (long long j = 1; j <= i; j++)
c[j][i] = (c[j - 1][i - 1] + c[j][i - 1]) % mod;
}
for (long long i = 1; i <= n; i++) {
vec[g_fa(i)].push_back(i);
}
for (long long i = 1; i <= n; i++) {
if (vec[i].size() > 1) {
Vec.clear();
for (long long j = 0; j < vec[i].size(); j++) {
if (in[vec[i][j]] == 0) Vec.push_back(vec[i][j]);
}
long long N = 1 << Vec.size(), cnt = 0;
memset(g, 0, sizeof g), memset(f, 0, sizeof f);
for (long long j = 0; j < vec[i].size(); j++) {
if (in[vec[i][j]]) {
cnt++;
for (long long k = 0; k < Vec.size(); k++) {
if (a[vec[i][j]] % a[Vec[k]] == 0) peach[vec[i][j]] |= 1 << k;
}
g[peach[vec[i][j]]]++;
}
}
for (long long j = 0; j < Vec.size(); j++) {
for (long long k = 0; k < N; k++) {
if (k >> j & 1) g[k] += g[k - (1 << j)];
}
}
f[0][0] = 1;
for (long long j = 0; j < N; j++) {
for (long long k = 0; k <= cnt; k++) {
if (f[j][k]) {
if (k < g[j])
f[j][k + 1] = (f[j][k + 1] + f[j][k] * (g[j] - k) % mod) % mod;
for (long long p : vec[i]) {
if (in[p] && ((peach[p] & j) != peach[p]) &&
((peach[p] & j) || j == 0)) {
f[j | peach[p]][k + 1] =
(f[j | peach[p]][k + 1] + f[j][k]) % mod;
}
}
}
}
}
ans = ans * f[N - 1][cnt] % mod * c[cnt - 1][hd + cnt - 1] % mod;
hd += cnt - 1;
}
}
cout << ans;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int maxn = 505, maxm = 1005;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long powermod(long long a, long long b, long long c) {
a = a % c;
long long ans = 1;
while (b) {
if (b % 2) ans = (ans * a) % c;
b = b / 2;
a = (a * a) % c;
}
return ans;
}
int main() {
long long T;
scanf("%lld", &T);
while (T--) {
long long n, k, i, j;
long long a1, a2, b1, b2;
scanf("%lld%lld", &n, &k);
scanf("%lld%lld", &a1, &a2);
scanf("%lld%lld", &b1, &b2);
if ((min(a2, b2) - max(a1, b1)) * n >= k) {
printf("0\n");
continue;
}
long long x = max((long long)0, (min(a2, b2) - max(a1, b1)) * n);
k = k - x;
long long ans = 1e15;
long long now, cnt, need;
long long part1, part2, part3;
if (min(a2, b2) < max(a1, b1)) {
part1 = max(a1, b1) - min(a2, b2);
part2 = max(a2, b2) - min(a1, b1);
} else {
part1 = 0;
part2 = abs(a1 - b1) + abs(a2 - b2);
}
for (i = 0; i < n; i++) {
now = i * part2;
cnt = i * (part1 + part2);
need = k - now;
if (need <= 0) {
ans = min(ans, cnt);
} else {
if (need <= part2) {
cnt = cnt + part1 + need;
} else {
cnt = cnt + part1 + part2 + 2 * (need - part2);
}
ans = min(ans, cnt);
}
}
printf("%lld\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int a[150][150], b[150][150], c[150][150];
int main() {
int n, m, x;
cin >> n >> m >> x;
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
for (int j = 0; j < m; j++) {
cin >> a[i][j] >> b[i][j] >> c[i][j];
}
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (i != j) {
int cur = 0;
vector<pair<int, int> > v;
for (int k = 0; k < m; k++) {
v.push_back(make_pair(b[j][k] - a[i][k], c[i][k]));
}
sort(v.begin(), v.end(), cmp);
int tmp = x;
for (int k = 0; k < m; k++) {
int val = v[k].first, ct = v[k].second;
if (val > 0) {
ct = min(ct, tmp);
cur += val * ct;
tmp -= ct;
}
if (!tmp) break;
}
ans = max(ans, cur);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
const int INF = 1.05e9;
int n, m;
pair<pair<int, int>, int> range[200005];
pair<pair<int, int>, pair<int, int> > ad[200005];
pair<int, int> Rmax[200005];
pair<long long int, pair<int, int> > ans;
void solve1() {
sort(range, range + n);
Rmax[0] = make_pair(-INF, -1);
for (int i = 0; i < (n); ++i) {
Rmax[i + 1] =
max(Rmax[i], make_pair(range[i].first.second, range[i].second));
}
for (int i = 0; i < (m); ++i) {
int a = ad[i].first.first, b = ad[i].first.second, c = ad[i].second.first,
id = ad[i].second.second;
int p =
lower_bound(range, range + n, make_pair(make_pair(a + 1, -INF), 0)) -
range;
chmax(ans, make_pair((min(b, Rmax[p].first) - a) * (long long int)c,
make_pair(Rmax[p].second, id)));
}
}
pair<pair<int, int>, pair<int, int> > event[400005];
bool cmp(const pair<pair<int, int>, pair<int, int> >& a,
const pair<pair<int, int>, pair<int, int> >& b) {
return make_pair(a.first.second, a.second.first) <
make_pair(b.first.second, b.second.first);
}
struct handler {
struct node {
pair<int, int> val;
node(pair<int, int> val = make_pair(0, 0)) : val(val) {}
};
handler() {}
static node def_node() { return node(make_pair(-INF, -INF)); }
static node merge(const node& a, const node& b) {
return node(max(a.val, b.val));
}
};
template <class Handler>
struct segtree {
static const int MAX_N = 1100000;
typename Handler::node val[MAX_N];
int n;
Handler hdl;
void init(int n_, typename Handler::node* a = NULL) {
n = 1;
while (n < n_) n <<= 1;
for (int i = 0; i < (n * 2); ++i) val[i] = hdl.def_node();
if (a != NULL) {
for (int i = 0; i < (n_); ++i) val[i + n - 1] = a[i];
for (int i = n - 2; i >= 0; --i)
val[i] = hdl.merge(val[i * 2 + 1], val[i * 2 + 2]);
}
}
void set(int k, typename Handler::node a) {
k += n - 1;
val[k] = a;
while (k > 0) {
k = (k - 1) / 2;
val[k] = hdl.merge(val[k * 2 + 1], val[k * 2 + 2]);
}
}
typename Handler::node query(int a, int b, int i, int l, int r) {
if (a <= l && r <= b) return val[i];
if (b <= l || r <= a) return hdl.def_node();
int md = (l + r) >> 1;
return hdl.merge(query(a, b, i * 2 + 1, l, md),
query(a, b, i * 2 + 2, md, r));
}
typename Handler::node query(int a, int b) { return query(a, b, 0, 0, n); }
};
segtree<handler> seg;
int xzip[400005];
void solve2() {
for (int i = 0; i < (n); ++i)
event[i] = make_pair(range[i].first, make_pair(-1, range[i].second));
for (int i = 0; i < (m); ++i) event[i + n] = ad[i];
int cnt = n + m;
sort(event, event + cnt, cmp);
for (int i = 0; i < (cnt); ++i) xzip[i] = event[i].first.first;
sort(xzip, xzip + cnt);
int zn = unique(xzip, xzip + cnt) - xzip;
seg.init(zn);
for (int i = 0; i < (cnt); ++i) {
pair<pair<int, int>, pair<int, int> >& e = event[i];
int p = lower_bound(xzip, xzip + zn, e.first.first) - xzip;
if (e.second.first == -1) {
seg.set(p, make_pair(e.first.second - e.first.first, e.second.second));
} else {
int p2 = lower_bound(xzip, xzip + zn, e.first.second) - xzip;
pair<int, int> tmp = seg.query(p, p2).val;
long long int val = tmp.first;
val *= e.second.first;
chmax(ans, make_pair(val, make_pair(tmp.second, e.second.second)));
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < (n); ++i) {
scanf("%d%d", &range[i].first.first, &range[i].first.second);
range[i].second = i;
}
for (int i = 0; i < (m); ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
ad[i] = make_pair(make_pair(a, b), make_pair(c, i));
}
solve2();
;
;
solve1();
for (int i = 0; i < (n); ++i) {
swap(range[i].first.first, range[i].first.second);
range[i].first.first *= -1;
range[i].first.second *= -1;
}
for (int i = 0; i < (m); ++i) {
swap(ad[i].first.first, ad[i].first.second);
ad[i].first.first *= -1;
ad[i].first.second *= -1;
};
;
solve1();
cout << ans.first << endl;
if (ans.first == 0) return 0;
cout << ans.second.first + 1 << ' ' << ans.second.second + 1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int imax = 1e9 + 7;
const long long lmax = 1e18;
vector<long long> v1, v2;
long long calc(long long arival, long long k, long long tb) {
int pos = lower_bound(v2.begin(), v2.end(), arival) - v2.begin();
pos += k;
if (pos >= v2.size()) return -1;
return v2[pos] + tb;
}
int calc() {
long long n, m, ta, tb, k, ans = 0, val;
cin >> n >> m >> ta >> tb >> k;
v1.resize(n);
v2.resize(m);
int i;
for (i = 0; i < ((int)v1.size()); ++i) {
cin >> v1[i];
v1[i] += ta;
}
for (i = 0; i < ((int)v2.size()); ++i) cin >> v2[i];
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
for (i = 0; i < ((int)v1.size()); ++i) {
val = calc(v1[i], k, tb);
if (val == -1) {
ans = -1;
break;
}
ans = max(ans, val);
k--;
if (k < 0) break;
}
if (i == v1.size()) ans = -1;
if (k >= n || k >= m) ans = -1;
cout << ans;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
calc();
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string y[n + 1];
for (int u = 1; u <= n; u++) {
cin >> y[u];
}
sort(y + 1, y + n + 1);
int k = (n / 2) + (n % 2);
cout << y[k];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, R, r;
cin >> n >> R >> r;
if (n == 1) {
if (R >= r)
cout << "YES";
else
cout << "NO";
return 0;
}
if (2 * r > R) {
if (n == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
double c = (R - r) * sin(3.1415926 / n) + 0.000001;
bool a = (c >= r);
if (a)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int n, a[N];
long long S;
bool chk(int k) {
int ct = 1;
long long z = S - 1;
long long lm = k;
memset(a, 0, (n + 1) << 2);
for (int i = 2; i <= n; i++) {
long long l = 1, r = min((long long)n - ct, lm);
while (l < r) {
long long c = (l + r + 1) >> 1;
long long u = n - ct - c, w = 0;
w = 1ll * i * (n - ct) + u * (u + 1) / 2;
if (w >= z)
l = c;
else
r = c - 1;
}
a[i] = l, lm = 1ll * l * k, z -= 1ll * i * l, ct += l;
if (z == 0 && ct == n) return true;
if (ct == n) return false;
}
return true;
}
int main() {
cin >> n >> S;
if (S < n + n - 1) return puts("No"), 0;
if (S > 1ll * n * (n + 1) / 2) return puts("No"), 0;
int l = 1, r = n - 1;
while (l < r) {
int mid = (l + r) >> 1;
if (chk(mid))
r = mid;
else
l = mid + 1;
}
chk(l);
vector<int> S;
S.push_back(1);
int z = 1;
static int d[N], fa[N];
for (int i = 2; i <= n; i++) {
vector<int> T;
for (int j = 0, u = 0; j < a[i]; j++) {
if (d[S[u]] == l) ++u;
++d[S[u]], fa[++z] = S[u], T.push_back(z);
}
S = T;
}
puts("Yes");
for (int i = 2; i <= n; i++) cout << fa[i] << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
bool vis[129];
int maxN[129];
int main() {
int p1 = 1, p2, minN, N, cnt = 0;
scanf("%d %s", &N, s + 1);
minN = N;
for (int i = 1; i <= N; i++)
if (!vis[s[i]]) {
vis[s[i]] = 1;
cnt++;
}
for (p2 = 1; p2 <= N; p2++) {
maxN[s[p2]] = p2;
while (p1 < p2 && maxN[s[p1]] != p1) p1++;
if (vis[s[p2]]) {
vis[s[p2]] = 0;
cnt--;
}
if (!cnt) minN = min(minN, p2 - p1 + 1);
}
cout << minN;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, m;
int mul = 1e9;
int gcd(int a, int b) {
if (a == 0 || b == 0) {
return a + b;
}
int r = a % b;
while (r) {
a = b;
b = r;
r = a % b;
}
return b;
}
int inverse(int a, int b) {
long long x0 = 1, x1 = 0, y0 = 0, y1 = 1;
long long q, r, c;
while (b != 0) {
q = a / b;
r = a % b;
a = b;
b = r;
c = x1, x1 = x0 - q * x1, x0 = c;
c = y1, y1 = y0 - q * y1, y0 = c;
}
return (x0 + m) % m;
}
int digits(int x) {
int k = 0;
while (x) {
x /= 10;
k++;
}
return k;
}
int main() {
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &m);
mul %= m;
if (b >= m - 1 || mul == 0) {
puts("2");
return 0;
}
int g = gcd(mul, m);
mul /= g;
m /= g;
int inv = inverse(mul, m);
int ans = a + 1;
for (int x = 1; x * g + b < m * g; x++) {
int s1 = (1LL * x * inv) % m;
if (s1 <= a) {
ans = min(ans, s1);
}
}
if (ans <= a) {
printf("1 ");
for (int i = 0; i < 9 - digits(ans); i++) {
printf("0");
}
printf("%d\n", ans);
return 0;
}
puts("2");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
//#include "testlib.h"
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define int long long
#define ll long long
#define M 1000000007
#define MM 998244353
#define inputarr(a,n) for(int i=0;i<n;++i) cin>>a[i]
#define GCD(m,n) __gcd(m,n)
#define LCM(m,n) m*(n/GCD(m,n))
#define mii map<ll ,ll >
#define msi map<string,ll >
#define rep(a,b) for(ll i=a;i<b;i++)
#define rep0(n) for(ll i=0;i<n;i++)
#define repi(i,a,b) for(ll i=a;i<b;i++)
#define pb push_back
#define vi vector<ll>
#define vs vector<string>
#define ppb pop_back
#define endl '\n'
#define asdf ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define r0 return 0;
#define FORD(i, a, b) for (int i = (int) (a); i >= (int) (b); --i)
#define inputoutput freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
#define Set(a, s) (a, s, sizeof (a))
#define FOR repi
#define vii vector<pii>
#define pii pair<int,int>
#define REVERSE(v) reverse(all(v))
#define trav(a, x) for(auto& a : x)
#define display(x) trav(a,x) cout<<a<<" ";cout<<endl
#define debug cerr<<"bhau"<<endl
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');std::cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
template<typename T, typename U> static inline void amin(T &x, U y)
{
if (y < x)
x = y;
}
template<typename T, typename U> static inline void amax(T &x, U y)
{
if (x < y)
x = y;
}
ll max(ll a, ll b) { return (a > b)? a : b;}
int min(int a, int b) { return (a < b)? a : b;}
const int N = (1<<21);
int poss[N];
int solve(){
int n,k;
cin>>n>>k;
string s;
cin>>s;
int k2 = log2(n-k+1)+1;
k2 = min(k,k2);
int cnt[n+1];
// memset(cnt,0,sizeof(cnt));
cnt[0]=0;
for(int i=0;i<n;i++){
if(i)
cnt[i] = cnt[i-1];
cnt[i]+=(s[i]-'0');
}
int left = k - k2;
for(int i=0;i<(1<<k2);i++)
poss[i]=1;
for(int i=0;i<=n-k;i++){
int cur = 0;
if(i+k-k2>=1)
cur=cnt[i+k-k2-1];
if(i)
cur-=cnt[i-1];
if(cur==k-k2 ){
int x = 0;
for(int j=k-k2;j<k;j++){
x*=2;
if(s[i+j]=='0')
x++;
}
// trace(i,x);
poss[x]=0;
}
}
// trace(poss[0]);
// trace(k2);
for(int i=0;i<(1<<k2);i++){
if(poss[i]){
cout<<"YES"<<endl;
string res="";
while(i){
if(i%2) res.pb('1');
else res.pb('0');
i/=2;
}
while(res.size()<k) res.pb('0');
reverse(all(res));
cout<<res<<endl;
r0
}
}
cout<<"NO"<<endl;
return 0;
}
signed main(){
asdf
int t=1;
cin>>t;
while(t--){
solve();
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const unsigned seed =
std::chrono::system_clock::now().time_since_epoch().count();
mt19937 rnd(seed);
const int MOD = 998244353;
long long getScore(long long aa, long long bb) {
return aa - 3 * bb * bb - 3 * bb;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
vector<long long> b(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long s = -3e18 - 3e9;
long long e = 1e9;
while (s <= e) {
long long m = (s + e) / 2;
if (s + e < 0 && (s + e) % 2 == -1) m--;
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] < m) {
b[i] = 0;
continue;
}
b[i] = (long long)(sqrt((a[i] - m) / 3.0 + 0.25) - 0.5) + 1;
b[i] = min(b[i], a[i]);
while (b[i] < a[i] && a[i] - 3 * b[i] * b[i] - 3 * b[i] >= m) b[i]++;
cnt += b[i];
}
if (s == e) break;
if (cnt <= k) {
e = m;
} else
s = m + 1;
}
long long cnt = 0;
priority_queue<pair<long long, long long>> qq;
for (int i = 0; i < n; i++) {
cnt += b[i];
if (a[i] > b[i]) qq.push({getScore(a[i], b[i]), i});
}
while (cnt < k) {
auto p = qq.top();
qq.pop();
b[p.second]++;
cnt++;
if (a[p.second] > b[p.second])
qq.push({getScore(a[p.second], b[p.second]), p.second});
}
for (int i = 0; i < n; i++) {
if (i != 0) cout << " ";
cout << b[i];
}
cout << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
int T = 1;
for (int i = 1; i <= T; i++) {
solve();
}
cout.flush();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, l, s = 0;
cin >> n >> m >> l;
vector<int> a(n);
vector<int> otvet;
for (int i = 0; i < n; ++i) cin >> a[i];
if (n == 1) {
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
if (x == 0) {
if (a[0] <= l)
otvet.push_back(0);
else
otvet.push_back(1);
continue;
}
int y, z;
cin >> y >> z;
if (a[0] <= l) a[0] += z;
}
for (int i = 0; i < otvet.size(); ++i) cout << otvet[i] << endl;
return 0;
}
int i = 0;
while (i < n) {
if (a[i] <= l) {
++i;
continue;
}
int j = i;
while (a[j] > l && j < n) {
j++;
}
s++;
i = j;
}
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
if (x == 0) {
otvet.push_back(s);
continue;
}
int y, z;
cin >> y >> z;
y--;
if (a[y] > l) continue;
a[y] += z;
if (a[y] > l) {
if (y > 0 && y < n - 1) {
if (a[y - 1] <= l && a[y + 1] <= l)
s++;
else if (a[y - 1] > l && a[y + 1] > l) {
s--;
}
} else if (y == 0) {
if (a[y + 1] <= l) s++;
} else if (y == n - 1) {
if (a[y - 1] <= l) s++;
}
}
}
for (int i = 0; i < otvet.size(); ++i) cout << otvet[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
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 - 48, ch = getchar();
return x * f;
}
const int N = 1000005;
int a[N];
int t, n;
struct node {
int y, nxt;
} e[N];
int h[N], tot;
void ad(int x, int y) {
++tot;
e[tot].y = y;
e[tot].nxt = h[x];
h[x] = tot;
}
int sta[N], vis[N], tp = 0;
bool dfs(int x) {
vis[x] = 1;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].y;
if (vis[y]) {
sta[++tp] = y;
return true;
}
if (dfs(y)) {
if (tp && y == sta[1]) return false;
sta[++tp] = y;
return true;
}
}
return false;
}
void clean() {
for (int i = 1; i <= n; ++i) vis[i] = h[i] = 0;
for (int i = 1; i <= tp; ++i) sta[i] = 0;
tot = 0;
tp = 0;
}
int main() {
t = read();
while (t--) {
clean();
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
ad(i, i - a[i]);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) dfs(i);
if (tp) break;
}
printf("%d\n", tp);
for (int i = 1; i <= tp; ++i) {
printf("%d ", sta[i]);
}
puts(" ");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 15;
struct Point {
int x, y;
long long key1, key2;
int pm1, pm2;
} poi[maxn];
int tot;
int tree[maxn];
int f[maxn], ans;
int n;
int a, b, c, d;
bool cm1(Point a, Point b) { return a.key1 < b.key1; }
bool cm2(Point a, Point b) {
if (a.key2 == b.key2) return a.key1 < b.key1;
return a.key2 < b.key2;
}
int ins(int x, int z) {
for (; x <= n; x += x & (-x)) tree[x] = max(tree[x], z);
return 0;
}
int ask(int x) {
int ans = 0;
for (; x; x -= x & (-x)) ans = max(ans, tree[x]);
return ans;
}
int main() {
scanf("%d", &n);
scanf("%d/%d%d/%d", &a, &b, &c, &d);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &poi[i].x, &poi[i].y);
poi[i].key1 = -1ll * d * poi[i].y + 1ll * c * poi[i].x;
poi[i].key2 = -1ll * a * poi[i].x + 1ll * b * poi[i].y;
if (poi[i].key1 <= 0 || poi[i].key2 <= 0) {
i--;
n--;
}
}
sort(poi + 1, poi + n + 1, cm1);
int s1 = 1;
poi[1].pm1 = 1;
for (int i = 2; i <= n; i++) {
if (poi[i].key1 != poi[i - 1].key1) s1++;
poi[i].pm1 = s1;
}
sort(poi + 1, poi + n + 1, cm2);
int las = 1;
for (int i = 1; i <= n; i++) {
if (poi[i].key2 != poi[i - 1].key2)
for (; las < i; las++) ins(poi[las].pm1, f[las]);
f[i] = ask(poi[i].pm1 - 1) + 1;
ans = max(ans, f[i]);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[30];
void prefix(string s, int m) {
int j = 0, i = 1;
a[0] = 0;
while (i < m) {
if (s[i] == s[j]) {
a[i] = j + 1;
i++;
j++;
} else if (j > 0) {
j = a[j - 1];
} else {
a[i] = 0;
i++;
}
}
}
int find(string p, int n, string q, int m) {
int i = 0, j = 0, count = 0;
prefix(q, m);
while (i < n) {
if (p[i] == q[j]) {
if (j == m - 1) {
count++;
j = 0;
i++;
} else {
i++;
j++;
}
} else if (j > 0) {
j = a[j - 1];
} else {
i++;
}
}
return count;
}
int main() {
string p, q;
cin >> p >> q;
int m, n;
n = p.size();
m = q.size();
int ans = find(p, n, q, m);
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<pair<long long, long long>, int> > a;
bool fn(pair<pair<long long, long long>, int>& lhs,
pair<pair<long long, long long>, int>& rhs) {
long long x[] = {lhs.first.first, rhs.first.first};
long long y[] = {lhs.first.second, rhs.first.second};
long long p[2], q[2];
for (int i = 0; i < 2; ++i) {
p[i] = x[i] * x[i] * (x[i] < 0 ? -1 : 1);
q[i] = x[i] * x[i] + y[i] * y[i];
if (y[i] < 0) p[i] = -p[i] - q[i] * 2;
}
return p[0] * q[1] < p[1] * q[0];
}
void mult(long long p, long long q, long long res[3], int* sign) {
*sign = (p >= 0 ? 1 : -1) * (q >= 0 ? 1 : -1);
p *= (p < 0 ? -1 : 1);
q *= (q < 0 ? -1 : 1);
long long a[] = {p >> 31, q >> 31};
long long b[] = {p & ((1LL << 31) - 1LL), q & ((1LL << 31) - 1LL)};
res[0] = b[0] * b[1];
res[1] = a[0] * b[1] + a[1] * b[0];
res[2] = a[0] * a[1];
for (int i = 0; i < 2; i++) {
if (res[i] >= (1LL << 31)) {
res[i + 1] += res[i] >> 31;
res[i] &= (1LL << 31) - 1LL;
}
}
}
bool cmp(long long a[3], long long b[3]) {
return a[2] != b[2] ? a[2] < b[2]
: (a[1] != b[1] ? a[1] < b[1] : a[0] < b[0]);
}
bool less_than(long long p0, long long q0, long long p1, long long q1) {
int sign[2];
long long res[2][3];
mult(p0, q1, res[0], &sign[0]);
mult(p1, q0, res[1], &sign[1]);
if (sign[0] != sign[1]) return sign[0] < sign[1];
if (sign[0] > 0) {
return cmp(res[0], res[1]);
} else
return cmp(res[1], res[0]);
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
a.push_back(make_pair(make_pair(x, y), i + 1));
}
sort(a.begin(), a.end(), fn);
long long mp = -2, mq = 1;
int ai = -1, aj = -1;
for (int i = 0; i < n; ++i) {
int j = (i == n - 1 ? 0 : i + 1);
long long x[] = {a[i].first.first, a[j].first.first};
long long y[] = {a[i].first.second, a[j].first.second};
long long p = x[0] * x[1] + y[0] * y[1];
p *= p * (p < 0 ? -1 : 1);
long long q = (x[0] * x[0] + y[0] * y[0]) * (x[1] * x[1] + y[1] * y[1]);
if (less_than(mp, mq, p, q)) {
mp = p;
mq = q;
ai = a[i].second;
aj = a[j].second;
}
}
printf("%d %d\n", ai, aj);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, M, ans[200011];
int depth[200011], p[200011][19], largest[200011][19];
vector<vector<int>> adj[200011];
int id[200011];
priority_queue<pair<int, int>> pq[200011];
void merge_pq(int a, int b) {
if (pq[id[a]].size() > pq[id[b]].size()) swap(a, b);
while (pq[id[a]].size()) {
pq[id[b]].push(pq[id[a]].top());
pq[id[a]].pop();
}
id[a] = id[b];
}
bool used[200011];
int edges[200011][3], container[200011];
int find(int x) { return x == p[x][0] ? x : p[x][0] = find(p[x][0]); }
void merge(int a, int b) { p[find(a)][0] = find(b); }
bool comp(int a, int b) { return edges[a][2] < edges[b][2]; }
int lca(int a, int b) {
if (depth[a] > depth[b]) swap(a, b);
int diff = depth[b] - depth[a];
for (int i = 0; i < 19; i++)
if (diff & (1 << i)) b = p[b][i];
if (a == b) return a;
for (int i = 19 - 1; i >= 0; i--) {
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
}
return p[a][0];
}
void dfs(int x, int v) {
p[x][0] = v;
depth[x] = depth[v] + 1;
for (auto e : adj[x]) {
if (e[1] != v && used[e[2]]) {
dfs(e[1], x);
largest[e[1]][0] = e[0];
}
}
}
void dfs2(int x, int v) {
int parentEdge = -1;
for (auto e : adj[x]) {
if (e[1] == v)
parentEdge = e[2];
else if (used[e[2]]) {
dfs2(e[1], x);
merge_pq(x, e[1]);
} else {
pq[id[x]].push(make_pair(-e[0], depth[lca(x, e[1])]));
}
}
while (pq[id[x]].size() && pq[id[x]].top().second >= depth[x])
pq[id[x]].pop();
if (parentEdge != -1 && pq[id[x]].size())
ans[parentEdge] = -pq[id[x]].top().first;
}
int main() {
if (fopen("data.in", "r")) freopen("data.in", "r", stdin);
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> edges[i][0] >> edges[i][1] >> edges[i][2];
edges[i][0]--;
edges[i][1]--;
container[i] = i;
adj[edges[i][0]].push_back({edges[i][2], edges[i][1], i});
adj[edges[i][1]].push_back({edges[i][2], edges[i][0], i});
}
sort(container, container + M, comp);
for (int i = 0; i < N; i++) p[i][0] = i;
for (int i = 0; i < M; i++) {
if (find(edges[container[i]][0]) != find(edges[container[i]][1])) {
merge(edges[container[i]][0], edges[container[i]][1]);
used[container[i]] = true;
}
}
dfs(0, 0);
for (int x = 1; x < 19; x++) {
for (int i = 0; i < N; i++) {
p[i][x] = p[p[i][x - 1]][x - 1];
largest[i][x] = max(largest[i][x - 1], largest[p[i][x - 1]][x - 1]);
}
}
for (int i = 0; i < N; i++) id[i] = i;
dfs2(0, 0);
for (int i = 0; i < M; i++) {
if (!used[i]) {
int c = lca(edges[i][0], edges[i][1]);
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 19; k++) {
if ((depth[edges[i][j]] - depth[c]) & (1 << k)) {
ans[i] = max(ans[i], largest[edges[i][j]][k]);
edges[i][j] = p[edges[i][j]][k];
}
}
}
}
cout << ans[i] - 1 << " ";
}
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
namespace {
int CC_;
const double EPS = 1E-9;
const double PI = 2 * acos(0.0);
const long long MOD = 1000000007;
template <class T>
void DA(T i, T e) {
while (i != e) {
cout << "Con>>( " << ++CC_ << " ) " << *i++ << "\n";
}
}
template <class T>
void DA(T* x, int l) {
for (int i = 0; i < l; i++) cout << "[" << i << "]>> " << x[i] << "\n";
}
template <class T>
inline void sary(T* st, T* nd) {
while (st < nd) cin >> *st++;
}
template <class T>
void tobin(T n, char* bin) {
int pos = 1 << ((int)log2(n));
while (pos >= 1) {
if ((n & pos) == 0)
*bin = '0';
else
*bin = '1';
pos >>= 1;
bin++;
}
*bin = '\0';
}
template <class T>
int strOccur(string& s, T& tgt) {
int oc = 0, p = s.find(tgt);
while (p != string::npos) {
p = s.find(tgt, p + 1);
oc++;
}
return oc;
}
template <class T>
inline T LCM(T x, T y) {
return ((x * y) / __gcd(x, y));
}
long long todec(string& num, int b) {
long long dec = num[0] - (isupper(num[0]) ? 'A' - 10 : '0');
for (int i = 1; num[i]; i++) {
if (num[i] >= 'A' && num[i] <= 'Z')
num[i] -= 'A' - 10;
else
num[i] -= '0';
dec *= b;
dec += num[i];
}
return dec;
}
int bigMod(int b, int e, int m) {
if (e == 0) return 1;
if (!(e & 1)) {
int temp = bigMod(b, e / 2, m) % m;
return (temp * temp) % m;
} else
return ((b % m) * (bigMod(b, e - 1, m)) % m) % m;
}
bool comp(const int a, const int b) { return a > b; }
} // namespace
const int sss = 1E6;
int a[200019];
void solve(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int lim = n / 2;
for (int i = 0, j = n - 1; i < lim; i++, j--) {
if (i % 2 == 0) {
swap(a[i], a[j]);
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[20020];
int y[20020];
int p;
int cost(int i, int j) {
int ret = x[i] + y[j];
return ret % p;
}
int a[20020];
int na[20020];
int b[20020];
int nb[20020];
void calc_a(int i0, int i1, int j0, int j1) {
for (int j = j0; j <= j1; ++j) {
for (int i = i0; i <= i1; ++i) {
na[i] = 0;
if (i > i0) na[i] = na[i - 1];
if (j > j0) na[i] = max(na[i], a[i]);
na[i] += cost(i, j);
}
for (int i = i0; i <= i1; ++i) a[i] = na[i];
}
}
void calc_b(int i0, int i1, int j0, int j1) {
for (int j = j1; j >= j0; --j) {
for (int i = i1; i >= i0; --i) {
nb[i] = 0;
if (i < i1) nb[i] = nb[i + 1];
if (j < j1) nb[i] = max(nb[i], b[i]);
nb[i] += cost(i, j);
}
for (int i = i0; i <= i1; ++i) b[i] = nb[i];
}
}
int goy[20202];
void solve(int i0, int i1, int j0, int j1) {
if (j0 == j1) return;
int mid = (j0 + j1) / 2;
calc_a(i0, i1, j0, mid);
calc_b(i0, i1, mid + 1, j1);
int res_i = i0;
int res = 0;
for (int i = i0; i <= i1; ++i) {
int cur = a[i] + b[i];
if (cur > res) {
res = cur;
res_i = i;
}
}
goy[mid] = res_i;
solve(i0, res_i, j0, mid);
solve(res_i, i1, mid + 1, j1);
}
int main() {
int n, m;
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
for (int i = 0; i < m; ++i) scanf("%d", &y[i]);
solve(0, n - 1, 0, m - 1);
int ans = 0;
string s;
int curi = 0;
goy[m - 1] = n - 1;
for (int j = 0; j < m; ++j) {
ans += cost(curi, j);
for (int i = curi + 1; i <= goy[j]; ++i) {
ans += cost(i, j);
s.push_back('C');
}
curi = goy[j];
if (j < m - 1) {
s.push_back('S');
}
}
cout << ans << endl << s;
return 0;
};
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000001;
string pattern[MAXN], s[MAXN];
long long h[MAXN], mod = 1110111110111;
const long long gob = 11;
long long ph[MAXN];
int ans[MAXN] = {
0,
};
set<long long> st;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
long long p = 1;
for (int j = 0; j < s[i].length(); j++) {
h[i] = (h[i] + (s[i][j] - 'a' + 1) * p) % mod;
p *= gob;
p %= mod;
}
st.insert(h[i]);
}
for (int i = 1; i <= m; i++) {
cin >> pattern[i];
long long p = 1;
for (int j = 0; j < pattern[i].length(); j++) {
ph[i] = (ph[i] + (pattern[i][j] - 'a' + 1) * p) % mod;
p *= gob;
p %= mod;
}
p = 1;
for (int j = 0; j < pattern[i].length(); j++) {
for (char w = 'a'; w <= 'c'; w++) {
if (pattern[i][j] == w) continue;
int change = w - pattern[i][j];
long long cand = ph[i] + change * p;
while (cand < 0) cand += mod;
while (cand > mod) cand %= mod;
if (st.find(cand) != st.end()) {
ans[i] = 1;
}
}
p *= gob;
p %= mod;
}
}
for (int i = 1; i <= m; i++) {
if (ans[i])
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 5000 + 10;
int n, x, a[sz], fr[sz];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
double a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int pen = 0, pencil = 0;
pen = ceil(a / c);
pencil = ceil(b / d);
if (pen + pencil > k)
cout << -1 << "\n";
else
cout << pen << " " << pencil << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 60;
const long long INF = 1e3;
long long t, n, m, dp[N][N][N], c;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> t;
for (int i = 1; i <= 30; i++) {
for (int j = 1; j <= 30; j++) {
for (int k = 1; k <= 50; k++) {
if (i == j && i == 1) continue;
if (i * j == k) continue;
dp[i][j][k] = INF;
if (i * j < k) continue;
for (int li = 1; li < i; li++) {
for (int lk = 0; lk <= k; lk++) {
dp[i][j][k] =
min(dp[i][j][k], dp[li][j][lk] + dp[i - li][j][k - lk] + j * j);
}
}
for (int lj = 1; lj < j; lj++) {
for (int lk = 0; lk <= k; lk++) {
dp[i][j][k] =
min(dp[i][j][k], dp[i][lj][lk] + dp[i][j - lj][k - lk] + i * i);
}
}
}
}
}
while (t--) {
cin >> n >> m >> c;
cout << dp[n][m][c] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define int int64_t
#define mod 1000000007
const int MAX = 1e5 + 5;
vector<int> f(MAX);
int modInverse(int a, int m = 1e9 + 7) {
int m0 = m;
int y = 0, x = 1;
if (m == 1)
return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0)
x += m0;
return x;
}
int C(int n, int r) {
if (n <= 0 || r > n) return 0;
return ((f[n] * modInverse(f[n - r]) % mod) * modInverse(f[r]) % mod) % mod;
}
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
f[0] = 1;
for (int i = 1; i < f.size(); i++) {
f[i] = (f[i - 1] * i) % mod;
}
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> vec;
for (int x = 1; C(n - (x - 1) * (k - 1), x) > 0; x++) {
vec.push_back(C(n - (x - 1) * (k - 1), x) * modInverse(C(n, x)) % mod);
}
vec.push_back(0);
int ans = 0;
for (int i = 0; i < vec.size() - 1; i++) {
ans += (i + 2) * (vec[i] - vec[i + 1] + mod) % mod;
ans %= mod;
}
cout << ans << endl;
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int MAX_S = 20000000;
const int INF = 0x3f3f3f3f;
pair<int, int> f[2][MAX_N + 10];
int p;
int n, maxb, pe;
int data[MAX_N + 10];
inline void readInt(int& a) {
a = 0;
int c;
do c = getchar();
while (c < '0' || c > '9');
do {
a = a * 10 - '0' + c;
c = getchar();
} while (c >= '0' && c <= '9');
}
int cnt[MAX_N + 10], order[MAX_N + 10];
void work() {
for (int i = 1; i <= n; i++) readInt(data[i]);
fill(cnt, cnt + maxb + 1, 0);
for (int i = 1; i <= n; i++) ++cnt[data[i]];
for (int i = 1; i <= maxb; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i <= n; i++) order[cnt[data[i]]--] = i;
data[n + 1] = INF;
f[0][0].first = f[0][0].second = 0;
fill(f[0] + 1, f[0] + maxb + 1, make_pair(INF, n + 1));
int cur = 0;
pair<int, int> nxt;
for (int i = 1; i <= n;) {
for (int j = 0; j <= maxb; j++) f[cur ^ 1][j] = f[cur][j];
do {
int c = order[i];
for (int j = maxb; j >= 0; j--) {
if (data[f[cur][j].second] < data[c]) {
nxt.second = c;
nxt.first = f[cur][j].first + (f[cur][j].second > c);
if (f[cur ^ 1][j + 1] > nxt) f[cur ^ 1][j + 1] = nxt;
}
}
++i;
} while (i <= n && data[order[i]] == data[order[i - 1]]);
cur ^= 1;
}
int ans;
for (ans = maxb; f[cur][ans].first >= pe; ans--)
;
printf("%d\n", ans);
}
int main() {
int t;
readInt(t);
readInt(n);
readInt(maxb);
readInt(pe);
while (t--) work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 200005;
long long n, a;
deque<long long> s;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a;
while (!s.empty() and s.back() == a) {
s.pop_back();
a++;
}
s.push_back(a);
}
cout << s.size() << '\n';
for (auto i : s) cout << i << ' ';
cout << '\n';
}
| 5 |
#include<iostream>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int n,f=0;
cin>>n;
int a[n];
for(int i=0;i<n;i++){
cin>>a[i];
if(a[i]<0){
f=1;
}
}
if(f==0){
cout<<"YES"<<endl;
cout<<101<<endl;
for(int i=0;i<=100;i++){
cout<<i<<" ";
}
cout<<endl;
}
else{
cout<<"NO"<<endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static const int MAXN = 1e5 + 10;
int a[MAXN];
int main() {
int T, n;
cin >> T;
while (T--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int k = 1;
for (int i = n - 1; i >= 0; i--)
if (a[i] <= i + 1) {
k = i + 2;
break;
}
cout << k << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(12) << fixed;
auto print = [](const vector<int>& a) {
int n = a.size();
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 < n) {
cout << '.';
}
}
cout << '\n';
};
int t;
cin >> t;
while (t--) {
vector<vector<int>> st = {{}};
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int last;
cin >> last;
if (last == 1) {
vector<int> cur = st.back();
cur.push_back(last);
st.push_back(cur);
} else {
while (st.back().back() != last - 1) {
st.pop_back();
}
st.back().back()++;
}
print(st.back());
}
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3e5;
int n, a[mxN], prv[mxN], dp[mxN];
map<int, int> mp[mxN];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
prv[i] = -1;
dp[i] = 0;
mp[i].clear();
}
for (int i = 1; i < n; ++i) {
if (a[i] == a[i - 1]) {
prv[i] = i - 1;
if (prv[i] > 0) {
swap(mp[i], mp[prv[i] - 1]);
mp[i][a[prv[i] - 1]] = prv[i] - 1;
}
} else {
auto it = mp[i - 1].find(a[i]);
if (it == mp[i - 1].end()) continue;
int pos = it->second;
prv[i] = pos;
if (pos > 0) {
swap(mp[i], mp[pos - 1]);
mp[i][a[pos - 1]] = pos - 1;
}
}
}
long long ans = 0;
for (int i = 1; i < n; ++i) {
if (prv[i] == -1) continue;
dp[i] = 1;
if (prv[i] > 0) dp[i] += dp[prv[i] - 1];
ans += dp[i];
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
char a[N], b[N];
int freq[N][2];
int main() {
scanf("%s%s", a, b);
int n = strlen(a), m = strlen(b);
for (int i = 1; i <= n; ++i) {
freq[i][0] = freq[i - 1][0];
freq[i][1] = freq[i - 1][1];
++freq[i][a[i - 1] - '0'];
}
long long res = 0;
for (int i = 1; i <= m; ++i) {
int x = (b[i - 1] - '0') ^ 1;
if (i <= n) {
int e = min(i, m - n + 1);
res += freq[i][x] - freq[i - e][x];
} else {
int e = min(n, m - i + 1);
res += freq[n][x] - freq[n - e][x];
}
}
printf("%lld\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[1111111], s2[111];
int c[27], n, Q, Q2, cnt[11111], q[11111], q2[11111];
pair<int, int> b[27];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i < 26; ++i) c[i] = n + 1;
scanf("%d", &Q);
for (int z = 1; z <= Q; ++z) {
scanf("%s", s2 + 1);
int l = strlen(s2 + 1);
int sta = 0;
for (int i = 1; i <= l; ++i) sta |= (1 << (s2[i] - 'a'));
q[z] = sta;
q2[z] = sta;
}
sort(q2 + 1, q2 + 1 + Q);
Q2 = unique(q2 + 1, q2 + 1 + Q) - q2 - 1;
for (int i = n; i >= 1; --i) {
c[s[i] - 'a'] = i;
for (int j = 0; j < 26; ++j) b[j] = make_pair(c[j], j);
sort(b, b + 26);
int sta = 0;
for (int j = 0; j < 26; ++j) {
if (b[j].second == s[i - 1] - 'a') break;
if (b[j].first > n) break;
sta |= (1 << b[j].second);
int t = lower_bound(q2 + 1, q2 + 1 + Q2, sta) - q2;
if (q2[t] == sta) cnt[t]++;
}
}
for (int i = 1; i <= Q; ++i) {
printf("%d\n", cnt[lower_bound(q2 + 1, q2 + 1 + Q2, q[i]) - q2]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[5009], x, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
for (int i = 1; i <= n; i++) {
if (!a[i]) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long MM = 1000000007;
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0 || b == 0) return abs(a - b);
long long res = a % b;
while (res) {
a = b;
b = res;
res = a % b;
}
return b;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long numberofdiviser(long long a) {
long long ans = 0;
long long i;
for (i = 1; i * i < a; i++) {
if (a % i == 0) ans += 2;
}
if (i * i == a) ans++;
return ans;
}
void fival(long long* a, long long b, long long n) {
for (int i = 0; i < n; i++) {
a[i] = b;
}
}
long long sum, ans, l, r, x;
long long ss(vector<long long> a, vector<long long>& b, int ii) {
for (int i = ii; i < a.size(); i++) {
b.push_back(a[i]);
sum += a[i];
if (b.size() > 1 && sum >= l && sum <= r && b[b.size() - 1] - b[0] >= x)
ans++;
ss(a, b, i + 1);
sum -= b[b.size() - 1];
b.pop_back();
}
return ans;
}
unsigned long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
unsigned long long Combinations(unsigned long long n, unsigned long long r) {
if (r > n) return 0;
if (r * 2 > n) r = n - r;
if (r == 0) return 1;
unsigned long long res = n;
for (int i = 2; i <= r; ++i) {
res *= (n - i + 1);
res /= i;
}
return res;
}
long long pow(long long a, long long b, long long m = MM) {
if (b == 0) return 1;
if (b == 1) return a;
long long x = pow(a, b / 2, m);
x = (x * x) % m;
if (b % 2) x = (x * a);
return x % m;
}
int solve() {
int n;
cin >> n;
int a, b, c, d;
for (int i = 0; i < 4; i++) {
cin >> a >> b >> c >> d;
if (min(a, b) + min(c, d) <= n) {
cout << i + 1 << " " << min(a, b) << " " << n - min(a, b);
return 0;
}
}
cout << -1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
map<int, int> mp;
while (t--) {
int a, b;
cin >> a >> b;
mp[a]++;
mp[b]--;
}
int maxi = -1, year, curr = 0;
for (auto e : mp) {
curr += e.second;
if (curr > maxi) {
year = e.first;
maxi = curr;
}
}
cout << year << " " << maxi << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ind;
const int MAXN = 100000, MAXK = 10;
long long A[MAXN + 10];
long long bit[MAXK + 3][MAXN + 1];
long long dp[MAXK + 3][MAXN + 1];
map<long long, int> id;
long long query(int B, int pos) {
long long sum = 0LL;
while (pos > 0) {
sum += bit[B][pos];
pos -= pos & -pos;
}
return sum;
}
void upd(int B, int pos, long long val) {
while (pos < ind) {
bit[B][pos] += val;
pos += pos & -pos;
}
}
long long B[MAXN + 10];
int main() {
scanf("%d %d", &n, &k);
k++;
ind = 1;
for (int i = 0; i < n; i++) {
scanf("%I64d", &A[i]);
B[i] = A[i];
}
sort(B, B + n);
for (int i = 0; i < n; i++) {
if (id.count(B[i]) == 0) id[B[i]] = ind++;
}
for (int i = 0; i < n; i++) A[i] = id[A[i]];
for (int i = 0; i < n; i++) {
dp[1][i] = 1LL;
upd(1, A[i], 1LL);
for (int j = 2; j <= k; j++) {
dp[j][i] += query(j - 1, A[i] - 1);
upd(j, A[i], dp[j][i]);
}
}
long long answer = 0LL;
for (int i = 0; i < n; i++) answer += dp[k][i];
printf("%I64d\n", answer);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 100000;
struct point {
int x, y;
};
point p[maxn + 10];
int n, used[maxn + 10];
inline int one_line(int a, int b, int c) {
if ((a == 0) || (b == 0) || (c == 0)) {
return 1;
}
return 1ll * (p[c].x - p[a].x) * (p[b].y - p[a].y) ==
1ll * (p[c].y - p[a].y) * (p[b].x - p[a].x);
}
int check(int a, int b) {
memset(used, 0, sizeof used);
used[a] = used[b] = 1;
for (register int i = 1; i <= n; ++i) {
if ((!used[i]) && (one_line(a, b, i))) {
used[i] = 1;
}
}
int u = 0, v = 0, w = 0, flag = 1;
for (register int i = 1; i <= n; ++i) {
if (!used[i]) {
u = v;
v = w;
w = i;
if (!one_line(u, v, w)) {
flag = 0;
break;
}
}
}
return flag;
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].x, &p[i].y);
}
if (check(1, 2) || check(2, 3) || check(1, 3)) {
puts("YES");
} else {
puts("NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int v[4005], d[4005], p[4005];
int ans[4005];
int flag[4005];
int n;
int main() {
memset(flag, 0, sizeof(flag));
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &v[i], &d[i], &p[i]);
int tot = 0;
for (int i = 1; i <= n; i++) {
if (p[i] < 0) continue;
ans[tot++] = i;
int sum = 0;
int time = v[i];
for (int j = i + 1; j <= n; j++) {
flag[j] = 0;
if (p[j] >= 0) {
flag[j] = 1;
if (time > 0) p[j] -= time;
time--;
}
}
for (int j = i + 1; j <= n; j++) {
if (p[j] >= 0) p[j] -= sum;
if (p[j] < 0 && flag[j]) sum += d[j];
}
}
printf("%d\n", tot);
for (int i = 0; i < tot; i++) printf("%d ", ans[i]);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
for (int i = 0; i <= s.length() - 1; i++) {
if (s[i] == '.' && s[i - 1] == '9') {
cout << "GOTO Vasilisa.";
return 0;
}
if (s[i] == '.' && s[i + 1] < '5') {
for (int j = 0; j <= i - 1; j++) cout << s[j];
}
if (s[i] == '.' && s[i + 1] >= '5') {
for (int j = 0; j <= i - 2; j++) cout << s[j];
cout << char(s[i - 1] + 1);
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 0; i < (int)9; ++i) cout << i << "??<>" << i + 1 << endl;
cout << "9??>>??0" << endl;
cout << "??<>1" << endl;
for (int i = 0; i < (int)10; ++i)
cout << "?" << i << ">>" << i << "?" << endl;
cout << "?>>??" << endl;
cout << ">>?" << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::cin.clear();
int n;
cin >> n;
int a[n], i;
bool w(false), b(false);
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) {
b = true;
} else if (a[i] == 1) {
w = true;
}
}
int c(1), p[n], j(0);
if (b == false || w == false) {
cout << "YES" << endl;
return 0;
} else {
for (i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
c++;
if (i == n - 2) {
p[j] = c;
}
} else if (a[i] != a[i + 1]) {
p[j] = c;
c = 1;
j++;
}
}
if (a[n - 1] != a[n - 2]) {
p[j] = 1;
}
}
sort(p, p + j + 1);
if (p[0] == p[j]) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
std::cin.ignore(32767, '\n');
std::cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1E-8;
inline bool eq(double a, double b) { return a - b < EPS && b - a < EPS; }
inline bool ne(double a, double b) { return a + EPS < b || b + EPS < a; }
inline bool ls(double a, double b) { return a + EPS < b; }
inline bool gr(double a, double b) { return b + EPS < a; }
inline bool le(double a, double b) { return a - EPS < b; }
inline bool ge(double a, double b) { return b - EPS < a; }
int arr[1111][1111];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &arr[i][j]);
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
sum = (sum + arr[i][j] * arr[j][i]) & 1;
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int ctrl;
scanf("%d", &ctrl);
if (ctrl == 3)
putchar('0' + sum);
else {
scanf("%d", &ctrl);
sum = 1 - sum;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = (a[i] + i) % n;
if (a[i] < 0) {
a[i] += n;
}
}
map<int, int> m;
for (int i = 0; i < n; i++) {
m[a[i]]++;
}
for (auto x : m) {
if (x.second > 1) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string rotate(string s, int t) {
string res = s;
if (t == 0) {
res[2] = s[5];
res[3] = s[2];
res[4] = s[3];
res[5] = s[4];
}
if (t == 1) {
res[0] = s[5];
res[3] = s[0];
res[1] = s[3];
res[5] = s[1];
}
if (t == 2) {
res[0] = s[2];
res[4] = s[0];
res[1] = s[4];
res[2] = s[1];
}
return res;
}
set<string> s;
int main() {
string ss;
cin >> ss;
sort(ss.begin(), ss.end());
int res = 0;
do {
string sss = ss;
if (s.find(ss) == s.end()) {
res++;
for (int i = (0); i < (4); ++i) {
sss = rotate(sss, 0);
for (int j = (0); j < (4); ++j) {
sss = rotate(sss, 1);
for (int k = (0); k < (4); ++k) {
sss = rotate(sss, 2);
s.insert(sss);
}
}
}
}
} while (next_permutation(ss.begin(), ss.end()));
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[100000], i, u, cnt, n, k;
void dfs(long long x, long long c) {
if (cnt >= 100000) return;
if (c == k || x == 1) {
printf("%I64d ", x);
++cnt;
return;
}
for (long long i = 1; i <= u && x >= a[i]; i++)
if (x % a[i] == 0) dfs(a[i], c + 1);
}
int main() {
scanf("%I64d%I64d", &n, &k);
long long w = sqrt(n);
for (long long i = 1; i <= w; i++)
if (n % i == 0) a[++u] = i, a[++u] = n / i;
if (w * w == n) u--;
sort(a + 1, a + u + 1);
dfs(n, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> arr(n);
for (auto &el : arr) cin >> el;
int i = n - 1, j = n - 2;
while (j >= 0 && arr[i] > arr[j]) i--, j--;
ll res = 0, lst = arr[i];
for (int k = n - 1; k >= i; --k) res += arr[k];
for (int k = i - 1; k >= 0; --k) {
lst--;
if (lst <= 0) break;
if (arr[k] >= lst)
res += lst;
else if (arr[k] < lst)
res += arr[k], lst = arr[k];
else
break;
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, A, B, K;
cin >> N >> A >> B >> K;
string str;
cin >> str;
str += '1';
int cnt = 0;
vector<pair<int, int> > lens;
vector<int> res;
for (int i = 0; i < (int)str.size(); i++) {
if (str[i] == '1') {
if (cnt) {
int ini = i - cnt;
lens.push_back({ini, cnt});
}
cnt = 0;
continue;
}
cnt++;
if (cnt && cnt % B == 0) res.push_back(i);
}
int r = res.size() - A + 1;
cout << r << '\n';
for (int i = 0; i < r; i++) cout << res[i] + 1 << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
const int MAXN = (1 << maxn);
long double p[maxn], sum[MAXN];
int L[MAXN];
long double dp[MAXN];
int main() {
ios::sync_with_stdio(false);
cout << setprecision(15) << fixed;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
sum[0] = 0;
for (int i = 1; 2 * i < MAXN; i *= 2) L[2 * i] = L[i] + 1;
for (int i = 1; i < (1 << n); i++) sum[i] = sum[i ^ (i & -i)] + p[L[i & -i]];
for (int i = 0; i < n; i++) {
if (p[i] == 0) {
cout << p[i] << ' ';
continue;
}
dp[0] = p[i];
long double res = dp[0];
for (int j = 1; j < (1 << n); j++) {
if ((j >> i) & 1) continue;
dp[j] = 0;
for (int x = j; x; x -= x & -x) dp[j] += p[L[x & -x]] * dp[j ^ (x & -x)];
dp[j] /= (1.0 - sum[j]);
if (__builtin_popcount(j) < k) res += dp[j];
}
cout << res << ' ';
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long have;
long long need;
long long dis;
} qlist1[100003], qlist2[100003];
int t1 = 0, t2 = 0;
int front[2] = {0}, rear[2];
bool operator<(const node &a, const node &b) { return a.need < b.need; }
int main() {
int n, i, j;
long long need, dis, t, tt, ttt, count = 1;
scanf("%d%I64d%I64d", &n, &dis, &need);
for (i = 0; i < n; i++) {
scanf("%I64d%I64d%I64d", &t, &tt, &ttt);
if (ttt < dis) tt = need + 1;
if (t == 0) {
qlist1[t1].have = t;
qlist1[t1].need = tt;
qlist1[t1++].dis = ttt;
} else {
count += t - 1;
qlist2[t2].have = t;
qlist2[t2].need = tt;
qlist2[t2++].dis = ttt;
}
}
sort(qlist1, qlist1 + t1);
sort(qlist2, qlist2 + t2);
rear[0] = t1 - 1;
rear[1] = t2 - 1;
long long tmp = need;
int ans = 0;
if (rear[1] > -1 && tmp >= qlist2[0].need) {
tmp -= qlist2[0].need;
ans = t2;
if (count >= t1) {
printf("%d %I64d\n", n, need - tmp);
return 0;
}
ans += count;
rear[0] -= count;
front[1] = 1;
while (front[0] <= rear[0]) {
if (front[1] <= rear[1]) {
if (qlist2[front[1]].need <= qlist1[front[0]].need &&
tmp >= qlist2[front[1]].need) {
tmp -= qlist2[front[1]++].need;
rear[0]--;
} else if (tmp >= qlist1[front[0]].need)
tmp -= qlist1[front[0]++].need;
else
break;
} else if (tmp >= qlist1[front[0]].need)
tmp -= qlist1[front[0]++].need;
else
break;
ans++;
}
}
front[0] = 0;
rear[0] = t1 - 1;
int tmp_ans = 0;
long long tmptmp = need;
while (front[0] <= rear[0] && tmptmp >= qlist1[front[0]].need) {
tmptmp -= qlist1[front[0]++].need;
tmp_ans++;
}
if (tmp_ans > ans || (tmp_ans == ans && tmptmp > tmp))
printf("%d %I64d\n", tmp_ans, need - tmptmp);
else
printf("%d %I64d\n", ans, need - tmp);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> G[N];
long long w[N];
long long sum[N];
long long ans = 0;
long long dfs(int x) {
if (G[x].empty()) {
ans = max(ans, w[x]);
sum[x] = w[x];
return 1;
}
int cnt = 0;
sum[x] = w[x];
for (int &v : G[x]) {
cnt += dfs(v);
sum[x] += sum[v];
}
ans = max(ans, sum[x] / cnt + (sum[x] % cnt ? 1 : 0));
return cnt;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
G[x].push_back(i);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
dfs(1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Pair {
int min;
int max;
Pair(int min, int max) : min(min), max(max) {}
};
char request(int i, int j) {
cout << "? " << i << " " << j << endl;
cout.flush();
char c;
cin >> c;
return c;
}
Pair *bs(int l, int r, int n) {
if (l > n) {
return NULL;
}
if (l == r) {
return new Pair(l, r);
}
if (r - l == 1) {
if (r > n) {
return new Pair(l, l);
}
char response = request(l, r);
if (response == '>')
return new Pair(r, l);
else
return new Pair(l, r);
}
Pair *left = bs(l, l + (r - l) / 2, n);
Pair *right = bs(l + (r - l) / 2 + 1, r, n);
int min = left->min;
int max = left->max;
if (right != NULL) {
if (request(left->min, right->min) == '>') {
min = right->min;
}
if (request(left->max, right->max) == '<') {
max = right->max;
}
}
return new Pair(min, max);
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int n;
cin >> n;
int m = 2 << (int)(log(n) / log(2));
Pair *p = bs(1, m, n);
cout << "! " << p->min << " " << p->max << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int q[2 * 250005], f[250005], t[2 * 250005], v[2 * 250005], di[250005],
u[250005], tot;
multiset<int> one[250005], two[250005];
long long sum[250005], dp[250005][2], tmp[250005], max_value, ans[250005];
int dl[250005], in[250005], timestamp, vis[250005];
vector<int> go[250005], va[250005];
int x, y, z, D, n, now;
void link(int x, int y, int z) {
q[++tot] = f[x];
t[tot] = y;
f[x] = tot;
v[tot] = z;
di[x]++;
}
bool cmpd(const int &a, const int &b) { return di[a] > di[b]; }
void adjust_12(int x) {
multiset<int>::iterator it;
while (one[x].size() > di[x] - D) {
it = one[x].end();
it--;
sum[x] -= *it;
two[x].insert(*it);
one[x].erase(it);
}
}
void adjust_21(int x) {
multiset<int>::iterator it;
while (one[x].size() < di[x] - D && two[x].size() > 0) {
it = two[x].begin();
sum[x] += *it;
one[x].insert(*it);
two[x].erase(it);
}
}
void add_2(int x, int y, int z) {
go[x].push_back(y);
va[x].push_back(z);
go[y].push_back(x);
va[y].push_back(z);
}
void add_1(int x, int y) {
one[x].insert(y);
sum[x] += y;
adjust_12(x);
}
void remove_1(int x, int y) {
if (one[x].find(y) != one[x].end()) {
sum[x] -= y;
one[x].erase(one[x].find(y));
adjust_21(x);
} else
two[x].erase(two[x].find(y));
}
void dfs(int x, int y) {
vis[x] = timestamp;
int m = go[x].size();
int ned = di[x] - D;
int has = 0;
int now;
for (int i = 0; i < m; i++)
if (go[x][i] != y) dfs(go[x][i], x);
tmp[0] = 0;
for (int i = 0; i < m; i++)
if (go[x][i] != y) {
now = go[x][i];
tmp[0] += dp[now][0];
tmp[++has] = dp[now][1] + va[x][i] - dp[now][0];
}
sort(tmp + 1, tmp + 1 + has);
for (int i = 1; i <= has; i++) tmp[i] += tmp[i - 1];
int res = one[x].size();
int cl;
for (int tp = 0; tp < 2; tp++) {
cl = 0;
int need = ned - tp;
multiset<int>::iterator it;
int qd = need - res;
if (qd < 0) {
it = one[x].end();
it--;
sum[x] -= *it;
dp[x][tp] = sum[x] + tmp[0];
dl[++cl] = *it;
one[x].erase(it);
qd = 0;
} else {
if (qd > has)
dp[x][tp] = max_value;
else
dp[x][tp] = tmp[qd] + sum[x];
}
for (int i = qd + 1; i <= has; i++)
if (one[x].size() > 0) {
it = one[x].end();
it--;
sum[x] -= *it;
dp[x][tp] = min(dp[x][tp], tmp[i] + sum[x]);
dl[++cl] = *it;
one[x].erase(it);
} else
dp[x][tp] = min(dp[x][tp], tmp[i]);
for (int i = 1; i <= cl; i++) sum[x] += dl[i], one[x].insert(dl[i]);
}
}
int main() {
max_value = (long long)250005 * 1000000;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", &x, &y, &z);
link(x, y, z);
link(y, x, z);
}
for (int i = 1; i <= n; i++) u[i] = i;
sort(u + 1, u + 1 + n, cmpd);
now = 0;
for (D = n - 1; D >= 0; D--) {
for (int i = 1; i <= now; i++) adjust_21(u[i]);
while (now < n && di[u[now + 1]] > D) {
now++;
x = u[now];
in[x] = 1;
for (int i = f[x]; i; i = q[i]) {
y = t[i];
if (!in[y])
add_1(x, v[i]);
else
remove_1(y, v[i]), add_2(x, y, v[i]);
}
}
timestamp++;
for (int i = 1; i <= now; i++)
if (vis[u[i]] != timestamp) {
dfs(u[i], 0);
ans[D] += dp[u[i]][0];
}
}
for (int D = 0; D < n; D++) printf("%I64d\n", ans[D]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test;
cin >> test;
while (test--) {
long long n;
cin >> n;
string second;
cin >> second;
long long ans0 = 0, ans1 = 0;
for (long long i = 1; i < (long long)n; ++i) {
if (second[i - 1] == second[i] and second[i] == '1')
ans1++;
else if (second[i - 1] == second[i] and second[i] == '0')
ans0++;
}
cout << max(ans1, ans0) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void maximize(T &x, U y) {
if (x < y) x = y;
}
template <class T, class U>
void minimize(T &x, U y) {
if (x > y) x = y;
}
template <class T>
T Abs(T x) {
return (x < (T)0 ? -x : x);
}
template <class T, class U, class V>
T addmod(T x, U y, V mod) {
return ((x + y) % mod + mod) % mod;
}
template <class T, class U, class V>
T submod(T x, U y, V mod) {
return ((x - y) % mod + mod) % mod;
}
template <class T, class U, class V>
T mulmod(T x, U y, V mod) {
return (long long)x * y % mod;
}
namespace task {
const int N = 1e5 + 5;
int par[N], minCost[N], c[N];
int n, m;
int findp(int u) { return (par[u] == u ? u : par[u] = findp(par[u])); }
void join(int u, int v) {
u = findp(u), v = findp(v);
if (u == v) return;
int mi = min(minCost[u], minCost[v]);
minCost[v] = minCost[u] = mi, par[v] = u;
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n; ++i) par[i] = i, minCost[i] = c[i];
for (int u, v, i = 1; i <= m; ++i) {
cin >> u >> v;
join(u, v);
}
long long ans = 0;
for (int u = 1; u <= n; ++u)
if (par[u] == u) ans += 1ll * minCost[u];
cout << ans;
}
} // namespace task
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
task::solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, maxx, idx, max1, s;
int main(int argc, char *argv[]) {
pair<int, int> a[10000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = 0;
}
maxx = 0;
max1 = 0;
for (int i = 0; i < n; i++) {
if (a[i].first > maxx) {
max1 = maxx;
maxx = a[i].first;
idx = i;
} else if (max1 < a[i].first)
max1 = a[i].first;
}
cout << idx + 1 << " " << max1 << endl;
return EXIT_SUCCESS;
}
| 0 |
#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
#define f(i,a,b) for( int i=a;i<=b;++i)
#define ff(i,a,b) for( int i=a;i>=b;--i)
#define debug(x) cerr << #x << " : " << x << " " << endl
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
const ll mod = 1e9 + 7;
const ll mod2 = 998244353;
const ll inf = 2e18;
const double tiaohe = 0.57721566490153286060651209;
ll oula(ll x) { ll res = x;f(i, 2, x / i) { if (x % i == 0) { res = res / i * (i - 1);while (x % i == 0) x /= i; } }if (x > 1) res = res / x * (x - 1);return res; }
ll quickmod(ll a, ll n, ll m) { ll s = 1;while (n) { if (n & 1) { s = s * a % m; }a = (a*a) % m;n = n / 2; }return s; }
ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
void ex_gcd(ll a, ll b, ll &x, ll &y, ll &d) { if (!b) { d = a, x = 1, y = 0; } else { ex_gcd(b, a % b, y, x, d);y -= x * (a / b); } }
ll inv(ll t, ll p) { ll d, x, y;ex_gcd(t, p, x, y, d);return d == 1 ? (x % p + p) % p : -1; }
bool isPrime(ll x) { if (x == 2)return true;if (x % 2 == 0)return false;for (ll i = 2;i*i <= x;i++) if (x % i == 0)return false; return true; }
inline ll in() { char ch = getchar();ll x = 0, f = 1;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; }
void print(double x) { printf("%.6lf\n", x); }
//double a = log(n) +tiaohe + 1.0 / (2 * n);
double eqa = (1 + sqrt(5.0)) / 2.0;
double E = 2.7182818284;
const double eps = 1e-8;
double pi = acos(-1);
const int N = 5e5 + 100;
int n, m;
ll k;
int a[N], b[N],id;
ll M[2], LCM;
pair<ll,ll> st[N];//等价类起点
pair<ll,ll> linear( ll B[], ll M[], int n)
{
//求解 A[i]x = B[i] (mod M[i]), 总共 n 个线性 方程组, →
ll x = 0, m = 1;
for (int i = 0; i < n; i++)
{
ll a = m, b = B[i] - x, d = gcd(M[i], a);
if (b % d != 0) return pair<ll,ll>(0, -1);//答案不存在，返回-1
ll t = b / d * inv(a / d, M[i] / d) % (M[i] / d);
x = x + m * t;
m *= M[i] / d;
}
x = (x % m + m) % m;
return pair<ll, ll>{x,m};//返回的 x 就是答案，m 是最后的 lcm 值
}
ll pos[N][2];
bool check(ll mid) {
ll res = mid;//减去命中的
f(i, 1, id) {
if (st[i].second == -1) {
continue;
}
if (st[i].first > mid)continue;
ll num = (ll)ceil((mid-1-st[i].first)*1.0/LCM);
res -= num;
}
//cout << mid << " " << res << endl;
return res <= k;
}
void work(ll k) {
ll l = 0, r = 2e18,res=0;
while (l <= r) {
ll mid = l + r >> 1;
if (check(mid)) {
res = mid;
l = mid + 1;
}
else {
r = mid - 1;
}
}
cout << res << endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
cin >> n >> m >> k;
unordered_map<int, int> mp;
f(i, 1, n)a[i] = in(), mp[a[i]] = i-1;
f(i, 1, m)b[i] = in();
id = 0;
f(i, 1, m) {
if (mp.count(b[i])) {
pos[++id][0] = mp[b[i]];
pos[id][1] = i-1;
}
}
LCM= 1ll*n * m / gcd(n, m);
M[0] = n, M[1] = m;
f(i, 1, id) {
st[i] = linear(pos[i], M, 2);
//cout << st[i].first << " " << st[i].second << endl;
}
work(k);
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t, n, m, i, j, k, x, y, xx, yy, ans, a, b, dx, dy, s;
cin >> t;
while (t--) {
cin >> n >> m >> x >> y >> xx >> yy;
if (x > xx) swap(x, xx);
if (y > yy) swap(y, yy);
xx -= x - 1;
yy -= y - 1;
x = 1;
y = 1;
dx = n - xx;
dy = m - yy;
s = (dx + 1) * (dy + 1) * 2;
if ((x + dx >= xx) && (y + dy >= yy))
s -= (x + dx + 1 - xx) * (y + dy + 1 - yy);
ans = n * m - s;
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
fastio();
long long int n, cnt = 0, flag = 0;
cin >> n;
long long int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
if (ar[i] == i) cnt++;
}
for (int i = 0; i < n; i++) {
if (ar[i] != i) {
if (ar[ar[i]] == i) {
cnt += 2;
flag = 1;
break;
}
}
}
if (flag == 0 && cnt != n)
cout << cnt + 1;
else
cout << cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5;
int a[maxn];
vector<int> b[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]].push_back(i);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (b[i].empty()) ans++;
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, K, dp[2][511][511], cum[511];
int main() {
scanf("%d", &N);
scanf("%d", &K);
if (K == 1) {
cout << 0 << endl;
return 0;
}
dp[0][1][1] = 1;
for (int i = 1; i < N; i++) {
for (int j = i; j >= 1; j--) {
for (int k = j; k >= 1; k--) {
if (!dp[j][k]) continue;
dp[1][max(j, k + 1)][k + 1] =
(1LL * dp[1][max(j, k + 1)][k + 1] + dp[0][j][k]) % 998244353;
dp[1][j][1] = (1LL * dp[1][j][1] + dp[0][j][k]) % 998244353;
}
}
memcpy(dp[0], dp[1], sizeof(dp[0]));
memset(dp[1], 0, sizeof(dp[1]));
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= i; j++) cum[i] = (cum[i] + dp[0][i][j]) % 998244353;
int ans = 0;
for (int i = 1; i < K && i <= N; i++) {
for (int j = 1; j <= N && 1LL * i * j < K; j++) {
ans = (ans + (2LL * cum[i] * cum[j]) % 998244353) % 998244353;
}
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void pairsort(long long a[], long long b[], long long k) {
pair<long long, long long> pairt[k];
for (long long i = 0; i < k; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + k);
for (long long i = 0; i < k; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long CheckPrime(long long k) {
for (long long i = 2; i < k; i++)
if (k % i == 0) return 0;
return 1;
}
long long countdigit(long long n) { return floor(log10(n) + 1); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
char a[n][n];
long long k = 0, l = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cin >> a[i][j];
if (a[i][j] == '.')
k++;
else
l++;
}
}
for (long long i = 1; i <= n - 2; i++) {
for (long long j = 1; j <= n - 2; j++) {
if (a[i][j] == '.' && a[i + 1][j] == '.' && a[i - 1][j] == '.' &&
a[i][j - 1] == '.' && a[i][j + 1] == '.') {
a[i][j] = '#';
a[i + 1][j] = '#';
a[i - 1][j] = '#';
a[i][j - 1] = '#';
a[i][j + 1] = '#';
k = k - 5;
}
}
}
if (k == 0)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,fast-math")
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const int maxn = 1000 * 30 + 5;
const long long inf = 9223372036854775807;
const long long mod = 1e9 + 7;
const int lg = 20;
const long long H = 1e7 + 19;
int n, k, q, dp[lg][maxn], sum, res[maxn], cnt, st[maxn], ft[maxn], v[maxn],
w[maxn], mark[maxn], h[4 * maxn];
vector<int> seg[4 * maxn], Q;
void upd(int l, int r, int i, int x = 1, int lx = 0, int rx = q + 1) {
if (lx >= r || rx <= l) return;
if (lx >= l && rx <= r) {
seg[x].push_back(i);
return;
}
int mid = lx + rx >> 1;
upd(l, r, i, x << 1, lx, mid);
upd(l, r, i, x << 1 | 1, mid, rx);
}
void go(int x = 1, int lx = 0, int rx = q + 1) {
if (rx - lx == 1) return;
h[x << 1] = h[x << 1 | 1] = h[x] + 1;
int mid = lx + rx >> 1;
go(x << 1, lx, mid);
go(x << 1 | 1, mid, rx);
}
void build(int x = 1, int lx = 0, int rx = q + 1) {
for (int i = 1; i <= k; i++) dp[h[x]][i] = dp[h[x] - 1][i];
for (auto u : seg[x]) {
for (int i = k; i >= 1; i--) {
if (w[u] <= i) dp[h[x]][i] = max(dp[h[x]][i], dp[h[x]][i - w[u]] + v[u]);
}
}
if (rx - lx == 1) {
if (mark[lx]) {
sum = 0;
for (int i = k; i >= 1; i--) {
sum = (long long)((long long)sum * H % mod + dp[h[x]][i]) % mod;
}
res[lx] = sum;
}
return;
}
int mid = lx + rx >> 1;
build(x << 1, lx, mid);
build(x << 1 | 1, mid, rx);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> v[i] >> w[i];
st[i] = 0;
}
cnt = n;
cin >> q;
int t, x;
for (int i = 1; i <= q; i++) {
cin >> t;
if (t == 2) {
cin >> x;
ft[x] = i + 1;
}
if (t == 1) {
n++;
cin >> v[n] >> w[n];
st[n] = i;
}
if (t == 3) {
Q.push_back(i);
mark[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (ft[i] == 0) ft[i] = q + 1;
upd(st[i], ft[i], i);
}
h[1] = 1;
go();
build();
for (int u : Q) cout << res[u] << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
void read(T &x) {
char ch;
x = 0;
int f = 1;
while (isspace(ch = getchar()))
;
if (ch == '-') ch = getchar(), f = -1;
do x = x * 10 + (ch - '0');
while (isdigit(ch = getchar()));
x *= f;
}
template <class T, class... A>
void read(T &x, A &...args) {
read(x);
read(args...);
}
const int N = 500005;
vector<int> pos[N];
int L[N / 2], R[N / 2], cnt = 0;
vector<int> rbound[N];
int tot_valued = 0;
struct node {
int mn, tag;
} t[N * 4];
void up(int x) { t[x].mn = min(t[x << 1].mn, t[x << 1 | 1].mn) + t[x].tag; }
void init(int x, int l, int r) {
t[x].tag = 0;
if (l == r) {
t[x].mn = l + tot_valued;
return;
}
int mid = (l + r) >> 1;
init(x << 1, l, mid);
init(x << 1 | 1, mid + 1, r);
up(x);
}
void modify(int x, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
t[x].mn += v;
t[x].tag += v;
return;
}
int mid = (l + r) >> 1;
if (ql <= mid) modify(x << 1, l, mid, ql, qr, v);
if (qr > mid) modify(x << 1 | 1, mid + 1, r, ql, qr, v);
up(x);
}
int main() {
int T;
read(T);
while (T--) {
int n;
read(n);
for (int i = 0; i <= n; ++i) pos[i].clear();
tot_valued = 0;
for (int i = 1; i <= n; ++i) {
int x;
read(x);
pos[x].push_back(i);
}
cnt = 0;
int len = pos[0].size() - pos[0].size() / 2;
for (size_t i = 0, li = pos[0].size() / 2; i < li; ++i) {
L[cnt] = pos[0][i];
R[cnt++] = pos[0][i + len];
}
for (int i = 0; i <= cnt; ++i) rbound[i].clear();
int res = pos[0].size() / 2;
if (!res) {
puts("0");
continue;
}
for (int i = 1; i <= n; ++i) {
if (pos[i].empty()) continue;
++tot_valued;
int lcnt = 0, rcnt = 0;
for (int p : pos[i]) {
if (L[cnt - 1] <= p && p <= R[0]) {
lcnt = cnt;
rcnt = cnt;
break;
} else if (p <= L[cnt - 1])
lcnt = max<int>(lcnt, upper_bound(L, L + cnt, p) - L);
else
rcnt = max<int>(rcnt, R + cnt - lower_bound(R, R + cnt, p));
}
rbound[lcnt].push_back(rcnt);
}
init(1, 0, cnt);
for (int l = 0; l <= cnt; ++l) {
for (int r : rbound[l]) modify(1, 0, cnt, r, cnt, -1);
res = min(res, l + t[1].mn);
}
printf("%d\n", res);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5, INF = 1e9;
int N, M, Q;
namespace Dinic {
struct node {
int v, next, k;
} E[MAXN];
int cur[MAXN], head[MAXN], Elen = 1, S, T;
void add(int u, int v, int k) {
++Elen, E[Elen].v = v, E[Elen].next = head[u], head[u] = Elen, E[Elen].k = k;
}
void ADD(int u, int v, int k) { add(u, v, k), add(v, u, 0); }
void reset() {
for (int i = 2; i < Elen; i += 2) {
E[i].k += E[i ^ 1].k, E[i ^ 1].k = 0;
}
}
int dis[MAXN];
queue<int> Q;
bool bfs() {
for (int i = 1; i <= N; ++i) dis[i] = 0;
dis[S] = 1, Q.push(S);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = head[u]; i; i = E[i].next)
if (E[i].k && !dis[E[i].v]) {
dis[E[i].v] = dis[u] + 1, Q.push(E[i].v);
}
}
return dis[T];
}
int dfs(int u, int lim) {
if (u == T || !lim) return lim;
int flow = 0;
for (int i = cur[u]; i; i = E[i].next) {
cur[u] = head[u];
if (dis[E[i].v] == dis[u] + 1) {
int d = dfs(E[i].v, min(lim, E[i].k));
if (d) {
lim -= d, flow += d, E[i].k -= d, E[i ^ 1].k += d;
if (!lim) return flow;
}
}
}
return flow;
}
int dinic(int u, int v) {
reset(), S = u, T = v;
int ans = 0;
while (bfs()) {
for (int i = 1; i <= N; ++i) cur[i] = head[i];
ans += dfs(S, INF);
}
return ans;
}
}; // namespace Dinic
namespace GomoryHu_Tree {
struct node {
int v, next, k;
} E[MAXN];
int head[MAXN], Elen = 1;
void add(int u, int v, int k) {
++Elen, E[Elen].v = v, E[Elen].next = head[u], head[u] = Elen, E[Elen].k = k;
}
int a[MAXN], x[MAXN], y[MAXN];
void build(int l, int r) {
if (l == r) return;
int k = Dinic::dinic(a[l], a[l + 1]);
add(a[l], a[l + 1], k), add(a[l + 1], a[l], k);
int xl = 0, yl = 0;
for (int i = l; i <= r; ++i) {
if (Dinic::dis[a[i]])
x[++xl] = a[i];
else
y[++yl] = a[i];
}
int pos = l - 1;
for (int i = 1; i <= xl; ++i) a[++pos] = x[i];
for (int i = 1; i <= yl; ++i) a[++pos] = y[i];
build(l, l + xl - 1), build(l + xl, r);
}
void build() {
for (int i = 1; i <= N; ++i) a[i] = i;
build(1, N);
}
int ret, retu, fa[MAXN], arr[MAXN], al;
long long ans;
void dfs(int u, int ff) {
fa[u] = ff;
for (int i = head[u]; i; i = E[i].next)
if (E[i].k && E[i].v != ff) {
if (E[i].k < ret) ret = E[i].k, retu = E[i].v;
dfs(E[i].v, u);
}
}
void solve(int u) {
ret = INF, retu = 0, dfs(u, 0);
if (ret == INF)
arr[++al] = u;
else {
ans += ret;
int tu = fa[retu], tv = retu;
for (int i = head[fa[retu]]; i; i = E[i].next)
if (E[i].v == retu) E[i].k = E[i ^ 1].k = 0;
solve(tu), solve(tv);
}
}
} // namespace GomoryHu_Tree
int main() {
scanf("%d%d", &N, &M);
int u, v, k;
for (int i = 1; i <= M; ++i)
scanf("%d%d%d", &u, &v, &k), Dinic::ADD(u, v, k), Dinic::ADD(v, u, k);
GomoryHu_Tree::build();
GomoryHu_Tree::solve(1);
printf("%lld\n", GomoryHu_Tree::ans);
for (int i = 1; i <= N; ++i) printf("%d ", GomoryHu_Tree::arr[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, w;
cin >> k >> n >> w;
cout << max((w * (k * (1 + w)) / 2) - n, 0) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e5 + 10;
unsigned long long ch[70][70];
int main() {
unsigned long long m, k, ans = 0;
int i, j;
scanf("%lld%lld", &m, &k);
if (m == 0) {
printf("1");
return 0;
}
ch[0][0] = 1;
for (i = 1; i <= 64; i++) {
ch[i][0] = 1;
for (j = 1; j <= i; j++) ch[i][j] = ch[i - 1][j] + ch[i - 1][j - 1];
}
for (k--; k >= 0; k--) {
if (m == 0) break;
if (k == 0) {
ans++;
break;
}
if (k == 1) {
if (m == 1)
ans += 2;
else if (m == 2)
ans += 4;
else
ans += (1LL << m - 1) + 1;
break;
}
for (i = 0; i < 64 && ch[i][k] <= m; i++)
;
ans += 1LL << (i - 1);
m -= ch[i - 1][k];
}
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, v[200001], eseen[200001], oseen[200001], ans[200001];
vector<vector<int>> p;
int main() {
cin >> n;
queue<int> odd, even;
p.resize(n + 1);
for (int i = 0; i < n; i += 1) {
cin >> v[i];
if (v[i] % 2 == 1) {
odd.push(i);
} else {
even.push(i);
}
if (v[i] + i < n) {
p[i + v[i]].push_back(i);
}
if (i - v[i] >= 0) {
p[i - v[i]].push_back(i);
}
}
int cnt = 0;
while (odd.size()) {
int f = odd.size();
while (f--) {
int next = odd.front();
odd.pop();
if (oseen[next]) {
continue;
}
oseen[next] = true;
if (v[next] % 2 == 0) {
ans[next] = cnt;
}
for (int i : p[next]) {
odd.push(i);
}
}
cnt += 1;
}
cnt = 0;
while (even.size()) {
int f = even.size();
while (f--) {
int next = even.front();
even.pop();
if (eseen[next]) {
continue;
}
eseen[next] = true;
if (v[next] % 2 == 1) {
ans[next] = cnt;
}
for (int i : p[next]) {
even.push(i);
}
}
cnt += 1;
}
for (int i = 0; i < n; i += 1) {
if (ans[i]) {
cout << ans[i] << " ";
} else {
cout << -1 << " ";
}
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double p, d, t, f, c;
int main(int argc, char const *argv[]) {
scanf("%lf%lf%lf%lf%lf", &p, &d, &t, &f, &c);
if (p >= d) {
printf("0\n");
return 0;
}
double pl = t * p, dl = 0;
int ans = 0;
while (pl < c) {
double t1 = (pl - dl) / (d - p);
dl = pl + t1 * p;
ans++;
double t2 = dl * 2 / d + f;
pl = dl + t2 * p;
}
if (dl >= c) ans--;
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, minm, maxm;
scanf("%d %d %d %d", &N, &M, &minm, &maxm);
int a[M];
bool fr[107] = {0}, chk = true;
for (int i = 0; i < M; i++) {
scanf("%d", &a[i]);
fr[a[i]] = true;
if (chk && (a[i] < minm || a[i] > maxm)) chk = false;
}
bool dne = false;
if (chk) {
if ((N - M) >= 0 && fr[minm] && fr[maxm]) dne = true;
if ((N - M) >= 1 && !fr[minm] && fr[maxm])
dne = true;
else if ((N - M) >= 1 && !fr[maxm] && fr[minm])
dne = true;
else if ((N - M) >= 2 && !fr[minm] && !fr[maxm])
dne = true;
}
if (dne)
printf("Correct\n");
else
printf("Incorrect\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void bSegT(long long int tree[], long long int a[], long long int s,
long long int e, long long int index, long long int od) {
if (s == e) {
tree[index] = a[s];
return;
}
long long int mid = (s + e) / 2;
if (od == 1)
od = 2;
else
od = 1;
bSegT(tree, a, s, mid, 2 * index, od);
bSegT(tree, a, mid + 1, e, 2 * index + 1, od);
if (od == 1)
tree[index] = tree[2 * index] ^ tree[2 * index + 1];
else
tree[index] = tree[2 * index] | tree[2 * index + 1];
}
void solve() {
int n;
cin >> n;
long long int result = INT_MAX;
for (int i = 1; i <= n; i++) {
int cnt = n - 2;
long long int sum = 0;
for (int j = (i + 2) % n; cnt > 0; j++) {
if (j == 0) j = n;
long long int p1 = i;
long long int p2 = j;
long long int p3 = j - 1;
if (p3 == 0) p3 = n;
sum += (p1 * p2 * p3);
cnt--;
}
result = min(result, sum);
}
cout << result << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long mod = 1000000007L;
using namespace std;
long long ar[200010], t1[200010], t2[200010];
int n;
long long solve(long long p[]) {
long long sum = p[0];
long long ans = p[0];
for (int i = 1; i < n - 1; i++) {
if (sum < 0)
sum = p[i];
else
sum += p[i];
ans = max(ans, sum);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 1; i < n; i++) {
long long x = abs(ar[i] - ar[i - 1]);
t1[i - 1] = x;
t2[i - 1] = x;
}
for (int i = 0; i < n - 1; i += 2) t1[i] = -t1[i];
for (int i = 1; i < n - 1; i += 2) t2[i] = -t2[i];
long long ans = max(solve(t1), solve(t2));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
string s[2000];
int D[2000][2000];
int vis[2000][2000];
pair<int, int> p[2000][2000];
int n, k;
string brute() {
string z, bst;
function<void(int, int, int)> dfs = [&](int i, int j, int k) {
if (i == n || j == n) return;
if (s[i][j] != 'a' && k)
z.push_back('a'), k--;
else
z.push_back(s[i][j]);
if (i == n - 1 && j == n - 1) {
if (bst.empty())
bst = z;
else
bst = min(bst, z);
}
dfs(i + 1, j, k);
dfs(i, j + 1, k);
z.pop_back();
};
dfs(0, 0, k);
return bst;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) D[i][j] = 1e9;
{
deque<pair<int, int>> q;
q.emplace_back(0, 0);
D[0][0] = (s[0][0] != 'a');
while (!q.empty()) {
auto [i, j] = q.front();
q.pop_front();
if (vis[i][j]) continue;
vis[i][j] = 1;
if (i + 1 < n) {
if (s[i + 1][j] == 'a') {
D[i + 1][j] = min(D[i + 1][j], D[i][j]);
q.emplace_front(i + 1, j);
} else {
D[i + 1][j] = min(D[i + 1][j], D[i][j] + 1);
q.emplace_back(i + 1, j);
}
}
if (j + 1 < n) {
if (s[i][j + 1] == 'a') {
D[i][j + 1] = min(D[i][j + 1], D[i][j]);
q.emplace_front(i, j + 1);
} else {
D[i][j + 1] = min(D[i][j + 1], D[i][j] + 1);
q.emplace_back(i, j + 1);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
}
}
string sol;
vector<pair<int, int>> v, w;
int md = -1e9;
if (k == 0 && D[0][0]) {
sol += s[0][0];
v.emplace_back(0, 0);
md = 0;
} else {
int x = 0, y = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (D[i][j] <= k) md = max(md, i + j);
sol += string(md + 1, 'a');
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (D[i][j] <= k && i + j == md) v.emplace_back(i, j), s[i][j] = 'a';
}
memset(vis, 0, sizeof vis);
while (!v.empty()) {
char mc = 'z' + 1;
for (auto [i, j] : v) mc = min(mc, s[i][j]);
for (auto [i, j] : v) {
if (s[i][j] != mc) continue;
if (i + 1 < n && !vis[i + 1][j]) {
p[i + 1][j] = {i, j};
vis[i + 1][j] = 1;
w.emplace_back(i + 1, j);
}
if (j + 1 < n && !vis[i][j + 1]) {
p[i][j + 1] = {i, j};
vis[i][j + 1] = 1;
w.emplace_back(i, j + 1);
}
}
swap(v, w);
w.clear();
}
int i = n - 1, j = n - 1;
string z;
while (i + j != md) {
z += s[i][j];
tie(i, j) = p[i][j];
}
reverse(begin(z), end(z));
sol += z;
cout << sol;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, fa, h[N];
vector<int> G[N], p, q;
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n - 1); ++i) scanf("%d", &fa), G[fa].push_back(i);
function<void(int)> dfs = [&](int u) {
for (int v : G[u]) dfs(v), h[u] = max(h[u], h[v] + 1);
};
dfs(0);
function<int(int, int)> solve = [&](int u, int nd) {
sort(G[u].begin(), G[u].end(), [&](int x, int y) { return h[x] < h[y]; });
p.push_back(u);
for (int i = (1); i <= (nd); ++i) q.push_back(u);
nd = 0;
for (int v : G[u]) nd = solve(v, nd);
return nd + 1;
};
solve(0, 0);
for (int x : p) printf("%d ", x);
printf("\n%d\n", q.size());
for (int x : q) printf("%d ", x);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17;
int T;
int n;
string s;
vector<pair<int, int>> query;
map<int, int> mp;
int a[N];
int cnt[N << 1];
long long sum[N << 1][5];
int pm[100005];
void pushup(int root) {
int l = 2 * root;
int r = 2 * root + 1;
cnt[root] = cnt[l] + cnt[r];
for (int i = 0; i < 5; i++) {
sum[root][i] = sum[l][i] + sum[r][(i - cnt[l] % 5 + 5) % 5];
}
}
int main() {
int tmp;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
cin >> s;
if (s[0] == 's') {
query.push_back(make_pair(2, 0));
} else {
scanf("%d\n", &tmp);
if (s[0] == 'a')
query.push_back(make_pair(0, tmp));
else
query.push_back(make_pair(1, tmp));
mp[tmp] = 0;
}
}
for (__typeof((mp).begin()) itr = ((mp).begin()); itr != (mp).end(); itr++) {
(itr->second) = T;
pm[T] = (itr->first);
T++;
}
for (int i = 0; i < n; i++) {
int type = query[i].first, x = query[i].second;
if (type == 2) {
printf("%I64d\n", sum[1][2]);
} else {
int id = N + mp[x];
cnt[id] = 1 - type;
sum[id][0] = (1 - type) * x;
for (int j = id / 2; j >= 1; j /= 2) pushup(j);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = 510;
int n, k, x;
bool dp[N][N];
vector<int> res;
int main() {
init_ios();
cin >> n >> k;
dp[0][0] = true;
while (n--) {
cin >> x;
for (int i = k; i >= 0; --i)
for (int j = k; j >= 0; --j) {
if (i - x >= 0 && dp[i - x][j]) dp[i][j] = true;
if (j - x >= 0 && dp[i][j - x]) dp[i][j] = true;
}
}
for (int i = 0; i <= k; ++i)
if (dp[i][k - i]) res.push_back(i);
cout << res.size() << "\n";
for (auto it : res) cout << it << " ";
cout << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int nmax = 1000100;
int n, m;
int a[nmax];
int us[nmax];
vector<pair<int, int> > now;
int main() {
cin >> n;
for (int i = 0; i < (int)(n); i++) scanf("%d", &a[i]);
cin >> m;
for (int i = 0; i < (int)(m); i++) {
int x;
scanf("%d", &x);
x--;
us[x] = 1;
}
for (int i = (int)(n)-1; i >= 0; i--) {
if (now.size() == 0 || us[i] || now.back().first != a[i]) {
now.push_back(make_pair(a[i], i));
a[i] *= -1;
continue;
}
now.pop_back();
}
if (now.size() != 0) {
puts("NO");
} else {
puts("YES");
for (int i = 0; i < (int)(n); i++) printf("%d ", a[i]);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
bool f = false;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = true;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ '0');
c = getchar();
}
return f ? -x : x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
long long n;
signed main() {
n = read();
if (n & 1) {
for (register long long i = 0; i < n - 1; ++i) cout << char('a' + (i & 2));
cout << "z\n";
for (register long long i = 0; i < n - 1; ++i) cout << char('b' + (i & 2));
cout << "z\n";
cout << 'q';
for (register long long i = 0; i < n - 1; ++i) cout << char('a' + (i & 2));
cout << '\n';
cout << 'q';
for (register long long i = 0; i < n - 1; ++i) cout << char('b' + (i & 2));
cout << '\n';
} else {
for (register long long i = 0; i < n; ++i) cout << char('a' + (i & 2));
cout << '\n';
for (register long long i = 0; i < n; ++i) cout << char('b' + (i & 2));
cout << '\n';
cout << 'z';
for (register long long i = 0; i < n - 2; ++i) cout << char('a' + (i & 2));
cout << "y\nz";
for (register long long i = 0; i < n - 2; ++i) cout << char('b' + (i & 2));
cout << "y\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
inline long long read() {
long long sum = 0, nega = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') nega = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum * nega;
}
const long long N = 5e5 + 9;
long long st[21][N], n, a[N], now, m, cnt, L, R;
long long lg[N], l[N], r[N];
map<long long, long long> mp;
inline void build() {
lg[0] = -1;
memset(st, 0x3f, sizeof(st));
for (long long i = 1; i <= cnt; i++) {
lg[i] = lg[i / 2] + 1;
st[0][i] = r[i] - l[i];
}
for (long long i = 1; i <= 20; i++)
for (long long j = 1; j <= cnt - (1 << i) + 1; j++)
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
inline long long query(long long x, long long y) {
long long k = lg[y - x + 1];
return min(st[k][x], st[k][y - (1 << k) + 1]);
}
signed main() {
n = read();
now = n + 1;
m = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = n; i >= 1; i--)
if (!mp[a[i]])
mp[a[i]] = i;
else if (now > mp[a[i]])
now = mp[a[i]], l[++cnt] = i, r[cnt] = mp[a[i]], mp[a[i]] = i;
else
mp[a[i]] = i;
for (long long i = 1; i <= cnt / 2; i++)
swap(l[i], l[cnt - i + 1]), swap(r[i], r[cnt - i + 1]);
build();
for (long long i = 1; i <= m; i++) {
L = read(), R = read();
long long x = lower_bound(l + 1, l + cnt + 1, L) - l,
y = upper_bound(r + 1, r + cnt + 1, R) - r - 1;
if (x <= y)
printf("%d\n", query(x, y));
else
puts("-1");
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define fastio ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;
int main() {
fastio;
int t; cin >> t;
while (t--) {
int ax, ay, bx, by, fx, fy; cin >> ax >> ay >> bx >> by >> fx >> fy;
int ans = abs(ax - bx) + abs(ay - by);
if (ax == bx && bx == fx && min(ay, by) < fy && fy < max(ay, by)) ans += 2;
else if (ay == by && by == fy && min(ax, bx) < fx && fx < max(ax, bx)) ans += 2;
cout << ans << "\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int GLL(long long& x) { return scanf("%lld", &x); }
int GI(int& x) { return scanf("%d", &x); }
int p, x, y;
bool test(int s) {
int i = (s / 50) % 475;
set<int> out;
for (int j = 0; j < (int)(25); j++) {
i = (i * 96 + 42) % 475;
out.insert(i);
}
return (out.find(p) != out.end());
}
int main() {
GI(p);
GI(x);
GI(y);
p -= 26;
int i = p;
vector<int> scores;
vector<int> diff;
int score = x;
int ans = 2000000000;
while (score >= y) {
if (test(score)) {
ans = 0;
}
score -= 50;
}
if (ans > 0) {
score = 0;
int cnt = 0;
while (true) {
if (test(x + score)) {
ans = min(ans, cnt);
break;
}
score += 50;
cnt = (score + 99) / 100;
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 1000020, C_MAX = 100020;
int n, m;
vector<int> L[N_MAX], R[N_MAX];
bool input() {
scanf("%d%d", &n, &m);
int i;
for (i = 0; i < m; i++) {
int p, c;
char t[9];
scanf("%d%d%s", &p, &c, t);
if (p >= c) return 0;
if (t[0] == 'L')
L[p].push_back(c);
else
R[p].push_back(c);
}
return 1;
}
vector<int> res;
int now = 1;
bool solve(int l, int r) {
if (l != now) return 0;
int ll, rr;
if (!L[l].empty()) {
ll = ++now;
rr = *max_element(L[l].begin(), L[l].end());
if (!solve(ll, rr)) return 0;
}
res.push_back(l);
if (!R[l].empty()) {
ll = min(++now, *min_element(R[l].begin(), R[l].end()));
rr = max(*max_element(R[l].begin(), R[l].end()), r);
if (!solve(ll, rr)) return 0;
} else if (now < r) {
if (!solve(++now, r)) return 0;
}
return 1;
}
int main() {
if (input() && solve(1, n)) {
int i;
for (i = 0; i < res.size(); i++) printf("%d ", res[i]);
puts("");
} else
puts("IMPOSSIBLE");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[5005], b[5005], c[5005], f[5005][5005], mx[5005];
vector<int> g[5005];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i], mx[i] = i;
for (int i = 1, x, y; i <= m; i++) cin >> x >> y, mx[y] = max(mx[y], x);
for (int i = 1; i <= n; i++) g[mx[i]].push_back(i);
memset(f, 0xc0, sizeof(f)), f[0][k] = 0;
for (int i = 1; i <= n; i++) {
for (int j = a[i]; j <= 5000 - b[i]; j++) f[i][j + b[i]] = f[i - 1][j];
for (int y : g[i]) {
for (int j = 1; j <= 5000; j++)
f[i][j - 1] = max(f[i][j - 1], f[i][j] + c[y]);
}
}
int ans = -1e8;
for (int i = 0; i <= 5000; i++) ans = max(ans, f[n][i]);
if (ans == -1e8)
cout << "-1";
else
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
pair<int, int> gas[MAXN];
vector<int> stations[4];
int dp[4][MAXN];
int calculate(int tip, int start, int s) {
int ona_posle =
lower_bound(stations[tip].begin(), stations[tip].end(), start) -
stations[tip].begin();
int do_kraja = dp[tip][ona_posle];
int do_mene = stations[tip][ona_posle] - start - s;
if (do_mene < 0) do_mene = 0;
return do_mene + do_kraja;
}
void fail() { puts("-1 -1"); }
int main() {
int e, s, n, m;
scanf("%d %d %d %d", &e, &s, &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &gas[i].first, &gas[i].second);
if (gas[i].second <= e) {
for (int t = 1; t <= gas[i].first; t++) {
stations[t].push_back(gas[i].second);
}
}
}
for (int t = 1; t <= 3; t++) {
stations[t].push_back(e);
sort(stations[t].begin(), stations[t].end());
stations[t].resize(unique(stations[t].begin(), stations[t].end()) -
stations[t].begin());
dp[t][(int)stations[t].size() - 1] = 0;
for (int i = (int)stations[t].size() - 2; i >= 0; i--) {
int to_next = stations[t][i + 1] - stations[t][i] - s;
if (to_next < 0) to_next = 0;
dp[t][i] = dp[t][i + 1] + to_next;
}
}
vector<int> starts(m);
for (int i = 0; i < m; i++) {
scanf("%d", &starts[i]);
int need_worst = calculate(3, starts[i], s);
int need_semi = calculate(2, starts[i], s);
int need_best = calculate(1, starts[i], s);
if (need_best > 0) {
fail();
} else {
printf("%d %d\n", need_semi, need_worst - need_semi);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int c = 2;
for (int i = 0; i < n - 1; i++) {
if ((a[i + 1] - a[i]) == 2 * d) {
c = c + 1;
} else if ((a[i + 1] - a[i]) > 2 * d) {
c = c + 2;
}
}
cout << c;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e6 + 6;
vector<int> adj[M];
int mark[M];
int ok[M];
void dfs(int v) {
mark[v] = 1;
for (auto u : adj[v])
if (!mark[u]) dfs(u);
}
int32_t main() {
long long n, m;
cin >> n >> m;
long long r = 0;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
ok[u] = 1, ok[v] = 1;
if (u != v) adj[u].push_back(v);
if (u != v) adj[v].push_back(u);
if (u == v) r++;
}
for (int i = 1; i <= n; i++)
if (ok[i]) {
dfs(i);
break;
}
for (int i = 1; i <= n; i++)
if (!mark[i] && ok[i]) return cout << 0 << endl, 0;
long long ans = r * (m - 1) - ((r) * (r - 1) / 2ll);
for (int i = 1; i <= n; i++) {
long long p = adj[i].size();
ans += p * (p - 1) / 2ll;
}
return cout << ans << endl, 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int i, j, n;
int arr[120];
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
for (i = 0; i < n; i++)
for (j = i; j < n; j++) {
if (arr[i] < arr[j]) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
float sum = 0;
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
sum += arr[i] * arr[i];
} else {
sum -= arr[i] * arr[i];
}
}
printf("%f\n", sum * 3.141592653589);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void rd(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void pp(T... args) {
((cout << args << " "), ...);
cout << "\n";
}
void add(long long &x, long long y) {
x += y;
if (x >= 1000000007) x %= 1000000007;
if (x < 0) x = x % 1000000007 + 1000000007;
}
void solve() {
int n;
rd(n);
string s;
rd(s);
string ans;
if (n <= 3)
cout << s << "\n";
else {
if (!(n & 1)) {
for (int i = 0; i + 1 < n; i += 2) {
ans.push_back(s[i]);
ans.push_back(s[i + 1]);
ans.push_back('-');
}
ans.pop_back();
} else {
int i = 0;
ans.push_back(s[i]);
ans.push_back(s[i + 1]);
ans.push_back(s[i + 2]);
ans.push_back('-');
for (int i = 3; i + 1 < n; i += 2) {
ans.push_back(s[i]);
ans.push_back(s[i + 1]);
ans.push_back('-');
}
ans.pop_back();
}
cout << ans << "\n";
}
}
void prep() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(12);
prep();
int t = 1;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct edge {
int v, next;
} e[200010];
int ecnt = 0, head[100010];
int n;
int d[100010];
int leg[100010];
void addedge(int a, int b) {
e[++ecnt].v = b;
e[ecnt].next = head[a];
head[a] = ecnt;
}
void del(int x) {
while (d[x] <= 2) {
d[x] = 0;
int xx = x;
for (int i = head[x]; ~i; i = e[i].next) {
if (d[e[i].v]) {
x = e[i].v;
break;
}
}
if (x == xx) break;
}
leg[x]++;
}
bool solve() {
for (int i = (1); i <= (n); i++) {
if (d[i]) {
int cnt = 0;
for (int j = head[i]; ~j; j = e[j].next) {
int v = e[j].v;
if (d[v]) {
if (leg[v] > 2)
cnt++;
else if (d[v] - leg[v] > 1)
cnt++;
}
}
if (cnt > 2) return false;
}
}
return true;
}
int main() {
cin >> n;
memset((head), (-1), sizeof(head));
memset((d), (0), sizeof(d));
memset((leg), (0), sizeof(leg));
for (int i = (1); i <= (n - 1); i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
d[u]++;
d[v]++;
}
for (int i = (1); i <= (n); i++) {
if (d[i] == 1) del(i);
}
puts(solve() ? "Yes" : "No");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
const int MOD = 1000000007;
const int MOD1 = 998244353;
const int maxn = 100010;
const int lim = (int)1e9;
vector<int> v[2 * maxn];
int red = 0, black = 0;
void dfs(int node, int pre, int colour) {
(colour == 0 ? ++black : ++red);
for (auto i : v[node])
if (i != pre) dfs(i, node, 1 - colour);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n = 0, x = 0, y = 0;
cin >> n;
for (int i = 0; i + 1 < n; ++i) {
cin >> x >> y;
--x;
--y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(0, 0, 0);
cout << min(red, black) - 1;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int T;
cin >> T;
while (T--) {
long long int n;
cin >> n;
bitset<32> b;
b = n;
long long int a1 = 0;
for (long long int i = 31; i >= 0; i--) {
if (b[i]) {
a1++;
}
}
a1 = pow(2, a1);
cout << a1 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
if (n < 5) return puts("No solution"), 0;
double x = 0, y = 0, L = 100, step = M_PI * 2 / n, cur = 0;
for (int i = 1; i <= n - 1; i++) {
printf("%lf %lf\n", x, y);
cur += step;
x += L * cos(cur);
y += L * sin(cur);
L += 0.002;
}
printf("%lf %lf\n", x - y / tan(cur), 0.0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[7];
for (int i = 0; i < 7; i++) cin >> a[i];
int i;
for (i = 0; n > 0; i++) {
i %= 7;
n -= a[i];
}
cout << i;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int a[t + 10];
for (int i = 0; i < t; i++) a[i] = (t - i);
int p = sqrt(t);
int i = 0;
while (i < t) {
sort(a + i, a + min(i + p, t));
i += p;
}
for (int i = 0; i < t; i++) {
cout << a[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
const int maxm = 1000010;
const int inf = 1 << 30;
int n, m;
int tot, ans;
int a[maxn];
int main() {
scanf("%d", &n);
if (n == 1 || (n % 2 == 0)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
ans = 0;
int tt = n / 2, cc;
for (int i = tt; i > 0; --i) {
cc = max(a[i << 1], a[(i << 1) + 1]);
a[i] = max(0, a[i] - cc);
ans += cc;
}
ans += a[1];
printf("%d\n", ans);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.