solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e8;
int mp[100][100];
int main(void) {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> mp[i][j];
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int flag = 0;
if (mp[i][j] == 1) continue;
for (int p = 1; p <= n; p++) {
if (p == i) continue;
for (int q = 1; q <= n; q++) {
if (q == j) continue;
if (mp[p][j] + mp[i][q] == mp[i][j]) {
flag = 1;
}
}
}
if (!flag) res = 1;
}
}
if (!res)
puts("Yes");
else
puts("No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1, mod = 998244353;
int n, k, m, valq[N];
int cnt[30][N], prv[30][N], dp[30][N];
int sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
int binpow(int a, int b) {
if (b == 0) return 1;
if (b == 1) return a;
int ret = binpow(a, b / 2);
if (b % 2 == 0) return 1LL * ret * ret % mod;
return 1LL * ret * ret % mod * a % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> m;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r >> valq[i];
for (int j = 0; j < k; j++) {
if (valq[i] & (1 << j)) {
cnt[j][l]++, cnt[j][r + 1]--;
} else {
prv[j][r] = max(prv[j][r], l);
}
}
}
int ans = 1;
for (int i = 0; i < k; i++) {
dp[i][0] = 1;
int sum = 0, pos = 0;
for (int j = 1; j <= n; j++) {
sum += cnt[i][j];
if (sum > 0)
dp[i][j] = dp[i][j - 1];
else
dp[i][j] =
sub(2LL * dp[i][j - 1] % mod, (pos - 1 >= 0 ? dp[i][pos - 1] : 0));
if (prv[i][j] != 0) pos = max(pos, prv[i][j]);
}
ans = 1LL * ans * sub(dp[i][n], (pos - 1 >= 0 ? dp[i][pos - 1] : 0)) % mod;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
const int N = 20010;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const double e = 2.718281828459046;
using namespace std;
int dp[5010][5010];
char s[5010];
unsigned long long h1[5010], h2[5010];
vector<int> vt[5010];
unsigned long long p[5010];
int len;
unsigned long long f1(int l, int r) {
if (l == 0) return h1[r] * (p[len - r - 1]);
return (h1[r] - h1[l - 1]) * (p[len - r - 1]);
}
unsigned long long f2(int l, int r) { return (h2[l] - h2[r + 1]) * p[l]; }
int t[5010];
int main() {
scanf("%s", s);
len = strlen(s);
p[0] = 1;
for (int i = 1; i <= len; i++) p[i] = p[i - 1] * 31;
for (int i = 0; s[i]; i++) {
if (i == 0)
h1[i] = s[0] - 'a';
else
h1[i] = h1[i - 1] + p[i] * (s[i] - 'a');
}
for (int i = len - 1, j = 0; i >= 0; j++, i--)
h2[i] = h2[i + 1] + p[j] * (s[i] - 'a');
for (int i = 0; i < len; i++)
for (int j = i; j < len; j++)
if (f1(i, j) == f2(i, j)) vt[i].push_back(j);
for (int k = 0; k < len; k++)
for (int i = 0; i + k < len; i++) {
if (k == 0)
dp[i][i + k] = 1;
else {
while (t[i] < (int((vt[i]).size()))) {
if (vt[i][t[i]] <= i + k)
t[i]++;
else
break;
}
dp[i][i + k] = dp[i + 1][i + k] + t[i];
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
l--, r--;
printf("%d\n", dp[l][r]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, m, d, v;
int result[300000];
std::map<int, int> myMap;
std::map<int, int>::iterator itlow;
while (scanf("%d%d%d", &n, &m, &d) == 3) {
for (int i = 0; i < n; i++) {
scanf("%d", &v);
myMap.insert(std::pair<int, int>(v, i));
}
int day;
for (day = 1; myMap.empty() == false; day++) {
for (int j = 1; j <= m;) {
itlow = myMap.lower_bound(j);
if (itlow != myMap.end()) {
result[itlow->second] = day;
j = itlow->first + d + 1;
myMap.erase(itlow);
} else
j = m + 1;
}
}
printf("%d\n", day - 1);
for (int j = 0; j < n; j++) printf("%d ", result[j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int debug = 1;
const int N = 3.1e5;
int n, m, u, v, clr = 1, d[N], was[N], lab[N], pr[N];
vector<array<int, 2> > g[N];
array<int, 2> ed[N];
vector<int> ans;
void dfs(int v, int edp) {
was[v] = 1;
int cnt = 0;
for (auto i : g[v]) {
int u = i[0], ind = i[1];
if (was[u]) continue;
dfs(u, ind);
cnt += lab[ind];
}
if (d[v] != -1 && cnt % 2 != d[v]) {
if (edp == -1) {
puts("-1");
exit(0);
}
lab[edp] = 1;
ans.push_back(edp);
}
}
int main() {
cin >> n >> m;
int st = 1;
for (int i = 1; i <= n; ++i) {
cin >> d[i];
if (d[i] == -1) st = i;
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
ed[i] = {{u, v}};
g[u].push_back({{v, i}});
g[v].push_back({{u, i}});
}
dfs(st, -1);
cout << ans.size() << '\n';
for (int i : ans) cout << i + 1 << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long en, cap, flow, next;
} edge[1000000];
long long head[50005], tot, now[50005];
long long source, sink, tot_num;
long long pre[50005], dis[50005], gap[50005];
void add_edge(long long st, long long en, long long cap) {
edge[tot].en = en;
edge[tot].cap = cap;
edge[tot].flow = 0;
edge[tot].next = head[st];
head[st] = tot++;
edge[tot].en = st;
edge[tot].cap = 0;
edge[tot].flow = 0;
edge[tot].next = head[en];
head[en] = tot++;
}
void augment(long long flow) {
for (long long i = source; i != sink; i = edge[now[i]].en) {
edge[now[i]].flow += flow;
edge[now[i] ^ 1].flow -= flow;
}
}
long long sap() {
memset(dis, 0, sizeof(dis));
memset(gap, 0, sizeof(gap));
memset(pre, -1, sizeof(pre));
for (long long i = 0; i < tot_num; i++) now[i] = head[i];
gap[0] = tot_num;
long long poLL = source, flow = 0, min_flow = 0x3fffffff;
while (dis[source] < tot_num) {
bool fg = false;
for (long long i = now[poLL]; i != -1; i = edge[i].next)
if (edge[i].cap - edge[i].flow > 0 && dis[poLL] == dis[edge[i].en] + 1) {
min_flow = min(min_flow, edge[i].cap - edge[i].flow);
now[poLL] = i;
pre[edge[i].en] = poLL;
poLL = edge[i].en;
if (poLL == sink) {
flow += min_flow;
augment(min_flow);
poLL = source;
min_flow = 0x3fffffff;
}
fg = true;
break;
}
if (fg) continue;
if (--gap[dis[poLL]] == 0) break;
long long Min = tot_num;
for (long long i = head[poLL]; i != -1; i = edge[i].next)
if (edge[i].cap - edge[i].flow > 0 && Min > dis[edge[i].en]) {
Min = dis[edge[i].en];
now[poLL] = i;
}
gap[dis[poLL] = Min + 1]++;
if (poLL != source) poLL = pre[poLL];
}
return flow;
}
long long sum;
void build(long long n) {
memset(head, -1, sizeof(head));
tot = 0;
source = 0;
sink = n * 2 + 1;
tot_num = n * 2 + 2;
long long a, b, c;
long long m;
long long j;
for (long long i = 1; i <= n; i++)
for (j = 1, cin >> m; j <= m; j++) {
cin >> a;
add_edge(i, n + a, 0x3fffffff);
}
sum = 0;
for (long long i = 1; i <= n; i++) {
add_edge(n + i, sink, 0x3fffffff);
cin >> a;
sum += a;
add_edge(source, i, 0x3fffffff - a);
}
}
int main() {
long long n, m;
while (cin >> n) {
build(n);
long long ans = sap();
cout << sum + ans - n * 0x3fffffff << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
queue<char> q;
cin >> s;
int n = s.size();
if (n % 2 == 0) {
int cond = 0;
int i;
for (i = 0; i < n / 2; i++) {
q.push(s[i]);
}
for (; i < n; i++) {
if (q.front() == s[i]) {
q.pop();
} else {
cond = 1;
break;
}
}
if (cond == 1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const ll mod = 1e9 + 7;
ll pw(ll x, ll y) {
ll res = 1;
while (y) {
if (y % 2) res = res * x % mod;
x = x * x % mod;
y = y / 2;
}
return ((res % mod) + mod) % mod;
}
vector<string> colors = {"white", "yellow", "green", "blue", "red", "orange"};
ll k;
map<ll, map<string, ll>> dp;
map<ll, set<ll>> g;
void addEdge(ll u, ll v) {
g[u].insert(v);
g[v].insert(u);
}
map<ll, ll> cache;
ll level(ll at) {
if (cache.count(at)) {
return cache[at];
}
if (at == 1) return 0;
return cache[at] = 1 + level(at / 2);
}
void mul(ll &x, ll y) {
x %= mod;
y %= mod;
x *= y;
x %= mod;
}
map<ll, ll> treeCache;
ll solveTree(ll k) {
if (treeCache.count(k)) {
return treeCache[k];
}
ll res = 1;
for (ll i = 0; i < k; i++) {
res *= pw(4, 1ll << i);
res %= mod;
}
return treeCache[k] = res;
}
bool compat(const string &s1, const string &s2) {
if (s1 == s2) return false;
if (s1 == "white") {
return s2 != "yellow";
} else if (s1 == "yellow") {
return s2 != "white";
} else if (s1 == "green") {
return s2 != "blue";
} else if (s1 == "blue") {
return s2 != "green";
} else if (s1 == "red") {
return s2 != "orange";
} else if (s1 == "orange") {
return s2 != "red";
}
assert(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
assert(solveTree(1) == 4);
assert(solveTree(2) == 4 * 4 * 4);
cin >> k;
vector<ll> nodes;
set<ll> assigned;
int n;
cin >> n;
assert(n >= 1);
for (int i = 0; i < n; i++) {
ll at;
string c;
cin >> at;
assigned.insert(at);
cin >> c;
for (auto col : colors) {
dp[at][col] = (col == c ? 1 : 0);
}
nodes.push_back(at);
while (at > 1) {
ll p = at / 2;
nodes.push_back(p);
addEdge(p, at);
at /= 2;
}
}
sort(nodes.begin(), nodes.end());
nodes.erase(unique(nodes.begin(), nodes.end()), nodes.end());
reverse(nodes.begin(), nodes.end());
int cnt = nodes.size();
assert(cnt < 2010 * 65);
for (ll at : nodes) {
if (level(at) + 1 == k) {
continue;
}
if (!assigned.count(at)) {
for (auto col : colors) {
dp[at][col] = 1;
}
}
for (auto &col : colors) {
for (ll to : {2ll * at, 2ll * at + 1}) {
if (!g[at].count(to)) {
mul(dp[at][col], solveTree(k - level(to)));
} else {
ll res = 0;
for (auto &col2 : colors) {
if (compat(col, col2)) {
res += dp[to][col2];
}
}
mul(dp[at][col], res);
}
}
}
}
ll res = 0;
for (auto &c : colors) {
res += dp[1][c];
res %= mod;
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, d;
int a[105];
int Max;
void getnum(int p, int q) {
if (q == n) return;
if (a[p] + d >= a[q]) {
Max = std::max(Max, q - p);
q++;
} else
p++;
getnum(p, q);
return;
}
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
std::sort(a, a + n);
getnum(0, 1);
printf("%d", n - Max - 1);
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int* A = new int[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int l, r, p;
for (int i = 0; i < m; i++) {
cin >> l >> r >> p;
if (p < l)
cout << "No" << endl;
else if (p > r)
cout << "No" << endl;
else {
int x = A[p - 1];
int count = 0;
for (int j = l; j <= r; j++) {
if (A[j - 1] < x) {
count++;
}
}
if (l + count == p)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20);
int n, k;
int a[MAXN];
void read() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
}
void solve() {
priority_queue<pair<int, int> > st;
for (int i = 1; i <= k; i++) st.push({a[i], i});
vector<int> answer;
answer.assign(n, -1);
int64_t answer_val = 0;
for (int i = k + 1; i <= n + k; i++) {
if (i <= n) st.push({a[i], i});
auto it = st.top();
answer[it.second - 1] = i;
answer_val += a[it.second] * 1ll * (i - it.second);
st.pop();
}
cout << answer_val << '\n';
for (int x : answer) cout << x << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[5005];
int dp[5005][5005][2];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= 1; ++k) {
dp[i][j][k] = 987654321;
}
}
}
dp[1][0][0] = 1;
dp[1][1][1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= round(n / 2.0); ++j) {
for (int k = 0; k <= 1; ++k) {
if (k == 0) {
dp[i + 1][j][0] = min(dp[i][j][k], dp[i + 1][j][0]);
dp[i + 1][j + 1][1] =
min(dp[i][j][k] + (a[i + 1] > a[i] ? 0 : a[i] - a[i + 1] + 1),
dp[i + 1][j + 1][1]);
} else {
dp[i + 1][j][0] =
min(dp[i][j][k] + (a[i] > a[i + 1] ? 0 : a[i + 1] - a[i] + 1),
dp[i + 1][j][0]);
dp[i + 2][j + 1][1] =
min(dp[i][j][k] + (min(a[i + 2], a[i]) > a[i + 1]
? 0
: a[i + 1] - min(a[i + 2], a[i]) + 1),
dp[i + 2][j + 1][1]);
}
}
}
}
for (int i = 1; i <= round(n / 2.0); ++i) {
int res = min(dp[n][i][0], dp[n][i][1]) - 1;
cout << res << " ";
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
const int MD = 1000000007;
inline void add(int& a, int b) {
a += b;
if (a >= MD) a -= MD;
}
int mod_mult(long long a, long long b) { return (a * b) % MD; }
int neg(int a) {
if (a == 0) return 0;
return -a + MD;
}
int exp(int a, int b) {
int res = 1;
while (b) {
if (b % 2 == 1) res = mod_mult(res, a);
a = mod_mult(a, a);
b /= 2;
}
return res;
}
inline int inv(int a) { return exp(a, MD - 2); }
struct FWT {
void fwt_add(int i, int d, int fwt[MX]) {
while (i < MX) {
add(fwt[i], d);
i += i & -i;
}
}
int fwt_get(int i, int fwt[MX]) {
int s = 0;
while (i) {
add(s, fwt[i]);
i -= i & -i;
}
return s;
}
int fwt1[MX], fwt2[MX];
void add_range(int l, int r, int d) {
fwt_add(l, d, fwt1);
fwt_add(r + 1, neg(d), fwt1);
fwt_add(l, mod_mult(d, l - 1), fwt2);
fwt_add(r + 1, mod_mult(neg(d), r), fwt2);
}
int prefix_sum(int i) {
int tmp = mod_mult(i, fwt_get(i, fwt1));
add(tmp, neg(fwt_get(i, fwt2)));
return tmp;
}
int get_sum(int l, int r) {
int tmp = prefix_sum(r);
add(tmp, neg(prefix_sum(l - 1)));
return tmp;
}
} T1, T2;
vector<int> neigh[MX];
int L[MX], R[MX];
int len_inv[MX];
bool removed[MX];
int sz[MX];
void dfs1(int v, int p) {
sz[v] = 1;
for (int u : neigh[v]) {
if (removed[u]) continue;
if (u == p) continue;
dfs1(u, v);
sz[v] += sz[u];
}
}
int findCentroid(int v) {
dfs1(v, -1);
int s = sz[v];
int p = -1;
while (true) {
int to = -1;
for (int u : neigh[v]) {
if (removed[u]) continue;
if (u == p) continue;
if (sz[u] * 2 > s) {
to = u;
break;
}
}
if (to == -1) return v;
p = v;
v = to;
}
}
int ans_cnt[MX];
pair<int, int> value[MX];
int to_add[MX], all[MX];
int cnt1 = 0, cnt2 = 0;
void dfs2(int v, int p, int d) {
to_add[cnt1++] = v;
pair<int, int> tmp = {T1.get_sum(L[v], R[v]), T2.get_sum(L[v], R[v])};
int x = tmp.first;
add(x, mod_mult(d, tmp.second));
add(ans_cnt[v], x);
value[v] = {mod_mult(d, len_inv[v]), len_inv[v]};
for (int u : neigh[v]) {
if (removed[u]) continue;
if (u == p) continue;
dfs2(u, v, d + 1);
}
}
void solve(int v) {
v = findCentroid(v);
value[v] = {0, len_inv[v]};
T1.add_range(L[v], R[v], value[v].first);
T2.add_range(L[v], R[v], value[v].second);
all[cnt2++] = v;
for (int u : neigh[v]) {
if (removed[u]) continue;
dfs2(u, v, 1);
while (cnt1 > 0) {
int x = to_add[--cnt1];
T1.add_range(L[x], R[x], value[x].first);
T2.add_range(L[x], R[x], value[x].second);
all[cnt2++] = x;
}
}
while (cnt2 > 0) {
int x = all[--cnt2];
T1.add_range(L[x], R[x], neg(value[x].first));
T2.add_range(L[x], R[x], neg(value[x].second));
}
removed[v] = true;
for (int u : neigh[v]) {
if (removed[u]) continue;
solve(u);
}
}
int main() {
int n;
ignore = scanf("%d", &n);
for (int i = 1; i <= n; i++) {
ignore = scanf("%d %d", L + i, R + i);
L[i]++;
R[i]++;
len_inv[i] = inv(R[i] - L[i] + 1);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
ignore = scanf("%d %d", &u, &v);
neigh[u].push_back(v);
neigh[v].push_back(u);
}
solve(1);
int ans = 0;
for (int i = 1; i <= n; i++) {
add(ans, mod_mult(ans_cnt[i], len_inv[i]));
}
for (int i = 1; i <= n; i++) {
ans = mod_mult(ans, R[i] - L[i] + 1);
}
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y;
cin >> x >> y;
int v1, v2, ans = 0, p = 0, q = 0, tp = 0, tq = 0, pos, neg = 1, turn = 0;
for (int i = 1, cnt = 1, alt = 1; i <= 10000; cnt++) {
tp = p;
tq = q;
if (alt) {
p += neg * i;
turn++;
} else {
q += neg * i;
turn++;
}
if (((y - tq) * (p - tp) == (q - tq) * (x - tp))) {
if ((tp == p)) {
v1 = min(tq, q);
v2 = max(tq, q);
if ((v1 <= y && y <= v2)) break;
}
if ((tq == q)) {
v1 = min(tp, p);
v2 = max(tp, p);
if ((v1 <= x && x <= v2)) break;
}
}
if (cnt % 2 == 0) {
neg = -neg;
i++;
}
alt = 1 - alt;
}
cout << turn - 1 << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
double res = 0.0;
bool vis[N];
vector<int> g[N];
inline int read() {
int s = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') s = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return s * x;
}
void dfs(int u, double d, double x) {
queue<int> q;
double y = 0.0;
for (int v : g[u])
if (!vis[v]) q.push(v), y++;
if (q.empty())
res += d * x;
else {
while (!q.empty()) {
int v = q.front();
q.pop();
vis[v] = 1;
dfs(v, d + 1, x / y);
}
}
}
int main() {
int n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
g[u].push_back(v);
g[v].push_back(u);
}
memset(vis, 0, sizeof(vis));
vis[1] = 1;
dfs(1, 0, 1);
return 0 * printf("%.8lf\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n[100001];
int N, i, zero, sign;
double div, a, b, c, d, e, f;
cin >> N;
zero = 0;
b = 0;
c = 0;
d = 0;
a = 0;
f = 0;
sign = 0;
for (i = 0; i < N; i++) {
cin >> n[i];
if (n[i] == 0) zero++;
}
if (N == 1 || N == 2 && n[0] != 0)
cout << "0" << endl;
else if (N == zero)
cout << "0" << endl;
else if (N - zero == 1) {
if (n[0] != 0)
cout << "0" << endl;
else
cout << "1" << endl;
} else if (N - zero == 2 && zero > 1) {
if (n[0] != 0)
cout << "1" << endl;
else
cout << "2" << endl;
} else if (N - zero > 1 && zero > 1) {
cout << "2" << endl;
} else if (zero == 1) {
if (n[0] == 0) {
b = n[2] / n[1];
for (i = 3; i < N; i++) {
div = n[i] / n[i - 1];
if (div != b) {
cout << "2" << endl;
return 0;
}
}
cout << "1" << endl;
} else if (n[1] == 0) {
b = n[2] / n[0];
for (i = 3; i < N; i++) {
div = n[i] / n[i - 1];
if (div != b) {
cout << "2" << endl;
return 0;
}
}
cout << "1" << endl;
} else {
b = n[1] / n[0];
for (i = 2; i < N; i++) {
if (n[i] == 0) {
if (i == N - 1) continue;
if (n[i + 1] / n[i - 1] == b) {
i++;
sign++;
continue;
}
}
div = n[i] / n[i - 1];
if (div != b) {
cout << "2" << endl;
return 0;
}
}
cout << "1" << endl;
}
} else if (N == 3) {
a = n[1] / n[0];
b = n[2] / n[1];
if (a == b)
cout << "0" << endl;
else
cout << "1" << endl;
} else if (N == 4) {
a = n[1] / n[0];
b = n[2] / n[1];
c = n[3] / n[2];
if (a == b && b == c)
cout << "0" << endl;
else if (a == b && b != c || b == c && b != a || n[2] / n[0] == c ||
a == n[3] / n[1])
cout << "1" << endl;
else
cout << "2" << endl;
} else {
a = n[1] / n[0];
b = n[2] / n[1];
c = n[3] / n[2];
d = n[4] / n[3];
if (a == b && b == c && c == d)
f = a;
else {
if (b == c && c == d)
f = b;
else if (a == b && b == c)
f = a;
else if (n[2] / n[0] == c && c == d)
f = c;
else if (n[3] / n[1] == a && a == d)
f = a;
else if (n[4] / n[2] == a && a == b)
f = a;
sign++;
}
for (i = 5; i < N; i++) {
if (n[i] / n[i - 1] != f) {
if (i == N - 1) {
sign++;
if (sign > 1) {
cout << "2" << endl;
return 0;
} else
continue;
}
if (n[i + 1] / n[i - 1] == f) {
i++;
sign++;
if (sign > 1) {
cout << "2" << endl;
return 0;
} else
continue;
} else {
cout << "2" << endl;
return 0;
}
}
}
if (sign == 1)
cout << "1" << endl;
else
cout << "0" << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string a;
int f[100005];
int main() {
cin >> a;
int n = a.size();
int ae = 0, ao = 0, be = 0, bo = 0;
long long anse = 0, anso = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 'a') {
if (i % 2 == 0) {
anse += ao;
anso += ae;
ae++;
} else {
anse += ae;
anso += ao;
ao++;
}
anso++;
} else {
if (i % 2 == 0) {
anse += bo;
anso += be;
be++;
} else {
anse += be;
anso += bo;
bo++;
}
anso++;
}
}
printf("%lld %lld", anse, anso);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using uint = unsigned int;
int n, a, b;
vector<int> h;
vector<int> hits;
vector<int> ans;
void go(int i) {
if (i == n) {
if (accumulate(begin(hits), end(hits), 0) <
accumulate(begin(ans), end(ans), 0)) {
ans = hits;
}
return;
}
int mn = max(0, (h[i - 1] - hits[i - 1] * a - hits[i - 2] * b + b - 1) / b);
int mx = max(mn, (h[i] - hits[i - 1] * b + a - 1) / a);
if (i == n - 1) {
mn = max(mn, (h[n] + b - 1) / b);
mx = max(mx, mn);
}
for (hits[i] = mn; hits[i] <= mx; ++hits[i]) {
go(i + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> a >> b;
h.resize(n + 1);
hits.resize(n + 1);
ans = vector<int>(n + 1, 100);
for (int i = 1; i <= n; ++i) {
cin >> h[i];
++h[i];
}
go(2);
cout << accumulate(begin(ans), end(ans), 0) << '\n';
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < ans[i]; ++j) {
cout << i << ' ';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long v[maxn], t[maxn], sumt[maxn], f[maxn], ans[maxn];
int n;
int lobit(int x) { return (x & -x); }
void add(long long x, long long val) {
while (x <= n) {
f[x] += val;
x += lobit(x);
}
}
long long query(long long x) {
long long sum = 0;
while (x) {
sum += f[x];
x -= lobit(x);
}
return sum;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
for (int i = 1; i <= n; i++) {
cin >> t[i];
sumt[i] = sumt[i - 1] + t[i];
}
for (int i = 1; i <= n; i++) {
long long tt =
lower_bound(sumt + i, sumt + n + 1, v[i] + sumt[i - 1]) - sumt;
if (tt == n + 1) {
add(i, 1);
add(n + 1, -1);
} else {
add(i, 1);
if (v[i] == t[i])
add(tt + 1, -1);
else {
add(tt, -1);
ans[tt] += v[i] - (sumt[tt - 1] - sumt[i - 1]);
}
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] + t[i] * query(i) << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool nums[101];
int main() {
int n, x, ans;
cin >> n >> x;
while (n--) {
int a;
cin >> a;
nums[a] = 1;
}
ans = nums[x];
for (int i = 0; i < x; i++) {
ans += !nums[i];
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int sx, sy, n, x, y, u, d, l, r;
int main() {
cin >> n >> sx >> sy;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
if (sx + 1 <= x) ++r;
if (sx - 1 >= x) ++l;
if (sy + 1 <= y) ++d;
if (sy - 1 >= y) ++u;
}
if (r >= l && r >= u && r >= d) {
cout << r << endl << sx + 1 << " " << sy;
} else if (l >= r && l >= u && l >= d) {
cout << l << endl << sx - 1 << " " << sy;
} else if (u >= l && u >= d && u >= r) {
cout << u << endl << sx << " " << sy - 1;
} else {
cout << d << endl << sx << " " << sy + 1;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double pi = acos(-1.0);
const int N = (int)2e6 + 10;
const int M = (int)1e9 + 9;
const int H = 2;
const long long P[2] = {17239, 23917};
long long h[2][N], ppow[2][N];
int n, prefsum[N], minprefsum[N], sufsum[N], minsufsum[N];
char s[N];
bool equal(int i, int j, int len) {
for (int t = 0; t < H; ++t)
if (((h[t][i + len] - h[t][i] * ppow[t][len]) -
(h[t][j + len] - h[t][j] * ppow[t][len])) %
M !=
0)
return false;
return true;
}
bool is_less(int i, int j) {
int l = 0, r = n;
while (l < r) {
int q = (l + r + 1) / 2;
if (equal(i, j, q))
l = q;
else
r = q - 1;
}
return (s[i + l] < s[j + l]);
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) s[i + n] = s[i];
for (int j = 0; j < 2; ++j) {
h[j][0] = 0, ppow[j][0] = 1;
for (int i = 0; i < 2 * n; ++i) {
h[j][i + 1] = (h[j][i] * P[j] + s[i]) % M;
ppow[j][i + 1] = (ppow[j][i] * P[j]) % M;
}
}
prefsum[0] = 0;
for (int i = 0; i < n; ++i)
prefsum[i + 1] = prefsum[i] + ((s[i] == '(') ? 1 : -1);
minprefsum[0] = prefsum[0];
for (int i = 0; i < n; ++i)
minprefsum[i + 1] = min(minprefsum[i], prefsum[i + 1]);
minsufsum[n] = prefsum[n];
for (int i = n - 1; i >= 0; --i)
minsufsum[i] = min(minsufsum[i + 1], prefsum[i]);
int total = prefsum[n], bound = min(total, 0);
vector<int> a;
for (int i = 0; i < n; ++i)
if ((minsufsum[i + 1] >= bound + prefsum[i]) &&
(minprefsum[i] >= bound - total + prefsum[i]))
a.push_back(i);
int best = a[0];
for (int i = 1; i < ((int)(a).size()); ++i)
if (is_less(a[i], best)) best = a[i];
for (int i = 0; i < -total; ++i) printf("(");
for (int i = 0; i < n; ++i) printf("%c", s[best + i]);
for (int i = 0; i < total; ++i) printf(")");
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, maxr = INT_MIN, maxc = INT_MIN, minr = INT_MAX, minc = INT_MAX,
c = 0;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 'B') {
c++;
}
}
}
if (c == 0) {
cout << 1;
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'B') {
minr = min(i, minr);
minc = min(j, minc);
maxr = max(i, maxr);
maxc = max(j, maxc);
}
}
}
if (max(maxr - minr + 1, maxc - minc + 1) > m ||
max(maxr - minr + 1, maxc - minc + 1) > n) {
cout << -1;
} else {
c = 0;
int R = maxr - max(maxr - minr, maxc - minc);
int C = maxc - max(maxr - minr, maxc - minc);
if (R < 0) {
R = 0;
}
if (C < 0) {
C = 0;
}
for (int i = R; i <= R + max(maxr - minr, maxc - minc); i++) {
for (int j = C; j <= C + max(maxr - minr, maxc - minc); j++) {
if (a[i][j] == 'W') {
c++;
}
}
}
cout << c;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
string s;
cin >> s;
if (n > 2 || s[0] < s[1]) {
cout << "YES\n2\n";
cout << s[0] << " ";
for (int i = 1; i < n; i++) cout << s[i];
cout << "\n";
} else {
cout << "NO\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum;
cin >> sum;
string ans = "";
int fours = floor((double)sum / 4.0);
int numFours = 0, numSevens = 0;
for (int i = 0; i <= fours; i++) {
int remainder = sum - i * 4;
if (ceil(remainder / 7.0) == floor(remainder / 7.0)) {
int sevens = remainder / 7;
int number = 0;
if ((numFours + numSevens == 0) || i + sevens < numFours + numSevens) {
numFours = i;
numSevens = sevens;
}
}
}
for (int j = 0; j < numFours; j++) ans += '4';
for (int j = 0; j < numSevens; j++) ans += '7';
if ((ans == "") || (sum == 0))
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int N;
std::vector<std::unordered_map<int, int>> timeSplitBIT;
std::unordered_map<int, int> timeToIndexMap;
int sumBIT(int timeLimit, int value) {
int valueCount = 0;
for (int bitIdx = timeToIndexMap[timeLimit]; bitIdx >= 0;
bitIdx = (bitIdx & (bitIdx + 1)) - 1) {
valueCount += timeSplitBIT[bitIdx][value];
}
return valueCount;
}
void add(int time, int value, int delta) {
for (int bitIdx = timeToIndexMap[time]; bitIdx < N;
bitIdx = bitIdx | (bitIdx + 1)) {
if (timeSplitBIT[bitIdx].find(value) == timeSplitBIT[bitIdx].end()) {
timeSplitBIT[bitIdx][value] = 0;
}
timeSplitBIT[bitIdx][value] += delta;
}
}
int main() {
std::ios_base::sync_with_stdio(false);
using namespace std;
cin >> N;
std::vector<std::vector<int>> queries =
std::vector<std::vector<int>>(N, std::vector<int>(3, 0));
std::vector<int> times(N, 0);
for (int i = 0; i < N; i++) {
cin >> queries[i][0] >> queries[i][1] >> queries[i][2];
times[i] = queries[i][1];
}
std::sort(times.begin(), times.end());
for (int i = 0; i < N; i++) {
timeToIndexMap[times[i]] = i;
}
timeSplitBIT = std::vector<std::unordered_map<int, int>>(
N, std::unordered_map<int, int>());
for (int i = 0; i < N; i++) {
switch (queries[i][0]) {
case 1:
add(queries[i][1], queries[i][2], 1);
break;
case 2:
add(queries[i][1], queries[i][2], -1);
break;
case 3:
std::cout << sumBIT(queries[i][1], queries[i][2]) << std::endl;
break;
default:
throw new std::runtime_error("Parsed input incorrectly?");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mycmp(const pair<pair<int, int>, int>& a,
const pair<pair<int, int>, int>& b) {
return a.first.first < a.first.first;
}
int main() {
{
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
cin.tie(0);
cout.tie();
}
{}
int n, k;
cin >> n >> k;
vector<int> f(300, 0);
vector<pair<pair<int, int>, int> > a(n);
for (int i = (int)(0); i < (int)(n); i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i + 1;
for (int j = (int)(a[i].first.first); j < (int)(a[i].first.second + 1); j++)
f[j]++;
}
sort(a.begin(), a.end());
vector<int> res(0);
vector<int> check(n, 0);
for (int i = 1; i <= 200; i++) {
while (f[i] > k) {
int Max = 0, dx = -1;
for (int j = 0; j < n; j++) {
if (check[j]) continue;
if (a[j].first.first <= i && i <= a[j].first.second) {
if (Max <= a[j].first.second - i) {
Max = a[j].first.second - i;
dx = j;
}
}
}
check[dx] = 1;
res.push_back(a[dx].second);
for (int j = (int)(a[dx].first.first); j < (int)(a[dx].first.second + 1);
j++)
f[j]--;
}
}
sort(res.begin(), res.end());
cout << res.size() << "\n";
for (int i : res) cout << i << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int b[10000000], c[10000000];
int n, m, a;
bool check(int x) {
int sum = a, p = x, at;
for (int i = 1; i <= x; i++) {
if (sum < 0) {
return 0;
}
if (b[i] < c[p]) {
sum -= c[p] - b[i];
}
p--;
}
if (sum >= 0) {
return 1;
} else {
return 0;
}
}
bool cc(int x, int y) { return x > y; }
int main() {
cin >> n >> m >> a;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) cin >> c[i];
sort(b + 1, b + 1 + n, cc);
sort(c + 1, c + 1 + m);
int l = 0, r = min(n, m), mx;
while (l <= r) {
mx = (l + r) / 2;
if (check(mx)) {
l = mx + 1;
} else {
r = mx - 1;
}
}
int sum = 0;
for (int i = 1; i <= l - 1; i++) {
sum += c[i];
}
int at = max(sum - a, 0);
int ao = l - 1;
cout << ao << " " << at;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
multiset<string> old;
multiset<string> curr;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
old.insert(s);
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
auto it = old.find(s);
if (it != old.end()) {
old.erase(it);
} else {
curr.insert(s);
}
}
cout << old.size() << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1234;
const long long NN = 123456;
const long long INF = 0x3f3f3f3f;
const long long mod = 998244353;
long long n, k, a[N], dp[N][N], cur[N][N], ans[NN], tot;
signed main() {
scanf("%d%d", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
a[0] = -INF;
for (long long x = 1; (k - 1) * x <= a[n]; x++) {
dp[0][0] = cur[0][0] = 1;
long long tmp = 0;
for (long long i = 1; i <= n; i++) {
while (a[tmp] <= a[i] - x) tmp++;
for (long long j = 0; j <= k; j++) {
if (j != 0) dp[i][j] = cur[tmp - 1][j - 1];
cur[i][j] = (cur[i - 1][j] + dp[i][j]) % mod;
}
ans[x] += dp[i][k];
}
tot = (tot + ans[x]) % mod;
}
cout << tot;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<double>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
const int di[4] = {-1, 0, 1, 0}, dj[4] = {0, 1, 0, -1};
const int di8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dj8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ld PI = acos((ld)-1);
const ll INF = 1e18;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(rng); }
bool pow2(int i) { return i && (i & -i) == i; }
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
ll half(ll x) { return fdiv(x, 2); }
bool inc(int a, int b, int c) { return a <= b && b <= c; }
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
void remDup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <class T, class U>
void remAll(vector<T>& v, U a) {
v.erase(remove((v).begin(), (v).end(), a), v.end());
}
template <class T, class U>
T fstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi);
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi + 1);
f(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p);
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p);
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return to_string((int)b); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
template <class T>
string to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
string to_string(vb v) {
string res = "{";
for (int i = (0); i < (((int)(v).size())); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (((int)(b).size())); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
string to_string(pair<T, U> p);
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p));
}
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p)) + " " + to_string(get<3>(p));
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p);
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p);
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(ld& d) {
string t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(array<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p) {
re(get<0>(p), get<1>(p), get<2>(p));
}
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p) {
re(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
struct chash {
const uint64_t C = ll(2e18 * PI) + 71;
const int RANDOM = rng();
ll operator()(ll x) const { return __builtin_bswap64((x ^ RANDOM) * C); }
};
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using mpq = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T, class U>
using um = unordered_map<T, U, chash>;
template <class T>
using us = unordered_set<T, chash>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
template <int MOD, int RT>
struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; }
int v;
explicit operator int() const { return v; }
mint() { v = 0; }
mint(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mint& a, const mint& b) { return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.v < b.v; }
friend void re(mint& a) {
ll x;
re(x);
a = mint(x);
}
friend string to_string(mint a) { return to_string(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
mint& operator*=(const mint& m) {
v = (ll)v * m.v % MOD;
return *this;
}
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mint inv(const mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD, 5> mi;
vector<vector<mi>> scmb;
void genComb(int SZ) {
scmb.assign(SZ, vector<mi>(SZ));
scmb[0][0] = 1;
for (int i = (1); i < (SZ); ++i)
for (int j = (0); j < (i + 1); ++j)
scmb[i][j] = scmb[i - 1][j] + (j ? scmb[i - 1][j - 1] : 0);
}
vi invs, fac, ifac;
void genFac(int SZ) {
invs.resize(SZ), fac.resize(SZ), ifac.resize(SZ);
invs[1] = fac[0] = ifac[0] = 1;
for (int i = (2); i < (SZ); ++i)
invs[i] = MOD - (ll)MOD / i * invs[MOD % i] % MOD;
for (int i = (1); i < (SZ); ++i) {
fac[i] = (ll)fac[i - 1] * i % MOD;
ifac[i] = (ll)ifac[i - 1] * invs[i] % MOD;
}
}
mi comb(int a, int b) {
if (a < b || b < 0) return 0;
return (ll)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using ul = unsigned long long;
ul modMul(ul a, ul b, const ul mod) {
ll ret = a * b - mod * (ul)((ld)a * b / mod);
return ret + ((ret < 0) - (ret >= (ll)mod)) * mod;
}
ul modPow(ul a, ul b, const ul mod) {
if (b == 0) return 1;
ul res = modPow(a, b / 2, mod);
res = modMul(res, res, mod);
return b & 1 ? modMul(res, a, mod) : res;
}
bool prime(ul n) {
if (n < 2 || n % 6 % 4 != 1) return n - 2 < 2;
ul A[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022},
s = __builtin_ctzll(n - 1), d = n >> s;
for (auto& a : A) {
ul p = modPow(a, d, n), i = s;
while (p != 1 && p != n - 1 && a % n && i--) p = modMul(p, p, n);
if (p != n - 1 && i != s) return 0;
}
return 1;
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void IOS(int n = 10, string s = "") {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(n);
cerr.precision(n);
cerr << fixed;
cout << fixed;
if (((int)(s).size())) {
setIn(s + ".in"), setOut(s + ".out");
}
}
const int mxN = 2e5;
namespace factorBasic {
template <class T>
vector<pair<T, int>> factor(T x) {
vector<pair<T, int>> pri;
for (T i = 2; i * i <= x; ++i)
if (x % i == 0) {
int t = 0;
while (x % i == 0) x /= i, t++;
pri.push_back({i, t});
}
if (x > 1) pri.push_back({x, 1});
return pri;
}
ll phi(ll x) {
for (auto& a : factor(x)) x -= x / a.first;
return x;
}
template <class T>
void tour(vector<pair<T, int>>& v, vector<T>& V, int ind, T cur) {
if (ind == ((int)(v).size()))
V.push_back(cur);
else {
T mul = 1;
for (int i = (0); i < (v[ind].second + 1); ++i) {
tour(v, V, ind + 1, cur * mul);
mul *= v[ind].first;
}
}
}
template <class T>
vector<T> getDivi(T x) {
auto v = factor(x);
vector<T> V;
tour(v, V, 0, (T)1);
sort((V).begin(), (V).end());
return V;
}
} // namespace factorBasic
using namespace factorBasic;
void solve(int tt) {
int n;
re(n);
str s, a = "aeiou";
vi v = getDivi(n);
bool ok = 0;
int l = 0, r = ((int)(v).size()) - 1, h, w;
while (l < r) {
ok |= v[l] >= 5 && v[r] >= 5;
if (ok) h = v[l], w = v[r];
++l, --r;
}
if (((int)(v).size()) & 1 && n >= 25)
ok = 1, h = v[((int)(v).size()) / 2], w = v[((int)(v).size()) / 2];
if (!ok) {
ps(-1);
return;
}
0;
for (int i = (0); i < (h); ++i) {
for (int j = (0); j < (w); ++j) {
s += a[(j + i) % 5];
}
}
ps(s);
}
int main() {
IOS();
int t = 1;
for (int i = (0); i < (t); ++i) {
solve(i + 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, m;
vector<long long> bs, todo;
int cnt[(1 << 16) + 1];
long long inv2 = (mod + 1) / 2;
int popcount(long long x) { return __builtin_popcountll(x); }
long long getp(long long x) { return 63 - __builtin_clzll(x); }
bool add(long long x) {
for (int i = m - 1; i >= 0; i--) {
if (!bs[i]) continue;
if (x >> i & 1) x ^= bs[i];
}
if (!x) return false;
bs[getp(x)] = x;
return true;
}
void build() {
for (int i = 0; i < (m); ++i) {
for (int j = i - 1; j >= 0; j--) {
if (bs[i] >> j & 1) bs[i] ^= bs[j];
}
}
vector<long long> new_bs;
for (int i = 0; i < m; i++) {
if (bs[i]) continue;
long long val = 0;
val |= (1LL << i);
for (int j = 0; j < m; j++) val |= (bs[j] >> i & 1) << j;
new_bs.push_back(val);
}
todo = new_bs;
}
long long pk = 1;
long long res[55], fres[55];
long long C[55][55], f[55][55];
void dfs(int d, long long cur) {
if (d == (int)(todo).size()) {
res[popcount(cur)]++;
return;
}
dfs(d + 1, cur);
if (todo[d]) dfs(d + 1, cur ^ todo[d]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 1; i < (1 << 16); i++) {
cnt[i] = cnt[i / 2] + i % 2;
}
cin >> n >> m;
bs.resize(m, 0);
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (!add(x)) pk *= 2, pk %= mod;
}
for (auto& x : bs)
if (x) todo.push_back(x);
if ((int)(todo).size() <= 26) {
dfs(0, 0);
for (int i = 0; i <= m; i++) cout << (pk * res[i] % mod + mod) % mod << " ";
cout << "\n";
} else {
for (int i = 0; i < 55; i++) C[i][i] = C[i][0] = 1;
for (int i = 0; i < 55; i++) {
for (int j = 1; j < i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
build();
dfs(0, 0);
for (int b = 0; b <= m; b++) {
for (int c = 0; c <= m; c++) {
for (int a = 0; a <= b && a <= c; a++) {
int s = (a % 2 == 0 ? 1 : -1);
f[b][c] = (f[b][c] + s * C[b][a] * C[m - b][c - a]) % mod;
}
fres[c] += (f[b][c] * res[b]);
fres[c] %= mod;
}
}
for (int i = 0; i < (int)(todo).size(); i++) pk = (pk * inv2) % mod;
for (int i = 0; i <= m; i++)
cout << (pk * fres[i] % mod + mod) % mod << " ";
cout << "\n";
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long tryit(long long now) {
long long tmp = 1, temp;
if (now >= 2) {
temp = tryit(now / 2);
tmp = tmp * temp % m * temp % m;
}
if (now % 2) tmp = tmp * 3 % m;
return tmp;
}
int main() {
cin >> n >> m;
cout << (tryit(n) + m - 1) % m << endl;
}
| 3 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
template <class T>
inline T Min(const T &a, const T &b) {
return a < b ? a : b;
}
const int N = 5e5 + 5, M = N << 1;
const long long INF = 1e18;
int n, ecnt, nxt[M], adj[N], go[M], sze[N], tot, top;
long long ans = INF, f[N];
struct point {
long long x, y;
friend inline point operator-(point a, point b) {
return (point){b.x - a.x, b.y - a.y};
}
friend inline long long operator*(point a, point b) {
return a.x * b.y - a.y * b.x;
}
} p[N], stk[N];
inline bool comp(point a, point b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
void add_edge(int u, int v) {
nxt[++ecnt] = adj[u];
adj[u] = ecnt;
go[ecnt] = v;
nxt[++ecnt] = adj[v];
adj[v] = ecnt;
go[ecnt] = u;
}
void dfs(int u, int fu) {
sze[u] = 1;
for (int e = adj[u], v; e; e = nxt[e]) {
if ((v = go[e]) == fu) continue;
dfs(v, u);
sze[u] += sze[v];
}
f[u] = 1ll * sze[u] * (sze[u] - 1);
tot = top = 0;
for (int e = adj[u], v; e; e = nxt[e]) {
if ((v = go[e]) == fu) continue;
f[u] = Min(f[u], 1ll * (sze[u] - sze[v]) * (sze[u] - sze[v] - 1) + f[v]);
ans = Min(ans, f[v] + 1ll * (n - sze[v]) * (n - sze[v] - 1));
p[++tot] = (point){
sze[v], f[v] - 1ll * ((n << 1) - 1) * sze[v] + 1ll * sze[v] * sze[v]};
}
std::sort(p + 1, p + tot + 1, comp);
for (int i = 1; i <= tot; i++) {
while (top > 1 && stk[top].y + p[i].x * stk[top].x * 2 >=
stk[top - 1].y + p[i].x * stk[top - 1].x * 2)
top--;
if (i > 1)
ans = Min(ans, 1ll * n * (n - 1) + p[i].y + stk[top].y +
p[i].x * stk[top].x * 2);
while (top > 1 && (stk[top - 1] - stk[top]) * (stk[top - 1] - p[i]) <= 0)
top--;
stk[++top] = p[i];
}
}
int main() {
int x, y;
read(n);
for (int i = 1; i < n; i++) read(x), read(y), add_edge(x, y);
dfs(1, 0);
return std::cout << 1ll * n * (n - 1) - (ans >> 1) << std::endl, 0;
}
| 9 |
#include <iostream>
#include <vector>
#include <cmath>
#include <list>
#include <map>
#include <algorithm>
#include <climits>
#include <iomanip>
#include <cstdio>
#include <bitset>
#include <cstring>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <string>
using namespace std;
#define ll long long int
#define cbit __builtin_popcountll
#define pl pair<long, long>
#define pqp priority_queue<pl>
// getline(cin, str); __gcd(a,b)
// vec.insert(vec.begin()+i,value); log2(n); tolower(s[i]);
// ostringstream s; s<<i; string ans =s.str();
// string c=to_string(i); s.push_back(c);
// next_permutation(nums.begin(),nums.end())
// priority_queue<PII, vector<PII>, greater<PII>> pq;
/* Iterative Function to calculate (x^y)%p
in O(log y) */
unsigned long long power(unsigned long long x, int y, int p)
{
unsigned long long res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
bool cmp(pair<string, int> &a, pair<string, int> &b)
{
return a.second < b.second;
}
void sort(map<string, int> &M)
{
// Declare vector of pairs
vector<pair<string, int> > A;
// Copy key-value pair from Map
// to vector of pairs
for (auto &it : M)
{
A.push_back(it);
}
// Sort using comparator function
sort(A.begin(), A.end(), cmp);
// Print the sorted value
for (auto &it : A)
{
cout << it.first << ' '
<< it.second << endl;
}
}
// Returns n^(-1) mod p
unsigned long long modInverse(unsigned long long n, int p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's little
// theorem.
unsigned long long nCrModPFermat(unsigned long long n, int r, int p)
{
// If n<r, then nCr should return 0
if (n < r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
}
long long gcd(long long int a, long long int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
long long lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
bool isPrime(ll n)
{
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
ll find(ll s, ll n, ll pos)
{
ll mid = s + n / 2;
if (mid == pos)
{
return 1;
}
else if (mid > pos)
{
return 1 + find(mid + 1, n, pos);
}
else
{
return 1 + find(s, mid, pos);
}
}
ll fact(ll n)
{
// single line to find factorial
return (n == 1 || n == 0) ? 1 : n * fact(n - 1);
}
ll num(ll n, ll ans)
{
n /= 10;
if (n == 0)
{
return ans;
}
else
{
return ans + num(n, ans + 1);
}
}
ll nof(ll n)
{
if (n == 1)
{
return 1;
}
ll ans = 2;
for (ll i = 2; i * i <= n; i++)
{
if (n % i == 0)
{
if (i * i != n)
{
ans += 2;
}
else
{
ans++;
}
}
}
return ans;
}
ll getsum(ll n)
{
ll ans = 0;
while (n)
{
ans += n % 10;
n /= 10;
}
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// #ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// #endif
// priority_queue<pl> p;
// bool del[500001]={0};
// ll i=0;
ll t = 1;
cin >> t;
while (t--)
{
ll n,m;
cin>>n>>m;
if(n%m==0)
{
cout<<1<<"\n";
}
else if(n>m)
{
cout<<2<<"\n";
}
else if(n==m)
{
cout<<1<<"\n";
}
else{
if(m%n==0)
{
cout<<m/n<<"\n";
}
else{
cout<<m/n +1<<"\n";
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5, M = 998244353, OO = 0x3f3f3f3f;
string s;
int main() {
cin >> s;
int n = s.size();
int ans = 0;
char lst = s[0];
int c = 1;
for (int i = 1; i < n; ++i) {
if (s[i] == lst) {
c++;
if (c > 5) {
ans++;
c = 1;
}
} else {
ans++;
c = 1;
lst = s[i];
}
}
if (c) ans++;
cout << ans << endl;
return 0;
}
| 0 |
#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;
for (int i = 0; i < t; i++) {
long long n, k;
cin >> n >> k;
long long c = 0;
while (n) {
if (n % k == 0) {
n /= k;
c++;
} else {
long long a = n % k;
n -= a;
c += a;
}
}
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long a[400105], s[400105], t[400105], st[400105];
long long C, ans;
long long T[400105 * 4], lz[400105 * 4];
void Up(int rt, int l, int r) { T[rt] = max(T[(rt << 1)], T[(rt << 1 | 1)]); }
void Down(int rt, int l, int r) {
if (lz[rt] != 0) {
T[(rt << 1)] += lz[rt];
lz[(rt << 1)] += lz[rt];
T[(rt << 1 | 1)] += lz[rt];
lz[(rt << 1 | 1)] += lz[rt];
lz[rt] = 0;
}
}
void upt(int rt, int l, int r, int L, int R, long long val) {
if (R <= l || r <= L) return;
if (L <= l && r <= R) {
T[rt] += val;
lz[rt] += val;
return;
}
Down(rt, l, r);
int mid = (l + r) / 2;
upt((rt << 1), l, mid, L, R, val);
upt((rt << 1 | 1), mid, r, L, R, val);
Up(rt, l, r);
}
void uptS(int rt, int l, int r, int L, long long val) {
if (l + 1 == r) {
T[rt] = val;
return;
}
Down(rt, l, r);
int mid = (l + r) / 2;
if (L <= mid)
uptS((rt << 1), l, mid, L, val);
else
uptS((rt << 1 | 1), mid, r, L, val);
Up(rt, l, r);
}
long long qy(int rt, int l, int r, int L, int R) {
if (R <= l || r <= L) return 0;
if (L <= l && r <= R) {
return T[rt];
}
Down(rt, l, r);
int mid = (l + r) / 2;
return max(qy((rt << 1), l, mid, L, R), qy((rt << 1 | 1), mid, r, L, R));
}
void fmain(int tid) {
scanf("%d%lld", &n, &C);
for (int(i) = 1; (i) <= (int)(n + n - 1); (i)++) scanf("%lld", a + i);
for (int(i) = 1; (i) <= (int)(n + n - 1); (i)++) s[i] = s[i - 1] + a[i];
int i = 0;
for (int(j) = 1; (j) <= (int)(n); (j)++) {
while (i + 1 <= j && s[j + j - 1] - s[(i + 1) * 2 - 1 - 1] >= C) i++;
if (i) {
long long z = max(C - (st[j - 1] - st[i - 1]), 0LL);
t[j] = max(t[j], z);
}
if (j > 1 && i < j - 1)
upt(1, 0, n, i, j - 1, a[j * 2 - 1] + a[j * 2 - 2] - t[j - 1]);
uptS(1, 0, n, j, a[j + j - 1]);
long long z = qy(1, 0, n, i, j);
t[j] = max(t[j], z);
ans += t[j];
st[j] = st[j - 1] + t[j];
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
cout << a[(n - 1) / 2];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[110], maxi[110], dp[110][110][110];
string s;
long long solve(int i, int j, int sz) {
if (dp[i][j][sz] != -1) return dp[i][j][sz];
if (i > j) return 0;
long long ret = solve(i + 1, j, 1) + maxi[sz];
for (int k = i + 1; k <= j; k++)
if (s[i] == s[k])
ret = max(ret, solve(k, j, sz + 1) + solve(i + 1, k - 1, 1));
return dp[i][j][sz] = ret;
}
int main() {
scanf("%d", &n);
cin >> s;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
maxi[i] = a[i];
for (int j = 1; j < i; j++) maxi[i] = max(maxi[i], a[j] + maxi[i - j]);
}
memset(dp, -1, sizeof dp);
printf("%lld\n", solve(0, n - 1, 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
std::list<int> stones = {1};
auto last_node = stones.begin();
for (int i = 0; i < s.length() - 1; i++) {
if (s[i] == 'r') {
last_node++;
}
last_node = stones.insert(last_node, i + 2);
}
for (auto it = stones.begin(); it != stones.end(); it++) {
printf("%d\n", *it);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30000 + 10;
const int maxm = 10000 + 10;
int a[maxn];
bool vis[maxn];
int main() {
int n, t;
scanf("%d%d", &n, &t);
memset(vis, false, sizeof(vis));
for (int i = 1; i < n; i++) scanf("%d", &a[i]);
a[n] = 1;
int tmp = 1;
while (tmp <= n) {
vis[tmp] = true;
tmp += a[tmp];
}
if (vis[t])
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int inf = 0x3f3f3f3f;
inline char nc() {
char buf[100000], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
if (p1 == p2) return EOF;
}
return *p1++;
}
inline void read(int &x) {
char c = getchar();
int b = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = getchar())
;
x = x * b;
}
inline void read(long long &x) {
char c = getchar();
int b = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = getchar())
;
x = x * b;
}
int n, A, B, sum, a[100005];
inline bool cmp(int x, int y) { return x > y; }
int main(int argc, char *argv[]) {
scanf("%d%d%d", &n, &A, &B);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum += a[i];
sort(a + 2, a + n + 1, cmp);
if (a[1] * 1.0 / sum * A >= B) {
printf("0\n");
return 0;
}
for (int i = 2; i <= n; i++) {
sum -= a[i];
if (a[1] * 1.0 / sum * A >= B) {
printf("%d\n", i - 1);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
pair<int, int> frog[400009], s[400009 << 2], mosq[400009];
set<int> sg;
multiset<pair<int, int> > onmosq;
set<pair<int, int> > in[400009];
map<int, int> pm;
int ans[400009];
int dsbul(int k) {
int son = *(--sg.end());
if (*sg.begin() > k) return -1;
if (son < k) return son;
return *(--sg.upper_bound(k));
}
void upd(int p, int v, int ind, int nd, int x, int y) {
if (x == y) {
in[x].insert(make_pair(v, ind));
umin(s[nd], make_pair(v, ind));
return;
}
int mid = (x + y) >> 1;
if (p <= mid)
upd(p, v, ind, nd << 1, x, mid);
else
upd(p, v, ind, nd << 1 | 1, mid + 1, y);
s[nd] = min(s[nd << 1], s[nd << 1 | 1]);
}
pair<int, int> tap(int l, int r, int nd, int x, int y) {
if (l > y or x > r) return make_pair(2147483647, -1);
if (l <= x and y <= r) return s[nd];
int mid = (x + y) >> 1;
pair<int, int> i1 = tap(l, r, nd << 1, x, mid);
pair<int, int> i2 = tap(l, r, nd << 1 | 1, mid + 1, y);
return min(i1, i2);
}
void poz(int p, int v, int ind, int nd, int x, int y) {
if (x == y) {
pair<int, int> nn;
in[x].erase(in[x].find(make_pair(v, ind)));
if (in[x].size() == 0)
nn = make_pair(2147483647, -1);
else
nn = *in[x].begin();
s[nd] = nn;
return;
}
int mid = (x + y) >> 1;
if (p <= mid)
poz(p, v, ind, nd << 1, x, mid);
else
poz(p, v, ind, nd << 1 | 1, mid + 1, y);
s[nd] = min(s[nd << 1], s[nd << 1 | 1]);
}
int main() {
for (int i = 0; i < 400009 << 2; i++) s[i] = make_pair(2147483647, -1);
int n, m, c = 1;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int posf, lent;
scanf("%d%d", &posf, &lent);
frog[i] = make_pair(posf, lent);
}
for (int i = 1; i <= m; i++) {
int posm, szm;
scanf("%d%d", &posm, &szm);
mosq[i] = make_pair(posm, szm);
pm[posm] = 1;
sg.insert(posm);
}
for (typeof((pm).begin()) it = (pm).begin(); it != (pm).end(); it++)
it->second = ++c;
pm[-1] = 1;
for (int i = 1; i <= n; i++) {
int where = frog[i].first + frog[i].second;
upd(pm[dsbul(where)], frog[i].first, i, 1, 1, c);
}
for (int i = 1; i <= m; i++) {
pair<int, int> k = tap(pm[mosq[i].first], c, 1, 1, c);
if (k.second == -1 or k.first > mosq[i].first) {
onmosq.insert(mosq[i]);
continue;
}
poz(pm[dsbul(frog[k.second].first + frog[k.second].second)],
frog[k.second].first, k.second, 1, 1, c);
frog[k.second].second += mosq[i].second;
upd(pm[dsbul(frog[k.second].first + frog[k.second].second)],
frog[k.second].first, k.second, 1, 1, c);
ans[k.second]++;
while (onmosq.size() > 0) {
if ((*(--onmosq.end())).first < frog[k.second].first) break;
pair<int, int> it =
*onmosq.lower_bound(make_pair(frog[k.second].first, -1));
if (it.first - frog[k.second].first > frog[k.second].second) break;
poz(pm[dsbul(frog[k.second].first + frog[k.second].second)],
frog[k.second].first, k.second, 1, 1, c);
frog[k.second].second += it.second;
upd(pm[dsbul(frog[k.second].first + frog[k.second].second)],
frog[k.second].first, k.second, 1, 1, c);
ans[k.second]++;
onmosq.erase(onmosq.find(it));
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", ans[i], frog[i].second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
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
int n;
int ar[100005];
int br[100005];
bool vis[100005];
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) cin >> ar[i], br[i] = ar[i];
sort(br, br + n);
for (int i = 0; i < (n); ++i) ar[i] = lower_bound(br, br + n, ar[i]) - br;
vector<vector<int> > ans;
for (int i = 0; i < (n); ++i)
if (!vis[i]) {
int cur = i;
vector<int> res;
while (!vis[cur]) {
vis[cur] = 1;
res.push_back(cur);
cur = ar[cur];
}
ans.push_back(res);
}
cout << ans.size() << endl;
for (auto res : ans) {
sort((res).begin(), (res).end());
printf("%d", (int)res.size());
for (auto e : res) printf(" %d", e + 1);
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int bank;
long int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] % 2 == 0)
bank = 0;
else
bank = 1;
for (int i = 1; i < n; i++) {
if (a[i] - bank >= 0) {
if ((a[i] - bank) % 2 == 0)
bank = 0;
else
bank = 1;
} else {
bank = 1;
break;
}
}
if (bank == 1)
cout << "NO";
else
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MAXN = 1123456;
const long long N = 1e6;
const long long inf = 3e18;
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void vout(T s) {
cout << s << endl;
exit(0);
}
vector<long long> c;
vector<long long> v[MAXN];
long long dist[MAXN], f[MAXN], k;
void find_cycle(long long x) {
if (f[x] == 2) return;
if (f[x] == 1) {
if ((int)c.size() - dist[x] >= k) {
vector<long long> ans;
while (!c.empty() && c.back() != x) {
ans.push_back(c.back());
c.pop_back();
}
ans.push_back(x);
cout << "2\n";
cout << (int)ans.size() << "\n";
for (auto i : ans) cout << i << " ";
cout << "\n";
exit(0);
}
return;
}
dist[x] = (int)c.size();
c.push_back(x);
f[x] = 1;
for (auto to : v[x]) find_cycle(to);
f[x] = 2;
c.pop_back();
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
k = sqrt(n);
while (k * k > n) k--;
while (k * k < n) k++;
while (m--) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++) shuffle(v[i].begin(), v[i].end(), rnd);
for (int i = 1; i <= n; i++) find_cycle(i);
vector<pair<long long, long long> > fufel;
for (int i = 1; i <= n; i++) fufel.push_back({(int)v[i].size(), i});
fill(f + 1, f + n + 1, 0);
sort(fufel.begin(), fufel.end());
vector<long long> ans;
for (auto kek : fufel) {
long long i = kek.second;
if (f[i]) continue;
if ((int)ans.size() < k) ans.push_back(i);
f[i] = 1;
for (auto j : v[i]) f[j] = 1;
}
cout << "1\n";
for (auto i : ans) cout << i << " ";
cout << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[5001];
int main() {
cin >> n >> a >> b >> c;
dp[0] = 0;
for (int i = 1; i <= 5000; i++) dp[i] = -1e9;
for (int i = 0; i <= 5000; i++) {
if (i >= a) {
dp[i] = max(dp[i], dp[i - a] + 1);
}
if (i >= b) dp[i] = max(dp[i], dp[i - b] + 1);
if (i >= c) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAX = 1e5 + 5;
const int MAX_V = 1e3 + 5;
const long long INF = 4e18 + 5;
const double M = 4e18;
using namespace std;
const int MOD = 1e9 + 7;
const double eps = 0.000000001;
int n, m, k, q, idx;
int fa[MAX], who[MAX], in[MAX], out[MAX];
vector<int> edge[MAX];
void dfs(int x) {
in[x] = ++idx;
for (int i = 0; i < edge[x].size(); i++) dfs(edge[x][i]);
out[x] = idx;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (who[y]) fa[x] = who[y];
who[y] = x;
}
for (int i = 1; i <= n; i++) edge[fa[i]].push_back(i);
for (int i = 1; i <= n; i++)
if (!in[i]) dfs(i);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
y = who[y];
if (in[x] <= in[y] && out[x] >= in[y])
printf("%d\n", out[x] - in[x] + 1);
else
printf("0\n");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long g[5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long a, b, sum = 0, k = 0;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b;
if (b > 0)
k = k + b;
else {
if (k == 0)
sum++;
else
k--;
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100010;
int dp[MAXN + 1][2];
char s[MAXN + 1], ans[MAXN + 1];
int main() {
scanf("%s", s + 1);
int N = strlen(s + 1);
dp[0][0] = dp[0][1] = 0;
for (int i = 1; i <= N; i++) {
dp[i][0] = dp[i - 1][0] + (s[i] == '0');
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0]) + (s[i] == '1');
}
if (dp[N][0] >= dp[N][1]) {
for (int i = 1; i <= N; i++) printf("%c", s[i]);
printf("\n");
return 0;
}
int now = dp[N][1] - dp[N][0];
for (int i = N; i >= 1; i--)
if (s[i] == '0')
ans[i] = '0';
else {
if (dp[i][1] - dp[i][0] == now && now)
--now, ans[i] = '0';
else
ans[i] = '1';
}
for (int i = 1; i <= N; i++) printf("%c", ans[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9;
int n, mxp, a[1000];
queue<int> Q;
int gcd(int x, int y) {
if (!x) return y;
return gcd(y % x, x);
}
int main() {
mxp = 999999937;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
Q.push(a[0]);
for (int i = 1; i < n; i++) {
int g = gcd(a[i], a[i - 1]);
if (g > 1) {
if (g == mxp)
Q.push(2);
else
Q.push(mxp);
}
Q.push(a[i]);
}
cout << Q.size() - n << endl;
while (!Q.empty()) {
cout << Q.front() << " ";
Q.pop();
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
const long long MOD = 1000000007;
int N, m[300001], pr[25998], v;
long long fc[300001], fi[300001], O, C[300002], H[300002], T[300002], W[300001];
std::vector<int> V[300001];
inline void add(long long &u, long long v) {
u = u + v < MOD ? u + v : u + v - MOD;
}
void F(std::vector<int> &x) {
std::sort(x.begin(), x.end());
size_t S = x.size();
for (size_t i = 0; i < S; i++) O = (O + x[i] * W[S - i]) % MOD;
}
int main() {
for (int i = 2; i <= 300000; i++) {
if (!m[i]) m[i] = pr[++v] = i;
for (int j = 1; j <= v && pr[j] * i <= 300000 && pr[j] <= m[i]; j++)
m[pr[j] * i] = pr[j];
}
scanf("%d", &N);
for (int i = 1, x; i <= N; i++) {
scanf("%d", &x);
while (x > 1) {
int md = m[x], cnt = 0;
do x /= md, cnt++;
while (x % md == 0);
V[md].push_back(cnt);
}
}
fc[0] = fi[0] = fi[1] = 1;
for (int i = 2; i <= N; i++) fi[i] = (MOD - MOD / i) * fi[MOD % i] % MOD;
for (int i = 1; i <= N; i++) {
fc[i] = fc[i - 1] * i % MOD;
fi[i] = fi[i - 1] * fi[i] % MOD;
}
for (int i = 0; i < N; i++)
C[i] = fc[N - 1] * fi[i] % MOD * fi[N - 1 - i] % MOD;
H[1] = T[N] = 0;
for (int i = 2; i <= N; i++) H[i] = (H[i - 1] + C[i - 2]) % MOD;
for (int i = N - 1; i; i--) T[i] = (T[i + 1] + C[i]) % MOD;
for (int i = 1; i <= N; i++) W[i] = (T[i] - H[i] + MOD) % MOD;
for (int i = 1; i <= v; i++) F(V[pr[i]]);
printf("%lld\n", O);
return 0;
}
| 11 |
#include<bits/stdc++.h>
#define N 300010
using namespace std;
int Next[N<<1],To[N<<1],c[N],cnt=0;
int dp[N][50],a[N],Ans[N],g[50];
int n,k;
void Add(int u,int v)
{
Next[++cnt]=c[u],c[u]=cnt,To[cnt]=v;
}
void Dfs(int x,int Fa)
{
dp[x][0]=a[x];
for (int i=c[x];i;i=Next[i])
{
int u=To[i];
if (u==Fa) continue;
Dfs(u,x);
for (int j=0;j<=2*k-1;++j) dp[x][(j+1)%(2*k)]^=dp[u][j];
}
}
void Find_Ans(int x,int Fa)
{
for (int i=k;i<2*k;++i) Ans[x]^=dp[x][i];
for (int i=c[x];i;i=Next[i])
{
int u=To[i];
if (u==Fa) continue;
for (int j=0;j<2*k;++j) g[(j+1)%(2*k)]=dp[x][(j+1)%(2*k)]^dp[u][j];
for (int j=0;j<2*k;++j) dp[u][(j+1)%(2*k)]^=g[j];
Find_Ans(u,x);
}
}
int main()
{
scanf("%d %d",&n,&k);
for (int i=1;i<n;++i)
{
int u,v;
scanf("%d %d",&u,&v);
Add(u,v);
Add(v,u);
}
for (int i=1;i<=n;++i) scanf("%d",&a[i]);
Dfs(1,0);
Find_Ans(1,0);
for (int i=1;i<=n;++i) printf("%d ",Ans[i]?1:0);
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[4] = {0};
while (n--) {
int val;
scanf("%d", &val);
a[val - 1]++;
}
int cnt = a[2] + a[3];
cnt += (a[1] / 2);
if (a[1] % 2 != 0) cnt++;
if (a[0] > a[2]) {
if (a[0] - a[2] > (a[1] % 2) * 2) {
int p = a[0] - a[2] - (a[1] % 2) * 2;
cnt += p / 4;
if (p % 4 != 0) cnt++;
}
}
printf("%d\n", cnt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, data[105][105], ans[105];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &data[i][j]);
for (int k = 0; k < 31; k++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) {
if (data[i][j] & (1 << k)) {
ans[i] |= 1 << k;
ans[j] |= 1 << k;
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, sum = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) {
int q;
cin >> q;
sum += q;
}
sum = abs(sum);
int ans = sum / x;
if (sum % x != 0) {
ans++;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int m, n, mn, ans, cnt, p[5005][4];
char c[5005];
int v[5005], vw;
int f(char c) {
switch (c) {
case 'L':
return 0;
case 'R':
return 1;
case 'U':
return 2;
case 'D':
return 3;
}
}
int solve(int x) {
for (int i = 0; i < mn; ++i) {
p[i][0] = i % n == 0 ? -1 : i - 1;
p[i][1] = i % n == n - 1 ? -1 : i + 1;
p[i][2] = i - n;
p[i][3] = i + n;
}
vw = x;
int ret = 0;
while (1) {
ret++;
v[x] = vw;
int z = f(c[x]);
int X = x;
while (c[X] == '.' || v[X] == vw) {
X = p[X][z];
if (!(0 <= X && X < mn)) return ret;
}
p[x][z] = X;
x = X;
}
}
int main() {
scanf("%d%d", &m, &n);
mn = m * n;
for (int i = 0; i < m; ++i) scanf("%s", c + i * n);
memset(v, -1, sizeof(v));
ans = cnt = 0;
for (int i = 0; i < mn; ++i) {
if (c[i] != '.') {
int tmp = solve(i);
if (tmp > ans) {
ans = tmp;
cnt = 1;
} else if (tmp == ans)
cnt++;
}
}
printf("%d %d\n", ans, cnt);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[5000];
int p[5000] = {0}, d[5000] = {0};
int f[5000][5000] = {{0}};
vector<pair<int, int>> e;
vector<tuple<int, int, int>> ask;
bool v[5000] = {false};
pair<int, int> a;
void fk(int x, int g) {
int y = p[x];
if (x > y) swap(x, y);
if (f[x][y])
f[x][y] = max(f[x][y], g);
else
f[x][y] = g;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
if (a > b) swap(a, b);
e.push_back({a, b});
}
stack<int> stk;
v[0] = true;
stk.push(0);
while (stk.size()) {
int c = stk.top();
stk.pop();
for (int ch : adj[c]) {
if (v[ch]) continue;
v[ch] = true;
p[ch] = c;
d[ch] = d[c] + 1;
stk.push(ch);
}
}
cin >> m;
while (m--) {
int a, b, g;
cin >> a >> b >> g;
a--, b--;
ask.push_back({a, b, g});
if (d[a] < d[b]) swap(a, b);
while (d[a] > d[b]) {
fk(a, g);
a = p[a];
}
while (a != b) {
fk(a, g);
fk(b, g);
a = p[a];
b = p[b];
}
}
pair<int, int> y;
for (tuple<int, int, int> abg : ask) {
int a, b, g;
tie(a, b, g) = abg;
if (d[a] < d[b]) swap(a, b);
while (d[a] > d[b]) {
y.first = a, y.second = p[a];
if (a > p[a]) swap(y.first, y.second);
if (f[y.first][y.second] == g) goto nxt;
;
a = p[a];
}
while (a != b) {
y.first = a, y.second = p[a];
if (a > p[a]) swap(y.first, y.second);
if (f[y.first][y.second] == g) goto nxt;
;
y.first = b, y.second = p[b];
if (b > p[b]) swap(y.first, y.second);
if (f[y.first][y.second] == g) goto nxt;
;
a = p[a];
b = p[b];
}
cout << "-1\n";
return 0;
nxt:;
}
for (pair<int, int> ed : e) {
if (f[ed.first][ed.second])
cout << f[ed.first][ed.second];
else
cout << 1;
if (ed == *--e.end())
cout << '\n';
else
cout << ' ';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int k = 0;
for (int j = 0; j < int(n); j++)
for (int i = 0; i < int(j); i++)
if (a[i] > a[j]) k++;
if (k & 1)
cout << 2 * k - 1 << endl;
else
cout << 2 * k << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
int n, m;
vector<int> edge[maxn];
int vis[maxn];
vector<pair<int, int> > mid;
int dep[maxn], fa[maxn];
void dfs(int u, vector<int>& need, int pre = 0) {
vis[u] = 1;
need.push_back(u);
dep[u] = dep[pre] + 1;
for (auto v : edge[u]) {
if (v != pre) {
dfs(v, need, u);
fa[v] = u;
}
}
}
int get_diameter(int u) {
vector<int> need;
dfs(u, need);
int st = u, ed = u;
for (auto i : need) {
if (dep[i] > dep[st]) st = i;
}
need.clear();
dfs(st, need);
for (auto i : need) {
if (dep[i] > dep[ed]) ed = i;
}
int midnow = dep[ed] - 1 >> 1;
int t = ed;
while (midnow--) t = fa[t];
mid.push_back(make_pair(dep[ed] - 1, t));
return dep[ed] - 1;
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) get_diameter(i);
}
sort(mid.begin(), mid.end());
for (int i = 0; i < mid.size() - 1; ++i) {
edge[mid[i].second].push_back(mid[mid.size() - 1].second);
edge[mid[mid.size() - 1].second].push_back(mid[i].second);
}
cout << get_diameter(1) << endl;
for (int i = 0; i < mid.size() - 2; ++i) {
cout << mid[mid.size() - 2].second << " " << mid[i].second << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long compare(string s, string t) { return s.size() < t.size(); }
int main() {
long long i, j, a, b, c, n, m, t;
cin >> t;
vector<string> v(t);
string s;
for (i = 0; i < t; i++) {
cin >> v[i];
}
sort(v.begin(), v.end(), compare);
for (i = 1; i < t; i++) {
if (v[i].find(v[i - 1]) == -1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (i = 0; i < t; i++) {
cout << v[i] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, h, dp[1009][31][31][31][2];
int rec(int x, int v1, int v2, int v3, int k) {
if (x == n) {
if (v1 <= h || v2 <= h || v3 <= h || k == 0) return 1;
return 0;
}
int &res = dp[x][v1][v2][v3][k];
if (res != -1) return res;
res = 0;
int a;
if (k)
a = 31;
else
a = 1;
int b = v1, c = v2, d = v3;
int na = (a <= h ? 1 : 31), nb = (b + 1 <= h ? b + 1 : 31),
nc = (c + 1 <= h ? c + 1 : 31), nd = (d + 1 <= h ? d + 1 : 31);
res = (res + rec(x + 1, nb, nc, nd, (na == 31 ? 1 : 0))) % 1000000009;
na = (a + 1 <= h ? a + 1 : 31);
nb = (b > h ? 31 : 1);
nc = (c + 1 <= h ? c + 1 : 31);
nd = (d + 1 <= h ? d + 1 : 31);
res = (res + rec(x + 1, na, nc, nd, (nb == 31 ? 1 : 0))) % 1000000009;
na = (a + 1 <= h ? a + 1 : 31);
nb = (b + 1 <= h ? b + 1 : 31);
nc = (c > h ? 31 : 1);
nd = (d + 1 <= h ? d + 1 : 31);
res = (res + rec(x + 1, na, nb, nd, (nc == 31 ? 1 : 0))) % 1000000009;
na = (a + 1 <= h ? a + 1 : 31);
nb = (b + 1 <= h ? b + 1 : 31);
nc = (c + 1 <= h ? c + 1 : 31);
nd = (d > h ? 31 : 1);
res = (res + rec(x + 1, na, nb, nc, (nd == 31 ? 1 : 0))) % 1000000009;
return res;
}
int main() {
scanf("%d %d", &n, &h);
memset(dp, -1, sizeof(dp));
printf("%d\n", rec(0, 1, 1, 1, 0));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << (i + 1 != (int)v.size() ? " " : "");
}
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v) is >> in;
return is;
}
const int mod = 998244353;
int tag[200200], pos[200200];
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> a(n), b(k);
cin >> a >> b;
for (int i = 0; i < n; ++i) {
pos[a[i]] = i + 1;
}
for (int i = 0; i < k; ++i) {
b[i] = pos[b[i]];
}
memset(tag, 0, (n + 2) << 2);
tag[0] = tag[n + 1] = 1;
for (int i = 0; i < k; ++i) {
tag[b[i]] = 1;
}
int ans = 1;
for (int i = 0; i < k; ++i) {
if (tag[b[i] - 1] && tag[b[i] + 1]) {
ans = 0;
break;
}
if (!tag[b[i] - 1] && !tag[b[i] + 1]) {
ans <<= 1;
ans %= mod;
}
tag[b[i]] = 0;
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000001;
char a[Maxn], b[Maxn], c[Maxn];
int n, i, j, p[Maxn], q[Maxn], z[Maxn], y[Maxn];
void kmp() {
memcpy(c, a, sizeof a);
reverse(c, c + n);
p[0] = j = 0;
for (i = 1; i < n; ++i) {
while (j && c[j] != c[i]) j = p[j - 1];
if (c[j] == c[i]) ++j;
p[i] = j;
}
j = 0;
for (i = 0; i < n; ++i) {
while (j && b[i] != c[j]) j = p[j - 1];
if (b[i] == c[j]) ++j;
q[i] = j;
}
}
void exkmp() {
int k, p;
for (j = 0; j + 1 < n && b[j] == b[j + 1]; ++j)
;
z[1] = p = j;
k = 1;
for (i = 2; i < n; ++i)
if (z[i - k] < p - i + 1)
z[i] = z[i - k];
else {
for (j = max(0, p - i + 1); i + j < n && b[i + j] == b[j]; ++j)
;
z[i] = j;
k = i;
p = i + j - 1;
}
for (j = 0; j < n && a[j] == b[j]; ++j)
;
y[0] = j;
k = 0;
p = j - 1;
for (i = 1; i < n; ++i)
if (z[i - k] < p - i + 1)
y[i] = z[i - k];
else {
for (j = max(0, p - i + 1); i + j < n && a[i + j] == b[j]; ++j)
;
y[i] = j;
k = i;
p = i + j - 1;
}
}
int main() {
gets(a);
gets(b);
n = strlen(a);
if (n != strlen(b)) {
puts("-1 -1");
return 0;
}
kmp();
exkmp();
int ii = -1, jj = -1;
for (i = 0; i + 1 < n && a[i] == b[n - 1 - i]; ++i)
if (y[i + 1] >= n - q[n - 2 - i] - i - 1) ii = i, jj = n - q[n - 2 - i];
printf("%d %d\n", ii, jj);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
struct node {
long long val, id, k;
} nod[maxn];
int tot;
bool cmp(node a, node b) { return a.val > b.val; }
int main() {
long long n, x, pos1 = 2;
cin >> n;
for (int i = 3; i <= n; i++) {
cout << "2 1 " << pos1 << " " << i << endl;
cout.flush();
cin >> x;
if (x == -1) pos1 = i;
}
for (int i = 2; i <= n; i++) {
if (i != pos1) {
cout << "1 1 " << pos1 << " " << i << endl;
cout.flush();
cin >> nod[tot].val;
nod[tot++].id = i;
}
}
sort(nod, nod + tot, cmp);
int mid = nod[0].id;
for (int i = 1; i < tot; i++) {
cout << "2 1 " << mid << " " << nod[i].id << endl;
cout.flush();
cin >> nod[i].k;
}
cout << "0 1 " << pos1;
for (int i = tot - 1; i > 0; i--)
if (nod[i].k < 0) cout << " " << nod[i].id;
cout << " " << mid;
for (int i = 1; i < tot; i++)
if (nod[i].k > 0) cout << " " << nod[i].id;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int nax = 15123;
const int INF = 1e9 + 5;
vector<pair<int, int>> edges[nax];
int kol[nax];
vector<int> path[3];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
edges[a].emplace_back(b, i);
edges[b].emplace_back(a, i);
}
vector<int> me;
srand(6969);
me.push_back(1 + rand() % n);
for (int rep = 0; rep < 2; ++rep) {
vector<int> dist(n + 1, INF);
int kol_size = 0;
for (int x : me) {
kol[kol_size++] = x;
dist[x] = 0;
}
for (int i = 0; i < kol_size; ++i) {
int a = kol[i];
for (const pair<int, int>& edge : edges[a]) {
int b = edge.first;
if (dist[b] == INF) {
dist[b] = dist[a] + 1;
kol[kol_size++] = b;
}
}
}
int best = -1;
for (int a = 1; a <= n; ++a) {
if (best == -1 || dist[a] > dist[best]) {
best = a;
}
}
assert(best != -1);
me.push_back(best);
}
cout << me[0] << " " << me[1] << " " << me[2] << endl;
int enemy;
cin >> enemy;
auto is_done = [&]() {
return me[0] == enemy || me[1] == enemy || me[2] == enemy;
};
vector<int> used(m + 1);
for (int turn = 1; turn <= (n >= 100 ? n - 1 : n); ++turn) {
cerr << "turn = " << turn << endl;
if (is_done()) {
return 0;
}
vector<int> dist(n + 1, INF);
{
int kol_size = 0;
kol[kol_size++] = enemy;
dist[enemy] = 0;
for (int i = 0;
i < kol_size &&
(dist[me[0]] == INF || dist[me[1]] == INF || dist[me[2]] == INF);
++i) {
int a = kol[i];
for (const pair<int, int>& edge : edges[a]) {
int b = edge.first;
if (dist[b] == INF) {
dist[b] = dist[a] + 1;
kol[kol_size++] = b;
}
}
}
}
vector<int> order{0, 1, 2};
sort(order.begin(), order.end(),
[&](int a, int b) { return dist[a] < dist[b]; });
int tu_turn = -1;
for (int which : order) {
int& start = me[which];
if (rand() % 10 == 0 && n >= 100) {
start = edges[start][rand() % edges[start].size()].first;
continue;
}
tu_turn++;
for (int rep = 0; rep < 2; ++rep) {
if (tu_turn != 0) {
for (int& x : dist) {
x = INF;
}
int kol_size = 0;
kol[kol_size++] = enemy;
dist[enemy] = 0;
for (int i = 0; i < kol_size && dist[start] == INF; ++i) {
int a = kol[i];
for (const pair<int, int>& edge : edges[a]) {
int b = edge.first;
int id = edge.second;
if ((rep == 1 || used[id] != turn) && dist[b] == INF) {
dist[b] = dist[a] + 1;
kol[kol_size++] = b;
}
}
}
}
if (dist[start] != INF) {
int tmp = start;
int first_move = -1;
while (tmp != enemy) {
if (which == 2 && first_move != -1) {
break;
}
bool done = false;
debug();
for (const pair<int, int>& e : edges[tmp]) {
int b = e.first;
int id = e.second;
debug() << " ["
<< "rep"
": "
<< (rep)
<< "] "
" ["
<< "b"
": "
<< (b)
<< "] "
" ["
<< "id"
": "
<< (id)
<< "] "
" ["
<< "used[id]"
": "
<< (used[id])
<< "] "
" ["
<< "dist[b]"
": "
<< (dist[b])
<< "] "
" ["
<< "dist[tmp]"
": "
<< (dist[tmp]) << "] ";
if (rep == 0 && used[id] == turn) {
continue;
}
if (dist[b] + 1 == dist[tmp]) {
used[id] = turn;
tmp = b;
if (first_move == -1) {
first_move = b;
} else {
}
done = true;
break;
}
}
assert(done);
}
assert(first_move != -1);
start = first_move;
break;
}
assert(rep != 1);
}
}
cout << me[0] << " " << me[1] << " " << me[2] << endl;
if (is_done()) {
return 0;
}
cin >> enemy;
if (is_done()) {
return 0;
}
}
assert(false);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, now, fac, dp[2][320 + 5][320 + 5];
int read() {
char c;
int x = 0, f = 1;
c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
int Inc(int a, int b) { return (a += b) >= 1000000007 ? a - 1000000007 : a; }
int Mul(int a, int b) { return 1ll * a * b % 1000000007; }
int main() {
n = read(), m = read(), x = read();
fac = 1;
for (int i = 1; i <= n; ++i) fac = Mul(fac, i);
if (n > m) {
puts("0");
return 0;
}
dp[0][0][0] = now = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= min(n, i); ++j)
for (int k = 0; k <= j; ++k) {
if (i != x) dp[now][j][k] = Inc(dp[now][j][k], dp[now ^ 1][j][k]);
if (i != x && k >= 1)
dp[now][j][k] = Inc(dp[now][j][k], dp[now ^ 1][j][k - 1]);
if (j >= 1) dp[now][j][k] = Inc(dp[now][j][k], dp[now ^ 1][j - 1][k]);
if (j >= 1 && k >= 1)
dp[now][j][k] = Inc(dp[now][j][k], dp[now ^ 1][j - 1][k - 1]);
}
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= n; ++k) dp[now ^ 1][j][k] = 0;
now ^= 1;
}
printf("%d", Mul(dp[now ^ 1][n][n], fac));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 50, mod = 1e9 + 7;
long long n, m, k;
long long a[maxn], t[maxn] = {1}, cnt;
map<long long, vector<long long> > g[maxn];
map<long long, vector<long long> > e;
map<long long, vector<long long> >::iterator it;
map<long long, long long> mk[maxn];
set<long long> s;
vector<long long> e1;
void dfs(long long u, long long z) {
cnt++;
for (long long i = 0; i < g[u][z].size(); ++i) {
long long v = g[u][z][i];
if (mk[v][z]) continue;
mk[v][z] = 1;
dfs(v, z);
}
}
int main() {
for (long long i = 1; i < maxn; ++i) t[i] = (t[i - 1] + t[i - 1]) % mod;
scanf("%d %d %d", &n, &m, &k);
for (long long i = 1; i <= n; ++i) scanf("%I64d", a + i);
for (long long i = 0; i < m; ++i) {
long long x, y;
scanf("%d %d", &x, &y);
long long z = a[x] ^ a[y];
s.insert(z);
e[z].push_back(x);
e[z].push_back(y);
g[x][z].push_back(y);
g[y][z].push_back(x);
}
long long ans = (((t[k] - s.size() + mod) % mod) * t[n]) % mod;
for (it = e.begin(); it != e.end(); it++) {
e1 = it->second;
long long tv = 0;
long long z = it->first;
cnt = 0;
for (long long i = 0; i < e1.size(); ++i) {
long long x = e1[i];
if (mk[x][z] == 0) {
tv++;
mk[x][z] = 1;
dfs(x, z);
}
}
tv += (n - cnt);
ans += t[tv];
ans %= mod;
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
multiset<int> s;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (!s.empty() && *s.begin() < a) {
ans += a - *s.begin();
s.erase(s.begin());
s.insert(a);
s.insert(a);
} else
s.insert(a);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > g[300010];
int mas[26][300010];
int d[300010];
char used[300010];
vector<int> h[300010];
int depth = 0;
map<int, int> cnt;
map<int, int> cnt2;
void dfs(int v) {
used[v] = true;
depth++;
h[depth].push_back(v);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
if (!used[to]) {
dfs(to);
d[v] += d[to];
}
}
d[v] += 1;
depth--;
}
void Merge(int t1, int t2) {
for (int i = 0; i < g[t2].size(); i++) {
int edge = g[t2][i].second - 'a';
if (mas[edge][t1] != 0) {
d[t1] -= d[mas[edge][t1]];
cnt2[t1] -= d[mas[edge][t1]];
Merge(mas[edge][t1], g[t2][i].first);
d[t1] += d[mas[edge][t1]];
cnt2[t1] += d[mas[edge][t1]];
} else {
g[t1].push_back(g[t2][i]);
mas[edge][t1] = g[t2][i].first;
d[t1] += d[g[t2][i].first];
cnt[t1]++;
cnt2[t1] += d[g[t2][i].first];
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
char c;
cin >> u >> v >> c;
g[u - 1].push_back(make_pair(v - 1, c));
mas[c - 'a'][u - 1] = v - 1;
}
dfs(0);
int ans = 1000000000, p = 0;
for (int i = 1; i <= n; i++) {
if ((int)h[i].size() == 0) break;
int diff = 0;
for (int j = 0; j < (int)h[i].size(); j++) {
int mxSz = 0, mxNum = 0;
int u = h[i][j];
if (g[u].size() == 0) continue;
for (int k = 0; k < (int)g[u].size(); k++) {
int v = g[u][k].first;
if (d[v] > mxSz) {
mxSz = d[v];
mxNum = k;
}
}
for (int k = 0; k < (int)g[u].size(); k++) {
if (k == mxNum) continue;
Merge(g[u][mxNum].first, g[u][k].first);
}
diff += d[u] - d[g[u][mxNum].first];
for (auto u : cnt) {
for (int k = 0; k < u.second; k++) {
pair<int, int> cur = g[u.first].back();
g[u.first].pop_back();
int edge = cur.second - 'a';
mas[edge][u.first] = 0;
}
}
for (auto u : cnt2) {
d[u.first] -= u.second;
}
cnt.clear();
cnt2.clear();
}
if (d[0] - diff < ans) {
ans = d[0] - diff;
p = i;
}
}
cout << ans << endl << p << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 506;
char c[N][N];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> c[i];
}
int ans = 0;
for (int i = (1); i <= (n - 1); ++i) {
for (int j = (1); j <= (n - 1); ++j) {
if (c[i][j] == 'X' && c[i + 1][j + 1] == 'X' && c[i + 1][j - 1] == 'X' &&
c[i - 1][j + 1] == 'X' && c[i - 1][j - 1] == 'X')
ans++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct posi {
int apples;
int pos;
} tree[200];
bool comp(const posi &a, const posi &b) { return a.pos < b.pos; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &tree[i].pos, &tree[i].apples);
}
sort(tree, tree + n, comp);
long long rsum = 0;
long long lsum = 0;
int ltrees = 0;
int rtrees = 0;
int st = 102;
for (int i = 0; i < n; i++) {
if (tree[i].pos > 0) {
if (i < st) {
st = i;
}
rsum += tree[i].apples;
rtrees++;
} else {
ltrees++;
lsum += tree[i].apples;
}
}
long long ans = 0;
long long sum1 = 0;
long long sum2 = 0;
long long sum3 = 0;
long long sum4 = 0;
long long sum5 = 0;
if (rtrees == 0) {
sum1 = tree[n - 1].apples;
} else if (ltrees > rtrees) {
for (int i = st; i < n; i++) {
sum1 += tree[i].apples;
}
int num = 0;
int sti = st - 1;
while (num < rtrees) {
sum1 += tree[sti].apples;
sti--;
num++;
}
sum2 += rsum;
num = 0;
sti = st - 1;
while (num < rtrees + 1) {
sum2 += tree[sti].apples;
sti--;
num++;
}
} else if (ltrees < rtrees) {
for (int i = 0; i < st; i++) {
sum3 += tree[i].apples;
}
int num = 0;
int sti = st;
while (num < ltrees) {
sum3 += tree[sti].apples;
sti++;
num++;
}
sum4 += lsum;
num = 0;
sti = st;
while (num < ltrees + 1) {
sum4 += tree[sti].apples;
sti++;
num++;
}
} else {
sum5 += lsum + rsum;
}
ans = max(sum1, max(sum2, max(sum3, max(sum4, sum5))));
printf("%lld\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct station {
int p, x, dir;
station() {}
station(int pp, int xx, int dirr) {
p = pp;
x = xx;
dir = dirr;
}
};
bool cmp(station a, station b) {
if (a.x != b.x) return a.x < b.x;
return a.dir == 1;
}
int d, n, m;
int main() {
ios_base::sync_with_stdio(0);
cin >> d >> n >> m;
vector<station> v;
for (int i = 0; i < m; i++) {
int x, p;
cin >> x >> p;
v.push_back(station(p, x, 1));
v.push_back(station(p, min(d, x + n), -1));
}
v.push_back(station(0, 0, 1));
v.push_back(station(0, n, -1));
sort(v.begin(), v.end(), cmp);
long long last = 0;
long long res = 0;
multiset<long long> s;
s.insert(0);
long long mx = 0;
for (int i = 1; i < v.size(); i++) {
long long cur = (long long)v[i].x;
long long mn = *s.begin();
res += (cur - last) * mn;
if (cur - last > n || s.size() == 0) return cout << -1, 0;
if (v[i].dir == 1) {
s.insert(v[i].p);
} else {
s.erase(s.find(v[i].p));
}
last = cur;
}
(last == d) ? cout << res : cout << -1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool F = false;
bool T = true;
void build(vector<pair<long long, long long>> &sgtree, int node, int l, int r,
int &minValue) {
if (l == r) {
sgtree[node] = make_pair(0, 0);
} else {
int m = (l + r) / 2;
int leftChild = 2 * node;
int rightChild = leftChild + 1;
build(sgtree, leftChild, l, m, minValue);
build(sgtree, rightChild, m + 1, r, minValue);
sgtree[node] =
make_pair(sgtree[leftChild].first + sgtree[rightChild].first, 0);
}
}
long long query(vector<pair<long long, long long>> &sgtree, int node, int l,
int r, int x, int y, bool &isMinQuery) {
if (x <= l && r <= y) {
if (isMinQuery) {
return sgtree[node].first;
} else {
return sgtree[node].second;
}
} else if (y < l || x > r) {
return 0;
} else {
int m = (l + r) / 2;
int leftChild = 2 * node;
int rightChild = leftChild + 1;
return query(sgtree, leftChild, l, m, x, y, isMinQuery) +
query(sgtree, rightChild, m + 1, r, x, y, isMinQuery);
}
}
void update(vector<pair<long long, long long>> &sgtree, int node, int l, int r,
int &minValue, int &maxVal, int &pos, int &val) {
if (l == r && l == pos) {
sgtree[node].second = min(sgtree[node].second + val, (long long)maxVal);
sgtree[node].first = min((long long)minValue, sgtree[node].second);
} else {
int m = (l + r) / 2;
if (pos <= m) {
update(sgtree, 2 * node, l, m, minValue, maxVal, pos, val);
} else {
update(sgtree, 2 * node + 1, m + 1, r, minValue, maxVal, pos, val);
}
sgtree[node].second = sgtree[2 * node].second + sgtree[2 * node + 1].second;
sgtree[node].first = sgtree[2 * node].first + sgtree[2 * node + 1].first;
}
}
void print_m(vector<pair<long long, long long>> &sgtree) {
for (int i = 0; i < sgtree.size(); i++) {
if (sgtree[i].first != 0) {
cout << "(" << sgtree[i].first << ", " << sgtree[i].second << ") ";
}
}
cout << endl;
}
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
vector<pair<long long, long long>> sgtree(4 * n);
build(sgtree, 1, 1, n, b);
int op, d, ai, sumDays;
long long val;
for (int i = 0; i < q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &d, &ai);
update(sgtree, 1, 1, n, b, a, d, ai);
} else {
scanf("%d", &d);
sumDays = d + k;
if (d == 1) {
val = query(sgtree, 1, 1, n, sumDays, n, F);
} else {
val = query(sgtree, 1, 1, n, 1, d - 1, T);
if (!(sumDays > n)) {
val += query(sgtree, 1, 1, n, min(sumDays, n), n, F);
}
}
cout << val << endl;
}
}
return EXIT_SUCCESS;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int n, m, fr, to, vis[1000005], f;
long long ans, deg[1000005], sl, cnt;
vector<int> v[1000005];
void dfs(int x) {
vis[x] = 2;
for (auto i : v[x])
if (vis[i] != 2) dfs(i);
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &fr, &to);
vis[fr] = vis[to] = 1;
v[fr].push_back(to);
v[to].push_back(fr);
deg[fr]++;
deg[to]++;
if (fr == to) {
deg[to] -= 2;
sl++;
} else
cnt++;
}
dfs(fr);
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) f = 1;
ans += deg[i] * (deg[i] - 1) / 2;
}
if (!f)
printf("%lld\n", ans + sl * cnt + (sl * (sl - 1)) / 2);
else
puts("0");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int mod = 1e9 + 7;
const int N = 3e5 + 1;
int main() {
ios::sync_with_stdio(0);
int n, b, p;
cin >> n >> b >> p;
int x = n;
int res = 0;
while (n > 1) {
int k = 1;
while (k <= n) k *= 2;
k /= 2;
int m = n - k;
res += (k / 2) * (b * 2 + 1);
n = m + k / 2;
}
cout << res << " " << p * x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 30005;
const int smax = 605;
int n, d, i, j, k, x, sol, g[nmax], dp[nmax][smax];
int main() {
cin.sync_with_stdio(false);
cin >> n >> d;
for (i = 1; i <= n; i++) {
cin >> x;
g[x]++;
}
memset(dp, -1, sizeof(dp));
dp[d][300] = g[d];
for (i = 0; i <= 30000; i++)
for (j = 0; j < 600; j++) {
if (dp[i][j] == -1) continue;
sol = max(sol, dp[i][j]);
for (k = -1; k <= 1; k++) {
int newi = i + d + j + k - 300;
int newj = j + k;
if (newi > 30000 || newi <= 0) continue;
dp[newi][newj] = max(dp[newi][newj], dp[i][j] + g[newi]);
}
}
cout << sol << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> s;
int a, c, b = 0;
cin >> a >> c;
for (int i = 0; i < a - 1; i++) {
int t;
cin >> t;
s.push_back(t);
}
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
while (c <= s[0]) {
c += 1;
s[0]--;
b++;
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
}
cout << b;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 300010;
int t[maxn], q[maxn];
int a, b, c, d, st, len;
int main() {
scanf("%d", &n);
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &st, &len);
for (int i = 1; i <= n; i++) scanf("%d%d", &t[i], &q[i]);
t[0] = -1;
long long down = 0, mn = 2e9, up = st;
int j = 1;
for (int i = 1; i <= n; i++) {
while (j <= n && t[j] < len + t[i - 1] + 1) {
down += q[j] ? c : -d;
mn = min(mn, down);
j++;
}
if (up + mn >= 0) {
printf("%d\n", t[i - 1] + 1);
return 0;
}
down -= q[i] ? c : -d;
mn -= q[i] ? c : -d;
up += q[i] ? a : -b;
if (up < 0) {
puts("-1");
return 0;
}
}
printf("%d\n", t[n] + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int INF = 1e9;
struct Data {
int a, idx;
bool operator<(const Data& b) const {
return a == b.a ? idx < b.idx : a > b.a;
}
} d[maxn];
struct Query {
int k, pos, idx;
bool operator<(const Query& b) const { return k < b.k; }
} q[maxn];
int res[maxn];
int n;
inline int lowbit(int x) { return x & (-x); }
int C[maxn];
int b[maxn];
inline void update(int idx, int v) {
for (; idx <= n; idx += lowbit(idx)) {
C[idx] += v;
}
}
inline int query(int idx) {
int sum = 0;
for (; idx; idx -= lowbit(idx)) {
sum += C[idx];
}
return sum;
}
inline int solve() {
memset(C, 0, sizeof(C));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i].a);
d[i].idx = i;
b[i] = d[i].a;
}
sort(d + 1, d + 1 + n);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &q[i].k, &q[i].pos);
q[i].idx = i;
}
sort(q, q + m);
int curL = 1;
for (int i = 0; i < m; i++) {
for (; curL <= q[i].k; curL++) {
update(d[curL].idx, 1);
}
int l = 1, r = n;
while (l < r) {
int mid = l + r >> 1;
if (query(mid) >= q[i].pos) {
r = mid;
} else {
l = mid + 1;
}
}
res[q[i].idx] = b[l];
}
for (int i = 0; i < m; i++) {
printf("%d\n", res[i]);
}
return 0;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0l);
const long long MOD = 1e9 + 7;
bool debug = 1;
const int N = 1e5 + 10;
map<int, int> mv[N];
void traceMap(map<int, int> m) {
for (auto it = m.begin(); it != m.end(); ++it) {
cout << "first = " << it->first << " second = " << it->second << endl;
}
}
int main() {
long long n, m;
cin >> n >> m;
long long ans = 0;
for (int ii = 0; ii < m; ii++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
long long cur = 0;
auto it = mv[a].lower_bound(w);
if (it != mv[a].begin()) {
it--;
cur = it->second;
}
cur++;
auto itc = mv[b].upper_bound(w);
if (itc != mv[b].begin()) {
itc--;
if (itc->second >= cur) continue;
}
mv[b][w] = cur;
ans = max(ans, cur);
for (auto it = ++mv[b].find(w); it != mv[b].end();) {
if (it->second > cur) break;
it = mv[b].erase(it);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> getPrimes(long long int n) {
bool prime[n + 1];
vector<long long int> primes;
for (long long int p = 2; p * p <= n; p++)
if (!prime[p])
for (long long int i = p * p; i <= n; i += p) prime[i] = true;
for (long long int p = 2; p <= n; p++)
if (!prime[p]) primes.push_back(p);
return primes;
}
int main() {
long long int t, i, j, temp, last, ans, en = 1000000000000000000, g;
vector<long long int> primes = getPrimes(100000);
long long int l = primes.size();
vector<pair<long long int, pair<long long int, long long int>>> elem;
cin >> t;
while (t--) {
ans = 1;
i = 22;
j = 0;
temp = last = 1;
while (i--) {
while (j < l && (en / temp) >= primes[j]) temp *= primes[j++];
cout << "? " << temp << "\n" << flush;
cin >> g;
if (g == last)
ans *= g, temp = 1;
else
temp = g * g;
last = g;
g = 1;
}
g *= ans;
ans = 1;
for (i = 0; i < j; i++) {
temp = 1;
while ((g % primes[i]) == 0) temp++, g /= primes[i];
ans *= temp;
}
ans *= 2ll;
cout << "! " << ans << "\n" << flush;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-8;
inline int sgn(const double x) { return (x > eps) - (x < -eps); }
template <class T>
bool get_max(T &a, const T b) {
return a < b ? a = b, true : false;
}
template <class T>
bool get_min(T &a, const T b) {
return a > b ? a = b, true : false;
}
int a[110], b[110];
bool u[110];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
memset(u, false, sizeof(u));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j && b[i] == a[j]) u[j] = true;
int ans = 0;
for (int i = 0; i < n; i++)
if (!u[i]) ans++;
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::max;
using std::min;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::sort;
using std::vector;
const long long maxN = (long long)1e12;
const int maxK = 10000 + 233;
long long n, m, a[maxK];
int k;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long combine(long long &r, long long &m, long long rr, long long mm) {
if (mm > m) {
std::swap(r, rr);
std::swap(m, mm);
}
while (r % mm != rr) r += m;
m *= mm;
}
bool solve() {
long long lcm = 1;
for (int i = 1; i <= k; ++i) {
long long g = gcd(lcm, a[i]);
lcm /= g;
if ((double)lcm * a[i] > 1e15) return false;
lcm *= a[i];
}
if (n < lcm) return false;
vector<long long> power, rem;
long long tmp = lcm;
for (long long i = 2; i * i <= tmp; ++i) {
if (tmp % i == 0) {
long long inp = 1;
while (tmp % i == 0) inp *= i, tmp /= i;
power.push_back(inp);
}
}
if (tmp > 1) power.push_back(tmp);
rem.resize(power.size());
for (int i = 0; i < power.size(); ++i) {
long long pn = power[i];
long long &r = rem[i];
for (int j = 1; j <= k; ++j)
if (a[j] % pn == 0) {
r = (-j) % pn;
if (r < 0) r += pn;
break;
}
}
long long ans = 0, mod = 1;
for (int j = 0; j < power.size(); ++j) combine(ans, mod, rem[j], power[j]);
if (ans + k > m) return false;
for (int i = 1; i <= k; ++i)
if (a[i] != gcd(lcm, ans + i)) return false;
return true;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; ++i) cin >> a[i];
printf("%s\n", solve() ? "YES" : "NO");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool isvalid(int a, int b, int c) {
if ((a + b) > c && (b + c) > a && (a + c) > b) return true;
return false;
}
int main() {
int n, ct = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int k = i ^ j;
if (k < j || k > n) continue;
if (isvalid(i, j, k)) ct++;
}
}
cout << ct << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int d[2222];
int find(int x) { return x != d[x] ? (d[x] = find(d[x])) : x; }
void uu(int x, int y) {
x = find(x);
y = find(y);
if (x != y) d[x] = y;
}
int main() {
int i, j, k, n, m;
const int MOD = 1000000007;
long long an = 1;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) d[i] = i;
for (i = 0; i + k <= n; i++)
for (j = 0; j < k - 1 - j; j++) uu(d[i + j], d[i + k - 1 - j]);
for (i = 0; i < n; i++)
if (d[i] == i) an = an * m % MOD;
cout << an << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
struct term {
int pos, ord;
term(int _pos, int _ord) : pos(_pos), ord(_ord) {}
};
bool operator<(const term& a, const term& b) { return a.pos < b.pos; }
vector<int> pool;
int n, m;
int f[maxn][maxn], rec[maxn][maxn];
int r[maxn], c[maxn];
vector<term> g[maxn];
vector<int> ans;
void get_path(int a, int b) {
if (a >= b) return;
for (int i = 0; i < g[a].size(); ++i)
if (g[a][i].pos == b) ans.push_back(g[a][i].ord);
if (rec[a][b] == 0 || rec[a][b] == b) return;
get_path(a, rec[a][b]);
get_path(rec[a][b], b);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &r[i], &c[i]);
pool.push_back(r[i] - c[i]);
pool.push_back(r[i] + c[i]);
}
sort(pool.begin(), pool.end());
pool.erase(unique(pool.begin(), pool.end()), pool.end());
for (int i = 1; i <= n; ++i)
g[lower_bound(pool.begin(), pool.end(), r[i] - c[i]) - pool.begin()]
.push_back(term(
lower_bound(pool.begin(), pool.end(), r[i] + c[i]) - pool.begin(),
i));
m = pool.size();
for (int i = 0; i < m; ++i) sort(g[i].begin(), g[i].end());
for (int k = 0; k < m; ++k)
for (int i = 0; i < m - k; ++i) {
int cnt = 0, now = f[i + 1][i + k];
rec[i][i + k] = i + 1;
for (int a = 0; a < g[i].size(); ++a) {
if (g[i][a].pos > i + k) break;
if (g[i][a].pos == i + k) cnt++;
int tmp = f[i][g[i][a].pos] + f[g[i][a].pos][i + k];
if (now < tmp) {
now = tmp;
rec[i][i + k] = g[i][a].pos;
}
}
f[i][i + k] = now + cnt;
}
get_path(0, m - 1);
printf("%d\n", f[0][m - 1]);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline namespace Infinity {
inline namespace IO {
const char CR = '\n';
const char SP = ' ';
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { cout << n; }
inline void write(const unsigned long long n) { cout << n; }
inline void writef(const double a, const int n = 15) { printf("%.*f", n, a); }
inline void writef(const long double a, const int n = 18) {
cout << setprecision(n) << fixed << a;
}
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[]) { printf("%s", s); }
inline void write(const string &s) { cout << s; }
inline void write(const pair<int, int> &p) {
printf("%d %d", p.first, p.second);
}
template <class T>
inline void write(const T a) {
for (auto i : a) write(i), write(SP);
}
inline void writeln() { write(CR); }
template <typename T>
inline void writeln(const T &a) {
write(a);
write(CR);
}
inline void writefln(const double a, int n) {
printf("%.*f", n, a);
write(CR);
}
inline void writefln(const long double a, int n = 18) {
cout << setprecision(n) << fixed << a << endl;
}
inline void writesln(const int *a, const int l, const int r) {
for (int i = l; i <= r; i++) printf("%d ", a[i]);
writeln(CR);
}
template <class T>
inline void writelns(const T a) {
for (__typeof a.begin() i = a.begin(); i != a.end(); i++) writeln(*i);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
write(a);
write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
write(args...);
write(CR);
}
template <typename... types>
inline void writeSP(const types &...args) {
write(args...);
write(SP);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
string caseSharpSpace(int n) { return "Case #" + to_string(n) + ": "; }
string caseNoSharpSpace(int n) { return "Case " + to_string(n) + ": "; }
string caseSharpNoSpace(int n) { return "Case #" + to_string(n) + ":"; }
string caseNoSharpNoSpace(int n) { return "Case " + to_string(n) + ":"; }
inline int read(int &n) { return scanf("%d", &n); }
inline int read(long long &n) { return cin >> n ? 1 : -1; }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
read(n);
return read(args...);
}
inline char getcc() {
char c;
do c = getchar();
while (c == ' ' || c == '\n');
return c;
}
inline int getint() {
int n;
read(n);
return n;
}
inline long long getll() {
long long n;
read(n);
return n;
}
inline double getdouble() {
double n;
scanf("%lf", &n);
return n;
}
inline vector<int> getints(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) v[i] = getint();
return v;
}
inline vector<pair<int, int>> getpairs(int n) {
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
int a = getint(), b = getint();
v[i] = pair<int, int>(a, b);
}
return v;
}
inline void read(string &str, const unsigned size) {
char s[size];
scanf("%s", s);
str = string(s);
}
inline string getstr(const unsigned size = 1048576) {
string s;
read(s, size + 1);
return s;
}
inline string getln(const unsigned size = 1048576) {
char s[size + 1];
scanf("%[^\n]", s);
getchar();
return string(s);
}
} // namespace IO
inline namespace Functions {
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
inline int dtoi(const double d) { return round(d); }
template <typename T>
inline bool in(T x, T l, T r) {
return l <= x && x <= r;
}
template <class T>
inline int size(const T &a) {
return a.size();
}
template <typename T1, typename T2>
inline pair<T1, T2> mkp(const T1 &a, const T2 &b) {
return make_pair(a, b);
}
template <class T>
inline void sort(T &a) {
std::sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1 &a, T2 comp) {
std::sort(a.begin(), a.end(), comp);
}
template <class T1, typename T2>
inline int lbound(const T1 &a, const T2 k) {
return lower_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, typename T2>
inline int ubound(const T1 &a, const T2 k) {
return upper_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, class T2>
int count(T1 &a, T2 k) {
return ubound(a, k) - lbound(a, k);
}
template <class T1, class T2>
int find(T1 &a, T2 k) {
return count(a, k) ? lbound(a, k) : -1;
}
template <typename T>
inline void clear(T &a) {
memset(a, 0, sizeof a);
}
template <typename T>
T gcd(T a, T b) {
while (b) {
T t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long qpow(long long a, long long b, long long c) {
return b ? qpow(a * a % c, b >> 1, c) * (b & 1 ? a : 1) % c : 1;
}
template <typename T>
T exGcd(T a, T b, T &x, T &y) {
T d = a;
if (b) {
d = exGcd(b, a % b, y, x);
y -= a / b * x;
} else {
x = 1;
y = 0;
}
return d;
}
template <typename T>
T mps(T l, T r, T k) {
return ((r - (r % k + k) % k) - (l + (k - l % k) % k)) / k + 1;
}
template <typename T>
T sgn(T a) {
return a == 0 ? 0 : a > 0 ? 1 : -1;
}
template <typename T>
constexpr T sq(T a) {
return a * a;
}
} // namespace Functions
inline namespace TypeDefine {}
inline namespace Constant {
const int maxint = INT_MAX;
const long long maxll = LLONG_MAX;
} // namespace Constant
} // namespace Infinity
class DisjointSetUnion {
public:
DisjointSetUnion(int n) : a(n + 1), r(n + 1) { iota(a.begin(), a.end(), 0); }
int find(int x) { return a[x] != x ? a[x] = find(a[x]) : x; }
void join(int x, int y) {
if ((x = find(x)) == (y = find(y))) return;
if (r[x] < r[y])
a[x] = y;
else
a[y] = x;
if (r[x] == r[y]) r[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
protected:
vector<int> a;
vector<int> r;
};
class DimensionConvert {
public:
DimensionConvert(int, int m) : m(m) {}
int ptoi(int x, int y) { return x * m + y; }
int ptoi(const pair<int, int> &p) { return ptoi(p.first, p.second); }
pair<int, int> itop(int n) { return pair<int, int>(n / m, n % m); }
protected:
int m;
};
int main(int, char *[]) {
int n = getint();
int m = getint();
DimensionConvert dc(n, m);
vector<pair<int, pair<int, int>>> v;
v.reserve(n * m);
DisjointSetUnion dsu(n * m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
v.push_back(mkp(getint(), mkp(i, j)));
if (i && v[dc.ptoi(i - 1, j)].first == v.back().first)
dsu.join(dc.ptoi(i - 1, j), dc.ptoi(i, j));
if (j && v[dc.ptoi(i, j - 1)].first == v.back().first)
dsu.join(dc.ptoi(i, j - 1), dc.ptoi(i, j));
}
for (int i = 0; i < n; i++) {
auto begin = v.begin() + dc.ptoi(i, 0);
auto end = v.begin() + dc.ptoi(i + 1, 0);
vector<pair<int, pair<int, int>>> t(end - begin);
copy(begin, end, t.begin());
sort(t);
for (int j = 1; j < size(t); j++)
if (t[j].first == t[j - 1].first)
dsu.join(dc.ptoi(t[j].second), dc.ptoi(t[j - 1].second));
}
for (int j = 0; j < m; j++) {
vector<pair<int, pair<int, int>>> t;
for (int i = 0; i < n; i++) t.push_back(v[dc.ptoi(i, j)]);
sort(t);
for (int i = 1; i < n; i++)
if (t[i].first == t[i - 1].first)
dsu.join(dc.ptoi(t[i].second), dc.ptoi(t[i - 1].second));
}
sort(v, [&dsu, &dc](const pair<int, pair<int, int>> &p1,
const pair<int, pair<int, int>> &p2) {
return p1.first != p2.first
? p1.first < p2.first
: dsu.find(dc.ptoi(p1.second)) < dsu.find(dc.ptoi(p2.second));
});
vector<int> xm(n), ym(m), mm(n * m);
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < size(v); i++) {
int j = i;
while (j < size(v) && v[j].first == v[i].first &&
dsu.find(dc.ptoi(v[j].second)) == dsu.find(dc.ptoi(v[i].second)))
j++;
int m = 0;
for (int k = i; k < j; k++)
m = max(m, max(xm[v[k].second.first], ym[v[k].second.second]) + 1);
for (int k = i; k < j; k++) {
a[v[k].second.first][v[k].second.second] = m;
xm[v[k].second.first] = ym[v[k].second.second] = m;
}
i = j - 1;
}
for (int i = 0; i < n; i++, writeln())
for (int j = 0; j < m; j++) write(a[i][j], SP);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int cal(vector<int> a, int x, int c) {
int l = 0;
int r = x - 1;
int count = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (a[mid] <= c) {
count = mid + 1;
l = mid + 1;
} else {
r = mid - 1;
}
}
return count;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k, d;
cin >> n >> k >> d;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int c, cc;
int r, l;
map<int, int> m;
int i;
for (int i = 0; i < n - d + 1; i++) {
if (i == 0) {
for (int j = 0; j < d; j++) m[a[j]]++;
c = m.size();
} else {
if (m[a[i - 1]] == 1)
m.erase(a[i - 1]);
else
m[a[i - 1]]--;
m[a[d + i - 1]]++;
if (m.size() < c) c = m.size();
}
}
cout << c << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
bool Walk[MAXN][MAXN];
double F[MAXN][MAXN];
int N, M;
void Dfs(int n, int m) {
if (Walk[n][m]) return;
Walk[n][m] = 1;
if (n == 0 || m == 0)
F[n][m] = (1.0 / (m + 1));
else {
Dfs(m - 1, n), Dfs(m, n - 1);
double x, y, x1, y1;
x = m / (m + 1.0) * (1 - F[m - 1][n]) - 1, y = 1;
x1 = m / (m + 1.0) * (1 - F[m - 1][n]) + 1.0 / (m + 1) + (F[m][n - 1] - 1),
y1 = 1 - F[m][n - 1];
double a = (y1 - y) / (x - x1);
F[n][m] = a * x1 + y1;
}
}
int main() {
scanf("%d%d", &N, &M);
Dfs(N, M);
printf("%.10f %.10f\n", F[N][M], 1 - F[N][M]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int cnt;
int n, a[150000], b[150000], c[150000], sz[150000], v[150000];
int sol[150000];
queue<int> F, D[150000];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n * 4); i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
--a[i], --b[i], --c[i];
F.push(i);
}
for (int i = (0); i < (n); i++) sz[i] = 4;
while (cnt < n * 4) {
if (F.size() == 0) {
}
int x = F.front();
F.pop();
--sz[a[x]];
if (b[x] == c[x]) {
if (sz[b[x]] < 8) {
sz[b[x]] += 2;
sol[cnt++] = x;
v[x] = 1;
if (a[x] != b[x]) {
while (D[a[x]].size() > 0) {
int y = D[a[x]].front();
D[a[x]].pop();
if (!v[y]) F.push(y);
}
}
} else
D[b[x]].push(x), ++sz[a[x]];
continue;
}
if (sz[b[x]] < 9 && sz[c[x]] < 9) {
sz[b[x]]++;
sz[c[x]]++;
v[x] = 1;
sol[cnt++] = x;
if (a[x] == b[x] || a[x] == c[x]) continue;
while (D[a[x]].size() > 0) {
int y = D[a[x]].front();
D[a[x]].pop();
if (!v[y]) F.push(y);
}
} else if (sz[b[x]] < 9 && sz[c[x]] == 9)
D[c[x]].push(x), ++sz[a[x]];
else
D[b[x]].push(x), ++sz[a[x]];
}
puts("YES");
for (int i = (0); i < (n * 4); i++) printf("%d ", sol[i] + 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, Y;
map<int, string> IAOs;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
IAOs.clear();
char str[128];
scanf("%s", str);
char num[12] = {'\0'};
strcpy(num, str + 4);
const int _l = strlen(num);
for (int j = 0; j < _l; ++j) {
switch (j + 1) {
case 1: {
int n = atoi(num + _l - j - 1), k = 198;
while (true) {
if (IAOs.find(10 * k + n) == IAOs.end() && 10 * k + n >= 1989) {
IAOs.insert(make_pair(10 * k + n, string(num + _l - j - 1)));
break;
} else {
k += 1;
}
}
} break;
case 2: {
int n = atoi(num + _l - j - 1), k = 19;
while (true) {
if (IAOs.find(100 * k + n) == IAOs.end() && 100 * k + n >= 1989) {
IAOs.insert(make_pair(100 * k + n, string(num + _l - j - 1)));
break;
} else {
k += 1;
}
}
} break;
case 3: {
int n = atoi(num + _l - j - 1), k = 1;
while (true) {
if (IAOs.find(1000 * k + n) == IAOs.end() && 1000 * k + n >= 1989) {
IAOs.insert(make_pair(1000 * k + n, string(num + _l - j - 1)));
break;
} else {
k += 1;
}
}
} break;
default: {
int t = int(pow(10, j + 1));
int n = atoi(num + _l - j - 1), k = 0;
while (true) {
if (IAOs.find(t * k + n) == IAOs.end() && t * k + n >= 1989) {
IAOs.insert(make_pair(t * k + n, string(num + _l - j - 1)));
break;
} else {
k += 1;
}
}
} break;
}
}
for (auto &i : IAOs) {
if (i.second == string(num)) {
printf("%d\n", i.first);
break;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int num[200010];
char str[200010];
int n, k, m, c;
int main() {
while (cin >> n) {
int count = 0, cnt = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
if (num[i] == 0) count++;
}
for (int i = 0; i < n; i++) {
if (num[i] == 1) {
ans += count - cnt;
} else
cnt++;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cmp(double x, double y = 0) {
return (x <= y + 1e-10) ? (x + 1e-10 < y) ? -1 : 0 : 1;
}
struct point {
double x, y;
point(double x = 0, double y = 0) : x(x), y(y) {}
point operator+(point b) { return point(x + b.x, y + b.y); }
point operator-(point b) { return point(x - b.x, y - b.y); }
bool operator<(const point b) const { return tie(x, y) < tie(b.x, b.y); }
};
inline double distPoints(point a) { return sqrt(a.x * a.x + a.y * a.y); }
inline double escalar(point a, point b) { return a.x * b.x + a.y * b.y; }
inline double vetorial(point a, point b) { return a.x * b.y - a.y * b.x; }
int ccw(point p, point q, point o) { return cmp(vetorial(p - o, q - o)); }
double angle(point p, point q, point o) {
point u = p - q, v = o - q;
return atan2(vetorial(u, v), escalar(u, v));
}
double polygon_area(vector<point> &points) {
if (points.size() < 3) return 0;
double area = vetorial(points.back(), points[0]);
for (int i = 1; i < (int)points.size(); i++)
area += vetorial(points[i - 1], points[i]);
return abs(area) / 2;
}
struct line {
double a, b, c;
line(double a, double b, double c) : a(a), b(b), c(c) {}
line(point p1, point p2)
: a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {}
};
inline double point_line(point a, point l1, point l2) {
return abs(vetorial(l2 - l1, a - l1)) / abs(distPoints(l2 - l1));
}
inline double point_line(point a, line l) {
return abs(l.a * a.x + l.b * a.y + l.c) / sqrt(l.a * l.a + l.b * l.b);
}
inline double point_segment(pair<point, point> s, point a) {
if (escalar(s.second - s.first, a - s.first) < 0)
return distPoints(a - s.first);
if (escalar(s.first - s.second, a - s.second) < 0)
return distPoints(a - s.second);
return point_line(a, s.first, s.second);
}
bool parallel(line a, line b) { return abs(a.b * b.a - a.a * b.b) < 1e-10; }
double distLines(line a, line b) {
if (!parallel(a, b)) return 0;
if (a.a == 0) return point_line(point(0, -a.c / a.b), b);
return point_line(point(-a.c / a.a, 0), b);
}
point intersection(line a, line b) {
point ret;
ret.x = (b.c * a.b - a.c * b.b) / (b.b * a.a - a.b * b.a);
ret.y = (b.c * a.a - a.c * b.a) / (a.b * b.a - b.b * a.a);
return ret;
}
bool equal_lines(line a, line b) {
if (!parallel(a, b)) return false;
return abs(distLines(a, b)) < 1e-10;
}
line perpendicular(line a, point b) {
double la, lb, lc;
la = a.b;
lb = -a.a;
lc = -a.a * b.x - a.b * b.y;
return line(la, lb, lc);
}
void print(vector<point> &pol) {
for (point P : pol) {
printf("%f %f\n", P.x, P.y);
}
puts("");
}
void print(point p) { printf("%.2f %.2f\n", p.x, p.y); }
vector<vector<point> > traps;
void create_traps(int l, int r, int h, int f) {
if (l < 0 && r > 0) {
create_traps(l, 0, h, f);
create_traps(0, r, h, f);
return;
}
if (h > 0) swap(l, r);
line axis(point(l, -h), point(r, -h));
line inter_l(point(0, f), point(l, h));
line inter_r(point(0, f), point(r, h));
vector<point> p;
p.push_back(point(l, h));
p.push_back(point(r, h));
p.push_back(intersection(axis, inter_r));
p.push_back(intersection(axis, inter_l));
traps.push_back(p);
}
double traps_intersec(vector<point> t1, vector<point> t2) {
for (int i = 0; i < t1.size(); i++) {
vector<point> c;
point v1 = t1[i];
point v2 = t1[(i + 1) % t1.size()];
line H(v1, v2);
for (int j = 0; j < t2.size(); j++) {
point v3 = t2[j];
point v4 = t2[(j + 1) % t2.size()];
point x = intersection(H, line(v3, v4));
if (ccw(v2, v3, v1) >= 0) {
c.push_back(v3);
if (ccw(v2, v4, v1) < 0) c.push_back(x);
} else {
if (ccw(v2, v4, v1) >= 0) c.push_back(x);
}
}
t2 = c;
}
return polygon_area(t2);
}
int main() {
int n, h, f, l, r;
scanf("%d %d %d", &n, &h, &f);
for (int i = 0; i < n; i++) {
scanf("%d %d", &l, &r);
create_traps(l, r, h, f);
create_traps(l, r, -h, -f);
}
double ans = 0;
for (int i = 0; i < traps.size(); i++) {
ans += polygon_area(traps[i]);
for (int j = i + 1; j < traps.size(); j++) {
ans -= traps_intersec(traps[i], traps[j]);
}
}
cout << setprecision(12) << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using db = double;
using ll = long long;
using uint = unsigned int;
using pii = pair<long long, long long>;
template <class T>
void cmax(T& x, const T& y) {
if (x < y) x = y;
}
template <class T>
void cmin(T& x, const T& y) {
if (x > y) x = y;
}
template <class T>
void sort(vector<T>& v) {
sort(v.begin(), v.end());
}
template <class T>
void unique(vector<T>& v) {
sort(v.begin(), v.end()), v.erase(unique(v.begin(), v.end()), v.end());
}
template <class T>
void reverse(vector<T>& v) {
reverse(v.begin(), v.end());
}
const long long SZ = 0x191981;
long long k, p, n, m;
const long long maxn = 5e4 + 45;
long long s[maxn];
struct mat {
long long a[2][2];
~mat() { clear(); }
void clear() { memset(a, 0, sizeof(a)); }
long long* operator[](long long x) { return a[x]; }
};
mat b[maxn];
mat operator*(mat a, mat b) {
mat c;
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++) c[i][j] = 0;
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++)
for (long long k = 0; k <= 1; k++)
c[i][j] = (c[i][j] + a[i][k] * b[k][j] % p) % p;
return c;
}
mat operator*=(mat& a, mat b) { return a = a * b; }
mat qpow(mat f, mat bs, long long y) {
for (; y; y >>= 1, bs *= bs)
if (y & 1) f *= bs;
return f;
}
mat a[maxn];
mat sum[maxn << 2];
mat ans;
void build(long long l, long long r, long long rt) {
if (l == r) {
sum[rt][0][0] = 0, sum[rt][0][1] = s[l - 1];
sum[rt][1][0] = 1, sum[rt][1][1] = s[l % n];
b[l] = a[l] = sum[rt];
return;
}
long long mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
sum[rt] = sum[rt << 1] * sum[rt << 1 | 1];
}
void change(long long l, long long r, long long rt, long long x, mat v) {
if (l == r) return sum[rt] = v, void();
long long mid = (l + r) >> 1;
if (x <= mid)
change(l, mid, rt << 1, x, v);
else
change(mid + 1, r, rt << 1 | 1, x, v);
sum[rt] = sum[rt << 1] * sum[rt << 1 | 1];
}
struct que {
long long x, y, k;
} q[maxn << 1];
signed main() {
cin >> k >> p >> n;
for (long long i = 0; i < n; i++) cin >> s[i];
build(1, n, 1);
cin >> m;
for (long long i = 1; i <= m; i++) cin >> q[i].x >> q[i].y;
for (long long i = 1; i <= m; i++) {
q[i].y %= p;
q[i].k = 1;
q[i + m] = q[i];
q[i + m].x++;
q[i + m].k--;
}
m <<= 1;
sort(q + 1, q + m + 1, [](const que& x, const que& y) { return x.x < y.x; });
while (m > 0 && q[m].x > k) --m;
ans.clear();
ans[0][1] = 1;
long long lasbl = 0;
for (long long i = 1, j = 1; i <= m; i = ++j) {
long long bl = (q[i].x - 1) / n;
while (j < m && bl == (q[j + 1].x - 1) / n) ++j;
ans = qpow(ans, sum[1], bl - lasbl);
lasbl = bl;
for (long long qwq = i; qwq <= j; qwq++) {
long long d = (q[qwq].x - 1) % n + 1;
b[d][q[qwq].k][1] = q[qwq].y;
change(1, n, 1, d, b[d]);
}
if (bl == k / n) break;
ans = ans * sum[1];
lasbl = bl + 1;
for (long long qwq = i; qwq <= j; qwq++) {
long long d = (q[qwq].x - 1) % n + 1;
b[d] = a[d];
change(1, n, 1, d, b[d]);
}
}
long long bl = k / n;
ans = qpow(ans, sum[1], bl - lasbl);
for (long long i = 1; i <= k % n; i++) ans *= b[i];
cout << ans[0][0] << '\n';
return 0;
}
| 9 |
/**
* D.cpp.c of project "2021_ICPC_NERC_FINAL".
* Created by KMGuan on 2021-04-04 18:26.
*/
// #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,sse3,sse4")
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
typedef long long ll;
const long double INF = 1;
const int MAXN = 1e5 + 7;
struct NODE {
int x, y;
}pre[MAXN][10];
vector<pair<int, double>> v;
int n, d, cc, pos, cnt, a[MAXN];
long double ans, f[MAXN][10];
signed main() {
// ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> d;
for (int x, i = 1; i <= n; i++) {
cin >> x;
if (x != 1) {
a[++cnt] = x;
}
}
for (int i = 0; i <= cnt; i++) {
for (int j = 0; j <= 9; j++) {
f[i][j] = -INF;
}
}
for (int i = 1; i <= cnt; i++) {
long double x = log2(a[i]);
for (int j = 0; j <= 9; j++) {
if (f[i - 1][j] != -INF) {
f[i][j] = f[i - 1][j];
pre[i][j].x = i - 1;
pre[i][j].y = j;
// pre[i][j].x = i - 1;
// pre[i][j].y = j;
}
}
if (x > f[i][a[i] % 10]) {
f[i][a[i] % 10] = x;
pre[i][a[i] % 10].x = -1;
pre[i][a[i] % 10].y = -1;
}
for (int j = 0; j <= 9; j++) {
if (f[i - 1][j] != -INF) {
int k = (j * a[i]) % 10;
if (f[i - 1][j] + x - f[i][k] > 1e-9) {
f[i][k] = f[i - 1][j] + x;
pre[i][k].x = i - 1;
pre[i][k].y = j;
}
}
}
if (f[i][d] > ans) {
ans = f[i][d];
pos = i;
}
}
int i = pos, j = d;
// cout << "@@@ " << i << " " << j << endl;
while (i > 0) {
// cout << a[i] << " ";
v.push_back(make_pair(a[i], f[i][j]));
int ii = i, jj = j;
i = pre[ii][jj].x;
j = pre[ii][jj].y;
}
if (pos == 0) {
cout << "-1" << endl;
return 0;
}
for (i = 1; i < (int) v.size(); i++) {
if (v[i].second == v[i - 1].second) {
cc++;
}
}
cout << (int) v.size() - cc << endl;
cout << v[(int) v.size() - 1].first << " ";
for (i = (int) v.size() - 2; i >= 0; i--) {
if (v[i].second != v[i + 1].second) {
cout << v[i].first << " ";
}
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
template <typename T>
T mo(T x, T y) {
x %= y;
return x <= 0 ? x + y : x;
}
const int MX = 200 * 1000 + 7;
int a[MX];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long h;
int n;
cin >> h >> n;
long long sm = 0, msm = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sm += a[i];
msm = min(msm, sm);
}
if (sm >= 0) {
if (h + msm > 0) {
cout << -1 << "\n";
return 0;
}
for (int i = 1; i <= n; i++) {
h += a[i];
if (h <= 0) {
cout << i << "\n";
return 0;
}
assert(false);
}
}
long long full = (-msm - h) / sm;
while (h + full * sm + msm > 0) {
full++;
}
while (full - 1 >= 0 && h + (full - 1) * sm + msm <= 0) {
full--;
}
full = max(full, 0ll);
h += full * sm;
if (h <= 0) {
cout << full * n << "\n";
} else {
for (int i = 1; i <= n; i++) {
h += a[i];
if (h <= 0) {
cout << full * n + i << "\n";
return 0;
}
}
assert(false);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define int long long
#define ld long double
#define ll long long
#define vll vector<int>
#define mset(a) memset(a,0,sizeof(a))
#define pb push_back
#define range(c) c.begin() , c.end()
#define forn(i,n) for(ll i=0; i<(int)n; ++i)
#define for1(i,n) for(ll i=1; i<(int)n; ++i)
#define endl '\n'
#define MOD 1000000007
#define pii pair<int,int>
#define test ll t;cin>>t;while(t--)
using namespace std;
vector<bool> sieve(ll n){
vector<bool>prime(n+1,true);
prime[0]=prime[1]=false;
for(ll i=2; i<=n; ++i){
if(prime[i]&&(i*i)<=n)
for(ll j=i*i; j<=n; j+=i)prime[j]=false;
}
return prime;
}
ll power(ll a, ll b, ll m = MOD) {
a %= m;
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
//////////////////////////////////////////////////////////////
vector<string> ans;
void fun(string s1, int val1, string s2, int val2, string s, int idx) {
if(val1 < 0 || val2 < 0 || ans.size() != 0)
return;
if(idx == (int)s.size()) {
if(val1 == 0 && val2 == 0) {
ans = {s1, s2};
}
return;
}
string s1f = s1 + '(';
string s1b = s1 + ')';
string s2f = s2 + '(';
string s2b = s2 + ')';
if(s[idx] == '1') {
fun(s1f, val1+1, s2f, val2+1, s, idx+1);
fun(s1b, val1-1, s2b, val2-1, s, idx+1);
} else {
fun(s1f, val1+1, s2b, val2-1, s, idx+1);
fun(s1b, val1-1, s2f, val2+1, s, idx+1);
}
}
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
test {
int n;
cin>>n;
string s;cin>>s;
int cnt = 0;
for(int i = 0; i < n; i++) {
cnt += (s[i] == '1');
}
if(cnt % 2 == 1 || s[0] == '0' || s.back() == '0') {
cout << "NO\n";
continue;
}
string a, b;
int k = 0;
bool flip = false;
for(int i = 0; i < n; i++) {
if(s[i] == '1') {
a.push_back(2 * k < cnt ? '(' : ')');
b.push_back(a.back());
k++;
}else {
a.push_back(flip ? '(' : ')');
b.push_back(flip ? ')' : '(');
flip = !flip;
}
}
cout << "YES\n" << a << '\n' << b << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, L, V, l, r;
cin >> n;
while (n--) {
cin >> L >> V >> l >> r;
cout << L / V - r / V + (l - 1) / V << endl;
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.