solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct MinCostFlow {
bool iszerocap(long long cap) { return cap == 0; }
struct edge {
int target;
long long cost;
long long residual_capacity;
long long orig_capacity;
size_t revid;
};
int n;
vector<vector<edge>> graph;
vector<long long> pi;
bool needNormalize, ranbefore;
int lastStart;
MinCostFlow(int n)
: graph(n), n(n), pi(n, 0), needNormalize(false), ranbefore(false) {}
void addEdge(int s, int e, long long cost, long long cap) {
if (s == e) return;
edge forward = {e, cost, cap, cap, graph[e].size()};
edge backward = {s, -cost, 0, 0, graph[s].size()};
if (cost < 0 || ranbefore) needNormalize = true;
graph[s].emplace_back(forward);
graph[e].emplace_back(backward);
}
bool normalize(int s) {
auto infinite_cost = numeric_limits<long long>::max();
vector<long long> dist(n, infinite_cost);
dist[s] = 0;
queue<int> q;
vector<int> v(n), relax_count(n);
v[s] = 1;
q.push(s);
while (!q.empty()) {
int cur = q.front();
v[cur] = 0;
q.pop();
if (++relax_count[cur] >= n) return false;
for (const auto &e : graph[cur]) {
if (iszerocap(e.residual_capacity)) continue;
auto next = e.target;
auto ncost = dist[cur] + e.cost;
if (dist[next] > ncost) {
dist[next] = ncost;
if (v[next]) continue;
v[next] = 1;
q.push(next);
}
}
}
for (int i = 0; i < n; i++) pi[i] = dist[i];
return true;
}
pair<long long, long long> AugmentShortest(int s, int e,
long long flow_limit) {
auto infinite_cost = numeric_limits<long long>::max();
auto infinite_flow = numeric_limits<long long>::max();
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
vector<pair<long long, long long>> dist(n, make_pair(infinite_cost, 0));
vector<int> from(n, -1), v(n);
if (needNormalize || (ranbefore && lastStart != s)) normalize(s);
ranbefore = true;
lastStart = s;
dist[s] = pair<long long, long long>(0, infinite_flow);
pq.emplace(dist[s].first, s);
while (!pq.empty()) {
auto cur = pq.top().second;
pq.pop();
if (v[cur]) continue;
v[cur] = 1;
if (cur == e) continue;
for (const auto &e : graph[cur]) {
auto next = e.target;
if (v[next]) continue;
if (iszerocap(e.residual_capacity)) continue;
auto ncost = dist[cur].first + e.cost - pi[next] + pi[cur];
auto nflow = min(dist[cur].second, e.residual_capacity);
if (dist[next].first <= ncost) continue;
dist[next] = make_pair(ncost, nflow);
from[next] = e.revid;
pq.emplace(dist[next].first, next);
}
}
auto p = e;
auto pathcost = dist[p].first + pi[p] - pi[s];
auto flow = dist[p].second;
if (iszerocap(flow) || (flow_limit <= 0 && pathcost >= 0))
return pair<long long, long long>(0, 0);
if (flow_limit > 0) flow = min(flow, flow_limit);
for (int i = 0; i < n; i++) {
if (iszerocap(dist[i].second)) continue;
pi[i] += dist[i].first;
}
while (from[p] != -1) {
auto nedge = from[p];
auto np = graph[p][nedge].target;
auto fedge = graph[p][nedge].revid;
graph[p][nedge].residual_capacity += flow;
graph[np][fedge].residual_capacity -= flow;
p = np;
}
return make_pair(pathcost * flow, flow);
}
pair<long long, long long> solve(
int s, int e, long long flow_minimum = numeric_limits<long long>::max()) {
long long total_cost = 0;
long long total_flow = 0;
for (;;) {
auto res = AugmentShortest(s, e, flow_minimum - total_flow);
if (res.second <= 0) break;
total_cost += res.first;
total_flow += res.second;
}
return make_pair(total_cost, total_flow);
}
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<long long> net_vsum(n);
int source = n, sink = n + 1;
MinCostFlow mcf(n + 2);
long long baseval = 0;
for (int i = 0; i < m; i++) {
int u, v, c, f;
scanf("%d%d%d%d", &u, &v, &c, &f);
u--, v--;
if (f <= c) {
net_vsum[u] -= f;
net_vsum[v] += f;
mcf.addEdge(u, v, 1, c - f);
mcf.addEdge(u, v, 2, LLONG_MAX / 100);
mcf.addEdge(v, u, 1, f);
} else {
net_vsum[u] -= c;
net_vsum[v] += c;
baseval += f - c;
mcf.addEdge(u, v, 0, f - c);
mcf.addEdge(u, v, 2, LLONG_MAX / 100);
mcf.addEdge(v, u, 1, c);
}
}
for (int i = 0; i < n; i++) {
if (net_vsum[i] > 0) {
mcf.addEdge(source, i, 0, net_vsum[i]);
} else if (net_vsum[i] < 0) {
mcf.addEdge(i, sink, 0, -net_vsum[i]);
}
}
mcf.addEdge(n - 1, 0, 0, LLONG_MAX / 100);
long long ans = mcf.solve(source, sink).first;
ans += baseval;
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve();
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++) {
solve();
cout << '\n';
}
return 0;
}
bool bud[200005];
int cnt = 0;
vector<int> V[200005];
void dfs(int now, int from) {
for (int x : V[now]) {
if (x == from) {
continue;
}
dfs(x, now);
}
if (now == 1) {
return;
}
for (int x : V[now]) {
if (x == from) {
continue;
}
bud[now] |= !bud[x];
}
cnt += bud[now];
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
V[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
V[x].push_back(y);
V[y].push_back(x);
}
memset(bud, 0, sizeof(bud));
cnt = 0;
dfs(1, 0);
int res = (n - cnt - 1) - (cnt - 1);
bool yes = false;
for (int x : V[1]) {
yes |= !bud[x];
}
res -= yes;
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, q;
cin >> n >> q;
vector<long long> a(3 * n + 3), b = vector<long long>({3, 3, 1});
vector<long long> fac(3 * n + 4, 1), ifac(3 * n + 4, 1);
for (long long i = 1; i < 3 * n + 4; i++) {
fac[i] = fac[i - 1] * i % 1000000007LL;
}
auto power = [](long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) res = res * x % 1000000007LL;
y >>= 1;
x = x * x % 1000000007LL;
}
return res;
};
ifac[3 * n + 3] = power(fac[3 * n + 3], 1000000007LL - 2);
for (long long i = 3 * n + 2; i >= 0; i--)
ifac[i] = ifac[i + 1] * (i + 1) % 1000000007LL;
auto C = [&fac, &ifac](long long n, long long k) {
return fac[n] * ifac[k] % 1000000007LL * ifac[n - k] % 1000000007LL;
};
for (long long i = 1; i <= 3 * n + 3; i++) {
a[i - 1] = C(3 * n + 3, i);
}
const long long INV3 = power(3, 1000000007LL - 2);
auto poly_div = [INV3](vector<long long> a, vector<long long> b) {
vector<long long> res(a.size() - b.size() + 1);
for (long long i = 0; i < (long long)a.size() - (long long)b.size() + 1;
i++) {
res[i] = a[i] * INV3 % 1000000007LL;
for (long long j = 0; j < (long long)b.size(); j++) {
a[i + j] = (a[i + j] - res[i] * b[j] % 1000000007LL + 1000000007LL) %
1000000007LL;
}
}
return res;
};
vector<long long> res = poly_div(a, b);
while (q--) {
long long x;
cin >> x;
cout << res[x] << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, side = 0, x, y;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (side < x + y) side = x + y;
}
cout << side;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > ans;
long double f(long double x, long double y) {
return x * (x + 1) * (y + 1) - (x + y + 2) * (x + 1) * x / 2 +
x * (x + 1) * (2 * x + 1) / 6;
}
int dcmp(long double x) {
if (fabs(x) < 1e-10) return 0;
return x < 0 ? -1 : 1;
}
int main() {
long double x;
cin >> x;
int ret = 0;
for (int i = 1; i <= 10000000; i++) {
long double now = f(i, i);
int flag = dcmp(now - x);
if (flag > 0) break;
if (flag == 0) {
ans.push_back({i, i});
break;
}
long long l = i, r = x + 1;
while (l + 1 < r) {
long long mid = (l + r) >> 1;
if (dcmp(f(i, mid) - x) >= 0)
r = mid;
else
l = mid;
}
if (dcmp(f(i, r) - x) == 0) {
ans.push_back({i, r});
ans.push_back({r, i});
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%I64d %I64d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using i3 = pair<int, ii>;
using li = pair<ll, int>;
using lii = pair<ll, ii>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<ii>;
using vpll = vector<pll>;
using vi3 = vector<i3>;
using vlii = vector<lii>;
const int N = 2e6 + 5;
const ll INF = 1e17 + 7;
const double eps = 1e-9, PI = acos(-1);
int n;
int ans[N];
void solve(int testCase) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
ans[max(0, i - x - 1)]++;
ans[i - 1]--;
}
int res = 0;
for (int i = n; i >= 1; i--) {
ans[i] += ans[i + 1];
if (ans[i] >= 0) res++;
}
printf("%d\n", res);
}
int main() {
int t = 1;
for (int testCase = 1; testCase <= t; testCase++) {
solve(testCase);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = (int)1e5 + 10;
int n;
int a[maxn];
void Read() { scanf("%d", &n); }
void Solve() {
if (n % 4 != 0 && n % 4 != 1) {
printf("-1\n");
return;
}
int i, t = n >> 1;
for (i = 1; i < t; i += 2)
a[i] = i + 1, a[i + 1] = n - i + 1, a[n - i + 1] = n - i, a[n - i] = i;
if (n & 1) a[n + 1 >> 1] = n + 1 >> 1;
for (i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
int main() {
Read();
Solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y, z;
cin >> x >> z;
bool possible = true;
for (int i = 0; i < x.length() && possible; i++) {
if (x[i] < z[i]) {
possible = false;
} else {
y += z[i];
}
}
if (possible) {
cout << y << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define endl "\n"
typedef long long int ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input1.txt", "r", stdin);
// for writing output to output.txt
freopen("output1.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int>number(n);
unordered_set<int>hashSet;
for (int i = 0; i < n; i++) {
cin >> number[i];
}
for (int i = 0; i < n; i++) {
if (hashSet.find(number[i]) == hashSet.end()) {
hashSet.insert(number[i]);
}
else {
hashSet.insert(number[i] + 1);
}
}
int maximul = hashSet.size();
cout << maximul << endl;
/*for (auto it : hashSet) {
cout << it << " ";
}
cout << endl << endl;*/
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 10007;
const long long inf = 1e16;
const long long ninf = LLONG_MIN;
const long double eps = 1e-10;
const long long N = 1000005;
const long long LOGN = 19;
const long double PI = 3.14159265358979323846;
long long mul(long long a, long long b) { return (a * b) % mod; }
long long add(long long a, long long b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long n, q;
long double p[N];
pair<long double, long double> st[N];
bool is(long double x) { return (abs(x) <= eps); }
pair<long double, long double> merge(pair<long double, long double> l,
pair<long double, long double> r) {
long double l1 = l.first, r1 = l.second, l2 = r.first, r2 = r.second;
if (is(l1 + 1) && is(r1 + 1)) return r;
if (is(l2 + 1) && is(r2 + 1)) return l;
long double rec = (l2 - 1) * r1 + 1;
if (is(rec)) return {0, 0};
long double x = (l1 * l2) / (rec);
long double y = r2 + (r1 * (1 - r2) * (l2)) / rec;
return {x, y};
}
void update(long long id, long long s, long long e, long long x,
long double v) {
if (s == e) {
st[id] = {v, v};
p[s] = v;
return;
}
long long m = (s + e) >> 1;
if (x <= m) {
update(id + id, s, m, x, v);
} else {
update(id + id + 1, m + 1, e, x, v);
}
st[id] = merge(st[id + id], st[id + id + 1]);
}
pair<long double, long double> query(long long id, long long s, long long e,
long long l, long long r) {
if (s > e || s > r || e < l) {
return {-1, -1};
}
if (l <= s && e <= r) {
return st[id];
}
long long m = (s + e) >> 1;
return merge(query(id + id, s, m, l, r), query(id + id + 1, m + 1, e, l, r));
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> q;
cout << fixed << setprecision(11);
for (int i = 0; i < n; i++) {
long double v, a, b;
cin >> a >> b;
v = a / b;
update(1, 0, n - 1, i, v);
}
for (int i = 0; i < q; i++) {
long long t;
cin >> t;
if (t == 1) {
long double v, a, b, in;
cin >> in >> a >> b;
in--;
v = a / b;
update(1, 0, n - 1, in, v);
} else {
long long l, r;
cin >> l >> r;
l--;
r--;
cout << query(1, 0, n - 1, l, r).first << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 12;
long long MOD;
long long dp[N][M][N];
long long curCom[M];
long long inv2[M];
long long inv1[M];
inline long long mypow(long long a, long long b) {
int res = 1;
while (b) {
if (b & 1) {
res = ((long long)res * a) % MOD;
}
a = ((long long)a * a) % MOD;
b >>= 1;
}
return res;
}
inline long long cmb(long long a, long long b) {
long long d1, d2;
if (a < b) {
return 0;
}
d1 = 1;
d2 = inv2[b];
while (b) {
d1 = (long long)d1 * a % MOD;
b--;
a--;
}
return (long long)d1 * d2 % MOD;
}
void calCurCom(long long n, int m) {
memset(curCom, 0, sizeof(curCom));
if (n = 0) {
return;
}
int i, j;
long long d1, d2;
long long tmp = n + m - 1;
for (i = m; i >= 1; i--, tmp--) {
inv1[i] = mypow(tmp, MOD - 2);
}
d1 = d2 = 1;
}
int main() {
int n, d, i, j, k, l;
scanf("%d%d%lld", &n, &d, &MOD);
if (n <= 2) {
printf("1\n");
return 0;
}
long long tmp = 1;
inv1[0] = 1;
inv2[1] = 1;
for (i = 2; i <= d; i++) {
tmp = tmp * i;
inv2[i] = mypow(tmp, MOD - 2);
}
for (k = 0; k <= n; k++) {
dp[1][0][k] = 1;
}
for (i = 2; i <= d + 1; i++) {
for (k = 1; k <= n; k++) {
dp[i][i - 1][k] = 1;
}
}
for (i = 3; i <= n; i++) {
for (j = 1; j <= d && j < i - 1; j++) {
for (k = 2; k <= n - 1; k++) {
dp[i][j][k] = dp[i][j][k - 1];
for (l = 1; l <= j && l * k < i; l++) {
tmp = (long long)dp[i - k * l][j - l][k - 1] *
cmb(dp[k][d - 1][k - 1] + l - 1, l) % MOD;
dp[i][j][k] = ((long long)dp[i][j][k] + tmp) % MOD;
}
}
}
}
long long ans = 0;
ans = dp[n][d][(n + 1) / 2 - 1];
if ((n & 1) == 0) {
ans = ((long long)ans + cmb(dp[n / 2][d - 1][n / 2 - 1] + 1, 2)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const long long INFLL = (long long)INF * INF;
template <class Key, class Val>
struct Top {
pair<Key, Val> t[2];
Top() {
for (int i = 0; i < (2); ++i) t[i] = make_pair(-INFLL, -1);
}
void set(Key k, Val v) {
static pair<Key, Val> tt[3];
for (int i = 0; i < (2); ++i) tt[i] = t[i];
tt[2] = make_pair(k, v);
sort(tt, tt + 3, greater<pair<Key, Val> >());
for (int i = 0; i < (2); ++i) t[i] = tt[i];
}
};
const int N = 100000;
const int N2 = N / 2 + 1;
Top<long long, int> top[N2];
typedef pair<int, int> cube;
long long best;
int bi, bj, bii, bjj;
static void f(int i, int ii, int j, int jj) {
if (top[i].t[ii].second == top[j].t[jj].second) {
return;
}
long long tmp = top[i].t[ii].first + top[j].t[jj].first;
if (tmp > best) {
best = tmp;
bi = i;
bii = ii;
bj = j;
bjj = jj;
}
}
int main() {
int n;
(scanf("%d", &(n)) == 1);
;
map<int, vector<cube> > M;
int c, s;
for (int i = (1); i <= (n); ++i) {
(scanf("%d", &(c)) == 1);
(scanf("%d", &(s)) == 1);
M[c].push_back(cube(s, i));
}
int bound = n / 2 + 2;
for (typeof((M).begin()) m = ((M).begin()); m != (M).end(); ++m) {
sort((m->second).begin(), (m->second).end(), greater<cube>());
long long sum = 0;
int bound2 = min(bound, ((int)(m->second).size()));
for (int i = 0; i < (bound2); ++i) {
sum += m->second[i].first;
top[i + 1].set(sum, m->first);
}
}
for (int i = (1); i <= (bound - 1); ++i) {
f(i, 0, i, 1);
f(i - 1, 0, i, 0);
f(i - 1, 0, i, 1);
f(i - 1, 1, i, 0);
}
printf("%I64d\n%d\n", best, bi + bj);
int c1 = top[bi].t[bii].second;
int c2 = top[bj].t[bjj].second;
const vector<cube> &v1 = M[c1];
const vector<cube> &v2 = M[c2];
for (int i = 0; i < (bi); ++i) {
printf("%d %d ", v2[i].second, v1[i].second);
}
if (bi != bj) {
printf("%d", v2[bi].second);
}
putchar('\n');
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
string s, t;
cin >> s;
cin >> t;
int n = s.length();
int nt = t.length();
int in[n][26];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) in[i][j] = -1;
}
for (int i = 0; i < 26; i++) {
if (s.at(n - 1) == 97 + i) in[n - 1][i] = n - 1;
for (int j = n - 2; j >= 0; j--) {
if (s.at(j) == 97 + i)
in[j][i] = j;
else
in[j][i] = in[j + 1][i];
}
}
int spos = 0;
int ans = 0;
int i = 0;
while (i < nt) {
int curr = t.at(i) - 97;
if (in[0][curr] == -1) {
ans = -1;
break;
}
if (in[spos][curr] == -1 || spos > n - 1) {
ans = ans + 1;
spos = 0;
} else {
spos = in[spos][curr] + 1;
i++;
}
}
if (ans == -1)
cout << ans << endl;
else
cout << ans + 1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int t = 0, s = 1e9;
for (int tt = 1; tt <= 100; tt++) {
int ss = 0;
for (int i = 1; i <= n; i++)
ss += min(abs(a[i] - tt), min(abs(a[i] - tt + 1), abs(a[i] - tt - 1)));
if (ss < s) {
t = tt;
s = ss;
}
}
cout << t << ' ' << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a[1005];
set<char> s;
int n, m;
void push() {
s.insert('1');
s.insert('2');
s.insert('3');
s.insert('4');
}
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
cout << (a[i][j] >= 49 && a[i][j] <= 52 ? (char)(a[i][j] + 48) : a[i][j]);
cout << endl;
}
}
int main() {
int i, j;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
bool can = true;
push();
for (i = 0; i < n && can; i++)
for (j = 0; j < m && can; j++)
if (a[i][j] == 'b')
can = false;
else if (a[i][j] == 'w' && a[i][j + 1] == 'b' && a[i][j + 2] == 'w') {
for (int j2 = j; j2 <= min(j + 2, m); j2++)
for (int i2 = -1; i2 <= 1; i2 += 2)
if (i + i2 >= 0 && i + i2 < n) s.erase(a[i + i2][j2]);
if (j - 1 >= 0) s.erase(a[i][j - 1]);
if (j + 3 < m) s.erase(a[i][j + 3]);
a[i][j] = *s.begin();
a[i][j + 1] = *s.begin();
a[i][j + 2] = *s.begin();
push();
} else if (a[i][j] == 'w' && a[i + 1][j] == 'b' && a[i + 2][j] == 'w') {
for (int i2 = i; i2 <= min(i + 2, n); i2++)
for (int j2 = -1; j2 <= 1; j2 += 2)
if (j + j2 >= 0 && j + j2 < m) s.erase(a[i][j + j2]);
if (i - 1 >= 0) s.erase(a[i - 1][j]);
if (i + 3 < n) s.erase(a[i + 3][j]);
a[i][j] = *s.begin();
a[i + 1][j] = *s.begin();
a[i + 2][j] = *s.begin();
push();
} else if (a[i][j] != '1' && a[i][j] != '2' && a[i][j] != '3' &&
a[i][j] != '4' && a[i][j] != '.')
can = false;
if (can) {
cout << "YES" << endl;
print();
} else
cout << "NO";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> m;
string ss;
int a, b, cnt;
while (scanf("%d %d", &a, &b) != EOF) cin >> ss;
cnt = 0;
for (int i = 0; i < ss.size(); i++) {
m[ss[i]]++;
}
map<char, int>::iterator it;
it = m.begin();
while (it != m.end()) {
if (it->second > b) {
printf("No\n");
cnt = 1;
break;
}
it++;
}
if (cnt == 0) printf("Yes\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void smin(T &a, T b) {
a = min(a, b);
}
template <class T>
void smax(T &a, T b) {
a = max(a, b);
}
template <class T>
void print(vector<T> &a, string sep) {
for (T el : a) cout << el << sep;
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
;
long long x = a[0] ^ a[1];
for (int i = 2; i < n; i++) {
x ^= a[i];
}
int final = n - 1;
if (n % 2 == 0) {
if (x != 0) {
cout << "NO" << endl;
return 0;
}
final = n - 2;
}
vector<tuple<int, int, int>> ops;
for (int i = 0; i < final - 1; i += 2) {
ops.push_back(make_tuple(i, i + 1, i + 2));
}
for (int i = 0; i < final - 1; i += 2) {
ops.push_back(make_tuple(final, i, i + 1));
}
cout << "YES" << endl;
cout << ops.size() << endl;
for (auto el : ops) {
cout << get<0>(el) + 1 << " " << get<1>(el) + 1 << " " << get<2>(el) + 1
<< endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string S;
long long N, D;
long long p(long long a, long long b) {
if (b == 0) return 1;
long long z = p(a, b / 2);
return z * z * (b % 2 == 1 ? a : 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> S >> D;
N = S.size();
long long ans = 0, ans2 = stoll(S);
for (int i = N - 1; i >= 0; i--) {
if (S[i] == '9')
ans++;
else
break;
}
for (int i = 0; i < N - 1; i++) {
if (S[i] == '0') continue;
long long need = 1 + stoll(S.substr(i + 1, N - 1 - i)) % (p(10, N - i - 1));
if (need <= D) {
if (N - i - 1 > ans) {
ans = N - i - 1;
ans2 = stoll(S) - need;
}
}
}
cout << ans2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, k;
string s;
int last[27];
long long dp[2000005];
const long long mod = 1000000007;
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
cin >> n >> k >> s;
memset(last, -1, sizeof(last));
for (int i = 0; i < s.size(); i++) {
last[s[i] - 'a'] = i;
}
for (int i = 0; i < n; i++) {
int ch = 0;
for (int j = 0; j < k; j++) {
if (last[j] < last[ch]) {
ch = j;
}
}
last[ch] = i + s.size();
s += ch + 'a';
}
dp[0] = 2;
memset(last, -1, sizeof(last));
last[s[0] - 'a'] = 0;
for (int i = 1; i < s.size(); i++) {
int call = last[s[i] - 'a'] - 1, v = 0;
if (call == -1) {
v = 1;
} else {
if (call < -1) {
v = 0;
} else {
v = dp[call];
}
}
dp[i] = (2 * dp[i - 1] - v + mod) % mod;
last[s[i] - 'a'] = i;
}
cout << dp[s.size() - 1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct node {
double x, y;
} t[300000];
int n, q;
int a[100005], b[100005];
void update(int id) {
t[id].x = t[id << 1].x * t[id << 1 | 1].x /
(1 - (1 - t[id << 1 | 1].x) * t[id << 1].y);
t[id].y = t[id << 1 | 1].y + (1 - t[id << 1 | 1].y) * t[id << 1].y *
t[id << 1 | 1].x /
(1 - (1 - t[id << 1 | 1].x) * t[id << 1].y);
}
void build(int id, int l, int r) {
if (l == r) return (void)(t[id].x = t[id].y = 1.0 * a[l] / b[l]);
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
update(id);
}
void change(int id, int l, int r, int p, double c) {
if (l == p && r == p) return (void)(t[id].x = t[id].y = c);
int mid = (l + r) / 2;
if (p <= mid)
change(id << 1, l, mid, p, c);
else
change(id << 1 | 1, mid + 1, r, p, c);
update(id);
}
pair<double, double> query(int id, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return make_pair(t[id].x, t[id].y);
int mid = (l + r) / 2;
if (qr <= mid)
return query(id << 1, l, mid, ql, qr);
else if (ql > mid)
return query(id << 1 | 1, mid + 1, r, ql, qr);
pair<double, double> lson = query(id << 1, l, mid, ql, mid),
rson = query(id << 1 | 1, mid + 1, r, mid + 1, qr), ans;
ans.first = lson.first * rson.first / (1 - (1 - rson.first) * lson.second);
ans.second = rson.second + (1 - rson.second) * lson.second * rson.first /
(1 - (1 - rson.first) * lson.second);
return ans;
}
int main() {
n = readint();
q = readint();
for (int i = 1; i <= n; i++) a[i] = readint(), b[i] = readint();
build(1, 1, n);
int opt, x, y;
while (q--) {
opt = readint();
x = readint();
y = readint();
if (opt == 1)
change(1, 1, n, x, 1.0 * y / readint());
else
printf("%.10lf\n", query(1, 1, n, x, y).first);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m = 0, a = 0;
for (int i = 0; i < 100; i++) {
string s;
getline(cin, s);
if (s[0] == '+') {
m++;
continue;
}
if (s[0] == '-') {
m--;
continue;
}
int c = 1;
int t = 0;
for (int j = 0; j < s.size(); j++) {
if (s[j] == ':' && c == 1) {
c = 0;
continue;
}
if (c == 0) {
a += (s.size() - j) * m;
break;
}
}
}
cout << a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a;
bool prefix[5005][5005], suffix[5005][5005];
long long ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> a;
for (int i = 0; i < (int)a.size(); i++) {
int s = 0;
for (int j = i; j < (int)a.size(); j++) {
if (a[j] == '(' || a[j] == '?')
s++;
else
s--;
if (s >= 0)
prefix[i][j] = true;
else
break;
}
}
for (int i = a.size() - 1; i >= 0; i--) {
int s = 0;
for (int j = i; j >= 0; j--) {
if (a[j] == ')' || a[j] == '?')
s++;
else
s--;
if (s >= 0)
suffix[i][j] = true;
else
break;
}
}
for (int i = 0; i < (int)a.size(); i++)
for (int j = i + 1; j < (int)a.size(); j += 2)
ans += prefix[i][j] && suffix[j][i];
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
int n, m;
char s[200005];
int mp[3][200005];
struct node {
int ab, aa, bb, ba;
void clear() { ab = aa = bb = ba = inf; }
} tr[200005 * 4];
node pushup(node l, node r) {
node res;
res.aa = min(inf, min(l.aa + r.aa, l.ab + r.ba) + 1);
res.ab = min(inf, min(l.aa + r.ab, l.ab + r.bb) + 1);
res.ba = min(inf, min(l.bb + r.ba, l.ba + r.aa) + 1);
res.bb = min(inf, min(l.bb + r.bb, l.ba + r.ab) + 1);
return res;
}
void build(int rt, int l, int r) {
if (l == r) {
tr[rt].clear();
if (mp[1][l] == 0 && mp[2][l] == 0) tr[rt].ab = tr[rt].ba = 1;
if (mp[1][l] == 0) tr[rt].aa = 0;
if (mp[2][l] == 0) tr[rt].bb = 0;
return;
}
build(rt << 1, l, ((l + r) >> 1));
build(rt << 1 | 1, ((l + r) >> 1) + 1, r);
tr[rt] = pushup(tr[rt << 1], tr[rt << 1 | 1]);
}
node query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return tr[rt];
if (R <= ((l + r) >> 1))
return query(rt << 1, l, ((l + r) >> 1), L, R);
else if (L > ((l + r) >> 1))
return query(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
return pushup(query(rt << 1, l, ((l + r) >> 1), L, R),
query(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= 2; ++i) {
scanf("%s", s);
for (int j = 1; j <= n; ++j) mp[i][j] = (s[j - 1] == 'X') ? 1 : 0;
}
build(1, 1, n);
for (int i = 1, l, r; i <= m; ++i) {
scanf("%d%d", &l, &r);
int x = l, y = r, ans;
if (x > n) x -= n;
if (y > n) y -= n;
if (x > y) {
swap(x, y);
swap(l, r);
}
node p = query(1, 1, n, x, y);
if (l > n && r > n) ans = p.bb;
if (l > n && r <= n) ans = p.ba;
if (l <= n && r <= n) ans = p.aa;
if (l <= n && r > n) ans = p.ab;
printf("%d\n", ans < inf ? ans : -1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int l = 1 << 20;
char buf[l], *s, *t;
inline char gc() {
if (s == t) {
t = (s = buf) + fread(buf, 1, l, stdin);
return s == t ? EOF : *s++;
}
return *s++;
}
char c;
bool f;
template <class IT>
inline void gi(IT &x) {
x = 0;
f = 0;
c = gc();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = gc();
}
while ('0' <= c && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ '0');
c = gc();
}
if (f) x = -x;
}
}; // namespace io
using io::gi;
struct qwq {
int a, b, c;
inline qwq() {}
inline qwq(int a, int b, int c) : a(a), b(b), c(c) {}
inline bool operator<(const qwq &x) const { return c < x.c; }
};
template <class IT>
inline void cmin(IT &a, IT b) {
if (b < a) a = b;
}
template <class IT>
inline void cmax(IT &a, IT b) {
if (a < b) a = b;
}
const int N = 1000005, inf = 1000000007;
qwq x[N << 1];
long long ans[N];
int a[N];
priority_queue<int> q1, q2;
inline int que() {
while (!q2.empty() && q1.top() == q2.top()) {
q1.pop();
q2.pop();
}
return q1.top();
}
int main() {
int q, n, m, t, tot, i, j;
gi(q);
gi(n);
while (q--) {
gi(m);
t = n - m + 1;
for (i = 1; i <= m; ++i) gi(a[i]);
tot = 3;
x[1] = qwq(1, 0, 1);
x[2] = qwq(0, 0, t);
x[3] = qwq(1, 0, m + 1);
for (i = 1; i <= m; ++i) {
x[++tot] = qwq(1, a[i], i);
x[++tot] = qwq(0, a[i], i + t);
}
sort(x + 1, x + tot + 1);
while (!q1.empty()) q1.pop();
while (!q2.empty()) q2.pop();
for (i = j = 1; i <= tot && x[i].c <= n; i = j) {
while (x[i].c == x[j].c) {
if (x[j].a)
q1.push(x[j].b);
else
q2.push(x[j].b);
++j;
}
ans[x[i].c] += que();
ans[x[j].c] -= que();
}
}
for (i = 1; i <= n; ++i) printf("%I64d ", ans[i] += ans[i - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, a, b;
int main() {
cin >> n >> s;
while (n--) {
cin >> a >> b;
s = max(s, a + b);
}
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n == m) {
cout << "0";
} else if (m == 0) {
cout << "1";
} else if (n >= 2 * m) {
cout << m;
} else {
cout << n - m;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int G[410][410];
int dy[200];
int dx[200];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n;
string s;
cin >> s;
int x = 200;
int y = 200;
dx['U'] = 1;
dx['R'] = 0;
dx['D'] = -1;
dx['L'] = 0;
dy['U'] = 0;
dy['R'] = 1;
dy['D'] = 0;
dy['L'] = -1;
int ans = 0;
for (int i = 0; i < s.size(); i++) {
int cx = x;
int cy = y;
for (int j = i; j < s.size(); j++) {
cx += dx[s[j]];
cy += dy[s[j]];
if (cx == x && cy == y) ans++;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> sele1, sele2;
int main() {
long long a, b;
long long tot1 = 0, tot2 = 0;
long long book1 = 0, book2 = 0;
scanf("%lld %lld", &a, &b);
long long i, mxn;
for (i = 1; (i * (i + 1)) / 2 <= (a + b); i++)
;
mxn = i - 1;
for (i = mxn; i > 0; i--) {
if (tot1 + i <= a) {
sele1.push_back(i);
tot1 += i;
book1++;
}
}
printf("%d\n", book1);
vector<long long>::iterator it;
for (it = sele1.begin(); it != sele1.end(); it++) {
if (it == sele1.begin()) {
printf("%d", *it);
} else {
printf(" %d", *it);
}
}
int pr = 0;
printf("\n%d\n", mxn - book1);
for (i = mxn; i > 0; i--) {
if (find(sele1.begin(), sele1.end(), i) == sele1.end()) {
if (pr == 0) {
printf("%d", i);
pr++;
} else {
printf(" %d", i);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
vector<int> ans;
ans.push_back(b);
while (b > a) {
if (b == 1)
break;
else if (b % 10 == 1) {
b = b / 10;
} else if (b % 2 == 0) {
b = b / 2;
} else
break;
ans.push_back(b);
}
if (b == a) {
cout << "YES\n";
cout << ans.size() << endl;
for (auto i = ans.rbegin(); i != ans.rend(); i++) cout << *i << " ";
cout << endl;
} else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
string pre = "", suf = "", sspre = "", sssuf = "";
string r = s;
reverse(r.begin(), r.end());
long long n = s.length();
long long f = 0;
while (f < n / 2) {
if (s[f] == r[f]) {
pre = pre + s[f];
suf = s[f] + suf;
} else
break;
f++;
}
for (int x = f; x <= n - 1 - f; x++) {
long long findex = f;
long long rindex = x;
string temp = "";
while (rindex >= f && s[rindex] == s[findex]) {
temp += s[rindex];
rindex--;
findex++;
}
if (rindex == f - 1 && temp.length() > sspre.length()) {
sspre = temp;
}
}
for (int x = f; x <= n - 1 - f; x++) {
long long findex = f;
long long rindex = x;
string temp = "";
while (rindex >= f && r[rindex] == r[findex]) {
temp += r[rindex];
rindex--;
findex++;
}
if (rindex == f - 1 && temp.length() > sssuf.length()) {
sssuf = temp;
}
}
if (s.length() == 1) {
pre = s[0];
suf = "";
sspre = "";
sssuf = "";
}
if (pre.length() == 0) {
if (sssuf.length() > sspre.length()) {
sspre = "";
} else {
sssuf = "";
}
} else if (s.length() - (pre.length() + suf.length()) != 1) {
if (sssuf.length() == 1) {
sssuf = "";
} else if (sspre.length() == 1) {
sspre = "";
}
} else {
sssuf = "";
}
cout << pre;
if (sspre.length() > sssuf.length()) {
cout << sspre;
} else {
cout << sssuf;
}
cout << suf << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
int ink[n];
int minBlock = INT_MAX;
for (int i = 0; i < n; i++) {
std::cin >> ink[i];
int endBlock = -1;
if (n % 7) {
endBlock = ink[i] / 6 + !!(ink[i] % 6) - 1;
} else {
if (i % 7 != 6) {
endBlock = ink[i] - 1;
}
}
if (endBlock != -1 && endBlock < minBlock) {
minBlock = endBlock;
}
}
for (int i = 0; i < n; i++) {
if (n % 7) {
ink[i] -= minBlock * 6;
} else {
if (i % 7 != 6) {
ink[i] -= minBlock;
}
}
}
int minDay = INT_MAX;
int minPen = 0;
for (int i = 0; i < n; i++) {
int a = ink[i];
int day = i;
for (;;) {
if (day % 7 == 6) {
day += n;
if (day % 7 == 6) {
break;
}
}
a--;
if (day >= minDay) {
break;
}
if (!a) {
minDay = day;
minPen = i;
break;
}
day += n;
}
}
std::cout << minPen + 1 << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 20;
const int INF = 1e9 + 7;
int n, m, k, num;
int a[N], fa[N], type[N], di[N], sz[N];
long long ans;
stack<pair<int, int> > st;
struct Node {
int u, v;
} e[N];
inline int read() {
int p;
scanf("%d", &p);
return p;
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
inline pair<int, int> findfa(int x) {
if (x == fa[x]) return {x, 0};
pair<int, int> p = findfa(fa[x]);
return {p.first, p.second ^ type[x]};
}
inline bool cmp(Node x, Node y) {
return a[x.u] == a[y.u] ? a[x.v] < a[y.v] : a[x.u] < a[y.u];
}
int main() {
n = read(), m = read(), k = read();
for (register int i = 1, _r = n; i <= _r; ++i) a[i] = read(), fa[i] = i;
for (register int i = 1, _r = m; i <= _r; ++i) {
int u = read(), v = read();
if (a[u] ^ a[v]) {
if (a[u] > a[v]) swap(u, v);
e[++num] = {u, v};
} else if (!di[a[u]]) {
pair<int, int> fu = findfa(u), fv = findfa(v);
if (fu.first ^ fv.first)
fa[fv.first] = fu.first, type[fv.first] = fu.second ^ fv.second ^ 1;
else if (fu.second == fv.second)
di[a[u]] = 1;
}
}
for (register int i = 1, _r = k; i <= _r; ++i) ans += !di[i];
sort(e + 1, e + num + 1, cmp);
ans = ans * (ans - 1) / 2;
int i = 1, j = 1;
while (i <= num) {
if (!di[a[e[i].u]] && !di[a[e[i].v]]) {
while (j <= num && a[e[j].u] == a[e[i].u] && a[e[j].v] == a[e[i].v]) {
pair<int, int> fu = findfa(e[j].u), fv = findfa(e[j].v);
if (fu.first ^ fv.first) {
st.push({fv.first, sz[fu.first] == sz[fv.first]});
fa[fv.first] = fu.first, sz[fu.first] += sz[fu.first] == sz[fv.first],
type[fv.first] = fu.second ^ fv.second ^ 1;
} else if (fu.second == fv.second) {
ans--;
break;
}
j++;
}
while (!st.empty()) {
pair<int, int> p = st.top();
st.pop();
sz[fa[p.first]] -= p.second, fa[p.first] = p.first, type[p.first] = 0;
}
}
while (j <= num && a[e[j].u] == a[e[i].u] && a[e[j].v] == a[e[i].v]) j++;
i = j;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e3;
const long long MOD = 123456789;
const long long INF = 1e9;
long long n, k, m;
long long a[MAX][MAX];
long long dp[MAX];
void solve() {
cin >> n;
if (n == 1)
cout << 1;
else
for (long long i = 2; i <= n + 1; i++) {
cout << i << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int test = 1;
cin >> test;
while (test--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
unsigned long long c[2507][2507], h[2507][2507];
inline int lowbit(int x) { return x & -x; }
void update(int x, int y, unsigned long long v) {
while (x <= n) {
int yy = y;
while (yy <= m) {
c[x][yy] += v;
yy += lowbit(yy);
}
x += lowbit(x);
}
}
unsigned long long query(int x, int y) {
unsigned long long res = 0;
while (x > 0) {
int yy = y;
while (yy > 0) {
res += c[x][yy];
yy -= lowbit(yy);
}
x -= lowbit(x);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
mt19937 rand(20171011);
int q;
cin >> n >> m >> q;
while (q--) {
int t, r1, c1, r2, c2;
cin >> t >> r1 >> c1 >> r2 >> c2;
if (t == 1) {
unsigned long long v = (((unsigned long long)rand()) << 32) + rand();
h[r1][c1] = v;
update(r1, c1, v);
update(r2 + 1, c1, -v);
update(r1, c2 + 1, -v);
update(r2 + 1, c2 + 1, v);
} else if (t == 2) {
unsigned long long v = h[r1][c1];
update(r1, c1, -v);
update(r2 + 1, c1, v);
update(r1, c2 + 1, v);
update(r2 + 1, c2 + 1, -v);
} else {
unsigned long long a = query(r1, c1);
unsigned long long b = query(r2, c2);
cout << (a == b ? "Yes" : "No") << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int w = 1, c = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) c = (c << 1) + (c << 3) + (ch ^ 48);
return w * c;
}
const int M = 3e5 + 10;
int mod, n, k;
long long fast(long long x, long long p) {
long long ret = 1;
for (; p; p >>= 1, x = x * x % mod)
if (p & 1) ret = ret * x % mod;
return ret;
}
int dp[30][M];
long long fac[M], inv[M];
int dfs(int x, int msk) {
if (dp[x][msk] != -1) return dp[x][msk];
if (x > k) return 0;
if (!msk) {
return dp[x][msk] = fac[n] * fac[k] % mod * inv[k - x] % mod;
}
dp[x][msk] = 0;
int U = msk - (msk & -msk);
for (int A = U; A; A = (A - 1) & U)
dp[x][msk] = (dp[x][msk] + inv[msk - A] * dfs(x + 1, A)) % mod;
dp[x][msk] = (dp[x][msk] + inv[msk] * dfs(x + 1, 0)) % mod;
return dp[x][msk];
}
int main() {
n = read();
k = read();
mod = read();
if (n & 1) {
cout << fast(k, n) << "\n";
return 0;
}
fac[0] = 1;
for (int i = (1); i <= (n); ++i) fac[i] = fac[i - 1] * i % mod;
inv[n] = fast(fac[n], mod - 2);
for (int i = (n); i >= (1); --i) inv[i - 1] = inv[i] * i % mod;
memset(dp, -1, sizeof dp);
cout << (mod + fast(k, n) - dfs(0, n)) % mod << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
bool spec = true;
int n, m, Q;
vector<vector<int> > a(N), b(N);
bool vis[N];
int sta[N], en[N];
const int INF = numeric_limits<int>::max() / 2;
struct BiconnectedComponent {
vector<int> low, num, in;
stack<int> st;
int Time, numcc;
BiconnectedComponent()
: low(n + 5, -1), num(n + 5, -1), in(n + 5, -1), Time(0), numcc(0) {
for (int i = (int)1; i <= (int)n; i++)
if (num[i] == -1) dfs(i, i);
}
void dfs(int u, int p) {
low[u] = num[u] = Time++;
st.push(u);
int meet = 0;
for (auto v : a[u]) {
if (v == p) {
meet++;
if (meet == 1) continue;
}
if (num[v] != -1) {
low[u] = min(low[u], num[v]);
} else {
dfs(v, u);
low[u] = min(low[u], low[v]);
}
}
if (low[u] == num[u]) {
numcc++;
while (true) {
int v = st.top();
num[v] = low[v] = INF;
in[v] = numcc;
st.pop();
if (v == u) break;
}
}
}
};
const int lgx = 20;
int par[lgx][N], depth[N];
void pdfs(int u, int p) {
par[0][u] = p;
vis[u] = true;
for (auto v : a[u]) {
if (v != p) {
depth[v] = depth[u] + 1;
pdfs(v, u);
}
}
}
void dfs(int u, int p) {
vis[u] = true;
for (auto v : a[u]) {
if (v != p) {
dfs(v, u);
sta[u] += sta[v];
en[u] += en[v];
}
}
if (sta[u] > 0 && en[u] > 0) {
cout << "No" << '\n';
exit(0);
}
}
int lca(int p, int q) {
if (depth[p] < depth[q]) swap(p, q);
for (int i = (int)lgx - 1; i >= (int)0; i--) {
if (depth[par[i][p]] >= depth[q]) p = par[i][p];
}
if (p == q) return p;
for (int i = (int)lgx - 1; i >= (int)0; i--) {
if (par[i][p] != par[i][q]) p = par[i][p], q = par[i][q];
}
if (par[0][p] != par[0][q]) throw 1;
return par[0][p];
}
void makelca() {
memset(vis, 0, sizeof(vis));
for (int i = (int)1; i <= (int)n; i++)
if (!vis[i]) pdfs(i, i);
for (int i = (int)1; i <= (int)lgx - 1; i++) {
for (int j = (int)1; j <= (int)n; j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
}
}
}
vector<pair<int, int> > query;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> Q;
if (n != 200000 || m != 199999 || Q != 199999) spec = false;
for (int i = (int)1; i <= (int)m; i++) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = (int)1; i <= (int)Q; i++) {
int u, v;
cin >> u >> v;
query.push_back({u, v});
}
BiconnectedComponent graph;
for (int u = (int)1; u <= (int)n; u++) {
for (auto v : a[u]) {
if (graph.in[u] != graph.in[v]) {
b[graph.in[u]].push_back(graph.in[v]);
}
}
}
a.swap(b);
n = graph.numcc;
makelca();
for (auto& [u, v] : query) {
u = graph.in[u];
v = graph.in[v];
try {
int p = lca(u, v);
sta[u]++;
en[v]++;
sta[p]--;
en[p]--;
} catch (...) {
cout << "No" << '\n';
exit(0);
}
}
memset(vis, 0, sizeof(vis));
for (int i = (int)1; i <= (int)n; i++)
if (!vis[i]) dfs(i, i);
cout << "Yes" << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n + 1];
for (int i = 0; i < n; i++) cin >> A[i + 1];
if (n <= 2 || n % 2 == 0 && A[n] != 0) {
cout << -1 << endl;
return 0;
}
int ts = 0;
int i = n;
while (i > 0) {
if (A[i] == 0) {
i--;
continue;
}
if (i % 2 == 0) {
int j = i / 2;
ts = ts + A[i];
A[j] = max(0, A[j] - A[i]);
i--;
continue;
} else {
if (i == 1) {
if (A[i] != 0) ts = ts + A[i];
break;
}
int x = max(A[i], A[i - 1]);
ts = ts + x;
A[i / 2] = max(0, A[i / 2] - x);
i = i - 2;
}
}
cout << ts << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, n, v[200010], m, a, b, x, y, h, w, l, p, ans, numitor, aux,
mini, sum, poz;
string s1, s2, second;
char c;
map<long long, long long> mip;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x;
for (long long i = 1; i <= n; i++) {
cin >> v[i];
if (v[i] < x)
v[i] = -1;
else if (v[i] > x)
v[i] = 1;
else {
v[i] = 0;
poz = i;
}
}
mip[0] = 1;
sum = 0;
for (long long i = 1; i <= n; i++) {
sum += v[i];
if (i >= poz) {
if (mip.find(sum) != mip.end()) ans += mip[sum];
if (mip.find(sum - 1) != mip.end()) ans += mip[sum - 1];
} else {
mip[sum] += 1;
v[i] = sum;
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<long long> g[], long long s, vector<long long> &ar,
vector<long long> &dp, vector<long long> &cnt,
vector<long long> &sum) {
sum[s] = ar[s];
if (!signed(g[s].size())) cnt[s] = 1;
for (auto i : g[s]) {
dfs(g, i, ar, dp, cnt, sum);
cnt[s] += cnt[i];
sum[s] += sum[i];
dp[s] = max(dp[s], dp[i]);
}
dp[s] = max(dp[s], sum[s] / cnt[s] + ((sum[s] % cnt[s]) > 0));
}
void solve() {
long long n;
cin >> n;
vector<long long> g[n + 1];
vector<long long> ar(n + 1, 0);
for (long long i = 1; i <= n - 1; i++) {
long long p;
cin >> p;
g[p].emplace_back(i + 1);
}
for (long long i = 1; i <= n; i++) cin >> ar[i];
vector<long long> dp(n + 1, 0);
vector<long long> cnt(n + 1, 0);
vector<long long> sum(n + 1, 0);
dfs(g, 1, ar, dp, cnt, sum);
cout << dp[1] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2 * 1000 * 1000 + 7], MOD = 1000 * 1000 * 1000 + 7;
int main() {
vector<long long> ans;
long long N, i, j, n, m, a, b, s, k;
dp[3] = dp[4] = 4;
for (i = 5; i <= 2 * 1000 * 1000; i++) {
dp[i] = (dp[i - 1] + 2 * dp[i - 2] + 4 * (i % 3 == 0 ? 1 : 0)) % MOD;
}
cin >> N;
for (int z = 1; z <= N; z++) {
cin >> n;
ans.push_back(dp[n]);
}
for (i = 0; i < ans.size(); i++) cout << ans[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, l, r, a, c = 0;
set<long long int> s;
set<long long int>::iterator it;
scanf("%lld%lld", &l, &r);
for (i = 0;; i++) {
if (pow(2, i) > 2000000000) break;
for (j = 0;; j++) {
a = pow(2, i) * pow(3, j);
if (a > 2000000000) break;
s.insert(a);
}
}
for (it = s.begin(); it != s.end(); it++) {
if (*it > r) break;
if (*it >= l) c++;
}
printf("%lld", c);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long fac[200005];
long long inv[200005];
inline void add(long long &a, long long b) {
a %= 1000000007;
b %= 1000000007;
a += b;
a %= 1000000007;
}
inline void sub(long long &a, long long b) {
a %= 1000000007;
b %= 1000000007;
a -= b;
if (a < 0) a += 1000000007;
}
inline void mul(long long &a, long long b) {
a %= 1000000007;
b %= 1000000007;
a *= b;
a %= 1000000007;
}
long long powm(long long a, long long b) {
long long ret = 1ll;
while (b) {
if (b & 1) ret = (1ll * ret * a) % 1000000007;
a = (1ll * a * a) % 1000000007;
b /= 2;
}
return ret;
}
long long modInv(long long a) { return powm(a, 1000000007 - 2); }
void pre() {
fac[0] = 1ll;
for (int i = 1; i < 200005; i++) fac[i] = (1ll * fac[i - 1] * i) % 1000000007;
for (int i = 0; i < 200005; i++) inv[i] = modInv(fac[i]);
}
long long ncr(long long a, long long b) {
long long ret = (((inv[b] * inv[a - b]) % 1000000007) * fac[a]) % 1000000007;
return ret;
}
vector<pair<int, int> > black;
long long dp[200005];
int main() {
int rows, cols, n, l, r;
cin >> rows >> cols >> n;
for (int i = 0; i < n; i++) {
cin >> l >> r;
l--;
r--;
black.push_back(make_pair(l, r));
}
black.push_back(make_pair(rows - 1, cols - 1));
sort(black.begin(), black.end());
n++;
pre();
for (int i = 0; i < n; i++) {
dp[i] =
ncr(1ll * (black[i].first + black[i].second), 1ll * black[i].second);
for (int j = 0; j < i; j++) {
if (black[j].second <= black[i].second) {
int dl = black[i].first - black[j].first;
int dr = black[i].second - black[j].second;
sub(dp[i], 1ll * dp[j] * ncr(1ll * dl + 1ll * dr, 1ll * dr));
}
}
}
cout << dp[n - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
queue<pair<int, int> > q;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
q.push(make_pair(x, i + 1));
}
while (q.size() != 1) {
pair<int, int> x = q.front();
if (x.first > m) {
x.first -= m;
q.pop();
q.push(x);
} else {
q.pop();
}
}
pair<int, int> ans = q.front();
cout << ans.second;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << a + b - 1 << endl;
for (int i = 1; i <= b; i++) {
cout << 1 << " " << i << endl;
}
for (int i = 2; i <= a; i++) {
cout << i << " " << 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100005], b[100005], p[100005];
int z[100005];
long long s;
priority_queue<int> q;
vector<int> w[100005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, ThxDem = n; i < ThxDem; ++i) scanf("%d", a + i);
for (int i = 0, ThxDem = m; i < ThxDem; ++i) scanf("%d", b + i);
for (int i = 0, ThxDem = m; i < ThxDem; ++i) scanf("%d", p + i);
for (int i = n - 1; i >= 0; --i) z[i] = -max(a[i], -z[i + 1]);
for (int i = 0, ThxDem = m; i < ThxDem; ++i) {
int k = upper_bound(z, z + n, -b[i]) - z - 1;
if (k >= 0) w[k].push_back(p[i]);
}
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
s += a[i];
for (int k : w[i]) {
if (k <= s)
s -= k, q.push(k);
else if (!q.empty() && q.top() > k) {
s += q.top() - k;
q.pop();
q.push(k);
}
}
}
printf("%d\n", ((int)q.size()));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<pair<char, char> > mp;
int p[50];
char s[100100], k[100100];
int getsetid(int x) {
if (x == p[x]) return x;
return p[x] = getsetid(p[x]);
}
bool areCon(int u, int v) { return getsetid(u) == getsetid(v); }
int main() {
int n;
for (int i = 1; i < 50; ++i) p[i] = i;
scanf("%d\n%s\n%s", &n, s, k);
for (int i = 0; i < n; ++i) {
if (areCon(s[i] - 'a', k[i] - 'a')) continue;
p[getsetid(s[i] - 'a')] = k[i] - 'a';
mp.insert(make_pair(min(s[i], k[i]), max(s[i], k[i])));
}
cout << mp.size() << endl;
for (set<pair<char, char> >::iterator it = mp.begin(); it != mp.end(); ++it)
cout << it->first << " " << it->second << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int d[2][4] = {{-1, 1, 0, 0}, {0, 0, -1, 1}};
int n, m;
char s[70][70];
bool v[70][70];
bool dfs(const int &x, const int &y, const int &p, const int &q) {
int i;
int a, b;
v[x][y] = true;
for (i = 0; i < 4; i++) {
a = x + d[0][i];
b = y + d[1][i];
if (a >= 0 && a < n && b >= 0 && b < m) {
if ((a != p || b != q) && v[a][b]) return true;
if (!v[a][b] && s[a][b] == s[x][y] && dfs(a, b, x, y)) return true;
}
}
v[x][y] = false;
return false;
}
int main(void) {
int i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (dfs(i, j, -1, -1)) {
puts("Yes");
return 0;
}
puts("No");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
int cost[123][123];
pair<int, int> C[123][123][5];
int bl[123];
int G[7], iG = 0, n;
int ans = (int)2e9 + 7;
inline int get_cost(int i, int j) {
for (int t = 0; t < 5; t++)
if (C[i][j][t].second != -1 && !bl[C[i][j][t].second])
return C[i][j][t].first;
return (int)2e9;
}
int cur[6][6];
int dp[6][6];
int maxlen;
void upd(int &a, int b) {
if (a > b) a = b;
}
void gen(int pos, int k, int ind) {
if (k == 0) {
for (int i = 0; i < iG; i++)
for (int j = 0; j < iG; j++) cur[i][j] = get_cost(G[i], G[j]);
fill(dp[0], dp[0] + iG, (int)2e9);
dp[0][0] = 0;
for (int len = 0; len < maxlen; len++) {
fill(dp[len + 1], dp[len + 1] + iG, (int)2e9);
for (int i = 0; i < iG; i++)
if (dp[len][i] != (int)2e9) {
for (int j = 0; j < iG; j++)
if (cur[i][j] != (int)2e9) {
upd(dp[len + 1][j], dp[len][i] + cur[i][j]);
}
}
}
ans = min(ans, dp[maxlen][0]);
} else {
for (int i = pos + 1; i <= n - k; i++) {
if (ind == 0 && i > 0) break;
bl[i] = 1;
G[iG++] = i;
gen(i, k - 1, ind + 1);
bl[i] = 0;
iG--;
}
}
}
void solve() {
cin >> n >> maxlen;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> cost[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
vector<pair<int, int>> cur;
for (int t = 0; t < n; t++)
if (i != t && t != j) cur.emplace_back(cost[i][t] + cost[t][j], t);
sort(cur.begin(), cur.end());
for (int t = 0; t < min(5, (int)cur.size()); t++) C[i][j][t] = cur[t];
for (int t = (int)cur.size(); t < 5; t++) C[i][j][t] = {-1, -1};
}
}
maxlen /= 2;
for (int t = 1; t <= min(n, maxlen); t++) {
gen(-1, t, 0);
}
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5 * 1e2 + 5;
int a[N], b[N];
map<pair<int, int>, int> m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
bool cond1 = 1;
if (n % 2) cond1 = (a[n / 2] == b[n / 2]);
for (int i = 0; i < n / 2; i++) {
m[{min(a[i], a[n - i - 1]), max(a[i], a[n - i - 1])}]++;
m[{min(b[i], b[n - i - 1]), max(b[i], b[n - i - 1])}]--;
}
bool cond2 = 1;
for (map<pair<int, int>, int>::iterator it = m.begin(); it != m.end();
it++) {
if (it->second) {
cond2 = 0;
break;
}
}
if (cond1 && cond2)
cout << "Yes" << '\n';
else
cout << "No" << '\n';
m.clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[3][3] = {0};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
int a;
cin >> a;
arr[i][j] += a;
if (j - 1 > -1) {
arr[i][j - 1] += a;
}
if (j + 1 < 3) {
arr[i][j + 1] += a;
}
if (i + 1 < 3) {
arr[i + 1][j] += a;
}
if (i - 1 > -1) {
arr[i - 1][j] += a;
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (arr[i][j] % 2 == 1) {
cout << "0";
} else
cout << "1";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_ = 500000 + 5;
int a[MAX_], b[MAX_];
int left_[MAX_], right_[MAX_];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = 0;
int num1 = 0, num2 = 0;
for (int i = 2; i < n; i++) {
if (a[i - 1] == 1 && a[i] == 0 && a[i + 1] == 1)
num1++;
else if (a[i - 1] == 0 && a[i] == 1 && a[i + 1] == 0)
num2++;
else {
ans = max(ans, max(num1, num2));
num1 = 0;
num2 = 0;
}
}
ans = max(ans, max(num1, num2));
cout << ans << endl;
int k = 1;
left_[k] = 1;
right_[k] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] == a[i - 1]) {
if (left_[k] == 0) left_[k] = i - 1;
right_[k] = i;
} else {
if (left_[k] == 0) continue;
left_[++k] = 0;
right_[k] = 0;
}
}
if (left_[k] == 0) {
left_[k] = n;
right_[k] = n;
}
for (int i = 1; i <= k; i++) {
for (int j = left_[i]; j <= right_[i]; j++) b[j] = a[j];
if (right_[i] != n) {
if (a[right_[i]] == a[left_[i + 1]])
for (int j = right_[i] + 1; j < left_[i + 1]; j++) b[j] = a[right_[i]];
else {
for (int j = right_[i] + 1; j <= (left_[i + 1] + right_[i] + 1) / 2;
j++)
b[j] = a[right_[i]];
for (int j = (left_[i + 1] + right_[i] + 1) / 2; j <= left_[i + 1]; j++)
b[j] = a[left_[i + 1]];
}
}
}
for (int i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, lastr, lastb, lastp, mr, mb, ans = 0;
char ch;
int main() {
scanf("%I64d", &n);
bool pp = false, bb = false, rr = false;
for (long long i = 1; i <= n; i++) {
scanf("%I64d %c", &x, &ch);
if (ch == 'R' || ch == 'P') {
if (rr) {
ans += x - lastr;
mr = max(mr, x - lastr);
}
rr = true;
lastr = x;
}
if (ch == 'B' || ch == 'P') {
if (bb) {
ans += x - lastb;
mb = max(mb, x - lastb);
}
bb = true;
lastb = x;
}
if (ch == 'P') {
if (pp) ans += min(0LL, x - lastp - mr - mb);
lastp = x;
mr = 0;
mb = 0;
pp = true;
}
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
long long int b[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 0; i < n; i++) cin >> b[i];
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
v.push_back({a[i], b[i]});
}
sort(v.begin(), v.end(),
[](pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first == b.first) {
return a.second > b.second;
}
return a.first < b.first;
});
priority_queue<long long int> pq;
long long int ans = 0;
long long int level = 0;
long long int i = 0;
long long int sum = 0;
while (i < n) {
if (!pq.empty()) {
sum -= pq.top();
pq.pop();
level++;
ans += sum;
} else {
level = v[i].first;
}
while (i < n && v[i].first == level) {
pq.push(v[i].second);
sum += v[i].second;
i++;
}
}
while (!pq.empty()) {
sum -= pq.top();
pq.pop();
level++;
ans += sum;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, n, k;
int minimo = 1000000001, acabou = 0, div;
long long total = 0;
cin >> n >> k;
int a[n + 1];
for (i = 0; i < n; i++) {
cin >> a[i];
minimo = min(minimo, a[i]);
}
for (i = 0; i < n && acabou == 0; i++) {
div = a[i] - minimo;
if (div % k != 0) {
acabou = 1;
cout << "-1" << endl;
} else
total += div / k;
}
if (!acabou) cout << total << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i] < 0) v[i] *= -1;
} else if (v[i] > 0)
v[i] *= -1;
}
for (auto& a : v) cout << a << " ";
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int n;
char s[100005];
unsigned int dp[2][100005];
int main() {
scanf("%d%s", &n, s);
int cur = 0, nxt = 1;
dp[cur][0] = 1;
for (int i = 0; i < n; ++i) {
int lim = min(n, min(i + 2, n - i + 2));
if (s[i] != '?') {
dp[nxt][0] = 0;
for (int j = 1; j < lim; ++j) dp[nxt][j] = dp[cur][j - 1];
} else {
dp[nxt][0] = dp[cur][1];
for (int j = 1; j < lim; ++j)
dp[nxt][j] = dp[cur][j - 1] * 25 + dp[cur][j + 1];
}
swap(cur, nxt);
}
unsigned int res = dp[cur][0];
cout << res << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
cin >> n;
int offCry[n], hallCry[n];
long long conf[n];
vector<int> sol;
for (i = 0; i < n; i++) cin >> offCry[i] >> hallCry[i] >> conf[i];
long long d;
int v;
bool inQueue[n];
fill(inQueue, inQueue + n, true);
for (i = 0; i < n; i++)
if (conf[i] >= 0) {
sol.push_back(i + 1);
v = offCry[i];
d = 0;
for (j = i + 1; j < n; j++) {
if (inQueue[j]) {
conf[j] -= (v + d);
if (conf[j] < 0) d += hallCry[j], inQueue[j] = false;
v = (v > 0) ? v - 1 : 0;
}
}
}
cout << sol.size() << '\n';
for (auto a : sol) cout << a << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_heap = priority_queue<T>;
template <typename T>
ostream &operator<<(ostream &os, min_heap<T> H) {
while (!H.empty()) {
os << H.top() << " ";
H.pop();
}
os << "\n";
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, max_heap<T> H) {
while (!H.empty()) {
os << H.top() << " ";
H.pop();
}
os << "\n";
return os << "";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, pair<F, S> P) {
return os << P.first << " " << P.second;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> arr) {
for (int i = 0; i < (int)arr.size(); i++) {
os << arr[i] << " ";
}
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, vector<vector<T>> matrix) {
os << "\n";
for (int i = 0; i < (int)matrix.size(); i++) {
for (int j = 0; j < (int)matrix[i].size(); j++) {
os << matrix[i][j] << " ";
}
os << "\n";
}
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, set<T> S) {
for (auto s : S) {
os << s << " ";
}
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, multiset<T> S) {
for (auto s : S) {
os << s << " ";
}
return os << "";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, map<F, S> M) {
os << "\n";
for (auto m : M) {
os << m << "\n";
}
return os << "";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, multimap<F, S> M) {
os << "\n";
for (auto m : M) {
os << m << "\n";
}
return os << "";
}
struct segment_tree {
int N;
int def_val;
vector<int> tree;
inline int merge_nodes(int left, int right) { return left + right; }
segment_tree() {}
segment_tree(int len, int val) {
N = (1LL << (int)(ceill(log2(len))));
def_val = val;
tree.resize(N << 1, def_val);
}
segment_tree(vector<int> &elements, int val) {
N = (1 << (int)(ceill(log2((int)elements.size()))));
def_val = val;
tree.resize(N << 1, def_val);
for (int i = 0; i < (int)elements.size(); i++) {
tree[N + i] = elements[i];
}
build_inner(1);
}
int query(int l, int r) { return query_inner(1, l, r, 0, N - 1); }
int walk(int want) {
int loc = 1;
int has = 0;
while (loc < N) {
if (has + tree[2 * loc] >= want) {
loc *= 2;
} else {
has += tree[2 * loc];
loc = 2 * loc + 1;
}
}
return loc - N;
}
void update(int pos, int val) {
tree[N + pos] = val;
update_inner((N + pos) >> 1);
}
void add(int pos, int val) {
tree[N + pos] += val;
update_inner((N + pos) >> 1);
}
private:
int build_inner(int current_node) {
if (current_node >= N) {
return tree[current_node];
}
tree[current_node] = merge_nodes(build_inner((current_node << 1)),
build_inner((current_node << 1) + 1));
return tree[current_node];
}
void update_inner(int current_node) {
if (current_node == 0) {
return;
}
tree[current_node] =
merge_nodes(tree[(current_node << 1)], tree[(current_node << 1) + 1]);
update_inner((current_node >> 1));
}
int query_inner(int current_node, int query_l, int query_r, int tree_l,
int tree_r) {
if (query_l <= tree_l && tree_r <= query_r) {
return tree[current_node];
}
if (query_l > tree_r || query_r < tree_l) {
return def_val;
}
int mid = ((tree_l + tree_r) >> 1);
return merge_nodes(
query_inner((current_node << 1), query_l, query_r, tree_l, mid),
query_inner((current_node << 1) + 1, query_l, query_r, mid + 1,
tree_r));
}
};
int n, q;
vector<vector<int>> adj;
vector<int> arr;
vector<set<int>> mp;
vector<vector<int>> query;
vector<int> ans;
vector<pair<int, int>> og;
void dfs(int node, int par, vector<int> &cnt, segment_tree &tree) {
if (cnt[arr[node]] != 0) {
mp[cnt[arr[node]]].erase(arr[node]);
tree.add(cnt[arr[node]], -1);
}
cnt[arr[node]]++;
mp[cnt[arr[node]]].insert(arr[node]);
tree.add(cnt[arr[node]], 1);
for (const auto &ind : query[node]) {
int extra = tree.query(0, og[ind].first - 1);
int want = extra + og[ind].second;
if (tree.query(0, n) < want) {
ans[ind] = -1;
} else {
ans[ind] = *mp[tree.walk(want)].begin();
}
}
for (const auto &nxt : adj[node]) {
if (nxt != par) {
dfs(nxt, node, cnt, tree);
}
}
mp[cnt[arr[node]]].erase(arr[node]);
tree.add(cnt[arr[node]], -1);
cnt[arr[node]]--;
if (cnt[arr[node]] != 0) {
mp[cnt[arr[node]]].insert(arr[node]);
tree.add(cnt[arr[node]], 1);
}
}
void solve() {
adj.clear();
arr.clear();
mp.clear();
query.clear();
ans.clear();
og.clear();
cin >> n >> q;
adj.resize(n + 1);
arr.resize(n + 1);
mp.resize(n + 1);
query.resize(n + 1);
ans.resize(q);
og.resize(q);
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
adj[p].push_back(i);
}
for (int i = 0; i < q; i++) {
int v, l, k;
cin >> v >> l >> k;
og[i] = {l, k};
query[v].push_back(i);
}
segment_tree tree(n + 1, 0);
vector<int> cnt(n + 1);
dfs(1, 0, cnt, tree);
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int no_of_testcases = 1;
cin >> no_of_testcases;
for (int i = 1; i <= no_of_testcases; i++) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
scanf("%d", &n);
set<int> s[2], ans;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
int prev = i & 1, next = (i + 1) & 1;
s[next].clear();
s[next].insert(a);
for (set<int>::iterator it = s[prev].begin(); it != s[prev].end(); it++) {
s[next].insert(*it | a);
}
for (set<int>::iterator it = s[next].begin(); it != s[next].end(); it++) {
ans.insert(*it);
}
}
printf("%d\n", ans.size());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
n = 1 << n;
vector<int> a(n), p(n), q(n), pos(n), v(n);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum ^= a[i];
p[i] = q[i] = pos[i] = i;
}
if (sum != 0) {
cout << "Fou";
return;
}
function<void(int, int)> fix = [&](int i, int j) {
int k = pos[a[i] ^ q[i]];
if (k == i) return;
swap(p[i], p[k]);
swap(pos[p[i]], pos[p[k]]);
if (k != j) swap(q[k], q[j]), fix(k, j);
};
for (int i = 0; i < n; i++) {
if (v[i] != a[i]) {
int d = v[i] ^ a[i];
v[i] ^= d;
v[i + 1] ^= d;
fix(i, i + 1);
}
}
cout << "Shi\n";
for (auto& x : p) {
cout << x << ' ';
}
cout << '\n';
for (auto& x : q) {
cout << x << ' ';
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 9;
int a[maxn][2], vis[maxn], mp[maxn];
vector<int> vec;
bool cmp(int a, int b) { return a > b; }
int main() {
ios::sync_with_stdio(0);
cin.tie();
int i, j, k, n, m;
cin >> n >> m;
for (i = 0; i < m; i++) {
for (j = 0; j < 2; j++) {
cin >> a[i][j];
}
}
int x = a[0][0], cnt = 1;
for (i = 1; i < m; i++) {
int flag = 0;
for (j = 0; j < 2; j++) {
if (a[i][j] == x) flag = 1;
}
if (flag) vis[i] = 1, cnt++;
}
for (i = 1; i < m; i++) {
if (!vis[i]) {
for (j = 0; j < 2; j++) {
mp[a[i][j]]++;
}
}
}
for (j = 0; j <= n; j++) {
vec.push_back(mp[j]);
}
sort(vec.begin(), vec.end(), cmp);
if (vec[0] >= m - cnt) {
cout << "YES" << endl;
return 0;
}
vec.clear();
memset(vis, 0, sizeof(vis));
memset(mp, 0, sizeof(mp));
x = a[0][1], cnt = 1;
for (i = 1; i < m; i++) {
int flag = 0;
for (j = 0; j < 2; j++) {
if (a[i][j] == x) flag = 1;
}
if (flag) vis[i] = 1, cnt++;
}
for (i = 1; i < m; i++) {
if (!vis[i]) {
for (j = 0; j < 2; j++) {
mp[a[i][j]]++;
}
}
}
for (j = 0; j <= n; j++) {
vec.push_back(mp[j]);
}
sort(vec.begin(), vec.end(), cmp);
if (vec[0] >= m - cnt) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
struct L {
struct L *next;
int j;
};
struct V {
struct L adj;
int pp[17];
int d, a, b;
} vv[100000];
void link(int i, int j) {
static struct L ll_[100000 * 2], *l = ll_;
l->j = j;
l->next = vv[i].adj.next;
vv[i].adj.next = l++;
}
void dfs(int p, int i, int d) {
static int time = 0;
struct V *u = &vv[i];
struct L *l;
int k;
u->pp[0] = p;
for (k = 1; 1 << k <= d; k++) u->pp[k] = vv[u->pp[k - 1]].pp[k - 1];
u->d = d;
u->a = time++;
for (l = u->adj.next; l; l = l->next)
if (l->j != p) dfs(i, l->j, d + 1);
u->b = time++;
}
int lca(int i, int j) {
int k;
if (vv[i].d < vv[j].d) return lca(j, i);
for (k = 17 - 1; k >= 0; k--)
if (1 << k <= vv[i].d - vv[j].d) i = vv[i].pp[k];
if (i == j) return i;
for (k = 17 - 1; k >= 0; k--)
if (1 << k <= vv[i].d && vv[i].pp[k] != vv[j].pp[k])
i = vv[i].pp[k], j = vv[j].pp[k];
return vv[i].pp[0];
}
int tt[100000 * 2];
void update(int i, int n, int x) {
while (i < n) {
tt[i] += x;
i |= i + 1;
}
}
int query(int i) {
int ans = 0;
while (i >= 0) {
ans += tt[i];
i &= i + 1;
i--;
}
return ans;
}
struct P {
int i, h;
} pp[100000];
int compare(const void *a, const void *b) {
struct P *p1 = (struct P *)a;
struct P *p2 = (struct P *)b;
return p1->h - p2->h;
}
int main() {
static char used[100000];
static int dp[1 + 300];
int n, q, h, i, j;
scanf("%d%d", &n, &q);
for (h = 0; h < n - 1; h++) {
scanf("%d%d", &i, &j), i--, j--;
link(i, j);
link(j, i);
}
dfs(-1, 0, 0);
while (q--) {
int k, m, r, ans;
scanf("%d%d%d", &k, &m, &r), r--;
for (i = 0; i < k; i++) {
int a;
scanf("%d", &a), a--;
pp[i].i = a;
used[a] = 1;
update(vv[a].a, n * 2, 1);
update(vv[a].b, n * 2, -1);
}
for (i = 0; i < k; i++) {
int a = pp[i].i, c = lca(a, r);
int ha = query(vv[a].a);
int hr = query(vv[r].a);
int hc = query(vv[c].a);
pp[i].h = ha + hr - 2 * hc + used[c] - 1;
}
qsort(pp, k, sizeof *pp, compare);
dp[0] = 1;
for (j = 1; j <= m; j++) dp[j] = 0;
for (i = 0; i < k; i++) {
for (j = m; j > 0; j--)
dp[j] = ((long long)dp[j] * (j - pp[i].h) + dp[j - 1]) % 1000000007;
dp[0] = 0;
}
ans = 0;
for (j = 1; j <= m; j++) ans = (ans + dp[j]) % 1000000007;
printf("%d\n", ans);
for (i = 0; i < k; i++) {
int a = pp[i].i;
used[a] = 0;
update(vv[a].a, n * 2, -1);
update(vv[a].b, n * 2, 1);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
int main() {
cin >> n >> k >> a >> b;
if (n > k)
cout << "First";
else
cout << "Second";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, neg = 0, count = 0, k = 0, i;
cin >> n;
long long int a[n], b[n], c = 0;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (a[i] < 0) neg++;
count++;
if (neg == 3 && i < n - 1) {
b[k++] = count - 1;
neg = 1;
count = 1;
c++;
} else if (i == n - 1 && neg < 3) {
b[k++] = count;
c++;
} else if (neg == 3 && i == n - 1) {
b[k++] = 1;
b[k++] = count - 1;
c += 2;
}
}
cout << c << "\n";
for (i = 0; i < k; i++) cout << b[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int modPow(long long int x, long long int n, long long int mod) {
long long int r = 1;
x = x % mod;
while (n) {
if (n & 1) r = (r * x) % mod;
n = n >> 1;
x = (x * x) % mod;
}
return r;
}
int main() {
long long int t, i, j, k, l, n, m, a, b, c, x, y, z;
cin >> t;
while (t--) {
cin >> n;
vector<long long int> V;
map<long long int, long long int> M;
bool ans = true;
for (i = 0; i < n; ++i) {
cin >> l;
M[l]++;
V.push_back(l);
if (M[l] > 1) ans = false;
}
vector<long long int> P(2 * n, 0);
for (i = 0; i < n; ++i) P[i * 2] = V[i];
set<pair<long long int, long long int> > S;
for (i = 0; i < n; ++i) {
bool milla = false;
for (j = V[i]; j <= 2 * n; ++j) {
if (M[j] == 0) {
M[j]++;
P[2 * i + 1] = j;
milla = true;
break;
}
}
if (milla == false) {
ans = false;
break;
}
}
if (ans) {
for (auto it : P) cout << it << " ";
cout << "\n";
} else {
cout << -1 << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long lis(long long s, long long e, vector<long long> &mark,
vector<long long> &ar) {
vector<long long> ans;
for (long long i = s; i <= e; i++) {
if (mark[i] == 0) {
auto it = upper_bound(ans.begin(), ans.end(), ar[i] - i);
if (it == ans.end())
ans.emplace_back(ar[i] - i);
else
*it = ar[i] - i;
}
}
return signed(ans.size());
}
void solve() {
long long n, k, nch = 0;
cin >> n >> k;
vector<long long> ar(n + 1), br(k + 1), mark(n + 1, 0);
for (long long i = 1; i <= n; i++) {
cin >> ar[i];
}
for (long long i = 1; i <= k; i++) {
cin >> br[i];
}
for (long long i = 2; i <= k; i++) {
if (ar[br[i]] - br[i] >= ar[br[i - 1]] - br[i - 1])
;
else {
cout << -1;
return;
}
}
long long p2 = 1;
for (long long i = 1; i <= n; i++) {
if (p2 <= k && i < br[p2] && ar[i] - i <= ar[br[p2]] - br[p2])
;
else if (p2 <= k)
mark[i] = 1;
if (p2 - 1 >= 1 && i > br[p2 - 1] &&
ar[i] - i >= ar[br[p2 - 1]] - br[p2 - 1])
;
else if (p2 - 1 >= 1)
mark[i] = 1;
if (p2 <= k && i == br[p2]) {
nch++;
p2++;
}
}
for (long long i = 1; i <= k; i++) {
if (i == 1)
nch += lis(i, br[i], mark, ar);
else
nch += lis(br[i - 1], br[i], mark, ar);
}
if (k > 0)
nch += lis(br[k], n, mark, ar);
else
nch += lis(1, n, mark, ar);
cout << n - nch;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int inf = 2e9;
const double eps = 1e-7;
const long long INF = (long long)1e18;
int n;
int m;
int a[N];
vector<int> ans;
int main() {
scanf("%d%d", &(n), &(m));
for (int i = 0; i < (n); ++i) scanf("%d", &(a[i]));
sort(a, a + n);
int j = 0, val = 1;
int k = (int)1e9;
while (m > 0 && j < n && val <= k) {
if (val < a[j]) {
if (m >= val) {
ans.push_back(val);
m -= val;
} else
break;
val++;
} else {
val++;
j++;
}
}
while (j == n && val <= k && m > 0) {
if (m >= val) {
ans.push_back(val);
m -= val;
} else
break;
val++;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000005];
int main() {
int n, i;
long long ans1, ans2, cnt1, cnt2;
while (scanf("%d", &n) == 1) {
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cnt1 = cnt2 = 0;
for (i = 0; i < n; i++) {
ans1 = a[n - 1] - a[0];
if (a[0] == a[i]) cnt1++;
if (a[n - 1] == a[i]) cnt2++;
}
if (cnt1 == n)
ans2 = (cnt1 * (cnt1 - 1)) / 2;
else
ans2 = (cnt1 * cnt2);
cout << ans1 << " " << ans2 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
double p[120] = {0};
double a[120] = {0};
double b[120] = {0};
bool fun(double a, double b) { return b < a; }
int main() {
int i;
scanf("%d", &n);
double mx = -1;
for (i = 0; i < n; i++) {
scanf("%lf", &p[i]);
mx = max(p[i], mx);
}
sort(p, p + n, fun);
a[0] = p[0];
b[0] = 1 - p[0];
for (i = 1; i < n; i++) {
double tmp = a[i - 1] * (1 - p[i]) + b[i - 1] * p[i];
if (tmp > a[i - 1]) {
a[i] = tmp;
b[i] = b[i - 1] * (1 - p[i]);
} else {
a[i] = a[i - 1];
b[i] = b[i - 1];
}
}
printf("%.10lf", max(a[n - 1], mx));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int maxians = 0;
long long int dp[100001][5];
long long int n;
long long int solve(long long int ar[], long long int i, long long int k,
long long int z) {
if (i < 0 || k == 0 || i >= n) return 0;
if (dp[i][z] != -1) return dp[i][z];
long long int ans = 0;
if (i < n) {
ans = max(ans, solve(ar, i + 1, k - 1, z) + ar[i]);
}
if (i >= 0 && z > 0) {
ans = max(ans, solve(ar, i - 1, k - 1, z - 1) + ar[i]);
}
return dp[i][z] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int tc;
cin >> tc;
while (tc--) {
memset(dp, -1, sizeof(dp));
long long int k, z;
cin >> n >> k >> z;
long long int ar[n];
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
}
long long int ans = solve(ar, 1, k, z) + ar[0];
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long low = 1, high = k / n + 1;
while (low < high) {
long long mid = (low + high) / 2;
if (mid * n >= k)
high = mid;
else
low = mid + 1;
}
cout << low << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
static const double PI2 = 8.0 * atan(1.0);
template <class T>
T MIN(const T &a, const T &b) {
return a < b ? a : b;
}
template <class T>
T MAX(const T &a, const T &b) {
return a > b ? a : b;
}
template <class T>
void MIN_UPDATE(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
void MAX_UPDATE(T &a, const T &b) {
if (a < b) a = b;
}
namespace std {
bool operator<(const complex<double> &a, const complex<double> &b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
} // namespace std
double cross(const complex<double> &a, const complex<double> &b) {
return imag(conj(a) * b);
}
double dot(const complex<double> &a, const complex<double> &b) {
return real(conj(a) * b);
}
struct L : public vector<complex<double> > {
L(const complex<double> &a, const complex<double> &b) {
push_back(a);
push_back(b);
}
};
struct C {
complex<double> p;
double r;
C(const complex<double> &p, double r) : p(p), r(r) {}
};
int ccw(complex<double> a, complex<double> b, complex<double> c) {
b -= a;
c -= a;
if (cross(b, c) > 0) return +1;
if (cross(b, c) < 0) return -1;
if (dot(b, c) < 0) return +2;
if (norm(b) < norm(c)) return -2;
return 0;
}
bool intersectLL(const L &l, const L &m) {
return abs(cross(l[1] - l[0], m[1] - m[0])) > EPS ||
abs(cross(l[1] - l[0], m[0] - l[0])) < EPS;
}
bool intersectLS(const L &l, const L &s) {
return cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0]) <
EPS;
}
bool intersectLP(const L &l, const complex<double> &p) {
return abs(cross(l[1] - p, l[0] - p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
bool intersectSP(const L &s, const complex<double> &p) {
return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < EPS;
}
complex<double> projection(const L &l, const complex<double> &p) {
double t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
return l[0] + t * (l[0] - l[1]);
}
complex<double> reflection(const L &l, const complex<double> &p) {
return p + 2.0 * (projection(l, p) - p);
}
double distanceLP(const L &l, const complex<double> &p) {
return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const complex<double> &p) {
const complex<double> r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
complex<double> crosspoint(const L &l, const L &m) {
double A = cross(l[1] - l[0], m[1] - m[0]);
double B = cross(l[1] - l[0], l[1] - m[0]);
if (abs(A) < EPS && abs(B) < EPS) return m[0];
if (abs(A) < EPS) assert(false);
return m[0] + B / A * (m[1] - m[0]);
}
void tangency(double x0, double y0, double x1, double y1, double r,
complex<double> out[2]) {
const double alpha = atan2(y1 - y0, x1 - x0);
const double L = hypot(x1 - x0, y1 - y0);
const double theta = asin(r / L);
const double M = sqrt(L * L - r * r);
out[0] =
complex<double>(x0 + M * cos(alpha + theta), y0 + M * sin(alpha + theta));
out[1] =
complex<double>(x0 + M * cos(alpha - theta), y0 + M * sin(alpha - theta));
}
double arc(complex<double> p, complex<double> q) {
double a = abs(p - q);
double b = abs(p);
double c = abs(q);
double cosa = (b * b + c * c - a * a) / (2 * b * c);
double theta = acos(MAX(-1.0, MIN(1.0, cosa)));
return theta * b;
}
double time(complex<double> src, double v, double r, complex<double> dst) {
L direct(src, dst);
double distFromO = distanceSP(direct, complex<double>(0, 0));
if (distFromO >= r) {
return abs(src - dst) / v;
}
complex<double> srcToO[2];
tangency(src.real(), src.imag(), 0, 0, r, srcToO);
complex<double> oToDst[2];
tangency(dst.real(), dst.imag(), 0, 0, r, oToDst);
double minDistance = 1e10;
for (int i = 0; i < (int)2; ++i)
for (int j = 0; j < (int)2; ++j) {
complex<double> a = srcToO[i];
complex<double> b = oToDst[j];
MIN_UPDATE(minDistance, abs(src - a) + arc(a, b) + abs(b - dst));
}
return minDistance / v;
}
int main() {
std::ios::sync_with_stdio(false);
double xp, yp, vp, x, y, v, r;
cin >> xp >> yp >> vp >> x >> y >> v >> r;
double R = hypot(xp, yp);
complex<double> a(x, y);
complex<double> b(xp, yp);
double left = 0;
double right = 1e10;
for (int loop = 0; loop < (int)200; ++loop) {
double middle = (left + right) * 0.5;
double theta = arg(b);
theta += middle * vp / R;
complex<double> p = polar(R, theta);
if (time(a, v, r, p) < middle) {
right = middle;
} else {
left = middle;
}
}
printf("%.20f\n", left);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
T _max(T a, T b) {
return (!(a < b) ? a : b);
}
template <class T>
T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
T sq(T x) {
return x * x;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
bool inside(T a, T b, T c) {
return a <= b && b <= c;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
const int MAXN = 1000;
int main() {
int n, mi1, mi2, mi3, ma1, ma2, ma3;
cin >> n >> mi1 >> ma1 >> mi2 >> ma2 >> mi3 >> ma3;
n -= (mi1 + mi2 + mi3);
if (n == 0)
cout << mi1 << " " << mi2 << " " << mi3 << endl;
else {
while (n && mi1 < ma1) {
n--;
mi1++;
}
while (n && mi2 < ma2) {
n--;
mi2++;
}
while (n && mi3 < ma3) {
n--;
mi3++;
}
cout << mi1 << " " << mi2 << " " << mi3 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str1, str2;
cin >> str1 >> str2;
int len1, len2, i, cnt = 0;
vector<char> v;
len1 = str1.length();
len2 = str2.length();
if (len1 != len2) {
printf("NO\n");
return 0;
}
for (i = 0; i < len1; i++) {
if (str1[i] != str2[i]) {
cnt++;
v.push_back(str1[i]);
v.push_back(str2[i]);
}
}
if (cnt != 2) {
printf("NO\n");
return 0;
}
if (v[0] == v[3] && v[1] == v[2]) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1;
s = "Bulbasaur";
cin >> s1;
map<char, long long int> m, m1;
for (long long int i{0}; i < s.size(); i++) m[s[i]]++;
for (long long int i{0}; i < s1.size(); i++) m1[s1[i]]++;
map<char, long long int>::iterator itr, itr1;
vector<long long int> vec;
for (itr = m.begin(); itr != m.end(); ++itr) {
int flag{1};
for (itr1 = m1.begin(); itr1 != m1.end(); ++itr1) {
if (itr1->first == itr->first) {
if (itr1->first == 'a' || itr1->first == 'u') {
vec.push_back((itr1->second) / 2);
} else
vec.push_back(itr1->second);
flag = 2;
}
}
if (flag == 1) vec.push_back(0);
}
long long int mimn{100001};
for (int i{0}; i < vec.size(); i++) {
mimn = min(mimn, vec[i]);
}
cout << mimn << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int m[200010];
int main() {
int n, b, a;
int k;
scanf("%d %d %d", &n, &b, &a);
int maxxa = a;
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i]);
}
if (a == 0 && b == 0) {
cout << "0" << endl;
return 0;
}
int ans = n;
for (int i = 1; i <= n; i++) {
if (m[i] == 1) {
if (b) {
if (a == maxxa)
a--;
else
a++, b--;
} else {
a--;
}
} else {
if (a) {
a--;
} else {
b--;
}
}
if (a <= 0 && b <= 0) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
int sum[n];
cin >> arr[0];
sum[0] = arr[0];
for (int i = 1; i < n; i++) {
cin >> arr[i];
sum[i] = sum[i - 1] + arr[i];
}
long double curavg;
long long int adder = 0;
long double ans = 0;
long double finans = 0;
for (int i = k; i <= n; i++) {
curavg = sum[i - 1] * 1.0 / i;
int t = 0;
int value = sum[i - 1];
ans = curavg;
for (int j = i; j < n; j++) {
curavg = (value - arr[t] + arr[j]) * 1.0 / i;
value = value - arr[t] + arr[j];
t++;
ans = max(ans, curavg);
}
finans = max(finans, ans);
}
cout << setprecision(15) << finans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int get() {
int x = 0;
char s = getchar();
while (s < '0' || s > '9') s = getchar();
while (s >= '0' && s <= '9')
x = (x << 3) + (x << 1) + (s ^ 48), s = getchar();
return x;
}
int Min(const int x, const int y) {
if (x < y) return x;
return y;
}
int Max(const int x, const int y) {
if (x > y) return x;
return y;
}
const int N = 55, M = 2e4 + 5;
int n, m, k, a[N][M], sum[N][M], dp[N][M], mxp[N][M], mxs[N][M];
deque<pair<int, int> > q;
int bj(const int i) { return Min(i + k - 1, m); }
int main() {
n = get(), m = get(), k = get();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) sum[i][j] = sum[i][j - 1] + (a[i][j] = get());
for (int i = 1; i <= m; ++i) {
dp[1][i] = sum[1][bj(i)] - sum[1][i - 1];
mxp[1][i] = Max(mxp[1][i - 1], dp[1][i] + sum[2][bj(i)] - sum[2][i - 1]);
}
for (int i = m; i; --i)
mxs[1][i] = Max(mxs[1][i + 1], dp[1][i] + sum[2][bj(i)] - sum[2][i - 1]);
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (j + k <= m)
dp[i][j] =
Max(dp[i][j], mxs[i - 1][j + k] + sum[i][bj(j)] - sum[i][j - 1]);
if (j - k >= 1)
dp[i][j] =
Max(dp[i][j], mxp[i - 1][j - k] + sum[i][bj(j)] - sum[i][j - 1]);
}
q.clear();
for (int j = 1; j <= m; ++j) {
while (!q.empty() && q.front().second <= j - k) q.pop_front();
while (!q.empty() && dp[i - 1][j] - sum[i][j - 1] > q.back().first)
q.pop_back();
q.push_back(pair<int, int>(dp[i - 1][j] - sum[i][j - 1], j));
dp[i][j] = Max(dp[i][j], q.front().first + sum[i][bj(j)]);
}
q.clear();
for (int j = m; j; --j) {
while (!q.empty() && q.front().second >= j + k) q.pop_front();
while (!q.empty() && dp[i - 1][j] + sum[i][bj(j)] > q.back().first)
q.pop_back();
q.push_back(pair<int, int>(dp[i - 1][j] + sum[i][bj(j)], j));
dp[i][j] = Max(dp[i][j], q.front().first - sum[i][j - 1]);
}
for (int j = 1; j <= m; ++j)
mxp[i][j] =
Max(mxp[i][j - 1], dp[i][j] + sum[i + 1][bj(j)] - sum[i + 1][j - 1]);
for (int j = m; j; --j)
mxs[i][j] =
Max(mxs[i][j + 1], dp[i][j] + sum[i + 1][bj(j)] - sum[i + 1][j - 1]);
}
int ans = 0;
for (int i = 1; i <= m; ++i) ans = Max(ans, dp[n][i]);
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
char a[2][3];
char ch;
int i, sign = 0, flog_a = 0, flog_b;
char b[] = {'6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'};
while (scanf("%c", &ch) != EOF) {
getchar();
scanf("%s%s", a[0], a[1]);
getchar();
sign = 0;
flog_a = 0;
flog_b = 0;
if (a[0][1] == ch) {
if (a[1][1] != ch) {
sign = 1;
} else {
for (i = 0; i < 9; i++) {
if (b[i] == a[0][0]) {
flog_a = i;
}
if (b[i] == a[1][0]) {
flog_b = i;
}
}
if (flog_a > flog_b) {
sign = 1;
}
}
} else {
if (a[1][1] == a[0][1]) {
for (i = 0; i < 9; i++) {
if (b[i] == a[0][0]) {
flog_a = i;
}
if (b[i] == a[1][0]) {
flog_b = i;
}
}
if (flog_a > flog_b) {
sign = 1;
}
}
}
if (sign) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-7;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int d8x[8] = {+1, +1, +1, 0, 0, -1, -1, -1};
int d8y[8] = {+1, 0, -1, +1, -1, +1, 0, -1};
int d4x[4] = {1, 0, 0, -1};
int d4y[4] = {0, -1, 1, 0};
long long power(long long x, long long y) {
long long ans = 1;
x = x;
while (y > 0) {
if (y & 1) ans = (ans * x);
y = y >> 1;
x = (x * x);
}
return ans;
}
long long sqr(long long x) { return x * x; }
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <class T>
inline void chmax(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void chmin(T &x, T y) {
x = min((x), (y));
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T powm(T a, T b, long long m) {
T cnt = 1;
while (b > 0) {
if (b % 2 == 1) cnt = (cnt * a) % m;
b /= 2;
a = (a * a) % m;
}
return cnt % m;
}
long long ncr(long long n, long long r) {
long long ans = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
ans *= (n - i);
ans /= (i + 1);
}
return ans;
}
const int MOD = 1000000007;
const int N = 200005;
int n, k, dp[N], u, v;
long long ans;
vector<int> g[N];
bool uni[N];
void dfs(int x, int par = 0) {
dp[x] = uni[x];
for (auto &it : g[x]) {
if (it ^ par) {
dfs(it, x);
dp[x] += dp[it];
}
}
}
void solve() {
cin >> n >> k;
for (int i = 1; i <= 2 * k; ++i) {
cin >> u;
uni[u] = 1;
}
for (int i = 1; i < n; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
for (int i = 1; i <= n; ++i) {
ans += min(dp[i], 2 * k - dp[i]);
}
cout << ans;
}
int32_t main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int tc;
tc = 1;
for (int i = 1; i <= tc; ++i) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
struct node {
int x, y;
} a[1005];
bool cmp(node a, node b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
}
sort(a + 1, a + n + 1, cmp);
string s = "";
int x = 0, y = 0;
for (int i = 1; i <= n; i++) {
if (y > a[i].y) {
printf("NO\n");
return;
}
for (int j = 1; j <= a[i].x - x; j++) s += "R";
for (int j = 1; j <= a[i].y - y; j++) s += "U";
x = a[i].x;
y = a[i].y;
}
cout << "YES\n" << s << endl;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1024;
int n;
int rje[MAX];
vector<int> ask(vector<int> T) {
printf("%d\n", (int)T.size());
for (auto it : T) printf("%d ", it + 1);
printf("\n");
fflush(stdout);
vector<int> R;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
R.push_back(x);
}
return R;
}
void pitaj(int bt, int val) {
vector<int> T;
for (int i = 0; i < n; i++)
if ((i >> bt & 1) == val) T.push_back(i);
if (T.empty()) return;
auto R = ask(T);
for (int i = 0; i < n; i++)
if ((i >> bt & 1) != val) rje[i] = min(rje[i], R[i]);
}
int main() {
memset(rje, 0x3f, sizeof rje);
scanf("%d", &n);
for (int i = 0; i < 10; i++)
for (int j = 0; j < 2; j++) pitaj(i, j);
printf("-1\n");
for (int i = 0; i < n; i++) printf("%d ", rje[i]);
printf("\n");
fflush(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 1100000;
const int inff = 0x3fffffff;
const double eps = 1e-8;
const double pi = acos(-1.0);
struct Complex {
double r, i;
Complex() {}
Complex(double r, double i) : r(r), i(i) {}
inline void real(const double& x) { r = x; }
inline double real() { return r; }
inline Complex operator+(const Complex& rhs) const {
return Complex(r + rhs.r, i + rhs.i);
}
inline Complex operator-(const Complex& rhs) const {
return Complex(r - rhs.r, i - rhs.i);
}
inline Complex operator*(const Complex& rhs) const {
return Complex(r * rhs.r - i * rhs.i, r * rhs.i + i * rhs.r);
}
inline void operator/=(const double& x) { r /= x, i /= x; }
inline void operator*=(const Complex& rhs) {
*this = Complex(r * rhs.r - i * rhs.i, r * rhs.i + i * rhs.r);
}
inline void operator+=(const Complex& rhs) { r += rhs.r, i += rhs.i; }
inline Complex conj() { return Complex(r, -i); }
};
void FFT(Complex* a, int n, int inverse) {
for (int i = 0, j = 0; i < n; i++) {
if (i < j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int l = 2; l <= n; l <<= 1) {
int mid = l >> 1;
double p0 = pi * inverse / mid;
Complex unit(cos(p0), sin(p0));
for (int i = 0; i < n; i += l) {
Complex temp(1.0, 0);
for (int j = 0; j < mid; j++) {
Complex w = temp * a[i + j + mid];
a[i + j + mid] = a[i + j] - w;
a[i + j] = a[i + j] + w;
temp *= unit;
}
}
}
}
Complex a1[nn], a2[nn];
int c[nn];
int main() {
int n, x, y;
scanf("%d%d%d", &n, &x, &y);
int val;
memset(c, -1, sizeof(c));
for (int i = 0; i <= n; i++) {
scanf("%d", &val);
a1[val] = Complex(1.0, 0);
a2[x - val] = Complex(1.0, 0);
}
FFT(a1, 1 << 19, 1);
FFT(a2, 1 << 19, 1);
for (int i = 0; i < (1 << 19); i++) {
a1[i] = a1[i] * a2[i];
}
FFT(a1, 1 << 19, -1);
for (int i = 0; i < (1 << 19); i++) a1[i] /= (1 << 19);
for (int i = x + 1; i < (1 << 19); i++) {
if (a1[i].real() > 0.5) {
c[i - x + y] = i - x + y;
for (int j = 2 * (i - x + y); j < (1 << 19); j += (i - x + y)) {
c[j] = i - x + y;
}
}
}
int q;
scanf("%d", &q);
int l;
while (q--) {
scanf("%d", &l);
if (c[l / 2] == -1) {
printf("-1 ");
} else {
printf("%d ", 2 * c[l / 2]);
}
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long n, dp[200000 + 1][3][2][2];
long long a[200000 + 1];
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
if (n == 1) {
cout << a[1] << endl;
return 0;
}
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= 2; j++)
dp[i][j][0][0] = dp[i][j][0][1] = dp[i][j][1][0] = dp[i][j][1][1] =
-999999999999;
dp[1][1][0][0] = a[1], dp[1][2][1][0] = -a[1];
for (long long i = 1; i < n; i++) {
for (long long j = 0; j <= 2; j++) {
dp[i + 1][(j + 1) % 3][0][0] =
max(dp[i + 1][(j + 1) % 3][0][0], dp[i][j][1][0] + a[i + 1]);
dp[i + 1][(j + 2) % 3][1][0] =
max(dp[i + 1][(j + 2) % 3][1][0], dp[i][j][0][0] - a[i + 1]);
dp[i + 1][(j + 1) % 3][0][1] = max(
dp[i + 1][(j + 1) % 3][0][1],
max(dp[i][j][0][0], max(dp[i][j][0][1], dp[i][j][1][1])) + a[i + 1]);
dp[i + 1][(j + 2) % 3][1][1] = max(
dp[i + 1][(j + 2) % 3][1][1],
max(dp[i][j][1][0], max(dp[i][j][1][1], dp[i][j][0][1])) - a[i + 1]);
}
}
cout << max(dp[n][1][0][1], dp[n][1][1][1]) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int MAX = 1e3 + 10;
using namespace std;
long long a[MAX], dum[MAX], res[MAX], dp[MAX][MAX];
vector<pair<long long, long long> > v;
long long st, n, m;
long long solve(int i, int rem) {
if (i == n + 1) {
return 0;
}
if (dp[i][rem] != -1)
return dp[i][rem];
else {
long long ans = max(0LL, solve(i + 1, rem) - a[i]);
if (rem > 0) {
ans = min(ans, solve(i + 1, rem - 1));
}
dp[i][rem] = ans;
return ans;
}
}
bool ok(int mid, long long st) { return (st >= solve(1, mid)); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
memset(dp, -1, sizeof dp);
while (m--) {
cin >> st;
int lo = 0, hi = n, ans = n;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (ok(mid, st)) {
hi = mid - 1;
ans = min(ans, mid);
} else
lo = mid + 1;
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k = 0, l, v[100005] = {0};
bool ch[100005] = {0};
cin >> n >> m;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i; i--) {
if (!ch[a[i]]) k++;
ch[a[i]] = 1, v[i] = k;
}
while (m--) {
cin >> l;
cout << v[l] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int a, b, c, d, m, n, p, q, r, x, y, z, aa, bb, cc, dd;
long long int i, j, k, l;
long long int cnt = 0, cnt1 = 0, cnt2 = 0, cnt3 = 0, sum = 0, mx = LLONG_MIN,
mn = LLONG_MAX;
long long int flag = 0, flag2 = 0;
vector<long long int> vec1, vec2, vec3;
string s1, s2, s3;
cin >> n;
if (n == 2) {
cout << "2\n";
cout << "1 2\n";
} else if (n == 3) {
cout << "2\n";
cout << "1 3\n";
cout << "2 2\n";
} else {
cout << "2\n";
cout << n - 2 << " " << n << endl;
cout << n - 1 << " " << n - 1 << endl;
x = n - 3;
y = n - 1;
for (long long int i = (long long int)(0); i < (long long int)(x); ++i) {
cout << y << " " << y - 2 << endl;
y--;
}
}
}
int main() {
ios::sync_with_stdio(false);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e2 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 1e10;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
struct Matrix {
int n, m;
long long M[N][N];
Matrix(int _n, int _m, long long num = 0) {
n = _n, m = _m;
if (num == -1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
M[i][j] = (i == j);
}
}
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
M[i][j] = num;
}
}
}
}
void Print(bool f = 0) {
cerr << "=======A.H=======\n";
if (f) cerr << "Size : " << n << ' ' << m << '\n';
for (int i = 0; i < n; i++, cerr << '\n') {
for (int j = 0; j < m; j++) cerr << M[i][j] << ' ';
}
cerr << "=======A.H=======\n";
}
Matrix operator+(const Matrix &T) {
Matrix R = Matrix(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
R.M[i][j] = (M[i][j] + T.M[i][j]) % mod;
}
}
return R;
}
Matrix operator*(const Matrix &T) {
Matrix R = Matrix(n, T.m, 1e13);
if (m != T.n) {
cerr << "Cannot * Matrices !" << '\n';
return R;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < T.m; j++) {
for (int k = 0; k < m; k++) {
R.M[i][j] = min(R.M[i][j], M[i][k] + T.M[k][j]);
}
}
}
return R;
}
Matrix operator^(const long long t) {
Matrix R = Matrix(n, m, -1);
if (n != m) {
cerr << "Cannot ^ Matrice with n != m !" << '\n';
return R;
}
if (t == 0) return R;
Matrix T = Matrix(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
T.M[i][j] = R.M[i][j] = M[i][j];
}
}
long long p = t;
while (p) {
if (p & 1ll) R = R * T;
T = (T * T), p /= 2;
}
return R;
}
};
long long a[N], b[N], dp[N][N][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
int k = 2 * n + 1;
Matrix base(k, k, inf), zarib(k, k, inf);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
dp[i][j][k] = inf;
}
}
}
for (int i = 0; i < k; i++) {
dp[0][i][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
for (int t = 0; t < k; t++) {
if (t) {
dp[i][j][t] = dp[i - 1][j][t - 1] + a[i];
}
if (t != k - 1) {
dp[i][j][t] = min(dp[i][j][t], dp[i - 1][j][t + 1] + b[i]);
}
}
}
}
for (int i = 0; i < k; i++) {
base.M[i][0] = dp[n][0][i];
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
zarib.M[i][j] = dp[n][j][i];
}
}
zarib = (zarib ^ (m - 1));
cout << zarib.M[0][0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7, N = 1005;
int n, k, C[N][N], dp[N][N], f[N];
long long res;
string s;
int main() {
ios::sync_with_stdio(0);
f[1] = 0;
C[0][0] = 1;
for (int i = 2; i < N; i++) f[i] = f[__builtin_popcount(i)] + 1;
for (int i = 1; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % M;
}
cin >> s >> k;
if (!k) return puts("1"), 0;
n = s.size();
reverse(s.begin(), s.end());
for (int i = 0; i < n; i++) s[i] -= '0';
dp[0][0] = 1;
dp[0][1] = (s[0] ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = 1;
for (int j = 1; j <= i + 1; j++)
if (s[i])
dp[i][j] = (dp[i - 1][j - 1] + C[i][j]) % M;
else
dp[i][j] = dp[i - 1][j] % M;
}
for (int i = 1; i <= n; i++)
if (f[i] == k - 1) res = (res + dp[n - 1][i]) % M;
if (k == 1) res--;
cout << (res % M + M) % M << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, m, i;
int a[100];
int count = 0;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
if (a[i] >= a[m - 1] && a[i]) count++;
}
printf("%d\n", count);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
int arr[n];
for (int j = 0; j < n; j++) {
cin >> arr[j];
}
sort(arr, arr + n);
int minn = 1000;
for (int j = 0; j < n - 1; j++) {
if (minn > (arr[j + 1] - arr[j])) {
minn = (arr[j + 1] - arr[j]);
}
}
cout << minn << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
int n, d, m, k, l;
long long a[maxn + 5], b[maxn + 5];
void solve(long long a[], int n) {
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
for (int i = (1); i <= int(n); i++) a[i] += a[i - 1];
}
int main() {
scanf("%d %d %d", &n, &d, &m);
for (int i = 0, x; i < n; i++) {
scanf("%d", &x);
if (x > m)
a[++k] = x;
else
b[++l] = x;
}
if (k == 0) {
long long s = 0;
for (int i = (1); i <= int(n); i++) s += b[i];
printf("%lld\n", s);
exit(0);
}
solve(a, k);
solve(b, l);
fill(b + l + 1, b + n + 1, b[l]);
long long res = 0;
for (int i = ((k + d) / (1 + d)); i <= int(k); i++)
if (1ll * (i - 1) * (d + 1) + 1 <= n) {
res = max(res, a[i] + b[n - 1ll * (i - 1) * (d + 1) - 1]);
}
printf("%lld\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = LLONG_MIN;
k = min(k, m - 1);
for (int i = 0; i <= k; i++) {
long long tans = LLONG_MAX;
for (int j = 0; j <= (m - 1 - k); j++) {
long long currans = max(a[i + j], a[i + j + n - m]);
tans = min(tans, currans);
}
ans = max(ans, tans);
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
#pragma GCC optimize(5)
#pragma GCC optimize(6)
#pragma GCC optimize(7)
#pragma GCC optimize(8)
#pragma GCC optimize(9)
#pragma GCC target("avx")
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
long long n, m, i, j, la, lb, sa, sb, a, b, op;
int main() {
cin >> n;
la = lb = 0;
sa = sb = 1;
while (sa || sb) {
a = la + sa;
b = lb + sb;
cout << a << ' ' << b << endl << flush;
cin >> op;
if (op == 1) {
la = a;
sa = min(sa * 2, n - la);
}
if (op == 2) {
lb = b;
sb = min(sb * 2, n - lb);
}
if (op == 3) {
sa /= 2;
sa = max(sa, 1ll);
sb /= 2;
sb = max(sb, 1ll);
}
if (op == 0) return 0;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long one = 1;
const long long INF = (one << 62);
long long br, k;
long long arr[500005];
vector<pair<long long, long long> > obl;
vector<long long> v;
vector<long long> vlis;
long long search(long long val) {
long long l = 0, r = vlis.size() - 1;
long long lastmid;
while (l <= r) {
long long mid = (l + r) / 2;
if (vlis[mid] > val) {
lastmid = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
return lastmid;
}
long long lis() {
vlis = vector<long long>();
for (long long i : v) {
if (vlis.empty()) {
vlis.push_back(i);
continue;
}
if (i >= vlis[vlis.size() - 1]) {
vlis.push_back(i);
continue;
}
long long idx = search(i);
vlis[idx] = i;
}
return v.size() - vlis.size();
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> br >> k;
for (long long i = 0; i < br; ++i) {
cin >> arr[i];
}
obl.push_back({-1, -INF});
for (long long i = 0; i < k; ++i) {
long long idx;
cin >> idx;
--idx;
obl.push_back({idx, arr[idx]});
}
obl.push_back({br, INF});
long long global = 0;
for (long long i = 0; i < obl.size() - 1; ++i) {
long long lidx = obl[i].first, ridx = obl[i + 1].first,
lval = obl[i].second, rval = obl[i + 1].second;
if (lval + (ridx - lidx) > rval) {
cout << -1 << '\n';
return 0;
}
long long l = lval + 1, r = rval - (ridx - lidx - 1);
v = vector<long long>();
long long result = 0;
for (long long z = lidx + 1; z <= ridx - 1; ++z, ++l, ++r) {
if (arr[z] < l || arr[z] > r) {
++result;
continue;
}
v.push_back(arr[z] - z);
}
result += lis();
global += result;
}
cout << global << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, answer;
vector<long long> a, visited, p;
long long BinarySearch(long long search) {
long long l = 0;
long long r = n - 1;
long long middle = (l + r) / 2;
while (l < r) {
if (a[middle] >= search) {
r = middle;
} else {
l = middle + 1;
}
middle = (l + r) / 2;
}
if (a[middle] != search) {
return n;
}
return middle;
}
int main() {
scanf("%lld %lld", &n, &k);
a.resize(n);
p.resize(n + 1);
fill(p.begin(), p.end(), n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
p[i] = BinarySearch(a[i] * k);
}
visited.resize(n + 1);
for (int i = 0; i < n; i++) {
if (!visited[i]) {
answer++;
visited[i] = 1;
visited[p[i]] = 1;
}
}
printf("%lld\n", answer);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, idx;
point(int x, int y, int idx) : x(x), y(y), idx(idx) {}
point() {}
};
int n, m;
bool inside(int x, int y) { return (0 <= x && x < n) && (0 <= y && y < n); }
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int mat[55][55];
void goToDiagonal(vector<point> v,
vector<pair<pair<int, int>, pair<int, int>>> &path,
vector<int> &order) {
set<pair<int, int>> s;
map<pair<int, int>, int> idx;
for (auto i : v) {
s.insert(make_pair(i.x, i.y));
idx[make_pair(i.x, i.y)] = i.idx;
}
for (int i = 0; i < m; i++) {
queue<pair<int, int>> Q;
map<pair<int, int>, pair<int, int>> par;
par[make_pair(i, i)] = make_pair(0, 0);
Q.emplace(i, i);
pair<int, int> piv;
while (!Q.empty()) {
auto p = Q.front();
Q.pop();
if (s.count(p)) {
piv = p;
break;
}
for (int k = 0; k < 4; k++) {
int x = p.first + dx[k];
int y = p.second + dy[k];
if (x == y && x < i) continue;
if (inside(x, y) && par.find(make_pair(x, y)) == par.end()) {
par[make_pair(x, y)] = p;
Q.emplace(x, y);
}
}
}
s.erase(piv);
order.push_back(idx[piv]);
while (piv != make_pair(i, i)) {
path.emplace_back(piv, par[piv]);
piv = par[piv];
}
}
}
int main() {
cin >> n >> m;
vector<point> a(m), b(m);
for (int i = 0; i < m; i++) {
cin >> a[i].x >> a[i].y;
a[i].idx = i;
a[i].x -= 1;
a[i].y -= 1;
}
for (int i = 0; i < m; i++) {
cin >> b[i].x >> b[i].y;
b[i].idx = i;
b[i].x -= 1;
b[i].y -= 1;
}
vector<pair<pair<int, int>, pair<int, int>>> pathA, pathB;
vector<int> orderA, orderB;
goToDiagonal(a, pathA, orderA);
goToDiagonal(b, pathB, orderB);
auto swapper = [](pair<int, int> p, pair<int, int> q,
vector<pair<pair<int, int>, pair<int, int>>> &path) {
path.emplace_back(p, make_pair(p.first + 1, p.second));
path.emplace_back(q, make_pair(q.first - 1, q.second));
path.emplace_back(make_pair(p.first + 1, p.second), q);
path.emplace_back(make_pair(q.first - 1, q.second), p);
};
for (int i = 0; i < m; i++) {
int piv = 0;
for (int j = i; j < m; j++) {
if (orderA[j] == orderB[i]) {
piv = j;
}
}
for (int j = piv; j > i; j--) {
swapper(make_pair(j - 1, j - 1), make_pair(j, j), pathA);
swap(orderA[j - 1], orderA[j]);
}
}
reverse(pathB.begin(), pathB.end());
for (auto i : pathB) {
pathA.emplace_back(i.second, i.first);
}
cout << pathA.size() << endl;
for (auto i : pathA) {
int u = i.first.first + 1;
int v = i.first.second + 1;
int x = i.second.first + 1;
int y = i.second.second + 1;
cout << u << ' ' << v << ' ' << x << ' ' << y << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, s = 0, x;
cin >> n;
for (int i = 19; i < 1000000000; i++) {
x = i;
while (x != 0) {
sum += x % 10;
x /= 10;
}
if (sum == 10) {
s++;
if (s == n) {
cout << i;
break;
}
}
sum = 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k;
int sz[1000100];
int cnt = 0;
string s;
int minl(int w) {
int lft = w;
int ret = 1;
for (int i = 1; i <= cnt; i++) {
if (lft < sz[i]) {
lft = w;
ret++;
}
lft -= sz[i];
}
return ret;
}
int main() {
cin >> k;
getline(cin, s);
getline(cin, s);
int lst = 0, mmax = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == ' ' || s[i] == '-') {
sz[++cnt] = (i - lst + 1);
mmax = max(mmax, i - lst + 1);
lst = i + 1;
}
sz[++cnt] = s.size() - lst;
mmax = max(mmax, (int)s.size() - lst);
int le = mmax, ri = s.size();
while (le != ri) {
int mi = (le + ri) / 2;
if (minl(mi) <= k)
ri = mi;
else
le = mi + 1;
}
cout << le << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.