solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int M = 100000000000000;
long long int M1 = 1000000007;
long long int cnt1[10000000];
long long int cnt2[10000000];
int main() {
int n, i, x1;
long long int ans;
cin >> n;
vector<int> v(n);
for (i = 0; i < n; i++) cin >> v[i];
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
for (i = 1; i < n; i++) v[i] = v[i] ^ v[i - 1];
cnt2[0]++;
for (i = 0; i < n; i++) {
x1 = v[i];
if (i % 2 == 0)
cnt1[x1]++;
else
cnt2[x1]++;
}
ans = 0;
for (i = 0; i < 10000000; i++) {
if (cnt1[i] > 0) {
ans = ans + (cnt1[i] * (cnt1[i] - 1)) / 2;
}
if (cnt2[i] > 0) {
ans = ans + (cnt2[i] * (cnt2[i] - 1)) / 2;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long base = 131;
const int inf = 0x3f3f3f3f;
const double PI = acos(-1.0);
const long double eps = 1e-20;
const int mod = 1e9 + 7;
const int M = 5e5 + 10;
int n, a[M], vis[M], mn = inf, mx = -inf;
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] < mn && a[i] > mx) {
if (a[i] > a[i + 1])
vis[i] = 1, mn = a[i];
else
vis[i] = 0, mx = a[i];
} else if (a[i] < mn)
vis[i] = 1, mn = a[i];
else if (a[i] > mx)
vis[i] = 0, mx = a[i];
else
return 0 * printf("NO\n");
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", vis[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 55;
const int inf = 1e9 + 77;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
map<char, int> mp;
map<int, int> mp2;
vector<int> v;
vector<int> vo;
set<int> c;
int x[MAX];
long long y[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long y = (n - 3) / 2;
if ((3 + (2 * y)) == n && y > 0)
cout << 1 << " " << y;
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int isprime[1000001];
void sieve() {
long long int i, j, k;
isprime[0] = isprime[1] = 1;
for (i = 2; i <= sqrt(1000000); i++) {
if (!isprime[i]) {
for (j = 2 * i; j <= 1000000; j += i) {
isprime[j] = 1;
}
}
}
}
long long int modInverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long int mod(long long int x, long long int n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long int y = mod(x, n / 2);
return ((y % 1000000007) * (y % 1000000007)) % 1000000007;
} else {
return ((x % 1000000007) * (mod(x, (n - 1)) % 1000000007)) % 1000000007;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n], i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] + a[1] > a[n - 1]) {
cout << "-1" << endl;
} else {
cout << 1 << " " << 2 << " " << n << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char ss[300005];
int qzh[300005];
int n, ans;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, q, l, r;
scanf("%d%d", &n, &q);
scanf("%s", ss + 1);
for (int i = 1; i <= n; ++i) {
int bj = 1;
if (i & 1)
bj = 1;
else
bj = -1;
if (ss[i] == '+')
qzh[i] = qzh[i - 1] + 1 * bj;
else
qzh[i] = qzh[i - 1] + (-1) * bj;
}
while (q--) {
scanf("%d%d", &l, &r);
int len = r - l + 1;
if (len & 1)
puts("1");
else {
if (l & 1) {
if (qzh[r] - qzh[l - 1] == 0)
puts("0");
else
puts("2");
} else {
int js = qzh[r] - qzh[l - 2];
if (ss[l - 1] == '+') {
--js;
} else {
++js;
}
js *= -1;
if (js == 0)
puts("0");
else
puts("2");
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long d, i, j, l;
string s;
int main() {
cin >> s;
if (s[0] == 'h') {
cout << "http://";
d = 4;
} else {
cout << "ftp://";
d = 3;
}
l = s.length();
for (i = l - 1; i > d; i--) {
if (s[i] == 'u' && s[i - 1] == 'r') {
for (j = d; j <= i - 2; j++) cout << s[j];
cout << ".ru";
if (i + 1 < l) {
cout << "/";
for (j = i + 1; j < l; j++) cout << s[j];
}
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str;
cin >> str;
if ((n - 2) % 2 == 0) {
for (int i = 0; i < n; i++) {
cout << str[i];
if (i % 2 == 1 && i != n - 1) {
cout << "-";
}
}
} else if ((n - 3) % 2 == 0) {
cout << str[0] << str[1];
for (int i = 2; i < n; i++) {
cout << str[i];
if (i % 2 == 0 && i != n - 1) {
cout << "-";
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
using ld = double;
const int MAXN = 1e5 + 1;
vector<int> G[MAXN], comp[MAXN], suf_freq[MAXN];
vector<int64> suf_sum[MAXN];
int comp_cnt, comp_ind[MAXN], p[MAXN], dp1[MAXN], dp2[MAXN], dp[MAXN],
diameter[MAXN];
void max_self(int &a, int b) { a = max(a, b); }
void dfs1(int u) {
comp_ind[u] = comp_cnt;
comp[comp_cnt].emplace_back(u);
for (int v : G[u])
if (!comp_ind[v]) {
p[v] = u;
dfs1(v);
if (dp1[u] <= dp1[v] + 1) {
dp2[u] = dp1[u];
dp1[u] = dp1[v] + 1;
} else
max_self(dp2[u], dp1[v] + 1);
}
}
void dfs2(int u, int dist) {
dp[u] = max(dp1[u], dist);
max_self(diameter[comp_cnt], dp[u]);
for (int v : G[u])
if (v != p[u]) {
if (dp1[u] == dp1[v] + 1)
dfs2(v, max(dp2[u], dist) + 1);
else
dfs2(v, max(dp1[u], dist) + 1);
}
}
ld solve(int x, int y) {
if (x == y) return -1;
if (comp[x].size() > comp[y].size()) swap(x, y);
int D = max(diameter[x], diameter[y]);
ld sum = 0;
for (int d = 0; d <= diameter[x]; ++d) {
int64 freq = suf_freq[x][d];
if (d < diameter[x]) freq -= suf_freq[x][d + 1];
if (freq == 0) continue;
int suf = max(0, min(D - d - 1, diameter[y]));
sum += freq * suf_sum[y][suf];
sum += freq * suf_freq[y][suf] * (d + 1);
int rest = comp[y].size() - suf_freq[y][suf];
sum += freq * rest * D;
}
return sum / ((ld)comp[x].size() * comp[y].size());
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, M, Q;
cin >> N >> M >> Q;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
G[u].emplace_back(v);
G[v].emplace_back(u);
}
for (int u = 1; u <= N; ++u)
if (!comp_ind[u]) {
++comp_cnt;
dfs1(u);
dfs2(u, 0);
suf_sum[comp_cnt] = vector<int64>(diameter[comp_cnt] + 1);
suf_freq[comp_cnt] = vector<int>(diameter[comp_cnt] + 1);
for (int v : comp[comp_cnt]) {
suf_sum[comp_cnt][dp[v]] += dp[v];
++suf_freq[comp_cnt][dp[v]];
}
for (int d = diameter[comp_cnt] - 1; d >= 0; --d) {
suf_sum[comp_cnt][d] += suf_sum[comp_cnt][d + 1];
suf_freq[comp_cnt][d] += suf_freq[comp_cnt][d + 1];
}
}
map<pair<int, int>, ld> sol;
cout << fixed << setprecision(8);
for (int q = 0; q < Q; ++q) {
int u, v;
cin >> u >> v;
u = comp_ind[u], v = comp_ind[v];
if (u > v) swap(u, v);
pair<int, int> p{u, v};
auto it = sol.find(p);
if (it != sol.end())
cout << it->second << '\n';
else {
ld ans = solve(u, v);
sol[p] = ans;
cout << ans << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long val(long long x, long long y, long long z) {
if (max(y - z, 0ll) == 0ll) return LLONG_MAX / 2;
return (x / (y - z)) + bool(x % (y - z));
}
int main() {
long long hy, atky, defy;
long long hm, atkm, defm;
long long h, a, d;
cin >> hy >> atky >> defy;
cin >> hm >> atkm >> defm;
cin >> h >> a >> d;
long long ans = LLONG_MAX / 2;
for (long long attack = 0; attack <= 200; ++attack) {
for (long long defence = 0; defence <= 200; ++defence) {
for (long long turns = 0; turns <= 200; ++turns) {
long long HPNEEDED = turns * max(0ll, (atkm - (defy + defence)));
if (hm <= turns * (atky + attack - (defm))) {
ans = min(ans, attack * a + defence * d +
h * (max(HPNEEDED - hy + 1, 0ll)));
}
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int seq[200005];
long long int n, k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%lld", seq + i);
long long int s = n;
long long int sum = 0;
long long int cnt = 0;
for (int i = 2; i <= n; i++) {
sum += seq[i - 1] * cnt;
long long int tmp = sum - (n - i) * seq[i] * (i - 1 - n + s);
if (tmp < k) {
printf("%d\n", i);
s--;
sum -= seq[i] * cnt;
} else {
cnt++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 20, C = 26;
int t, n, m, k;
string a[N], ans[N];
vector<char> v;
int main() {
for (int i = 0; i < C; i++) v.push_back(i + 'a');
for (int i = 0; i < C; i++) v.push_back(i + 'A');
for (int i = 0; i < 10; i++) v.push_back(i + '0');
cin >> t;
while (t--) {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i], ans[i] = a[i];
int rice = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 'R') rice++;
vector<int> dp(k, 0), req(k, rice / k);
for (int i = 0; i < rice % k; i++) req[i]++;
vector<pair<int, int>> path;
for (int i = 0; i < n; i++)
if (i & 1)
for (int j = m - 1; j >= 0; j--) path.push_back({i, j});
else
for (int j = 0; j < m; j++) path.push_back({i, j});
int current = 0;
for (auto p : path) {
int i = p.first, j = p.second;
ans[i][j] = v[current];
if (a[i][j] == '.') continue;
if (dp[current] == req[current]) ans[i][j] = v[++current];
dp[current]++;
}
for (int i = 0; i < n; i++) cout << ans[i] << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
const long long MOD = 1e9 + 7;
const double err = 1e-10;
const int N = 1e5 + 5;
int xs, ys, n, mx;
vector<pair<int, int> > V;
vector<bool> used(25, 0);
vector<int> dp(2e7, INT_MAX);
vector<int> par(2e7, -1);
void rec(int val) {
if (val == mx - 1) return;
int msk = 1, p, cost = dp[val];
for (int i = 0; i < n; i++) {
if (!(val & msk)) {
p = i;
break;
}
msk *= 2;
}
if (dp[(val | msk)] >
cost + (V[p].first * V[p].first) + (V[p].second * V[p].second)) {
dp[(val | msk)] =
cost + (V[p].first * V[p].first) + (V[p].second * V[p].second);
par[(val | msk)] = val;
rec(val | msk);
}
int msk2 = msk;
for (int i = p + 1; i < n; i++) {
msk2 *= 2;
if (!(val & msk2)) {
int nwmsk = ((val | msk) | msk2);
if (dp[nwmsk] >
cost + ((V[p].first - V[i].first) * (V[p].first - V[i].first)) +
((V[p].second - V[i].second) * (V[p].second - V[i].second))) {
dp[nwmsk] = cost +
((V[p].first - V[i].first) * (V[p].first - V[i].first)) +
((V[p].second - V[i].second) * (V[p].second - V[i].second));
par[nwmsk] = val;
rec(nwmsk);
}
}
}
}
void solve() {
cin >> xs >> ys >> n;
mx = 1;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
V.push_back({u - xs, v - ys});
mx *= 2;
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += (V[i].first * V[i].first) + (V[i].second * V[i].second);
}
dp[0] = 0;
rec(0);
cout << dp[mx - 1] + ans << endl;
vector<int> path(1, 0);
int val = mx - 1;
while (val != 0) {
int nwval = par[val], tval = (nwval ^ val), msk = 1;
for (int i = 0; i < n; i++) {
if ((msk & tval)) {
path.push_back(i + 1);
}
msk *= 2;
}
path.push_back(0);
val = par[val];
}
reverse((path).begin(), (path).end());
for (int i = 0; i < ((int)(path).size()); i++) cout << path[i] << ' ';
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string str;
scanf("%d", &t);
while (t--) {
cin >> str;
if (str[str.size() - 1] == 'o') printf("FILIPINO\n");
if (str[str.size() - 1] == 'u') printf("JAPANESE\n");
if (str[str.size() - 1] == 'a') printf("KOREAN\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int main() {
cin >> n;
for (int i = n; i >= 0; i--) {
if (n - 7 * i >= 0 && (n - 7 * i) % 4 == 0) {
for (int j = 0; j < (n - 7 * i) / 4; j++) cout << 4;
for (int j = 0; j < i; j++) cout << 7;
cout << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
int x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
struct Num {
int val;
bool pre;
bool operator<(const Num& x) const { return val < x.val; }
} a[1000005];
long long l, Sum;
int n, k, Rem;
vector<long long> f[1000005];
int main() {
scanf("%d%I64d%d", &n, &l, &k);
Sum = (l - 1) / n + 1;
Rem = (l - 1) % n;
for (int i = 0; i <= n - 1; i++) a[i].val = IN();
for (int i = 0; i <= Rem; i++) a[i].pre = 1;
for (int i = Rem + 1; i <= n - 1; i++) a[i].pre = 0;
sort(a, a + n);
for (int i = 0; i <= n - 1; i++) f[1].push_back(1);
for (int i = 2; i <= ((k) < (Sum) ? (k) : (Sum)); i++) {
long long s = 0;
for (int j = 0; j <= n - 1; j++) {
int st = j;
while (j < n - 1 && a[j].val == a[j + 1].val) j++;
for (int k = st; k <= j; k++) (s += f[i - 1][k]) %= 1000000007;
for (int k = st; k <= j; k++) f[i].push_back(s);
}
}
long long Ans = 0;
for (int i = 0; i <= n - 1; i++) {
if (a[i].pre)
for (int j = 1; j <= ((k) < (Sum) ? (k) : (Sum)); j++)
(Ans += (Sum - j + 1) % 1000000007 * f[j][i] % 1000000007) %=
1000000007;
else
for (int j = 1; j <= ((k) < (Sum - 1) ? (k) : (Sum - 1)); j++)
(Ans += (Sum - j) % 1000000007 * f[j][i] % 1000000007) %= 1000000007;
}
printf("%d\n", Ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long n, ans1, ans2, ans3;
int main() {
cin >> n;
ans1 = 1;
ans2 = 1;
ans3 = n - 2;
if (ans3 % 3 == 0) {
ans3--;
ans1++;
}
cout << ans1 << " " << ans2 << " " << ans3 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int getidx(const vector<int> &ar, int x) {
return lower_bound(ar.begin(), ar.end(), x) - ar.begin();
}
inline long long GCD(long long a, long long b) {
long long n;
if (a < b) swap(a, b);
while (b != 0) {
n = a % b;
a = b;
b = n;
}
return a;
}
inline long long LCM(long long a, long long b) {
if (a == 0 || b == 0) return GCD(a, b);
return a / GCD(a, b) * b;
}
inline long long CEIL(long long n, long long d) {
return n / d + (long long)(n % d != 0);
}
inline long long ROUND(long long n, long long d) {
return n / d + (long long)((n % d) * 2 >= d);
}
inline long long POW(long long a, long long n) {
if (n < 0) return 0;
long long ret = 1;
while (n) {
if (n % 2) ret *= a;
a = a * a;
n /= 2;
}
return ret;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int MAXN = 75000 + 10, RANGE = 2e5 + 10, MOD = 1e9;
struct node {
long long x;
node *l, *r;
node(long long x = 0, node *l = 0, node *r = 0) : x(x), l(l), r(r) {}
node *addtree(int u, long long c, int ns = 0, int ne = RANGE) {
if (ns <= u && u <= ne) {
if (ns == ne) return new node(x + c);
int mid = (ns + ne) / 2;
return new node(x + c, l->addtree(u, c, ns, mid),
r->addtree(u, c, mid + 1, ne));
}
return this;
}
long long sum(int s, int e, int ns = 0, int ne = RANGE) {
if (s <= ns && ne <= e) return x;
if (e < ns || ne < s) return 0;
int mid = (ns + ne) / 2;
return l->sum(s, e, ns, mid) + r->sum(s, e, mid + 1, ne);
}
} * coe[MAXN], *cons[MAXN], *nul;
int n, m;
void input() {
cin >> n;
nul = new node();
nul->l = nul->r = nul;
coe[0] = cons[0] = nul;
for (int(i) = (1); (i) < (int)(n + 1); ++(i)) {
int sx, ex, v1, v2, av, bv;
cin >> sx >> ex >> v1 >> av >> bv >> v2;
coe[i] = coe[i - 1];
cons[i] = cons[i - 1];
coe[i] = coe[i]->addtree(sx + 1, av);
coe[i] = coe[i]->addtree(ex + 1, -av);
cons[i] = cons[i]->addtree(0, v1);
cons[i] = cons[i]->addtree(sx + 1, bv - v1);
cons[i] = cons[i]->addtree(ex + 1, v2 - bv);
}
cin >> m;
}
int solve() {
long long res = 0;
while (m--) {
long long l, r, x;
cin >> l >> r >> x;
x = (x + (res % MOD)) % MOD;
42;
res = x * (coe[r]->sum(0, x) - coe[l - 1]->sum(0, x)) + cons[r]->sum(0, x) -
cons[l - 1]->sum(0, x);
cout << res << '\n';
}
return 0;
}
void execute() { input(), solve(); }
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
execute();
return 0;
}
| 8 |
//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("-Ofast","-funroll-all-loops","-ffast-math")
//~ #pragma GCC target ("avx2")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <algorithm>
#include <cassert>
#include <bits/stdc++.h>
#include <functional>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
using namespace std;
using LL = long long;
#define int LL
#define eps 1e-8
#define fi first
#define se second
#define endl '\12'
#define eb emplace_back
#define SZ(a) int32_t(a.size())
#define ALL(x) (x).begin(),(x).end()
#define trav(a,x) for (auto& a: x)
#define LOG(FMT...) fprintf(stderr, FMT)
#define close std::ios::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr),cout<<fixed<<setprecision(10)
#define FOR(i, x, y) for (LL i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y) for (LL i = (x), _##i = (y); i > _##i; --i)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define CASET int ___T; cin>>___T; for(int __CS=1;__CS<=___T;__CS++)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int,int> pii;
constexpr int mod = 1e9+7; // 998244353
// mt19937 dlsrand(random_device{}());
// mt19937 mrand(std::chrono::system_clock::now().time_since_epoch().count());
// int rnd(int x) { return mrand() % x;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
ll ex_gcd(ll a, ll b, ll& x, ll& y){if(!b){x=1;y=0;return a;}ll ret=ex_gcd(b,a%b,y,x);y-=a/b*x;return ret;}
LL bin(LL x, LL n, LL MOD) {LL ret = MOD != 1;for (x %= MOD; n; n >>= 1, x = x * x % MOD)if (n & 1) ret = ret * x % MOD;return ret;}
int norm(int x) { return x >= mod ? (x - mod) : x; }
inline LL get_inv(LL x, LL p) { return bin(x, p - 2, p); }
inline ll get_inv(ll a) { ll x, y; ex_gcd(a, mod, x, y); return norm(x + mod);}
template<class T>inline void umin(T &x, T y) {x = x > y ? y : x;}
template<class T>inline void umax(T &x, T y) {x = x < y ? y : x;}
template<class T>inline void dec(T &x, T y) {x -= y; if(x < 0) x += mod;}
template<class T>inline void add(T &x, T y) {x += y; if(x >= mod) x -= mod;}
const double PI = acos(-1.0);
constexpr int INF = 0x3f3f3f3f;
constexpr ll linf = 0x3f3f3f3f3f3f3f3f;
constexpr ull base=2333, P_1=19260817, P_2=999998639;
constexpr int maxn = 1e6+10; // remember to calculate. if tle, check maxn first.
vector<pii> e[maxn];
int dis[maxn][2][2], vis[maxn][2][2];
struct node {
int u , dis , a1 , a2;
friend int operator < (node const &a , node const& b){
return a.dis > b.dis;
}
};
void dijstra(){
dis[1][0][0] = 0;
priority_queue<node>q;
q.push({1, 0 ,0, 0});
while(not q.empty()){
node fr = q.top();
q.pop();
int u = fr.u, a1 = fr.a1, a2 = fr.a2;
if(vis[u][a1][a2]) continue;
vis[u][a1][a2] = 1;
for(auto x : e[u]){
int v = x.fi, w = x.se;
if(dis[v][a1][a2] > dis[u][a1][a2] + w){
dis[v][a1][a2] = dis[u][a1][a2] + w;
q.push({v, dis[v][a1][a2], a1 , a2});
}
if(!a1){
if(dis[v][1][a2] > dis[u][0][a2]){
dis[v][1][a2] = dis[u][0][a2];
q.push({v, dis[v][1][a2], 1 , a2});
}
}
if(!a2){
if(dis[v][a1][1] > dis[u][a1][0] + w + w ){
dis[v][a1][1] = dis[u][a1][0] + w + w;
q.push({v,dis[v][a1][1],a1,1});
}
}
}
}
}
int32_t main()
{
int n , m;
cin >> n >> m;
memset(dis , INF, sizeof dis);
while(m -- ){
int u ,v , w;
cin >>u >> v >> w;
if(u > v)swap(u , v);
if(u == 1) dis[v][1][1] = w;
e[u].eb(v , w);
e[v].eb(u , w);
}
dijstra();
for(int i = 2; i <= n; i++){
cout << dis[i][1][1] << " \n"[i == n];
}
return 0;
}
/*
Though leaves are many , the root is one.
Through all the lying days of my youth
I swayed my leaves and flowers in the sun.
Now I may wither into the truth.
- William Butler Yeats
*/
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1e5 + 5;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > seg[MAXN];
vector<int> ans;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
seg[l].push_back(make_pair(r, i));
}
set<pair<int, int> > conj;
for (int i = 1; i < MAXN; i++) {
for (auto &ele : seg[i]) {
conj.insert(ele);
}
while (true) {
if (conj.empty() || conj.begin()->first >= i) break;
conj.erase(conj.begin());
}
while (conj.size() > k) {
int idx = conj.rbegin()->second;
ans.push_back(idx);
conj.erase(*conj.rbegin());
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] + 1 << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 30 * N, A = 1e9, inf = 1e9;
int n, K, q, pon = 1, pon2 = 1, num[N], ans[N], t[M], t2[M], lson[M], lson2[M],
rson[M], rson2[M];
struct aa {
int r, a, p, x, y;
} a[N], b[N];
bool cmp(aa x, aa y) { return x.r < y.r; }
void add(int now, int l, int r, int v) {
int mid = l + r >> 1;
t[now]++;
if (l == r) return;
if (v <= mid)
add((lson[now]) ? lson[now] : (lson[now] = ++pon), l, mid, v);
else
add((rson[now]) ? rson[now] : (rson[now] = ++pon), mid + 1, r, v);
}
void add2(int now, int l, int r, int v, int vv) {
int mid = l + r >> 1;
t2[now] = max(t2[now], vv);
if (l == r) return;
if (v <= mid)
add2((lson2[now]) ? lson2[now] : (lson2[now] = ++pon2), l, mid, v, vv);
else
add2((rson2[now]) ? rson2[now] : (rson2[now] = ++pon2), mid + 1, r, v, vv);
}
int query(int now, int l, int r, int ll, int rr) {
int mid = l + r >> 1, ans = 0;
if (ll <= l && r <= rr) return t[now];
if (ll <= mid) ans += (lson[now]) ? query(lson[now], l, mid, ll, rr) : 0;
if (mid < rr) ans += (rson[now]) ? query(rson[now], mid + 1, r, ll, rr) : 0;
return ans;
}
int query2(int now, int l, int r, int ll, int rr) {
int mid = l + r >> 1, ans = -1e9;
if (ll <= l && r <= rr) return t2[now];
if (ll <= mid)
ans = max(ans, (lson2[now]) ? query2(lson2[now], l, mid, ll, rr) : 0);
if (mid < rr)
ans = max(ans, (rson2[now]) ? query2(rson2[now], mid + 1, r, ll, rr) : 0);
return ans;
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].a), a[i].p = i;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) num[a[i].p] = i;
for (int i = 1, j; i <= n; i = j + 1) {
for (j = i; (j < n) && (a[j + 1].r == a[i].r); j++)
;
for (int k = i; k <= j; k++) add(1, 1, A, a[k].a);
for (int k = i; k <= j; k++)
a[k].x = query(1, 1, A, max(a[k].a - K, 1), min(a[k].a + K, A));
}
scanf("%d", &q);
for (int i = 1, x, y; i <= q; i++) {
scanf("%d%d", &x, &y);
b[i].p = i;
b[i].r = max(a[num[x]].r, a[num[y]].r);
b[i].x = max(max(a[num[x]].a, a[num[y]].a) - K, 1);
b[i].y = min(min(a[num[x]].a, a[num[y]].a) + K, A);
}
sort(b + 1, b + q + 1, cmp);
for (int i = q, j = n; i; i--) {
for (; (j >= 1) && (a[j].r >= b[i].r); add2(1, 1, A, a[j].a, a[j].x), j--)
;
if (b[i].x <= b[i].y) ans[b[i].p] = query2(1, 1, A, b[i].x, b[i].y);
}
for (int i = 1; i <= q; i++) printf("%d\n", (ans[i]) ? ans[i] : -1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int len1 = s1.length();
int len2 = s2.length();
if (s1 == s2)
cout << "-1" << endl;
else if (len1 > len2)
cout << len1 << endl;
else if (len2 > len1)
cout << len2 << endl;
else if (s1 != s2)
cout << len1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long a = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) a = (a << 3) + (a << 1) + ch - '0';
return a * f;
}
const long long mod = 1e9 + 7;
const long long N = 1e2 + 5;
const long long inf = 0x3f3f3f3f;
long long f[N][N], n, k, ans;
char str[N];
map<char, long long> lst;
signed main() {
n = read();
k = read();
scanf("%s", str + 1);
f[n][0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= i; j++) {
if (!lst.count(str[i]))
f[i][j] = f[i - 1][j] + max(f[i - 1][j - 1], 1ll);
else
f[i][j] = f[i - 1][j] + f[i - 1][j - 1] - f[lst[str[i]] - 1][j - 1];
}
lst[str[i]] = i;
}
for (long long i = n; i >= 0; i--) {
if (k <= f[n][i]) {
ans += k * (n - i);
k = 0;
break;
}
k -= f[n][i];
ans += f[n][i] * (n - i);
}
printf("%lld\n", k > 0 ? -1 : ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> a[101];
int n, vs[101], u, v, w, p;
int dfs(int x) {
vs[x] = 1;
int r = 0;
for (auto e : a[x])
if (!vs[e.first]) r = max(r, dfs(e.first) + e.second);
return r;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++)
cin >> v >> u >> w, a[u].push_back({v, w}), a[v].push_back({u, w});
cout << dfs(0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
bool flag = 0, alleq = 1;
int minindex = -1, minelem = INT_MAX;
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) alleq = 0;
}
if (alleq == 1) {
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
if (a[i] < minelem) {
minelem = a[i];
}
}
for (int i = 0; i < n; i++) {
if (a[i] == minelem) {
minindex = i;
break;
}
}
while (a[minindex] == a[(minindex + n - 1) % n])
minindex = (minindex + n - 1) % n;
for (int i = 0; i < n - 1; i++) {
if (a[(i + minindex) % n] > a[(i + minindex + 1) % n]) flag = 1;
}
if (flag == 1)
cout << -1;
else
cout << (n - minindex) % n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> adj_list[3001];
multimap<pair<pair<int, int>, int>, bool> forbidden;
bool visited[3001][3001];
int pred[3001][3001];
long long int dist[3001][3001];
int dest;
void init() {
for (int i = 1; i <= 3000; i++)
for (int j = 1; j <= 3000; j++) {
visited[i][j] = false;
dist[i][j] = LONG_MAX;
}
}
bool BFS() {
queue<pair<int, int>> checkers;
visited[1][1] = true;
dist[1][1] = 0;
checkers.push(make_pair(1, 1));
while (!checkers.empty()) {
pair<int, int> u = checkers.front();
checkers.pop();
for (int i = 0; i < adj_list[u.second].size(); i++) {
if ((visited[u.second][adj_list[u.second][i]] == false) &&
(forbidden.find(make_pair(u, adj_list[u.second][i])) ==
forbidden.end())) {
visited[u.second][adj_list[u.second][i]] = true;
dist[u.second][adj_list[u.second][i]] = dist[u.first][u.second] + 1;
pred[u.second][adj_list[u.second][i]] = u.first;
checkers.push(make_pair(u.second, adj_list[u.second][i]));
if (adj_list[u.second][i] == n) {
dest = u.second;
return true;
}
}
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int temp1, temp2;
cin >> temp1 >> temp2;
adj_list[temp1].push_back(temp2);
adj_list[temp2].push_back(temp1);
}
for (int i = 1; i <= k; i++) {
int temp1, temp2, temp3;
cin >> temp1 >> temp2 >> temp3;
forbidden.insert(
make_pair(make_pair(make_pair(temp1, temp2), temp3), false));
}
if (BFS() == false)
cout << -1;
else {
vector<int> path;
path.push_back(n);
int destination = n;
int road = dest, temp;
path.push_back(road);
while (road != 1) {
temp = destination;
destination = road;
road = pred[road][temp];
path.push_back(road);
}
cout << dist[dest][n] << '\n';
for (int i = path.size() - 1; i >= 0; i--) cout << path[i] << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, a[1000000], x, y, ma1, ma2;
double r1, r2;
void swa() {
int te;
te = x;
x = y;
y = te;
}
int main() {
cin >> n >> x >> y;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<int>());
if (x > y) swa();
for (i = 0; i < x; i++) {
ma1 = ma1 + a[i];
}
for (i = x; i < x + y; i++) {
ma2 = ma2 + a[i];
}
r1 = (float)ma1 / x;
r2 = (float)ma2 / y;
cout << fixed << setprecision(10) << r1 + r2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 10;
long long v[MAXN];
int dp[1 << MAXN][MAXN];
int qfact[MAXN];
int n;
inline bool overflows(long long a, long long b) {
return ((1ll << 63) & (a * b)) != 0 ||
64 - __builtin_clzll(a) + 64 - __builtin_clzll(b) - 1 >= 64;
}
long long go(int mask, int i) {
if (i == n) {
return (__builtin_popcount(mask) > 1) + __builtin_popcount(mask);
}
if (dp[mask][i] != -1) return dp[mask][i];
int best = INF;
for (int m = 0; m < (1 << i); ++m) {
if ((m & mask) != m) continue;
if (m == 0) best = min<long long>(best, qfact[i] + go(mask ^ m, i + 1));
long long prod = 1;
int sum = 0;
bool flag = 0;
for (int a = 0; a < i; ++a) {
if (m & (1 << a)) {
sum += max(qfact[a], 1);
if (!overflows(prod, v[a]) && prod * v[a] <= v[i])
prod *= v[a];
else
flag = 1;
}
}
if (flag) continue;
if (v[i] % prod == 0) {
best = min<long long>(
best, qfact[i] - sum + go(mask ^ m, i + 1) + __builtin_popcount(m));
}
}
return dp[mask][i] = best;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int a = 0; a < n; ++a) {
cin >> v[a];
}
sort(v, v + n);
for (int a = 0; a < n; ++a) {
long long o = v[a];
for (long long p = 2; p * p <= o; ++p) {
while (o % p == 0) {
o /= p;
++qfact[a];
}
}
if (o > 1) ++qfact[a];
if (qfact[a] == 1) qfact[a] = 0;
}
printf("%d\n", go((1 << n) - 1, 0));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool uax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = false;
string r = "{";
for (auto x : v) {
if (f) r += ", ";
r += to_string(x);
f = true;
}
return r += "}";
}
template <typename A>
string to_string(vector<vector<A>> v) {
string r;
for (auto x : v) r += "\n" + to_string(x);
return r;
}
void err(istream_iterator<string>) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " =: " << to_string(a) << "; ";
err(++it, args...);
}
template <typename T>
void kek(T ans) {
cout << ans << endl;
exit(0);
}
int const MOD = 1e9 + 7;
long long const INF = 1e18 + 42;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
int x = 0;
for (int &z : a) {
cin >> z;
if (z & 1) {
if (x)
z = (int)ceil(z / 2.0);
else
z = (int)floor(z / 2.0);
x ^= 1;
} else {
z = z / 2;
}
cout << z << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int depth;
cin >> depth;
int n = (1 << (depth + 1)) - 1;
vector<int> pre(n + 1, 0), add(n + 1, 0);
for (int i = 2; i <= n; ++i) {
cin >> pre[i];
}
vector<int> way(n + 1, 0);
for (int i = 2; i <= n; ++i) {
way[i] = way[i / 2] + pre[i];
}
int target = *max_element((way).begin(), (way).end());
for (int i = n / 2 + 1; i <= n; ++i) {
add[i] = target - way[i];
}
for (int i = n / 2; i >= 2; --i) {
add[i] = min(add[2 * i], add[2 * i + 1]);
add[2 * i] -= add[i];
add[2 * i + 1] -= add[i];
}
cout << accumulate((add).begin(), (add).end(), 0) << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 2000;
bool mp[MN][MN];
int mark[MN][MN];
bool good[MN][MN];
int n, m;
vector<pair<int, int> > all;
vector<int> rays;
int cc = 0;
bool isg(int x, int y) {
int cnt = 0;
for (int i = x - 2; i <= x + 2; i++) {
for (int j = y - 2; j <= y + 2; j++) {
if (i >= 0 && j >= 0 && i < n && j < m && mp[i][j] && mark[i][j] == 1)
cnt++;
}
}
return cnt <= 11;
}
void dfs1(int x, int y) {
mark[x][y] = 1;
all.push_back(pair<int, int>(x, y));
for (int i = x - 1; i <= x + 1; i++) {
for (int j = y - 1; j <= y + 1; j++) {
if (i >= 0 && j >= 0 && i < n && j < m && mp[i][j] && mark[i][j] == 0)
dfs1(i, j);
}
}
}
void dfs2(int x, int y) {
mark[x][y] = 2;
cc++;
for (int i = x - 1; i <= x + 1; i++) {
for (int j = y - 1; j <= y + 1; j++) {
if (i >= 0 && j >= 0 && i < n && j < m && mp[i][j] && mark[i][j] == 1 &&
good[i][j])
dfs2(i, j);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mp[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mark[i][j] == 0 && mp[i][j] == 1) {
int cnt = 0;
all.clear();
dfs1(i, j);
for (int k = 0; k < all.size(); k++) {
int x = all[k].first, y = all[k].second;
good[x][y] = isg(x, y);
}
for (int k = 0; k < all.size(); k++)
if (good[all[k].first][all[k].second] &&
mark[all[k].first][all[k].second] == 1) {
cc = 0;
dfs2(all[k].first, all[k].second);
if (cc >= 2) cnt++;
}
for (int k = 0; k < all.size(); k++)
mark[all[k].first][all[k].second] = 3;
rays.push_back(cnt);
}
}
}
sort(rays.begin(), rays.end());
cout << rays.size() << endl;
for (int i = 0; i < rays.size(); i++) cout << rays[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
char a[N];
map<pair<int, int>, int> b;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
b[make_pair(0, 0)] = -1;
int p0 = 0, p1 = 0;
int ans = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == '0')
p0++;
else
p1++;
int pp0 = p0, pp1 = p1;
pp0 -= min(p0, p1);
pp1 -= min(p0, p1);
if (b.find(make_pair(pp0, pp1)) != b.end())
ans = max(ans, i - b[make_pair(pp0, pp1)]);
else
b[make_pair(pp0, pp1)] = i;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int main() {
int n;
cin >> n;
int res = 0;
int p = 1;
while (n > 0) {
res++;
n -= p;
p *= 2;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int NPOS = -1;
struct SegmentTree {
struct Val {
int l, r;
int sum;
Val(int l, int r) : l(l), r(r), sum(0) {}
Val(const Val &lc, const Val &rc)
: l(lc.l), r(rc.r), sum(lc.sum + rc.sum) {}
void upd(int mul, int add) { sum = sum * mul + add * (r - l + 1); }
};
struct Node : Val {
int lc, rc;
Node(Val &&v) : Val(v), lc(NPOS), rc(NPOS) {}
};
vector<Node> v;
SegmentTree(int l = 0, int r = 1e9 + 7) : v{Val(l, r)} {}
void down(int rt) {
int m = (v[rt].l + v[rt].r) / 2;
if (v[rt].lc == NPOS) v[rt].lc = v.size(), v.push_back(Val(v[rt].l, m));
if (v[rt].rc == NPOS) v[rt].rc = v.size(), v.push_back(Val(m + 1, v[rt].r));
}
void upd(int l, int r, int mul, int add, int rt = 0) {
if (l <= v[rt].l && v[rt].r <= r) return v[rt].upd(mul, add);
down(rt);
if (r <= v[v[rt].lc].r)
upd(l, r, mul, add, v[rt].lc);
else if (l >= v[v[rt].rc].l)
upd(l, r, mul, add, v[rt].rc);
else
upd(l, v[v[rt].lc].r, mul, add, v[rt].lc),
upd(v[v[rt].rc].l, r, mul, add, v[rt].rc);
dynamic_cast<Val &>(v[rt]) = Val(v[v[rt].lc], v[v[rt].rc]);
}
Val ask(int l, int r, int rt = 0) {
if (l <= v[rt].l && v[rt].r <= r) return v[rt];
down(rt);
if (r <= v[v[rt].lc].r) return ask(l, r, v[rt].lc);
if (l >= v[v[rt].rc].l) return ask(l, r, v[rt].rc);
return Val(ask(l, v[v[rt].lc].r, v[rt].lc),
ask(v[v[rt].rc].l, r, v[rt].rc));
}
};
map<int, SegmentTree> mp;
int n, a, t, x;
int main() {
for (scanf("%d", &n); n--;) {
scanf("%d%d%d", &a, &t, &x);
if (a == 3)
printf("%d\n", mp[x].ask(0, t).sum);
else
mp[x].upd(t, t, 1, a == 2 ? -1 : 1);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int numemp, numchats, numlog;
cin >> numemp >> numchats >> numlog;
bool arr[20001][11];
int arrout[20001];
int arrchatlog[11];
memset(arrchatlog, 0, sizeof arrchatlog);
memset(arrout, 0, sizeof arrout);
for (int i = 0; i < numemp; i++) {
for (int j = 0; j < numchats; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < numlog; i++) {
int empid, chatid;
cin >> empid >> chatid;
empid--;
chatid--;
arrout[empid]--;
arrchatlog[chatid]++;
}
for (int i = 0; i < numemp; i++) {
for (int j = 0; j < numchats; j++) {
if (arr[i][j]) arrout[i] += arrchatlog[j];
}
}
for (int i = 0; i < numemp; i++) cout << arrout[i] << " ";
cout << endl;
cin.get();
cin.get();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i, c;
while (cin >> n >> x) {
c = 0;
for (i = 1; i <= n; i++) {
if (x % i == 0 && x / i <= n) c++;
}
cout << c << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, num = 0, mx, b;
vector<long long> vec;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
vec.push_back(a);
if (a >= num) {
mx = a;
num = a;
b = i;
}
}
for (int i = 0; i < b; i++) {
if (vec[i] > vec[i + 1]) {
cout << "NO" << endl;
return 0;
}
}
for (int i = b; i < n - 1; i++) {
if (vec[i] < vec[i + 1]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int num[1 << N];
int a[1 << N];
int b[1 << N];
long long val[N];
long long all[N];
long long rev(int* num, int i) {
if (i == 0) return 0;
int m = 1 << (i - 1);
long long ret = rev(num, i - 1) + rev(num + m, i - 1);
memcpy(a, num, sizeof(int) * m);
memcpy(b, num + m, sizeof(int) * m);
int p = 0;
for (int j = 0; j < m; j++) {
while (p < m && a[p] <= b[j]) p++;
ret += m - p;
}
p = 0;
int q = 0;
int j = 0;
while (p < m && q < m) {
if (a[p] <= b[q])
num[j++] = a[p++];
else
num[j++] = b[q++];
}
while (p < m) num[j++] = a[p++];
while (q < m) num[j++] = b[q++];
for (int j = 0, k = 0; j < m * 2; j = k) {
while (k < m * 2 && num[k] == num[j]) k++;
int c = k - j;
all[i] -= 1ll * c * (c - 1) / 2;
}
val[i] += ret;
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) scanf("%d", num + i);
for (int i = 1; i <= n; i++) all[i] = 1ll * (1 << n) * ((1 << i) - 1) / 2;
rev(num, n);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int q;
scanf("%d", &q);
long long d = all[q] - val[q] - val[q];
for (int j = 1; j <= q; j++) val[j] = all[j] - val[j];
for (int j = q + 1; j <= n; j++) val[j] = val[j] + d;
printf("%I64d\n", val[n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> inpVec(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
return v;
}
void printVec(vector<int> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
auto v = inpVec(n);
unordered_map<int, bool> m1;
unordered_map<int, bool> m2;
vector<pair<int, int>> ans;
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(v[i]);
if (*s.rbegin() == s.size() && s.size() == i + 1) {
m1[*s.rbegin()] = true;
}
}
s.clear();
reverse(v.begin(), v.end());
for (int i = 0; i < n; i++) {
s.insert(v[i]);
if (*s.rbegin() == s.size() && s.size() == i + 1) {
m2[*s.rbegin()] = true;
}
}
for (auto e : m1) {
if (m2.find(n - e.first) != m2.end()) {
ans.push_back(make_pair(e.first, n - e.first));
}
}
cout << ans.size() << endl;
for (auto e : ans) cout << e.first << " " << e.second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:300000000")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
template <class T>
T abs(const T &a) {
return a >= 0 ? a : -a;
};
template <class T>
T sqr(const T &x) {
return x * x;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
}
int main() {
long long a, b, c;
cin >> a >> b >> c;
long long x, y;
long long g = exgcd(a, b, x, y);
c *= -1;
if (c % g != 0)
cout << -1;
else
cout << x * (c / g) << ' ' << y * (c / g);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long x[100007], y[100007], xx, yy, m, p, q;
long long ans;
int get(int p, int q) {
while ((x[q] - x[p]) * (yy - y[p]) - (y[q] - y[p]) * (xx - x[p]) <= 0)
q = q % n + 1;
q = (q + n - 2) % n + 1;
return q;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &x[i], &y[i]);
for (cin >> m; m; m--) {
cin >> xx >> yy;
int now = 0;
ans = 0;
for (int i = 1; i <= n; i++)
if ((xx - x[i]) * (y[i % n + 1] - y[i]) -
(yy - y[i]) * (x[i % n + 1] - x[i]) <
0)
now++;
if (now != 0 && now != n) {
cout << 0 << endl;
continue;
}
for (p = 1, q = get(1, 1); p <= n; p++, q = get(p, q)) {
int r = ((q - p) % n + n) % n;
ans += ((long long)r) * (r - 1) / 2;
}
ans = ((long long)n * (n - 1) * (n - 2) / 6 - ans);
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 5e3 + 10;
const long long INF = 1e17;
const long long SGM = 30;
long long n, m, ted;
long long T[MXN], Sum[MXN], Last[MXN], Sz[MXN], dp[MXN][MXN], Nxt[MXN][SGM];
vector<long long> Pos[MXN][SGM];
string s, t;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> ted;
for (int i = 1; i <= ted; i++) {
cin >> t, Sz[i] = (long long)t.size();
for (int j = 0; j < t.size(); j++) Pos[i][t[j] - 'a'].push_back(j);
}
cin >> m, Sum[m + 1] = INF;
for (int i = 1; i <= m; i++) cin >> T[i], Sum[i] = Sum[i - 1] + Sz[T[i]];
for (int i = 0; i < SGM; i++) Last[i] = INF;
for (int i = m; i >= 1; i--) {
for (int j = 0; j < SGM; j++)
Last[j] = (Pos[T[i]][j].empty() ? Last[j] : i);
for (int j = 0; j < SGM; j++) Nxt[i][j] = Last[j];
}
cin >> s, n = s.size();
s = "$" + s;
for (int i = 1; i <= n; i++) {
dp[i][0] = INF;
for (int j = 1; j <= n; j++) {
long long val = INF, p = dp[i - 1][j - 1], c = s[j] - 'a', idx;
if (p < Sum[m]) {
long long l = 0, r = m + 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (Sum[mid] > p)
r = mid;
else
l = mid;
}
idx = lower_bound(Pos[T[r]][c].begin(), Pos[T[r]][c].end(),
p - Sum[r - 1]) -
Pos[T[r]][c].begin();
if (idx != Pos[T[r]][c].size()) {
val = Sum[r - 1] + Pos[T[r]][c][idx] + 1;
} else if (r + 1 <= m && Nxt[r + 1][c] < INF) {
val = Sum[Nxt[r + 1][c] - 1] + Pos[T[Nxt[r + 1][c]]][c][0] + 1;
}
}
dp[i][j] = min(dp[i][j - 1], val);
}
}
for (int i = n; ~i; i--) {
if (dp[i][n] < INF) return cout << i << '\n', 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
long t, s, x;
scanf("%ld%ld%ld", &t, &s, &x);
printf(((x - t) % s > 1) || (x == t + 1) || (x < t) ? "NO" : "YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int K = 6, N = 100000;
int arr[N + 2], mod = 1000000007;
long long MOD = 1LL * mod * mod;
int C[K][K];
int SumOfPowers[K][N + 2];
void fill() {
C[0][0] = 1;
for (int i = 1; i < K; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
for (int j = 1; j <= N; ++j) SumOfPowers[0][j] = 1;
for (int i = 1; i < K; ++i) {
for (int j = 1; j <= N; ++j)
SumOfPowers[i][j] = 1LL * SumOfPowers[i - 1][j] * j % mod;
}
for (int i = 0; i < K; ++i) {
for (int j = 1; j <= N; ++j) {
SumOfPowers[i][j] += SumOfPowers[i][j - 1];
if (SumOfPowers[i][j] >= mod) SumOfPowers[i][j] -= mod;
}
}
}
struct tree {
tree() : left(NULL), right(NULL), val(0), size(1), notPushed(false){};
int ans[K], val, size;
bool notPushed;
tree *left, *right;
};
tree* merge(tree* l, tree* r, tree* to = NULL) {
tree* ret = to == NULL ? new tree() : to;
ret->left = l;
ret->right = r;
ret->size = l->size + r->size;
for (int i = 0; i < K; ++i) {
long long res = l->ans[i];
int pw = 1, k = l->size;
for (int j = 0; j <= i; ++j) {
for (int t = 0; t < C[i][j]; ++t) {
res = (res + 1LL * pw * r->ans[i - j]);
if (res >= MOD) res -= MOD;
}
pw = (1LL * pw * k) % mod;
}
ret->ans[i] = res % mod;
}
return ret;
}
void setFixed(tree* root, int val) {
if (root) {
root->notPushed = true;
root->val = val;
for (int i = 0; i < K; ++i)
root->ans[i] = 1LL * val * SumOfPowers[i][root->size] % mod;
}
}
void push(tree* root) {
if (root && root->notPushed) {
root->notPushed = false;
setFixed(root->left, root->val);
setFixed(root->right, root->val);
merge(root->left, root->right, root);
}
}
tree* build(int l, int r) {
if (l == r) {
tree* ret = new tree();
for (int i = 0; i < K; ++i) ret->ans[i] = arr[l];
return ret;
}
int m = (l + r) >> 1;
return merge(build(l, m), build(m + 1, r));
}
tree* find(tree* root, int l, int r, int L, int R) {
if (l == L && r == R) return root;
push(root);
int m = (l + r) >> 1;
if (R <= m) return find(root->left, l, m, L, R);
if (L > m) return find(root->right, m + 1, r, L, R);
return merge(find(root->left, l, m, L, m),
find(root->right, m + 1, r, m + 1, R));
}
void update(tree* root, int l, int r, int L, int R, int val) {
if (l == L && r == R) {
setFixed(root, val);
return;
}
push(root);
int m = (l + r) >> 1;
if (R <= m)
update(root->left, l, m, L, R, val);
else if (L > m)
update(root->right, m + 1, r, L, R, val);
else {
update(root->left, l, m, L, m, val);
update(root->right, m + 1, r, m + 1, R, val);
}
merge(root->left, root->right, root);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
fill();
tree* root = build(0, n - 1);
scanf("\n");
for (int i = 0; i < m; ++i) {
char c;
int a, b, v;
scanf("%c %d %d %d\n", &c, &a, &b, &v);
--a;
--b;
if (c == '=')
update(root, 0, n - 1, a, b, v);
else
printf("%d\n", find(root, 0, n - 1, a, b)->ans[v]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, i, a[100005], f[100005];
int g[100005], tag;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n == 1) {
printf("0\n");
return 0;
}
f[1] = 1;
if (a[1] == 0 && a[2] != 0)
f[2] = 0;
else
f[2] = 1;
for (i = 3; i <= n; i++) {
if (f[i - 1] == 0) break;
if (a[i - 1] == 0) {
if (a[i] == 0)
f[i] = 1;
else
f[i] = 0;
} else {
if (a[i - 1] * a[i - 1] == a[i - 2] * a[i])
f[i] = 1;
else
f[i] = 0;
}
}
if (n == 2) {
printf("%d\n", 1 - f[2]);
return 0;
}
if (f[n] == 1) {
printf("0\n");
return 0;
}
if (f[n - 1] == 1) {
printf("1\n");
return 0;
}
g[n] = 1;
if (a[n - 1] == 0 && a[n] != 0)
g[n - 1] = 0;
else
g[n - 1] = 1;
for (i = n - 2; i >= 1; i--) {
if (g[i + 1] == 0) continue;
if (a[i + 1] == 0) {
if (a[i] == 0)
g[i] = 1;
else
g[i] = 0;
} else {
if (a[i + 1] * a[i + 1] != a[i] * a[i + 2])
g[i] = 0;
else
g[i] = 1;
}
}
if (g[2] == 1) {
printf("1\n");
return 0;
}
if (n == 3) {
printf("1\n");
return 0;
}
for (i = 2; i < n; i++) {
if (f[i - 1] == 0 || g[i + 1] == 0) continue;
tag = 1;
if (a[i - 1] == 0) {
if (a[i + 1] == 0) {
printf("1\n");
return 0;
} else
tag = 0;
}
if (tag == 0) continue;
if (i > 2) {
if (a[i - 1] * a[i - 1] != a[i - 2] * a[i + 1]) tag = 0;
}
if (i < n - 1) {
if (a[i + 1] * a[i + 1] != a[i - 1] * a[i + 2]) tag = 0;
}
if (tag == 1) {
printf("1\n");
return 0;
}
}
printf("2\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k = 1, sum = 0, i;
cin >> n;
for (i = 1; i <= n; i++) {
k *= 2;
sum += k;
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long ZERO = 0LL;
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long MOD = 1e9 + 7;
const long double PI = acos(-1.0L);
const long double EPS = static_cast<long double>(1e-9);
const long long N = 1e6 + 7;
long long n, q;
long long a[N], b[N], res[N];
map<long long, long long> mp;
void input() {
cin >> n >> q;
for (long long i = (0); i < (n); i++) {
cin >> a[i];
}
for (long long i = (0); i < (q); i++) {
cin >> b[i];
}
}
void debug() {
if (true) {
}
}
void solve() {
for (long long i = (0); i < (n); i++) {
if (!mp.count(a[i])) {
mp[a[i]] = 0;
}
mp[a[i]]++;
}
for (long long i = (0); i < (q); i++) {
map<long long, long long> mp2 = mp;
for (long long x = 1LL << 32; x > 0; x /= 2) {
while (x & b[i]) {
long long y = x;
while (y > 0 and !mp2.count(y)) {
y /= 2;
}
if (y == 0) {
res[i] = -1;
break;
}
long long cnt = min(x / y, mp2[y]);
res[i] += cnt;
mp2[y] -= cnt;
if (mp2[y] == 0) {
mp2.erase(y);
}
b[i] -= y * cnt;
}
}
}
}
void output() {
for (long long i = (0); i < (q); i++) {
cout << res[i] << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
input();
solve();
output();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
long long fact[20];
long long num[15];
long long ans;
long long tot;
char s[100];
int use[10];
void dfs(int x, int now) {
if (x == 10) {
int t = 0;
int y = 0;
for (int i = 0; i < 10; ++i) {
t += use[i];
if (use[i]) y++;
}
long long tmp = 1;
for (int i = 1; i <= t; ++i) tmp *= i;
for (int i = 0; i < 10; ++i) {
for (int j = 1; j <= use[i]; ++j) tmp /= j;
}
ans += tmp;
return;
}
if (!num[x]) {
use[x] = 0;
dfs(x + 1, now);
return;
}
for (int i = (x == now) ? 0 : 1; i <= num[x]; ++i) {
use[x] = i;
dfs(x + 1, now);
}
}
int main() {
fact[0] = 1;
for (int i = 1; i <= 18; i++) fact[i] = fact[i - 1] * (long long)i;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) num[s[i] - '0']++;
for (int i = 0; i <= 9; i++) {
if (num[i]) {
tot++;
}
}
int tmp = tot;
for (int i = 1; i <= 9; i++) {
if (!num[i]) continue;
num[i]--;
dfs(0, i);
num[i]++;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string s, t;
int dp[1001][1001][11][2];
int rec(int i, int j, int cnt, int check) {
int x = dp[i][j][cnt][check];
if (cnt == k) return 0;
if (x != -1) return x;
if (i == n || j == m) return -10000;
int ret = 0;
if (s[i] == t[j]) {
ret = max(ret, rec(i + 1, j + 1, cnt, 1) + 1);
ret = max(ret, rec(i + 1, j + 1, cnt + 1, 0) + 1);
}
if (check == 1) {
ret = max(ret, rec(i + 1, j, cnt + 1, 0));
ret = max(ret, rec(i, j + 1, cnt + 1, 0));
} else if (check == 0) {
ret = max(ret, rec(i + 1, j, cnt, 0));
ret = max(ret, rec(i, j + 1, cnt, 0));
}
return dp[i][j][cnt][check] = ret;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
cin >> s >> t;
memset(dp, -1, sizeof(dp));
printf("%d\n", rec(0, 0, 0, 0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct vertex {
string name;
int version;
vertex(string name, int version) : name(name), version(version) {}
vertex() {}
const bool operator<(vertex other) const {
return name != other.name ? name < other.name : version < other.version;
}
} start;
map<vertex, vector<vertex> > graph;
map<vertex, int> dist;
set<string> used;
set<vertex> ans;
bool cmp(const vertex &a, const vertex &b) {
if (dist[a] != dist[b]) {
return dist[a] < dist[b];
}
if (a.version != b.version) {
return a.version > b.version;
}
return a.name < b.name;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string name;
int version;
cin >> name >> version;
int count;
vertex v(name, version);
if (i == 0) {
start = v;
}
cin >> count;
for (int j = 0; j < count; ++j) {
cin >> name >> version;
graph[v].emplace_back(vertex(name, version));
}
}
set<vertex, bool (*)(const vertex &, const vertex &)> q(cmp);
q.insert(start);
dist[start] = 0;
while (!q.empty()) {
vertex v = *q.begin();
q.erase(q.begin());
if (used.count(v.name)) {
continue;
}
used.insert(v.name);
ans.insert(v);
for (auto &to : graph[v]) {
if (dist.count(to)) {
dist[to] = min(dist[to], dist[v] + 1);
} else {
dist[to] = dist[v] + 1;
}
q.insert(to);
}
}
ans.erase(start);
cout << ans.size() << endl;
for (auto &i : ans) {
cout << i.name << " " << i.version << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100001], b[100001], c[100001];
int Len, num[100001], cnt[100001];
void Init() {
int i, x;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
++a[x];
}
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
++b[x];
}
}
void Solve() {
int i, j;
for (i = 0; i < m; ++i) {
++Len;
num[Len] = i;
cnt[Len] = a[i];
for (j = m - i - 1; Len && b[j];) {
if (b[j] >= cnt[Len]) {
c[(j + num[Len]) % m] += cnt[Len];
b[j] -= cnt[Len--];
} else {
c[(j + num[Len]) % m] += b[j];
cnt[Len] -= b[j];
b[j] = 0;
}
}
}
for (i = m - 1; Len && i >= 0; --i)
while (Len && b[i]) {
if (b[i] >= cnt[Len]) {
c[(i + num[Len]) % m] += cnt[Len];
b[i] -= cnt[Len--];
} else {
c[(i + num[Len]) % m] += b[i];
cnt[Len] -= b[i];
b[i] = 0;
}
}
for (i = m - 1; i >= 0; --i)
for (; c[i]; --c[i]) printf("%d ", i);
printf("\n");
}
int main() {
Init();
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void ONLINE__JUDGE();
const int mod = 998244353;
const int MAX = 1009;
bool negative;
string s, res;
bool zero(string x) {
for (int i = 0; i < (int)s.length(); i++)
if (isdigit(s[i]) == true && s[i] != '0') return 0;
return 1;
}
int main() {
ios::sync_with_stdio(NULL);
cin.tie(NULL);
ONLINE__JUDGE();
cin >> s;
if (s[0] == '-') negative = 1, s.erase(0, 1);
if (zero(s))
cout << "$0.00";
else {
if (negative)
res += "($";
else
res += "$";
int point_index = s.find('.');
if (point_index == -1) {
string num = "";
long long cnt = 0;
for (int i = s.length() - 1; i > -1; i--, cnt++) {
if (cnt % 3 == 0 && cnt > 0) num = "," + num;
num = s[i] + num;
}
res += num + ".00";
} else {
if (s[0] == '0') {
res += "0.";
long long cnt = 0;
for (int i = point_index + 1; i < (int)s.length(); i++) {
res += s[i];
cnt++;
if (cnt == 2) break;
}
if (cnt == 0)
res += "00";
else if (cnt == 1)
res += "0";
} else {
string num = "";
long long cnt = 0;
for (int i = point_index - 1; i > -1; i--, cnt++) {
if (cnt % 3 == 0 && cnt > 0) num = "," + num;
num = s[i] + num;
}
num += ".";
cnt = 0;
for (int i = point_index + 1; i < (int)s.length(); i++) {
num += s[i];
cnt++;
if (cnt == 2) break;
}
if (cnt == 0)
num += "00";
else if (cnt == 1)
num += "0";
res += num;
}
}
if (negative) res += ")";
}
cout << res;
return 0;
}
void ONLINE__JUDGE() {}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int n;
long long wys[N][N][2][2], m;
bool visited[N][N][2][2];
int bit[N];
long long f(int l, int r, int rev, int inv) {
if (l > r) return 1;
if (visited[l][r][rev][inv]) return wys[l][r][rev][inv];
visited[l][r][rev][inv] = true;
long long &val = wys[l][r][rev][inv] = 0;
for (int u = 0; u < 2; ++u)
if (bit[l] == -1 || bit[l] == u)
for (int v = 0; v < 2; ++v)
if (bit[r] == -1 || bit[r] == v) {
if ((l != r || u == v) && (rev || u <= v) && (inv || u <= 1 - v)) {
int tRev = rev || u < v;
int tInv = inv || u < 1 - v;
val += f(l + 1, r - 1, tRev, tInv);
}
}
return val;
}
int main() {
cin >> n >> m;
memset(bit, -1, sizeof(bit));
bit[0] = 0;
m++;
if (f(0, n - 1, 0, 0) < m) return puts("-1"), 0;
for (int i = 1; i < n; ++i) {
memset(visited, 0, sizeof(visited));
bit[i] = 0;
long long number = f(0, n - 1, 0, 0);
if (number < m) {
m -= number;
bit[i] = 1;
}
}
for (int i = 0; i < n; ++i) printf("%d", bit[i]);
puts("");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class K>
inline bool cmax(K& a, const K& b) {
return (a < b) ? a = b, 1 : 0;
}
template <class K>
inline bool cmin(K& a, const K& b) {
return (a > b) ? a = b, 1 : 0;
}
inline int read() {
register int s = 0;
register char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) s = (s << 1) + (s << 3) + c - '0', c = getchar();
return s;
}
int n, T, m;
long long t;
char s[7000007];
int main() {
register int i, j, flg;
char k;
T = read();
while (T--) {
m = read(), scanf("%s", s + 1), t = strlen(s + 1), flg = 1;
for (i = 1; i <= m; i++) {
if (s[i] == '1') continue;
if (t < m && flg) {
n = t;
for (k = '2'; k <= s[i]; ++k)
for (j = i + 1; j <= n; j++) s[++t] = s[j];
} else {
flg = 0;
t = (t + (t - i) * (s[i] - '1')) % 1000000007;
}
}
printf("%d\n", (t % 1000000007 + 1000000007) % 1000000007);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, cnt, l, r, u, d, arr[2005][2005];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
void fill(int x, int y) {
if (!arr[x][y]) return;
cnt++;
if (x > r || (x == r && y > d)) {
r = x;
d = y;
}
if (x < l || (x == l && y < u)) {
l = x;
u = y;
}
arr[x][y] = 0;
for (int i = 0; i < 4; i++) {
int newx = x + dx[i], newy = y + dy[i];
if (newx < 0 || newx >= n || newy < 0 || newy >= n) continue;
fill(newx, newy);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) scanf("%d", arr[i] + j);
}
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!arr[i][j]) continue;
cnt = 0;
l = 1e9;
r = 0;
u = 1e9;
d = 0;
fill(i, j);
if (cnt < 150) continue;
int dia = (r - l) * (r - l) + (d - u) * (d - u);
(cnt > dia * 1.1 / 2 ? x : y)++;
}
}
printf("%d %d\n", x, y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, top, ans = 0, f[10][20][10], g[10][20][10];
int a[20], w[20];
void findans(int Max, int whe, int x) {
if (f[Max][whe][x]) return;
if (whe == 1) {
int k = x - max(Max, x);
if (k == 0)
f[Max][whe][x] = 2, g[Max][whe][x] = 10 - Max;
else
f[Max][whe][x] = 1, g[Max][whe][x] = 10 + x - Max;
return;
}
f[Max][whe][x] = 0;
int y = x;
for (int i = 9; i >= 0; i--) {
findans(max(Max, i), whe - 1, y);
f[Max][whe][x] += f[max(Max, i)][whe - 1][y];
y = g[max(Max, i)][whe - 1][y];
}
g[Max][whe][x] = y;
}
void dfs(int whe, int Max) {
if (whe == 1) {
findans(Max, whe, a[whe]);
w[whe] = g[Max][whe][a[whe]];
ans += f[Max][whe][a[whe]];
return;
}
dfs(whe - 1, max(Max, a[whe]));
int y = w[whe - 1];
for (int i = a[whe] - 1; i >= 0; i--) {
findans(max(Max, i), whe - 1, y);
ans += f[max(Max, i)][whe - 1][y];
y = g[max(Max, i)][whe - 1][y];
}
w[whe] = y;
}
int main() {
cin >> n;
long long z = n;
if (n == 0) {
printf("0");
return 0;
}
for (int i = 1; i <= 20; i++) {
a[i] = z % 10;
z /= 10;
if (!z) {
top = i;
break;
}
}
dfs(top, 0);
cout << ans - 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
ll n, x, k;
cin >> n >> x >> k;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
ll res = 0;
for (int i = 0; i < n; i++) {
ll val = (a[i] - 1) / x * x;
ll ub = lower_bound(a.begin(), a.end(), val + (k + 1) * x) - a.begin();
ll lb = lower_bound(a.begin(), a.end(), val + k * x) - a.begin();
lb = max(lb, (ll)(lower_bound(a.begin(), a.end(), a[i]) - a.begin()));
res += max(0ll, ub - lb);
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int inv(int a, int m) {
int p = 1, q = 0, b = m, c, d;
while (b > 0) {
c = a / b;
d = a;
a = b;
b = d % b;
d = p;
p = q;
q = d - c * q;
}
return p < 0 ? p + m : p;
}
long long pow(int a, int b) {
long long res = 1;
long long k = a;
while (b) {
if (b & 1) {
res = res * k % 1000000007;
}
k = k * k % 1000000007;
b >>= 1;
}
return res;
}
long long c[2000005];
int main() {
cin >> n;
c[n] = 1;
for (int i = n + 1; i <= 2 * n; i++) {
c[i] = c[i - 1] * i % 1000000007 * inv(i - n, 1000000007) % 1000000007;
}
long long res = (pow(2, n + 1) - 1 + 1000000007) % 1000000007;
long long Count = pow(2, n);
for (int i = n + 1; i <= 2 * n; i++) {
Count = (2 * Count - 2 * c[i - 1] + 1000000007 * 2) % 1000000007;
res = (res + Count) % 1000000007;
}
printf("%I64d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, k, c[27], dp[27][200005];
int main() {
scanf("%d", &t);
dp[0][0] = 1;
while (t--) {
memset(c, 0, sizeof c);
scanf("%d%d%d", &n, &m, &k);
getchar();
for (int i = 0; i < k; ++i) ++c[getchar() - 'A' + 1];
int ans = 1e9;
for (int i = 1; i <= 26; ++i) {
for (int j = i; j <= 26; ++j) {
for (int s = 0; s <= k; ++s) {
dp[j][s] = dp[j - 1][s];
if (s >= c[j] && i != j) dp[j][s] |= dp[j - 1][s - c[j]];
}
}
for (int a = 1; a < c[i] && a <= n; ++a) {
if (dp[26][n - a]) {
int b = max(0, m - (k - (n - a) - c[i]));
ans = min(ans, a * b);
}
}
for (int s = c[i]; s <= k; ++s) {
dp[i][s] |= dp[i - 1][s - c[i]];
}
}
for (int s = n; s <= k - m; ++s) {
if (dp[26][s]) {
ans = 0;
break;
}
}
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int x[3], y[3];
map<pair<int, int>, bool> cleaned;
int cost(int cx, int cy) {
int sum = 0;
for (int i = 0; i < (3); i++)
sum += ((cx - x[i]) > 0 ? (cx - x[i]) : -(cx - x[i])) +
((cy - y[i]) > 0 ? (cy - y[i]) : -(cy - y[i]));
return sum;
}
void clean(int x1, int y1, int x2, int y2) {
cleaned[pair<int, int>(x1, y1)] = true;
if (x1 == x2 && y1 == y2) return;
if (x1 < x2)
clean(x1 + 1, y1, x2, y2);
else if (x1 > x2)
clean(x1 - 1, y1, x2, y2);
else if (y1 < y2)
clean(x1, y1 + 1, x2, y2);
else
clean(x1, y1 - 1, x2, y2);
}
int main() {
ios_base::sync_with_stdio(false);
int bestX = 0, bestY = 0, bestCost;
for (int i = 0; i < (3); i++) cin >> x[i] >> y[i];
bestCost = cost(0, 0);
for (int ix = 0; ix < (1001); ix++)
for (int iy = 0; iy < (1001); iy++) {
int curCost = cost(ix, iy);
if (curCost < bestCost) {
bestCost = curCost;
bestX = ix;
bestY = iy;
}
}
for (int i = 0; i < (3); i++) clean(x[i], y[i], bestX, bestY);
cout << ((cleaned).size()) << endl;
for (map<pair<int, int>, bool>::iterator it = cleaned.begin();
it != cleaned.end(); ++it) {
cout << it->first.first << " " << it->first.second << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
int t;
cin>>t;
while(t--)
{
int n,x,c=1,m=-1;
cin>>n;
for(int i=0;i<n;i++){
cin>>x;
m=max(m,x);
if(x<0)
c=0;
}
if(!c)
cout<<"NO\n";
else{
cout<<"Yes"<<endl<<m+1<<endl;
for(int i=0;i<=m;i++){
if(i)
cout<<' '<<i;
else
cout<<i;
}
cout<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int nag = 2e5 + 5;
template <typename T>
void add(T& a, T b) {
a += b;
while (a >= mod) a -= mod;
while (a < 0) a += mod;
}
template <typename T>
void mul(T& a, T b) {
a = a * b % mod;
}
template <typename T>
void up_self(T& a, T b) {
a = max(a, b);
}
template <typename T>
void min_self(T& a, T b) {
a = min(a, b);
}
string find_largest_pref_palindrome(const string& a) {
string second = a;
reverse(second.begin(), second.end());
second = a + "%" + second;
int c = 0;
vector<int> pref(2 * ((int)a.size()) + 2);
for (int i = 1; i < second.size(); i++) {
while (c != 0 && second[i] != second[c]) c = pref[c - 1];
if (second[i] == second[c]) c++;
pref[i] = c;
}
return second.substr(0, c);
}
long long int binexpomodulo(long long int x, long long int y) {
long long int res = 1;
x %= mod;
if (!x) return 0;
while (y) {
if (y & 1) {
mul(res, x);
}
mul(x, x);
y >>= 1;
}
return res;
}
long long int nCrInOr(long long int n, long long int r) {
long long int res = 1;
if (r > n - r) r = n - r;
long long int rin = 1;
for (long long int i = 1; i <= r; i++) rin = (rin * i) % mod;
rin = binexpomodulo(rin, mod - 2);
for (long long int i = 1; i <= r; i++) res = (res * (n - i + 1)) % mod;
res = (res * rin) % mod;
return res;
}
int msb(long long int n) {
int ans;
for (int i = 0; i < 64; i++)
if (n & (1LL << i)) ans = i + 1;
return ans;
}
long long int get_(vector<long long int>& a, int pos) {
long long int res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
res += a[pos];
}
return res;
}
void upd(vector<long long int>& a, int pos, int val) {
for (; pos < a.size(); pos = (pos | (pos + 1))) a[pos] += val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, a, b, c;
cin >> n >> a >> b >> c;
vector<long long int> pref(n), suff(n);
vector<long long int> ar(n);
for (int i = 0; i < n; i++) cin >> ar[i];
;
pref[0] = ar[0] * a;
suff[n - 1] = ar[n - 1] * c;
for (int i = 1; i < n; i++) {
pref[i] = max(pref[i - 1], ar[i] * a);
}
for (int i = n - 2; i >= 0; i--) {
suff[i] = max(suff[i + 1], ar[i] * c);
}
long long int ans = -(long long int)9e18;
for (int i = 0; i < n; i++) {
up_self(ans, pref[i] + b * ar[i] + suff[i]);
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool f(int &a) {
if (a < 10) return false;
int t = 0;
while (a) t += a % 10, a /= 10;
a = t;
return true;
}
int main() {
string st;
cin >> st;
if (st.length() == 1) {
cout << 0 << endl;
return 0;
}
int ans = 1;
int sum = 0;
for (int i = 0; i < st.length(); i++) sum += st[i] - '0';
while (f(sum)) ans++;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000011;
int S[M], dfn[M], ct, n, m, k, f[M], T, s[M];
vector<int> v[M];
long long tag[M * 4], ans[M];
int ff(int x) {
if (f[x] == x) return x;
return f[x] = ff(f[x]);
}
struct vv {
int tag, x, y, k;
} q[M / 2];
int ver[M * 2], nex[M * 2], head[M * 2], cnt;
void add(int x, int y) { ver[++cnt] = y, nex[cnt] = head[x], head[x] = cnt; }
void dfs(int x) {
s[x] = 1;
dfn[x] = ++ct;
for (int i = head[x]; i; i = nex[i]) {
dfs(ver[i]);
s[x] += s[ver[i]];
}
}
void add(int now, int l, int r, int L, int R, int k) {
if (l >= L && r <= R) {
tag[now] += k;
return;
}
int mid = (l + r) >> 1;
if (L <= mid) add(now * 2, l, mid, L, R, k);
if (R > mid) add(now * 2 + 1, mid + 1, r, L, R, k);
}
long long ask(int now, int l, int r, int k) {
if (l == r) return tag[now];
int mid = (l + r) >> 1;
if (k <= mid)
return tag[now] + ask(now * 2, l, mid, k);
else
return tag[now] + ask(now * 2 + 1, mid + 1, r, k);
}
void mody(int now, int l, int r, int L, int R, int k) {
if (l >= L && r <= R) {
tag[now] = k;
return;
}
if (tag[now]) {
tag[now * 2] = tag[now * 2 + 1] = tag[now];
tag[now] = 0;
}
int mid = (l + r) >> 1;
if (L <= mid) mody(now * 2, l, mid, L, R, k);
if (R > mid) mody(now * 2 + 1, mid + 1, r, L, R, k);
}
int Ask(int now, int l, int r, int k) {
if (l == r || tag[now]) return tag[now];
int mid = (l + r) >> 1;
if (k <= mid) return Ask(now * 2, l, mid, k);
return Ask(now * 2 + 1, mid + 1, r, k);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
char c;
int x, y;
scanf("\n%c%d", &c, &q[i].x);
if (c == 'U' || c == 'M') scanf("%d", &q[i].y);
if (c == 'U') q[i].tag = 0;
if (c == 'M') q[i].tag = 1;
if (c == 'A') q[i].tag = 2;
if (c == 'Z') q[i].tag = 3;
if (c == 'Q') q[i].tag = 4;
}
for (int i = 1; i <= n + m; i++) f[i] = i;
int N = n;
for (int i = 1; i <= m; i++) {
if (q[i].tag != 1) continue;
int x = q[i].x, y = q[i].y;
N += 1;
add(N, ff(x)), add(N, ff(y));
f[ff(x)] = f[ff(y)] = N;
}
for (int i = N; i >= 1; i--)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= n + m; i++) f[i] = i;
N = n;
for (int i = 1; i <= m; i++) {
int x = q[i].x, y = q[i].y;
if (q[i].tag == 1) {
N++;
f[ff(x)] = f[ff(y)] = N;
}
if (q[i].tag == 3) {
x = ff(x);
mody(1, 1, n + m, dfn[x], dfn[x] + s[x] - 1, i);
}
if (q[i].tag == 4) {
y = Ask(1, 1, n + m, dfn[x]);
v[y].push_back(i);
}
}
memset(nex, 0, sizeof(nex));
memset(head, 0, sizeof(head));
memset(tag, 0, sizeof(tag));
memset(dfn, 0, sizeof(dfn));
cnt = ct = 0;
N = n;
for (int i = 1; i <= n + m; i++) f[i] = i;
for (int i = 1; i <= n; i++) S[i] = 1;
for (int i = 1; i <= m; i++) {
if (q[i].tag != 0) continue;
int x = q[i].x, y = q[i].y;
N += 1;
add(N, ff(x)), add(N, ff(y));
f[ff(x)] = f[ff(y)] = N;
}
for (int i = N; i >= 1; i--)
if (!dfn[i]) dfs(i);
for (int i = 1; i <= n + m; i++) f[i] = i;
N = n;
for (int i = 1; i <= m; i++) {
int x = q[i].x, y = q[i].y;
if (q[i].tag == 0) {
N++;
S[N] = S[ff(x)] + S[ff(y)];
f[ff(x)] = f[ff(y)] = N;
}
if (q[i].tag == 2) {
x = ff(x);
add(1, 1, n + m, dfn[x], dfn[x] + s[x] - 1, S[x]);
}
if (q[i].tag == 4) ans[i] += ask(1, 1, n + m, dfn[x]);
for (auto j : v[i]) {
ans[j] -= ask(1, 1, n + m, dfn[q[j].x]);
}
}
for (int i = 1; i <= m; i++)
if (q[i].tag == 4) {
printf("%I64d\n", ans[i]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 200000 + 9;
long long a[maxN];
long long n, m, k;
bool judge(int x) {
int res = 1;
int tmp = k;
for (int i = x; i <= n; i++) {
if (tmp >= a[i])
tmp -= a[i];
else {
tmp = k - a[i];
res++;
}
}
return res <= m;
}
int main() {
scanf("%lld %lld %lld", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
int l = 1, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (judge(mid))
r = mid;
else
l = mid;
}
if (judge(l))
printf("%d\n", n - l + 1);
else
printf("%d\n", n - r + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, A[5][5], minCost;
bool flag = 1;
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(4); i++)
for (int j = (int)(1); j <= (int)(4); j++) scanf("%d", &A[i][j]);
for (int i = (int)(1); i <= (int)(4); i++) {
minCost = min(A[i][1], A[i][2]) + min(A[i][3], A[i][4]);
if (minCost <= n) {
flag = 0;
printf("%d %d %d", i, min(A[i][1], A[i][2]), n - min(A[i][1], A[i][2]));
break;
}
}
if (flag) printf("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long s[35];
set<int> off_pos[35];
int v[100005];
long long x[100005];
long long parejas(long long n) { return n * (n + 1) / 2; }
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < 30; i++) {
off_pos[i].insert(0);
s[i] = 0;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
if (i) {
for (int j = 0; j < 30; j++) {
if (v[i] & (1 << j)) continue;
int last = *off_pos[j].rbegin();
s[j] += 1LL * parejas(i - last - 1) * (1 << j);
off_pos[j].insert(i);
}
}
}
for (int i = 0; i < 30; i++) {
int nxt = n + 1;
int prev = *off_pos[i].rbegin();
s[i] += 1LL * parejas(nxt - prev - 1) * (1 << i);
}
for (int i = 0; i < 30; i++) off_pos[i].insert(n + 1);
while (q--) {
int pos, value;
cin >> pos >> value;
int prev = v[pos];
for (int i = 0; i < 17; i++) {
int n_bit = value & (1 << i);
int p_bit = prev & (1 << i);
if (n_bit == p_bit) continue;
set<int>::iterator it = off_pos[i].lower_bound(pos);
if (n_bit) {
int pivot = *it;
it--;
int before = *it;
it++;
it++;
int next = *it;
s[i] -= 1LL * parejas(pivot - before - 1) * (1 << i);
s[i] -= 1LL * parejas(next - pivot - 1) * (1 << i);
s[i] += 1LL * parejas(next - before - 1) * (1 << i);
off_pos[i].erase(pos);
} else {
int next = *it;
it--;
int before = *it;
s[i] -= 1LL * parejas(next - before - 1) * (1 << i);
s[i] += 1LL * parejas(pos - before - 1) * (1 << i) +
1LL * parejas(next - pos - 1) * (1 << i);
off_pos[i].insert(pos);
}
}
v[pos] = value;
long long ans = 0;
for (int i = 0; i < 17; i++) {
if (!s[i]) continue;
ans += s[i];
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
while(cin >> n >> m && (n || m)){
vector<int> G[n + 1], g[n + 1];
vector<int> dfn(n + 1), vis(n + 1), fa(n + 1);
int dfs_clock = 0;
int bcc_cnt = 0;
vector<pair<int, int> > use_edge;
function<void(int, int) > dfs = [&](int u, int f){
dfn[u] = ++dfs_clock;
fa[u] = f;
for(auto v : G[u]){
if(v == f) continue;
if(!dfn[v])dfs(v, u);
else if(dfn[v] > dfn[u]) continue;
else{
bcc_cnt++;
int p = u;
while(1){
use_edge.emplace_back(min(p, fa[p]), max(p, fa[p]));
vis[p] = bcc_cnt;
p = fa[p];
if(p == v) break;
}
use_edge.emplace_back(min(u, v), max(u, v));
}
}
};
for (int i = 1; i <= m; i += 1){
int len;
cin >> len;
vector<int> path(len);
for(int j = 0; j < len; j += 1){
cin >> path[j];
}
for(int j = 1; j < len; j += 1){
G[path[j]].emplace_back(path[j - 1]);
G[path[j - 1]].emplace_back(path[j]);
}
}
for(int i = 1; i <= n; i++){
sort(G[i].begin(), G[i].end());
G[i].erase(unique(G[i].begin(), G[i].end()), G[i].end());
}
if(n <= 2){
cout << "0\n";
continue;
}
for(int i = 1; i <= n; i += 1){
if(!dfn[i]) dfs(i, 0);
}
sort(use_edge.begin(), use_edge.end());
use_edge.erase(unique(use_edge.begin(), use_edge.end()), use_edge.end());
/*
cout << "used\n";
for(auto[x, y] : use_edge){
cout << x << " " << y << "\n";
}
*/
vector<pair<int, int> > new_edge;
for (int i = 1; i <= n; i += 1){
for(auto u : G[i]){
if(i > u) continue;
int x = min(i, u);
int y = max(i, u);
if(!binary_search(use_edge.begin(), use_edge.end(), make_pair(x, y))) {
new_edge.emplace_back(x, y);
new_edge.emplace_back(y, x);
}
}
}
/*
cout << "edge list\n";
for(auto [x, y] : new_edge){
cout << x << " " << y << "\n";
}
*/
vector<int> deg(n + 1);
sort(new_edge.begin(), new_edge.end());
new_edge.erase(unique(new_edge.begin(), new_edge.end()), new_edge.end());
for(auto [x, y] : new_edge){
assert(x != y);
g[x].emplace_back(y);
}
for (int i = 1; i <= n; i += 1){
sort(g[i].begin(), g[i].end());
g[i].erase(unique(g[i].begin(), g[i].end()), g[i].end());
deg[i] = g[i].size();
}
auto done = vector<int>(n + 1, 0);
fa.clear();
fa = vector<int>(n + 1, 0);
vector<pair<int, int> > res;
auto add = [&](int x, int y){
assert(x != y);
res.emplace_back(x, y);
};
vector<int> tag(n + 1);
function<void(int, int, vector<int> &) > find_point = [&](int u, int f, vector<int> &vec){
vec.emplace_back(u);
for(auto v : g[u]){
if(v == f || done[v]) continue;
find_point(v, u, vec);
}
};
function<int(int, int) > solve = [&](int u, int f){
done[u] = 1;
fa[u] = f;
vector<int> vec;
for(auto v : g[u]){
if(v == f || done[v]) continue;
int p = solve(v, u);
if(p < 0) {
tag[u] = -p;
}
if(p)vec.emplace_back(p);
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
if(tag[u]) vec.pop_back();
for(auto &p : vec){
p = abs(p);
}
for(int i = 1; i < vec.size(); i += 2){
add(vec[i - 1], vec[i]);
}
if(int(vec.size()) % 2){
if(fa[u]){
return vec.back();
}
else{
if(fa[vec.back()] != u) add(u, vec.back());
else if(tag[vec.back()]) add(u, tag[vec.back()]);
return 0;
}
}
else{
if(tag[u]) return u;
return -u;
}
};
for(int i = 1; i <= n; i += 1){
if(!done[i]) {
vector<int> point;
find_point(i, 0, point);
int rt = -1;
for(auto u : point){
if(deg[u] == 1){
rt = u;
break;
}
}
if(rt == -1){
done[i] = 1;
continue;
}
solve(rt, 0);
}
}
/*
cout << res.size() << "\n";
for(auto [x, y] : res){
cout << x << " " << y << "\n";
}
cout << "left list:\n";
for(auto [x, y] : left){
cout << x << " " << y << "\n";
}*/
cout << res.size() << "\n";
for(auto [x, y] : res){
cout << x << " " << y << "\n";
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INF64 = 1e18;
const int MOD = INF + 7;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
int n, a, b;
string s;
cin >> n >> a >> b >> s;
int ans = 0;
for (int i = 0; i < n && (a > 0 || b > 0); i++) {
if (a >= b && a > 0)
if (s[i] == '.' && (i == 0 || s[i - 1] != 'a')) {
a--;
ans++;
s[i] = 'a';
} else if (b > 0 && s[i] == '.' && (i == 0 || s[i - 1] != 'b')) {
b--;
ans++;
s[i] = 'b';
} else
;
else if (b >= a && b > 0)
if (s[i] == '.' && (i == 0 || s[i - 1] != 'b')) {
b--;
ans++;
s[i] = 'b';
} else if (a > 0 && s[i] == '.' && (i == 0 || s[i - 1] != 'a')) {
a--;
ans++;
s[i] = 'a';
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 411111;
const int M = 1e9 + 7;
int k, n;
long long lsh[N + N], g[N], f[N], h[N];
struct Node {
int l, r;
} a[N];
long long RP(long long a) {
long long Ans = 1, b = M - 2;
for (; b; b >>= 1) {
if (b & 1) Ans = Ans * a % M;
a = a * a % M;
}
return Ans;
}
long long C(long long n, long long m) {
return f[n] * RP(f[m]) % M * RP(f[n - m]) % M;
}
int main() {
f[0] = 1;
for (int i = 1; i <= 400000; i++) f[i] = f[i - 1] * i % M;
scanf("%d%d", &n, &k);
int m = 0;
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
lsh[++m] = l;
lsh[++m] = r;
a[i].l = l;
a[i].r = r;
}
sort(lsh + 1, lsh + m + 1);
m = unique(lsh + 1, lsh + m + 1) - (lsh + 1);
for (int i = 1; i <= n; i++) {
int t = lower_bound(lsh + 1, lsh + m + 1, a[i].l) - lsh;
h[t]++;
g[t]++;
t = lower_bound(lsh + 1, lsh + m + 1, a[i].r) - lsh;
h[t + 1]--;
g[t]--;
}
long long Ans = 0;
for (int i = 1; i <= 400000; i++)
h[i] = h[i] + h[i - 1], g[i] = g[i] + g[i - 1];
for (int i = 1; i <= 400000; i++) {
if (k <= h[i]) Ans = (Ans + C(h[i], k) % M) % M;
if (k <= g[i] && i < 400000)
Ans = (Ans + (lsh[i + 1] - lsh[i] - 1) * C(g[i], k) % M) % M;
}
cout << (Ans % M + M) % M << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool used[1000001];
int main() {
int n;
cin >> n;
vector<pair<int, int>> arr;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr.push_back(make_pair(x, i));
}
sort(arr.begin(), arr.end());
vector<int> ans[100001];
int k = 0;
for (int i = 0; i < n; i++) {
if (used[i]) {
} else {
int x = i;
while (!used[x]) {
used[x] = 1;
ans[k].push_back(x + 1);
x = arr[x].second;
}
k++;
}
}
cout << k << endl;
for (int i = 0; i < k; i++) {
cout << ans[i].size() << " ";
for (int x : ans[i]) {
cout << x << " ";
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long N, K, A, B;
int main() {
cin >> N >> K >> A >> B;
long long x = 1e18, y = 0;
for (int d = -1; d <= 1; d += 2) {
long long s = 1 + A * d;
if (s < 0) s += N * K;
for (int j = 0; j < N; j++) {
for (int e = -1; e <= 1; e += 2) {
long long t = 1 + j * K + e * B;
t %= N * K;
if (t < 0) t += N * K;
long long now = N * K / gcd(abs(s - t), N * K);
if (x > now) x = now;
if (y < now) y = now;
}
}
}
cout << x << " " << y << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 10;
const long long M = 2111;
const long long INF = 1e18;
const long long inf = -1e18;
const long long MOD = 1e9 + 7;
const long long xesh = 31;
long long a, b, k, t;
int main() {
long long o = 1;
cin >> o;
while (o--) {
cin >> a >> b;
k = b + 1;
t = 0;
while (k > 0) {
t++;
k /= 10;
}
cout << a * (t - 1) << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> a;
long long dp[5005][5005];
long long v[5005];
long long floodFill() {
for (long long l = n - 1; l >= 0; l--) {
for (long long r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
else if (a[l] == a[r])
dp[l][r] = 1 + dp[l + 1][r - 1];
else
dp[l][r] = 1 + min(dp[l + 1][r], dp[l][r - 1]);
}
}
return dp[0][n - 1];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin.tie(nullptr);
cin >> n;
for (long long i = 0; i < n; i++) cin >> v[i];
long long st = v[0];
long long i = 0;
while (i < n) {
st = v[i];
while (i < n and v[i] == st) i++;
a.emplace_back(st);
}
n = a.size();
cout << floodFill();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
vector<long long> p(n), t(2 * n);
for (long long i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
}
long long cur = 0;
long long delta = 0;
for (long long i = 0; i < n; i++) {
cur += abs(i - p[i]);
if (i <= p[i])
delta--;
else
delta++;
t[(p[i] - i + n) % n]++;
}
const long long INF = 1e18;
pair<long long, long long> best = {INF, INF};
for (long long i = 0; i < n; i++) {
best = min(best, {cur, i});
delta += 2 * t[i];
cur += delta;
long long x = p[n - i - 1];
cur -= n - x;
cur += x;
delta -= 2;
}
cout << best.first << ' ' << best.second << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int maxm = 26e3 + 7;
const long long mod = 998244353;
int n, k;
int flag[12];
vector<int> v;
string s;
int check(int pos) {
set<int> second;
for (int i = (0); i <= (pos); ++i) {
second.insert(s[i] - '0');
}
return (second.size() < k);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> s >> k;
memset(flag, 0, sizeof(flag));
v.clear();
int pos = -1;
for (int i = (0), __ = (s.size()); i < __; ++i) {
if (!flag[s[i] - '0']) {
if (v.size() == k) {
pos = i;
break;
} else
flag[s[i] - '0']++, v.push_back(s[i] - '0');
}
}
if (pos == -1) {
cout << s << '\n';
continue;
}
sort(v.begin(), v.end());
int tb = 0;
for (int i = pos; i >= 0; i--) {
int p = upper_bound(v.begin(), v.end(), s[i] - '0') - v.begin();
if (check(i - 1) && s[i] != '9') {
int fd = 0;
for (int j = 0; j < v.size(); j++) {
if (s[i] - '0' == v[j])
v.erase(v.begin() + j), j--;
else if (s[i] - '0' + 1 == v[j])
fd = 1;
}
if (!fd) {
v.push_back(s[i] - '0' + 1);
sort(v.begin(), v.end());
}
s[i] = char(s[i] + 1);
pos = i;
break;
} else if (p != v.size()) {
s[i] = char(v[p] + '0');
pos = i;
break;
}
if (!i) tb = 1;
}
if (v.size() < k) v[0] = 0;
if (tb) {
if (k == 1) {
for (int i = (1); i <= (s.size() + 1); ++i) cout << 1;
} else {
cout << 1;
for (int i = (1); i <= (s.size()); ++i) cout << 0;
}
} else {
for (int i = (0); i <= (pos); ++i) cout << s[i];
for (int i = (pos + 1), __ = (s.size()); i < __; ++i) cout << v[0];
}
cout << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
long long n, x, first = 0, t = 0, an = 0;
int main() {
cin >> n;
for (int(i) = 0; i < (n); i++) {
cin >> x;
if (x == 25)
t++;
else if (x == 50 && t != 0) {
first++;
t--;
} else if (x == 100 && t != 0 && first != 0) {
t--;
first--;
} else if (x == 100 && t >= 3) {
t -= 3;
} else
an++;
}
cout << (an == 0 ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
struct Node {
long long x, y;
} ra[maxn], rb[maxn];
long long a, b;
long long dis(Node i, Node j) {
return (i.x - j.x) * (i.x - j.x) + (i.y - j.y) * (i.y - j.y);
}
int main() {
int i, j, k, m, n;
while (scanf("%I64d%I64d", &a, &b) != EOF) {
int tota = 0, totb = 0;
for (i = a - 1; i > 0; i--) {
j = a * a - i * i;
long long tmp = sqrt(1.0 * j);
if (tmp * tmp == j) {
ra[tota].x = i;
ra[tota++].y = tmp;
}
}
for (i = -1; i > -1 * b; i--) {
j = b * b - i * i;
long long tmp = sqrt(1.0 * j);
if (tmp * tmp == j) {
rb[totb].x = i;
rb[totb++].y = tmp;
}
}
int f = 1;
for (i = 0; i < tota && f; i++) {
for (j = 0; j < totb && f; j++) {
if (dis(ra[i], rb[j]) == a * a + b * b && ra[i].y != rb[j].y) {
printf("YES\n");
printf("0 0\n");
printf("%I64d %I64d\n", ra[i].x, ra[i].y);
printf("%I64d %I64d\n", rb[j].x, rb[j].y);
f = 0;
}
}
}
if (f) printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
const long long MOD = 1e9 + 7;
int n, a, b;
long long h[N], d[N];
int main() {
scanf("%d%d%d", &n, &a, &b);
vector<pair<long long, int> > v;
for (int i = 0; i < n; i++) {
scanf("%lld%lld", h + i, d + i);
v.push_back(make_pair(h[i] - d[i], i));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long ans = 0;
long long A = 1ll << a;
if (b) {
int s = min(n, b);
long long tmp = 0;
for (int i = 0; i < s; i++) tmp += max(h[v[i].second], d[v[i].second]);
for (int i = s; i < n; i++) tmp += d[v[i].second];
for (int i = 0; i < n; i++) {
if (i < s)
ans = max(ans, tmp -
(i < s ? max(h[v[i].second], d[v[i].second])
: d[v[i].second]) +
max(d[v[i].second], h[v[i].second] * A));
else
ans = max(ans, tmp -
(i < s ? max(h[v[i].second], d[v[i].second])
: d[v[i].second]) +
max(d[v[i].second],
h[v[i].second] * A -
max(d[v[s - 1].second], h[v[s - 1].second]) +
d[v[s - 1].second]));
}
} else {
for (int i = 0; i < n; i++) ans += d[v[i].second];
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int res;
bool isP(int l, int r) {
for (int i = l; i <= (l + r) / 2; ++i) {
if (s[i] != s[l + r - i]) {
return false;
}
}
return true;
}
void process(int l) {
for (int i = 0; i <= s.length() - l; i++) {
if (!isP(i, i + l - 1)) {
res = l;
cout << res;
return;
}
}
process(l - 1);
}
int main() {
cin >> s;
process(s.length());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
struct BITree {
int freq[MAXN + 1];
BITree() { memset(freq, 0, sizeof freq); }
void insert(int x, int cnt = 1) {
for (; x <= MAXN; x += x & -x) freq[x] += cnt;
}
int query(int x) {
int sum = 0;
for (; x; x -= x & -x) sum += freq[x];
return sum;
}
void insert_range(int xl, int xr, int cnt = 1) {
insert(xl, cnt);
insert(xr + 1, -cnt);
}
int query_range(int xl, int xr) { return query(xr) - query(xl - 1); }
int get_nth(int n) {
int x = 1 << 30;
for (int step = x >> 1; step; step >>= 1)
if (x - step > MAXN || freq[x - step] >= n)
x -= step;
else
n -= freq[x - step];
return x;
}
};
BITree count2[4][11][10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
map<char, int> m;
m.insert(pair<char, int>('A', 0));
m.insert(pair<char, int>('T', 1));
m.insert(pair<char, int>('G', 2));
m.insert(pair<char, int>('C', 3));
char s[100002];
string ss, t;
int q, len, sum;
int type, pos, right, temp;
char c;
cin >> ss;
len = ss.size();
strcpy(s, ss.c_str());
for (int mod = 1; mod <= 10; mod++) {
for (int i = 0; i < len; i++) {
count2[m[s[i]]][mod][(i + 1) % mod].insert(i + 1, 1);
}
}
cin >> q;
while (q--) {
cin >> type;
if (type == 1) {
cin >> pos >> c;
for (int mod = 1; mod <= 10; mod++) {
count2[m[s[pos - 1]]][mod][pos % mod].insert(pos, -1);
count2[m[c]][mod][pos % mod].insert(pos, 1);
}
s[pos - 1] = c;
} else {
cin >> pos >> right >> t;
sum = 0;
temp = t.size();
for (int i = 0; i < min(right, temp); i++) {
sum += count2[m[t[i]]][temp][(pos + i) % temp].query_range(pos, right);
}
cout << sum << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int cache_bits = 20;
const int cache_mask = (1 << cache_bits) - 1;
vector<long long> count_cache;
int count(long long x) {
int s = 0;
while (x) {
s += count_cache[x & cache_mask];
x >>= cache_bits;
}
return s;
}
void build_count_cache() {
count_cache.resize(1 << cache_bits);
for (int i = (1); i < (int)(count_cache.size()); i++)
count_cache[i] = count_cache[i & (i - 1)] + 1;
}
void solve() {
build_count_cache();
int n;
cin >> n;
vector<string> S(n);
for (int(i) = 0; (i) < (n); (i)++) cin >> S[i];
int m = S[0].size();
vector<long long> mask_array(1 << m);
for (int(i) = 0; (i) < (n); (i)++) {
for (int j = (i + 1); j < (int)(n); j++) {
long long s = 0;
for (int(k) = 0; (k) < (m); (k)++)
if (S[i][k] == S[j][k]) s |= (1 << k);
mask_array[s] |= (1LL << i) | (1LL << j);
}
}
for (int i = mask_array.size() - 1; i; --i) {
if (!mask_array[i]) {
continue;
}
for (int(bit_idx) = 0; (bit_idx) < (m); (bit_idx)++) {
long long bit = (1 << bit_idx);
if (bit & i) {
mask_array[i ^ bit] |= mask_array[i];
}
}
}
vector<double> subset_probs(m, 1.);
for (int k = (0); k < (int)(subset_probs.size()); k++) {
for (int(i) = 0; (i) < (k); (i)++) {
subset_probs[k] *= double(k - i) / (m - i);
}
subset_probs[k] /= (m - k);
}
vector<double> cnt_per_attemp(m);
for (int i = 0; i < (int)(mask_array).size(); i++) {
if (!mask_array[i]) {
continue;
}
int attemps = count(i);
int unk_before = count(mask_array[i]);
for (int(bit_idx) = 0; (bit_idx) < (m); (bit_idx)++) {
long long bit = 1 << bit_idx;
if ((bit & i) == 0) {
long long unk_after_mask = mask_array[i] & mask_array[(i | bit)];
int unk_after = count(unk_after_mask);
cnt_per_attemp[attemps] += (unk_before - unk_after);
}
}
}
double mexp = 0;
for (int(i) = 0; (i) < (m); (i)++)
mexp += (i + 1) * subset_probs[i] * cnt_per_attemp[i] / n;
cout.precision(15);
cout << mexp;
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxk = 1e5 + 10;
int n, m, cnt, ans = 1;
char s[Maxk];
unsigned int f[Maxk] = {1};
inline int read() {
int s = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) s = s * 10 + (ch ^ 48), ch = getchar();
return f ? -s : s;
}
signed main() {
n = read();
if (n & 1) {
printf("0\n");
return 0;
}
cin >> (s + 1);
n = strlen(s + 1);
m = n >> 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '?') {
for (int j = i >> 1; j >= i - m && j; j--) f[j] += f[j - 1];
} else
cnt++;
}
for (int i = 1; i <= m - cnt; i++) ans *= 25;
printf("%u\n", ((unsigned int)ans * f[m]));
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
template <typename T>
inline void _debug(const char *name, T &&t) {
std::cerr << name << "=" << t << std::endl;
}
template <typename T1, typename... T>
inline void _debug(const char *names, T1 &&t1, T &&...t) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << "=" << t1 << ",";
_debug(comma + 1, t...);
}
using namespace std;
template <typename T>
void chmax(T &a, const T &b) {
if (b > a) a = b;
}
template <typename T>
void chmin(T &a, const T &b) {
if (b < a) a = b;
}
template <typename T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <typename T>
using max_queue = priority_queue<T>;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
const long double PI = 3.1415926535897932384626433832795, EPS = 1e-9;
const int inf = 0x3f3f3f3f;
const int mod1 = 1000000007, mod2 = 998244353;
int t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (1 << (__builtin_popcount(n))) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int str[10005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &str[i]);
}
int ans = 0;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
ans += min(str[a], str[b]);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
long long qp(long long a, long long b) {
long long x = 1;
a %= MOD;
while (b) {
if (b & 1) x = x * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return x;
}
namespace linear_seq {
inline vector<int> BM(vector<int> x) {
vector<int> ls, cur;
int lf, ld;
for (int i = 0; i < int(x.size()); ++i) {
long long t = 0;
for (int j = 0; j < int(cur.size()); ++j)
t = (t + x[i - j - 1] * (long long)cur[j]) % MOD;
if ((t - x[i]) % MOD == 0) continue;
if (!cur.size()) {
cur.resize(i + 1);
lf = i;
ld = (t - x[i]) % MOD;
continue;
}
long long k = -(x[i] - t) * qp(ld, MOD - 2) % MOD;
vector<int> c(i - lf - 1);
c.push_back(k);
for (int j = 0; j < int(ls.size()); ++j) c.push_back(-ls[j] * k % MOD);
if (c.size() < cur.size()) c.resize(cur.size());
for (int j = 0; j < int(cur.size()); ++j) c[j] = (c[j] + cur[j]) % MOD;
if (i - lf + (int)ls.size() >= (int)cur.size())
ls = cur, lf = i, ld = (t - x[i]) % MOD;
cur = c;
}
for (int i = 0; i < int(cur.size()); ++i) cur[i] = (cur[i] % MOD + MOD) % MOD;
return cur;
}
int m;
long long a[233333], h[233333], t_[233333], s[233333], t[233333];
inline void mull(long long* p, long long* q) {
for (int i = 0; i < m + m; ++i) t_[i] = 0;
for (int i = 0; i < m; ++i)
if (p[i])
for (int j = 0; j < m; ++j) t_[i + j] = (t_[i + j] + p[i] * q[j]) % MOD;
for (int i = m + m - 1; i >= m; --i)
if (t_[i])
for (int j = m - 1; ~j; --j)
t_[i - j - 1] = (t_[i - j - 1] + t_[i] * h[j]) % MOD;
for (int i = 0; i < m; ++i) p[i] = t_[i];
}
inline long long calc(long long K) {
for (int i = m; ~i; --i) s[i] = t[i] = 0;
s[0] = 1;
if (m != 1)
t[1] = 1;
else
t[0] = h[0];
while (K) {
if (K & 1) mull(s, t);
mull(t, t);
K >>= 1;
}
long long su = 0;
for (int i = 0; i < m; ++i) su = (su + s[i] * a[i]) % MOD;
return (su % MOD + MOD) % MOD;
}
inline int work(vector<int> x, long long n) {
if (n < int(x.size())) return x[n];
vector<int> v = BM(x);
m = v.size();
if (!m) return 0;
for (int i = 0; i < m; ++i) h[i] = v[i], a[i] = x[i];
return calc(n);
}
} // namespace linear_seq
using linear_seq::work;
int main() {
int n;
cin >> n;
for (int i = n; i >= 1; i--)
cout << work({10, 180, 2610, 34200, 423000}, i - 1) << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char d[1000005];
int N, cCoun, st, pN, fOnes, lChain, ans;
bool fChain, canUse;
int main() {
scanf("%s", d);
N = strlen(d);
for (int i = 0; i < N; d[i] -= '0', i++)
;
if (d[N - 1] == d[0]) {
for (st = N - 2; d[st] == d[st + 1]; st--)
;
st += 2;
st %= N;
} else {
st = 1;
}
cCoun = 1;
canUse = true;
fChain = true;
fprintf(stderr, "%d\n", st);
for (int i = 0; i < N; st++, i++, cCoun++) {
if (st == N || st == 0) {
st = 0;
pN = N - 1;
} else {
pN = st - 1;
}
if (d[st] != d[pN] || i == N - 1) {
if (fChain) {
fOnes += (cCoun == 1);
fChain = (cCoun == 1);
}
if (cCoun == 1) {
lChain++;
} else {
lChain = 0;
}
if (!canUse)
canUse = true;
else {
ans++;
if (cCoun == 1) canUse = false;
}
cCoun = 0;
}
fprintf(stderr, "%d: %d %d\n", i, ans, cCoun);
}
if (fChain) lChain = 0;
if ((lChain + fOnes) % 2 && !canUse) ans--;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void read(int& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
long long n, i;
int main() {
cin >> n;
for (i = 1; n % i == 0; i *= 3)
;
cout << n / i + 1 << endl;
scanf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[300];
int main() {
int n;
cin >> n;
for (int i = 0; i < 2 * n; i++) cin >> arr[i];
sort(arr, arr + 2 * n);
if (arr[n] > arr[n - 1])
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const int mxN = 1e6 + 5;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
int n;
long long a[mxN], s1[4 * mxN], s[4 * mxN];
void build(int id = 1, int l = 0, int r = n) {
if (r - l < 2) {
s1[id] = a[l];
s[id] = a[l];
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid, r);
s[id] = max(s[id * 2], s[id * 2 + 1]);
s1[id] = min(s1[id * 2], s1[id * 2 + 1]);
}
long long minQ(int x, int y, int id = 1, int l = 0, int r = n) {
if (x >= r || l >= y) return 1e18;
if (x <= l && r <= y) return s1[id];
int mid = (l + r) / 2;
return min(minQ(x, y, id * 2, l, mid), minQ(x, y, id * 2 + 1, mid, r));
}
long long maxQ(int x, int y, int id = 1, int l = 0, int r = n) {
if (x >= r || l >= y) return -1e18;
if (x <= l && r <= y) return s[id];
int mid = (l + r) / 2;
return max(maxQ(x, y, id * 2, l, mid), maxQ(x, y, id * 2 + 1, mid, r));
}
long long ans = 0LL;
vector<int> pos[mxN];
void solveMax(int l, int r) {
if (l >= r) return;
long long mx = maxQ(l, r);
int m = (l + r) / 2;
int l1 = 0, r1 = pos[mx].size() - 1;
while (l1 < r1) {
int mid1 = (l1 + r1) / 2;
if (pos[mx][mid1] >= l)
r1 = mid1;
else
l1 = mid1 + 1;
}
int bst = -1;
if (pos[mx][l1] >= m)
bst = l1;
else {
int l2 = 0, r2 = pos[mx].size() - 1;
while (l2 < r2) {
int mid2 = (l2 + r2 + 1) / 2;
if (pos[mx][mid2] <= m)
l2 = mid2;
else
r2 = mid2 - 1;
}
if (l2 == (int)(pos[mx].size() - 1))
bst = l2;
else {
bst = l2;
if ((pos[mx][l2 + 1] - m) < (m - pos[mx][l2])) bst = l2 + 1;
}
}
assert(bst != -1);
long long add =
(long long)(1LL * (pos[mx][bst] - l + 1) * (r - pos[mx][bst]) * mx);
ans += add;
if (l < pos[mx][bst]) solveMax(l, pos[mx][bst]);
if (pos[mx][bst] + 1 < r) solveMax(pos[mx][bst] + 1, r);
}
void solveMin(int l, int r) {
if (l >= r) return;
long long mx = minQ(l, r);
int m = (l + r) / 2;
int l1 = 0, r1 = pos[mx].size() - 1;
while (l1 < r1) {
int mid1 = (l1 + r1) / 2;
if (pos[mx][mid1] >= l)
r1 = mid1;
else
l1 = mid1 + 1;
}
int bst = l1;
long long sub =
(long long)(1LL * (pos[mx][bst] - l + 1) * (r - pos[mx][bst]) * mx);
ans -= sub;
if (l < pos[mx][bst]) solveMin(l, pos[mx][bst]);
if (pos[mx][bst] + 1 < r) solveMin(pos[mx][bst] + 1, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> a[i], pos[a[i]].push_back(i);
build();
solveMax(0, n);
solveMin(0, n);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
long long qwe;
cin >> qwe;
while (qwe--) {
long long flag = 1;
long long n, c;
cin >> n >> c;
long long last = 0;
long long minn = c, maxx = c;
for (long long i = 0; i < n; i++) {
long long t, l, r;
cin >> t >> l >> r;
minn = max(minn - (t - last), l);
maxx = min(maxx + (t - last), r);
last = t;
if (minn > maxx) {
flag = 0;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const string nl = "\n";
const long long MOD = 1000000007;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
int j = m - 1;
long long frnt[n], bck[n];
long long cnt = 0;
for (int i = n - 1; i >= 0; i--) {
bck[i] = cnt;
if (s[i] == t[j]) {
cnt++;
j--;
}
}
j = 0;
cnt = 0;
for (int i = 0; i < n; i++) {
frnt[i] = cnt;
if (s[i] == t[j]) {
cnt++;
j++;
}
}
int i = 0;
j = 0;
int mx = 0;
while ((i < n) && (j < n)) {
if (frnt[i] + bck[j] >= m) {
j++;
} else {
mx = max(mx, j - i);
if (i == j) j++;
i++;
}
}
mx = max(n - i, mx);
cout << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int Dp[1010][110][11], id[30];
struct AcAuto {
int next[1010][4], fail[1010], Cover[1010];
int tot, root;
int New_node() {
for (int i = 0; i < 4; i++) next[tot][i] = -1;
Cover[tot++] = 0;
return tot - 1;
}
void Init() {
tot = 0;
root = New_node();
}
void Insert(char *T) {
int len = (int)strlen(T);
int now = root;
for (int i = 0; i < len; i++) {
int num = id[T[i] - 'A'];
if (next[now][num] == -1) next[now][num] = New_node();
now = next[now][num];
}
Cover[now] = len;
}
void Build_Failtree() {
queue<int> Q;
fail[root] = root;
for (int i = 0; i < 4; i++) {
if (next[root][i] == -1)
next[root][i] = root;
else {
fail[next[root][i]] = root;
Q.push(next[root][i]);
}
}
while (!Q.empty()) {
int now = Q.front();
Q.pop();
Cover[now] = max(Cover[now], Cover[fail[now]]);
for (int i = 0; i < 4; i++) {
if (next[now][i] == -1)
next[now][i] = next[fail[now]][i];
else {
fail[next[now][i]] = next[fail[now]][i];
Q.push(next[now][i]);
}
}
}
}
void Solve() {
memset(Dp, 0, sizeof(Dp));
Dp[0][0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < tot; j++) {
for (int k = 0; k < 10; k++) {
for (int t = 0; t < 4; t++) {
int nowj = next[j][t], nowi = i + 1;
if (Cover[nowj] >= k + 1)
Dp[nowi][nowj][0] =
(Dp[nowi][nowj][0] + Dp[i][j][k]) % 1000000009;
else
Dp[nowi][nowj][k + 1] =
(Dp[nowi][nowj][k + 1] + Dp[i][j][k]) % 1000000009;
}
}
}
}
int Ans = 0;
for (int i = 0; i < tot; i++) Ans = (Ans + Dp[n][i][0]) % 1000000009;
printf("%d\n", Ans);
return;
}
};
AcAuto A;
char S[20];
int main() {
cin >> n >> m;
id[0] = 0;
id[2] = 1;
id['G' - 'A'] = 2;
id['T' - 'A'] = 3;
A.Init();
for (int i = 1; i <= m; i++) {
scanf("%s", S);
A.Insert(S);
}
A.Build_Failtree();
A.Solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const long long N = 5e3 + 7;
const long long M = 1e9 + 7;
const long long MAXN = 2e18 + 7;
const long long Mod = 998244353;
long long _, i, j, k, n, m, p, q, s, T, t, l, r, o, u, v, w, x, y, z, ans, nex,
sum, num, len, en, sx, sy, tx, ty, th, ma, mi, mod, op, res, flag, cas, bk,
ret, mid, now, tmp, rt;
long long a[N], b[N], dp[N][N];
char c[N], d[N];
vector<long long> g[N], h;
string s1, s2, s3;
signed main() {
long long T = 1;
while (T--) {
scanf("%lld%lld", &n, &m);
scanf("%s%s", c + 1, d + 1);
ma = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (c[i] == d[j])
dp[i][j] =
max(dp[i - 1][j - 1] + 2, max(dp[i - 1][j], dp[i][j - 1]) - 1);
else
dp[i][j] =
max(max(dp[i][j - 1], dp[i - 1][j]) - 1, dp[i - 1][j - 1] - 2);
dp[i][j] = max(0ll, dp[i][j]);
ma = max(ma, dp[i][j]);
}
}
printf("%lld\n", ma);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)2e5 + 5;
const long long mod = (long long)1e9 + 7;
const long long inf = (long long)1e18 + 7;
long long n, m, k;
long long A[N];
long long fn(long long pos) {
long long res = n - pos + 1;
long long used = 0;
while (used < m && pos <= n) {
long long cap = k;
while (pos <= n && A[pos] <= cap) {
cap -= A[pos];
pos++;
}
used++;
}
return pos == n + 1 ? res : 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) cin >> A[i];
long long l = 1, r = n;
long long res = 0;
while (l <= r) {
long long m = (l + r) >> 1;
if (fn(m)) {
res = max(res, n - m + 1);
r = m - 1;
} else
l = m + 1;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;
long long int powmod(long long int a, long long int b) {
long long int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int nxt() {
int x;
scanf("%d", &x);
return x;
}
int main() {
int tc = nxt();
while (tc--) {
int n = nxt();
long long int w;
cin >> w;
vector<long long int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> order(n);
iota((order).begin(), (order).end(), 0);
sort((order).begin(), (order).end(),
[&](int i, int j) { return a[i] < a[j]; });
long long int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
if (a[order[0]] > w || sum < (w + 1) / 2) {
puts("-1");
continue;
}
sum = 0;
vector<int> ans;
for (int i : order) {
if (sum + a[i] >= (w + 1) / 2) {
if (sum + a[i] > w) {
if (a[i] > w) {
puts("-1");
} else
printf("1\n%d\n", i + 1);
goto end;
} else {
ans.push_back(i);
printf("%d\n", ans.size());
for (int j : ans) printf("%d ", j + 1);
printf("\n");
goto end;
}
} else {
sum += a[i];
ans.push_back(i);
}
}
end:;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 3000010;
const long long INF = 1ll << 60;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
int t;
int n, m;
int a[N];
int b[N];
bool SameLine(int i, int j, int k) {
long long dx1 = a[j] - a[i];
long long dy1 = b[j] - b[i];
long long dx2 = a[k] - a[i];
long long dy2 = b[k] - b[i];
return !(dx1 * dy2 - dx2 * dy1);
}
bool Ok(int id1, int id2) {
int id3 = -1, id4 = -1;
bool flag = true;
for (int i = 1; i <= n; ++i) {
if (!SameLine(id1, id2, i)) {
if (id3 == -1)
id3 = i;
else if (id4 == -1)
id4 = i;
else {
if (!SameLine(id3, id4, i)) {
flag = false;
break;
}
}
}
}
return flag;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i], &b[i]);
}
if (n <= 2) {
printf("YES\n");
} else {
if (Ok(1, 2) || Ok(1, 3) || Ok(2, 3))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAX_N = 1e6 + 55;
using namespace std;
long long ans = 0;
int f[MAX_N][8];
char a[MAX_N];
char b[MAX_N];
int l, r, x, y, n, m;
int main() {
scanf("%s", a);
scanf("%s", b);
for (n = 0; a[n]; n++) a[n] %= 3;
for (m = 0; b[m]; m++) b[m] %= 3;
for (int i = 1; i < n; i++) {
memcpy(f[i], f[i - 1], 32);
if (a[i] != a[i - 1]) {
++f[i][(a[i] < a[i - 1]) * 4 + a[i] + a[i - 1]];
}
}
memcpy(f[n], f[n - 1], 32);
for (int i = 0; i < m; i++) {
if (i && b[i] != b[i - 1]) {
int x = (b[i] > b[i - 1]) * 4 + b[i] + b[i - 1];
ans -= f[r][x] - f[l][x];
}
while (r < n && a[r] != b[i]) ++r;
ans += r - l + 1 - (r == n);
if (r < n) ++r;
if (l < r && a[l] == b[i]) ++l;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int arr[100001], min = INT_MAX, minInd = -1, i, j, n;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] >= 0) {
arr[i] = -arr[i] - 1;
}
if (min > arr[i]) {
min = arr[i];
minInd = i;
}
}
if (n % 2 == 1) {
arr[minInd] = -arr[minInd] - 1;
}
for (i = 0; i < n; i++) {
cout << arr[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long power(long long B, long long P) {
if (P == 0) return 1;
long long X = power(B, P / 2);
if (P % 2 == 0)
return X * X;
else
return B * X * X;
}
long long fx4[] = {1, -1, 0, 0};
long long fy4[] = {0, 0, 1, -1};
long long A[300005];
int main() {
long long T, N, M, X, Y, W, K, Q, R, P;
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
vector<long long> ans;
string S;
long long i = 1, j = N;
long long mm = 1;
while (mm <= (min(N, 2000005))) {
if (mm == 1) {
if (A[i] < A[j]) {
S += 'L';
ans.push_back(A[i]);
i++;
} else {
S += 'R';
ans.push_back(A[j]);
j--;
}
mm++;
continue;
}
X = ans[ans.size() - 1];
if (A[i] < A[j] && A[i] > X) {
ans.push_back(A[i]);
S += 'L';
i++;
} else if (A[j] < A[i] && A[j] > X) {
ans.push_back(A[j]);
S += 'R';
j--;
} else {
if (A[i] > X) {
ans.push_back(A[i]);
i++;
S += 'L';
} else if (A[j] > X) {
ans.push_back(A[j]);
j--;
S += 'R';
}
}
mm++;
}
cout << ans.size() << endl;
cout << S << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const long long mod = 1000000007;
void Open() {}
long long fac[100010], inv[100010];
long long n;
long long pow_mod(long long x, long long k, long long mod) {
int res = 1;
while (k) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
k >>= 1;
}
return res;
}
long long get(int x) {
return fac[n] * inv[x] % mod * inv[n - x] % mod * pow_mod(20, x, mod) % mod *
pow_mod(27, n - x, mod);
}
int main() {
scanf("%I64d", &n);
fac[0] = 1, inv[0] = pow_mod(fac[0], mod - 2, mod);
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % mod, inv[i] = pow_mod(fac[i], mod - 2, mod);
long long mul = -1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
mul *= -1;
ans = (ans + mul * get(i) % mod) % mod;
}
printf("%I64d\n", (ans + mod) % mod);
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.