solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
const int INF = (int)1e9 + 7, N = (int)1e5 + 123;
const double eps = 1e-9;
int x, mini = INF;
int p[(int)1e6 + 123];
vector<int> pr;
inline void check(int x) {
for (int i = 0; pr[i] * pr[i] <= x; i++) {
if (x % pr[i] == 0) {
if (pr[i] < x - pr[i] + 1 && x - pr[i] + 1 > 2)
mini = (mini) < (x - pr[i] + 1) ? (mini) : (x - pr[i] + 1);
if (x / pr[i] < x - x / pr[i] + 1 && x - x / pr[i] + 1 > 2 &&
!p[x / pr[i]])
mini = (mini) < (x - x / pr[i] + 1) ? (mini) : (x - x / pr[i] + 1);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
for (int i = 2; i <= 1e6; i++) {
if (!p[i]) {
pr.push_back(i);
for (ll j = i + i; j <= 1e6; j += i) {
p[j] = i;
}
}
}
cin >> x;
for (int i = x - p[x] + 1; i <= x; i++) {
if (!p[i] && i > 2) mini = (mini) < (i) ? (mini) : (i);
if (p[i] && i - p[i] + 1 > 2)
mini = (mini) < (i - p[i] + 1) ? (mini) : (i - p[i] + 1);
}
cout << mini;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, ans = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return f * ans;
}
const long long MAXN = 1e5 + 11;
long long N, rt, siz[MAXN], Ans;
vector<long long> vec[MAXN];
void dfs(long long u, long long fath, long long opt) {
long long Maxn = 0;
siz[u] = 1;
for (auto v : vec[u]) {
if (v == fath) continue;
dfs(v, u, opt);
siz[u] += siz[v];
Maxn = max(Maxn, siz[v]);
}
Maxn = max(Maxn, N - siz[u]);
if (!opt)
if (!Ans || Maxn < Ans) Ans = Maxn, rt = u;
return;
}
long long sta[MAXN], nex[MAXN];
void dfs1(long long u, long long fath) {
sta[++sta[0]] = u;
for (auto v : vec[u])
if (v != fath) dfs1(v, u);
}
signed main() {
N = read();
for (long long i = 1; i < N; i++) {
long long u = read(), v = read();
vec[u].push_back(v), vec[v].push_back(u);
}
dfs(1, 0, 0);
dfs(rt, 0, 1);
long long Ans = 0;
for (long long i = 1; i <= N; i++) Ans += 2 * min(siz[i], N - siz[i]);
printf("%lld\n", Ans);
for (auto u : vec[rt]) dfs1(u, rt);
sta[++sta[0]] = rt;
long long e = (N / 2);
for (long long i = 1; i <= e; i++) {
long long u = sta[i], v = sta[i + e];
nex[u] = v, nex[v] = u;
}
if (N & 1) {
long long u = sta[1], v = sta[1 + e], x = rt;
nex[u] = v, nex[v] = rt, nex[rt] = u;
}
for (long long i = 1; i <= N; i++) printf("%lld ", nex[i]);
printf("\n");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b;
map<long long, long long> mp;
vector<long long> pos(100007, 0);
long long funct(long long st, long long ed) {
if (ed - st + 1 == 1) {
if (mp.find(st) == mp.end())
return a;
else {
return (b * mp[st]);
}
}
long long diff = ed - st + 1;
long long c;
long long idx1 = lower_bound(pos.begin(), pos.begin() + k, st) - pos.begin();
long long idx2 = upper_bound(pos.begin(), pos.begin() + k, ed) - pos.begin();
long long no = 0;
idx2--;
if ((idx1 < k && idx1 >= 0) && (idx2 < k && idx2 >= 0) && (idx1 <= idx2)) {
if (pos[idx1] < st) {
if (idx1 + 1 < k)
idx1++;
else
idx1 = -1;
}
if (pos[idx2] > ed) {
if (idx2 - 1 >= 0)
idx2--;
else
idx2 = -1;
}
if ((idx1 < k && idx1 >= 0) && (idx2 < k && idx2 >= 0) && (idx1 <= idx2))
no = idx2 - idx1 + 1;
else
no = 0;
}
if (no == 0) {
return a;
}
c = b * no * diff;
long long c1 = funct(st, st + (diff / 2) - 1),
c2 = funct(st + (diff / 2), ed);
return min(c, (c1 + c2));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> a >> b;
for (long long i = 0; i < k; i++) {
long long a1;
cin >> a1;
pos[i] = a1;
mp[a1]++;
}
sort(pos.begin(), pos.begin() + k);
cout << funct(1, pow(2, n));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r;
cin >> n >> m >> l >> r;
vector<int> s, v;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
s.push_back(t);
}
for (int i = 0; i < m; i++) {
int t;
cin >> t;
v.push_back(t);
}
int i = 0, j = 0, x = 0;
int a[100007][2];
while (i < n && j < m) {
if (v[j] <= s[i] + r && v[j] >= s[i] - l) {
a[x][0] = i + 1;
a[x][1] = j + 1;
i++;
j++;
x++;
} else {
if (s[i] + r < v[j])
i++;
else
j++;
}
}
cout << x << endl;
for (int t = 0; t < x; t++) {
cout << a[t][0] << ' ' << a[t][1];
if (t < x - 1) cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1;
cin >> s >> s1;
int count_4s = 0, count_7s = 0;
int count_4s1 = 0, count_7s1 = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != s1[i]) {
if (s[i] == '4') count_4s++;
if (s1[i] == '4') count_4s1++;
if (s[i] == '7') count_7s++;
if (s1[i] == '7') count_7s1++;
}
}
int nums = max(count_4s, count_7s);
cout << nums << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 10;
const long long mo = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return (gcd(b, a % b));
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - a / b * y;
return g;
}
long long mp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % mo;
a = a * a % mo;
b >>= 1;
}
return ans;
}
struct qw {
long long id, va;
} a[200010];
bool cmp(qw a, qw b) { return a.va < b.va; }
stack<long long> b;
int main() {
long long n, i, j, k, m, t = 0, pd = 1, ans = 0, mn = 0, ps, q;
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i].va);
a[i].id = i;
}
sort(a + 1, a + 1 + n, cmp);
j = 1;
k = 1;
for (i = 0; i < 2 * n; i++) {
scanf("%1lld", &t);
if (t == 0) {
printf("%lld ", a[j].id);
b.push(a[j].id);
j++;
} else {
printf("%lld ", b.top());
b.pop();
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 250 + 5;
int a[MAXN][MAXN], n, m;
char s[MAXN];
bool vis[MAXN][MAXN];
int bel[MAXN][MAXN];
int cnt, ts;
int mnx, mny, mxx, mxy;
inline void dfs(int x, int y) {
vis[x][y] = 1;
++cnt;
bel[x][y] = ts;
mnx = std::min(mnx, x);
mxx = std::max(mxx, x);
mny = std::min(mny, y);
mxy = std::max(mxy, y);
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (!dx && !dy) continue;
int xx = x + dx, yy = y + dy;
if (xx < 1 || xx > n || yy < 1 || yy > m || !a[xx][yy] || vis[xx][yy])
continue;
dfs(xx, yy);
}
}
}
inline void Solve() {
scanf("%d%d", &n, &m);
ts = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j) {
a[i][j] = s[j] - '0';
vis[i][j] = 0;
bel[i][j] = 0;
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (!a[i][j] || vis[i][j]) continue;
cnt = 0;
mxx = mnx = i;
mxy = mny = j;
++ts;
dfs(i, j);
if (cnt <= 1) continue;
if (mxx - mnx != mxy - mny) continue;
bool flag;
if (bel[mnx][mny] == ts && bel[mxx][mxy] == ts) {
flag = (cnt == 4 * (mxx - mnx));
for (int i = mnx; i <= mxx; ++i) flag &= a[i][mny] & a[i][mxy];
for (int i = mny; i <= mxy; ++i) flag &= a[mnx][i] & a[mxx][i];
} else {
flag = (cnt == 2 * (mxx - mnx)) && (mxx - mnx >= 2) && (mxy - mny >= 2);
int midx = (mxx + mnx) / 2, midy = (mxy + mny) / 2;
auto pd = [&](int x1, int y1, int x2, int y2) {
bool flag = 1;
if (x1 + y1 == x2 + y2) {
for (int i = x1; i <= x2; ++i) flag &= a[i][x1 + y1 - i];
} else {
for (int i = x1; i <= x2; ++i) flag &= a[i][i + y1 - x1];
}
return flag;
};
flag &= pd(mnx, midy, midx, mny) & pd(mnx, midy, midx, mxy) &
pd(midx, mny, mxx, midy) & pd(midx, mxy, mxx, midy);
}
ans += flag;
}
}
printf("%d\n", ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) Solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int add(int a, int b) {
long long x = a + b;
if (x >= 1000000007) x -= 1000000007;
if (x < 0) x += 1000000007;
return x;
}
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand_seed() {
long long a = rng();
return a;
}
int t, n, mb, p;
int vv[20000002];
int aib[100002], mxx[100002], lu[100002];
void upd(int nod, int val) {
for (; nod <= mb; nod += (nod & (-nod))) aib[nod] = max(aib[nod], val);
}
int compute(int nod) {
int ans = 0;
for (; nod; nod -= (nod & (-nod))) ans = max(ans, aib[nod]);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t >> n >> mb >> p;
for (; t; --t) {
for (int j = 1; j <= n; ++j) cin >> vv[j];
int maxx = n;
for (int j = 1; j < min(p, mb); ++j)
for (int x = 1; x <= n; ++x) vv[j * n + x] = vv[x], maxx = j * n + x;
int ans = 0;
for (int j = 1; j <= maxx; ++j) {
int bk = j / n + (j % n > 0);
if (mxx[vv[j]] != vv[j]) {
if (mb <= 500 && lu[j] < bk - 1) continue;
int ax = 1 + compute(vv[j] - 1);
if (ax > mxx[vv[j]]) mxx[vv[j]] = ax, upd(vv[j], ax);
ans = max(ans, ax);
if (mb <= 500)
for (int p = vv[j]; p <= mb; ++p) lu[p] = j / n + (j % n > 0);
}
}
cout << ans << '\n';
memset(aib, 0, sizeof(aib));
memset(mxx, 0, sizeof(mxx));
memset(lu, 0, sizeof(lu));
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, k;
const int N = 200020;
long long dp[N];
int qpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return res;
}
void solve() {
cin >> n >> k;
long long ans = qpow(2, n - 1);
if (n & 1) {
int t1 = (qpow(2, n - 1) + 1) % mod;
cout << qpow(t1, k) << endl;
} else {
long long res = 0;
for (int i = 0; i < k; ++i) {
res = (res +
1ll * qpow(ans * 2 % mod, i) * qpow(ans - 1, k - i - 1) % mod) %
mod;
}
res = (res + qpow(ans - 1, k)) % mod;
cout << res << endl;
}
}
int T = 1;
signed main() {
cin >> T;
while (T--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
string s, t;
cin >> t;
int m;
cin >> m;
vector<int> f(26), b(m);
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < t.length(); i++) {
f[t[i] - 'a']++;
}
vector<char> ans(m);
int done = 0;
while (1) {
if (done == m) break;
int cnt = 0;
vector<int> adj;
for (int i = 0; i < m; i++) {
if (b[i] == 0) {
adj.push_back(i);
cnt++;
}
}
done += cnt;
int ch;
for (int i = 25; i >= 0; i--) {
if (f[i] >= cnt) {
ch = i;
f[i] = 0;
break;
} else
f[i] = 0;
}
for (int i = 0; i < m; i++) {
if (b[i] == 0) {
ans[i] = ((char)('a' + ch));
}
}
for (int k : adj) {
b[k] = -1;
for (int i = 0; i < m; i++) {
int p = abs(k - i);
b[i] -= p;
}
}
}
for (char c : ans) cout << c;
cout << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const int N = 1e5;
int a[24], b[24];
int solved() {
for (int i = 0; i < 6; ++i) {
bool f = 0;
for (int j = 0; j < 4; ++j) {
if (b[i * 4 + j] != b[i * 4]) return 0;
}
}
return 1;
}
void moveU() {
for (int i = 0; i < 24; ++i) b[i] = a[i];
int c[] = {13, 14, 5, 6, 17, 18, 21, 22};
int d[] = {5, 6, 17, 18, 21, 22, 13, 14};
for (int i = 0; i < 8; ++i) b[c[i] - 1] = a[d[i] - 1];
}
void moveUpr() {
for (int i = 0; i < 24; ++i) b[i] = a[i];
int c[] = {5, 6, 17, 18, 21, 22, 13, 14};
int d[] = {13, 14, 5, 6, 17, 18, 21, 22};
for (int i = 0; i < 8; ++i) b[c[i] - 1] = a[d[i] - 1];
}
void moveR() {
for (int i = 0; i < 24; ++i) b[i] = a[i];
int c[] = {2, 4, 6, 8, 10, 12, 21, 23};
int d[] = {6, 8, 10, 12, 23, 21, 4, 2};
for (int i = 0; i < 8; ++i) b[c[i] - 1] = a[d[i] - 1];
}
void moveRpr() {
for (int i = 0; i < 24; ++i) b[i] = a[i];
int c[] = {6, 8, 10, 12, 23, 21, 4, 2};
int d[] = {2, 4, 6, 8, 10, 12, 21, 23};
for (int i = 0; i < 8; ++i) b[c[i] - 1] = a[d[i] - 1];
}
void moveF() {
for (int i = 0; i < 24; ++i) b[i] = a[i];
int c[] = {3, 4, 17, 19, 10, 9, 16, 14};
int d[] = {16, 14, 3, 4, 17, 19, 10, 9};
for (int i = 0; i < 8; ++i) b[c[i] - 1] = a[d[i] - 1];
}
void moveFpr() {
for (int i = 0; i < 24; ++i) b[i] = a[i];
int c[] = {16, 14, 3, 4, 17, 19, 10, 9};
int d[] = {3, 4, 17, 19, 10, 9, 16, 14};
for (int i = 0; i < 8; ++i) b[c[i] - 1] = a[d[i] - 1];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 0; i < 24; ++i) cin >> a[i];
moveU();
if (solved()) {
cout << "YES" << '\n';
return 0;
}
moveUpr();
if (solved()) {
cout << "YES" << '\n';
return 0;
}
moveRpr();
if (solved()) {
cout << "YES" << '\n';
return 0;
}
moveR();
if (solved()) {
cout << "YES" << '\n';
return 0;
}
moveF();
if (solved()) {
cout << "YES" << '\n';
return 0;
}
moveFpr();
if (solved()) {
cout << "YES" << '\n';
return 0;
}
cout << "NO" << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400005;
const long long MOD = 998244353;
const long long G = 3, Ginv = 332748118, Inv2 = 499122177;
template <typename T>
inline void read(T &a) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
a = flag * x;
}
long long ksm(long long x, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret = (ret * x) % MOD;
x = (x * x) % MOD;
k >>= 1;
}
return ret;
}
int N, M, rev[MAXN];
long long cnt[MAXN], ans[MAXN], A[MAXN], B[MAXN], C[MAXN], D[MAXN];
void NTT(long long *a, int len, int type) {
for (int i = 0; i < len; ++i) {
if (i < rev[i]) {
swap(a[i], a[rev[i]]);
}
}
for (int i = 1; i < len; i <<= 1) {
int p = i << 1;
long long wn = ksm((type == 1) ? G : Ginv, (MOD - 1) / p);
for (int j = 0; j < len; j += p) {
long long wnk = 1;
for (int k = 0; k < i; ++k) {
long long A1 = a[j + k], A2 = wnk * a[j + k + i] % MOD;
a[j + k] = (A1 + A2) % MOD;
a[j + k + i] = (A1 - A2 + MOD) % MOD;
wnk = wnk * wn % MOD;
}
}
}
if (type == -1) {
long long Ninv = ksm(len, MOD - 2);
for (int i = 0; i < len; ++i) {
a[i] = a[i] * Ninv % MOD;
}
}
}
void Inv(int n, long long *a, long long *b) {
if (n == 1) {
b[0] = ksm(a[0], MOD - 2);
return;
}
Inv(n >> 1, a, b);
int m = (n << 1), len, bit;
for (len = 1, bit = 0; len < m; len <<= 1) ++bit;
for (int i = 0; i < len; ++i) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
}
copy(a, a + n, C);
fill(C + n, C + len, 0);
NTT(b, len, 1);
NTT(C, len, 1);
for (int i = 0; i < len; ++i) {
b[i] = ((long long)2 - C[i] * b[i] % MOD + MOD) % MOD * b[i] % MOD;
}
NTT(b, len, -1);
fill(b + n, b + len, 0);
}
void Sqrt(int n, long long *a, long long *b) {
if (n == 1) {
b[0] = a[0];
return;
}
Sqrt(n >> 1, a, b);
Inv(n, b, D);
int m = (n << 1), len, bit;
for (len = 1, bit = 0; len < m; len <<= 1) ++bit;
for (int i = 0; i < len; ++i) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
}
copy(a, a + n, C);
fill(C + n, C + len, 0);
NTT(D, len, 1);
NTT(C, len, 1);
for (int i = 0; i < len; ++i) {
D[i] = D[i] * C[i] % MOD;
}
NTT(D, len, -1);
for (int i = 0; i < n; ++i) {
b[i] = (b[i] + D[i]) % MOD * Inv2 % MOD;
}
fill(D + 0, D + len, 0);
}
void solve() {
read(N);
read(M);
for (int i = 1; i <= N; ++i) {
int x;
read(x);
++cnt[x];
}
int len = 1;
while (len <= M) len <<= 1;
for (int i = 0; i < len; ++i) {
cnt[i] = (MOD - cnt[i] * 4) % MOD;
}
++cnt[0];
Sqrt(len, cnt, B);
B[0] = (B[0] + 1) % MOD;
Inv(len, B, A);
for (int i = 1; i <= M; ++i) {
printf("%lld\n", A[i] * 2 % MOD);
}
}
int main() {
solve();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int inf = 1e9 + 7;
int n, m;
int a[500005];
int q[2000006];
pair<int, int> g[2000006];
map<int, int> p;
pair<int, int> get(int v, int lr, int rl, int l, int r) {
if (rl < l || lr > r || q[v] > r) return make_pair(inf, inf);
if (lr >= l && rl <= r && g[v].second <= r) return g[v];
int mid = (lr + rl) / 2;
pair<int, int> x = get(v * 2, lr, mid, l, r);
pair<int, int> y = get(v * 2 + 1, mid + 1, rl, l, r);
if (x.second > r && y.second > r) return make_pair(inf, inf);
if (x.second > r) return y;
if (y.second > r) return x;
if (x.first <= y.first) return x;
return y;
}
void upd(int v) {
if (g[v * 2].first <= g[v * 2 + 1].first)
g[v] = g[v * 2];
else
g[v] = g[v * 2 + 1];
q[v] = min(q[v * 2], q[v * 2 + 1]);
if (v != 1) upd(v / 2);
}
int main() {
scanf("%d %d", &n, &m);
int z = 1;
while (z < n) z *= 2;
for (int i = 1; i < 2 * z; ++i) {
g[i] = make_pair(inf, inf);
q[i] = inf;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (p[a[i]]) {
g[z - 1 + p[a[i]]] = make_pair(i - p[a[i]], i);
q[z - 1 + p[a[i]]] = i;
upd((z - 1 + p[a[i]]) / 2);
}
p[a[i]] = i;
}
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d %d", &l, &r);
pair<int, int> ans = get(1, 1, z, l, r);
if (ans.first >= inf)
puts("-1");
else
printf("%d\n", ans.first);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, l, ans;
long long int cal(long long int a, long long int b, long long int c,
long long int l) {
long long int ans = 0;
for (long long int i = ((b + c - a) > (0) ? (b + c - a) : (0)); i <= l; ++i)
ans += (1 + ((l - i) < (a + i - b - c) ? (l - i) : (a + i - b - c))) *
(2 + ((l - i) < (a + i - b - c) ? (l - i) : (a + i - b - c))) / 2;
return ans;
}
int main() {
cin >> a >> b >> c >> l;
for (long long int i = 0; i <= l; ++i) ans += (i + 1) * (i + 2) / 2;
ans -= cal(a, b, c, l) + cal(b, a, c, l) + cal(c, a, b, l);
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int inv = numeric_limits<int>::max();
vector<vector<int> > mmul(vector<vector<int> > A, vector<vector<int> > B) {
int N = A.size();
vector<vector<int> > res(N, vector<int>(N, inv));
for (int i = 0; i < (N); i++)
for (int j = 0; j < (N); j++)
for (int k = 0; k < (N); k++)
if (A[i][k] != inv and B[k][j] != inv)
res[i][j] = min(res[i][j], A[i][k] + B[k][j]);
return res;
}
vector<vector<int> > power(vector<vector<int> > A, int k) {
int N = A.size();
vector<vector<int> > res(N, vector<int>(N));
if (!k) {
for (int i = 0; i < (N); i++)
for (int j = 0; j < (N); j++)
if (i == j)
res[i][j] = 0;
else
res[i][j] = inv;
return res;
}
res = power(A, k >> 1);
res = mmul(res, res);
if (k & 1) res = mmul(res, A);
return res;
}
const int max_n = 25;
int n, m;
int a[max_n], b[max_n];
int dp[max_n][2 * max_n][2 * max_n];
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
for (int i = 0; i < (n); i++) scanf("%d", &b[i]);
for (int i = 0; i < (2 * n + 1); i++)
for (int j = 0; j < (2 * n + 1); j++) dp[0][i][j] = ((i == j) ? 0 : inv);
for (int l = (1); l <= (n); l++)
for (int i = 0; i < (2 * n + 1); i++)
for (int j = 0; j < (2 * n + 1); j++) {
dp[l][i][j] = inv;
if (j > 0 and dp[l - 1][i][j - 1] != inv)
dp[l][i][j] = min(dp[l][i][j], dp[l - 1][i][j - 1] + a[l - 1]);
if (j < 2 * n and dp[l - 1][i][j + 1] != inv)
dp[l][i][j] = min(dp[l][i][j], dp[l - 1][i][j + 1] + b[l - 1]);
}
vector<vector<int> > T(2 * n + 1, vector<int>(2 * n + 1));
for (int i = 0; i < (2 * n + 1); i++)
for (int j = 0; j < (2 * n + 1); j++) T[i][j] = dp[n][i][j];
vector<vector<int> > res = power(T, m);
printf("%d\n", res[0][0]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, ans = 0;
cin >> n >> m;
for (int i = 2; i <= n; i += 2)
for (int j = 2; j <= m; j += 2) ans += (m - j + 1) * (n - i + 1);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, K;
bool a[6][105];
int main() {
cin >> n >> K;
int mid = (1 + n) / 2;
if (K % 2 == 0) {
int k = K / 2;
for (int i = 1; i <= (1 + k) / 2; i++)
a[2][mid - i + 1] = 1, a[3][mid - i + 1] = 1;
for (int i = 1; i <= k - (1 + k) / 2; i++)
a[2][mid + i] = 1, a[3][mid + i] = 1;
} else if (K <= n - 2) {
int k = K;
for (int i = 1; i <= (1 + k) / 2; i++) a[2][mid - i + 1] = 1;
for (int i = 1; i <= k - (1 + k) / 2; i++) a[2][mid + i] = 1;
} else {
for (int i = 2; i <= n - 1; i++) a[2][i] = a[3][i] = 1;
int k = n - K + n - 4;
for (int i = 1; i <= (1 + k) / 2; i++) a[3][mid - i + 1] = 0;
for (int i = 1; i <= k - (1 + k) / 2; i++) a[3][mid + i] = 0;
}
puts("YES");
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++)
if (a[i][j])
cout << '#';
else
cout << '.';
puts("");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, sum = 0.00, i, n;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b;
sum += b;
}
sum /= i;
sum += 5.00;
printf("%.3lf", sum);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
string s[300003], h, cur, l, r;
int n;
bool ok = 0, q = 0;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n;
cin >> h;
for (int i = 0; i < n; i++) cin >> s[i];
while (true) {
q = 0;
for (int i = 0; i < n; i++) {
if (s[i] != "-") {
l = s[i].substr(0, 3);
r = s[i].substr(5, 3);
if (l == h) {
s[i] = "-";
q = 1;
break;
}
}
}
ok = 0;
if (!q) {
cout << "home\n";
break;
}
for (int i = 0; i < n; i++) {
if (s[i] != "-") {
if (r == s[i].substr(0, 3) && s[i].substr(5, 3) == h) {
ok = 1;
s[i] = "-";
break;
}
}
}
if (!ok) {
cout << "contest\n";
break;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin >> n >> k;
if (n > k * (k - 1)) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
long long num = 0;
if (k % 2) {
for (int i = 1; i <= k / 2 && num < n; i++) {
for (int j = 1; j <= k && num < n; j++) {
cout << j << " " << (((j + i) % k) ? (j + i) % k : k) << endl;
num++;
}
}
for (int i = k / 2; i >= 1 && num < n; i--) {
for (int j = k; j >= 1 && num < n; j--) {
cout << (((j + i) % k) ? (j + i) % k : k) << " " << j << endl;
num++;
}
}
return 0;
}
for (int i = 1; i <= k / 2 && num < n; i++) {
if (i == k / 2) {
for (int j = 1; j <= k / 2 && num < n; j++) {
cout << j << " " << (((j + i) % k) ? (j + i) % k : k) << endl;
num++;
}
break;
}
for (int j = 1; j <= k && num < n; j++) {
cout << j << " " << (((j + i) % k) ? (j + i) % k : k) << endl;
num++;
}
}
for (int i = k / 2; i >= 1 && num < n; i--) {
if (i == k / 2) {
for (int j = k / 2; j >= 1 && num < n; j--) {
cout << (((j + i) % k) ? (j + i) % k : k) << " " << j << endl;
num++;
}
continue;
}
for (int j = k; j >= 1 && num < n; j--) {
cout << (((j + i) % k) ? (j + i) % k : k) << " " << j << endl;
num++;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, count, n;
int flag = 1;
char fst[101];
char ans[101];
char sec[101];
char *a = NULL;
scanf("%s", fst);
scanf("%s", ans);
for (i = 0; i < strlen(ans); ++i) {
if (fst[i] < ans[i]) {
printf("-1");
return 0;
} else {
if (fst[i] == ans[i]) {
sec[i] = fst[i] + 1;
if (sec[i] == ('z' + 1)) sec[i]--;
} else {
sec[i] = ans[i];
}
}
}
sec[strlen(ans)] = 0;
int end = strlen(fst) - 1;
printf("%s", sec);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> p, m;
int main() {
int n;
cin >> n;
if (n == 1) {
int x;
cin >> x;
cout << x << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x > 0)
p.push_back(x);
else if (x < 0)
m.push_back(x);
}
if ((p.size() == 0 && m.size() == 0) || (m.size() == 1 && p.size() == 0)) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < p.size(); i++) cout << p[i] << " ";
sort(m.begin(), m.end());
reverse(m.begin(), m.end());
if (m.size() % 2)
for (int i = 1; i < m.size(); i++) cout << m[i] << " ";
else
for (int i = 0; i < m.size(); i++) cout << m[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int Q[110], n;
string goal = "", P = "", PP = "";
char ret1[110], ret2[110];
inline string go(string s) {
for (int x = 0; x < n; x++) ret1[x] = s[Q[x]];
return ret1;
}
inline string goo(string s) {
for (int x = 0; x < n; x++) ret2[Q[x]] = s[x];
return ret2;
}
int main() {
int k, x, y;
scanf("%d", &n);
;
scanf("%d", &k);
;
for (int x = 0; x < n; x++) {
scanf("%d", &Q[x]);
;
Q[x]--;
}
for (int x = 1; x <= n; x++) P.push_back(x);
for (int x = 1; x <= n; x++) {
int p;
scanf("%d", &p);
;
goal.push_back(p);
}
PP = P;
for (x = 0; x <= k and P != goal; x++, P = go(P))
;
for (y = 0; y <= k and PP != goal; y++, PP = goo(PP))
;
if ((k - x) % 2 && (k - y) % 2 || x == 0 || (k > 1 && x == 1 && y == 1))
puts("NO");
else
puts("YES");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, int> coun;
set<long long int> g;
int main() {
long long int b, d, l, m;
int i;
long long int u;
int terms = 0;
cin >> b >> d >> l >> m;
for (i = 0; i < m; i++) {
cin >> u;
coun[u] = 1;
}
if (b == 0) {
if (coun[0] == 1)
cout << "0";
else
cout << "inf";
} else if (d == 0) {
if (coun[0] == 1) {
if (coun[b] == 1)
cout << "0";
else if (abs(b) <= l)
cout << "1";
else
cout << "0";
} else {
if (abs(b) > l)
cout << "0";
else
cout << "inf";
}
} else if (d == 1) {
if (coun[b] == 0 && abs(b) <= l)
cout << "inf";
else
cout << "0";
} else if (d == -1) {
if (coun[b] == 1 && coun[-1 * b * 1LL] == 1)
cout << "0";
else if (abs(b) <= l)
cout << "inf";
else
cout << "0";
} else {
u = b;
long long int k;
for (i = 0; i <= 30; i++) {
k = b * pow(d, i);
if (coun[k] == 0 && abs(k) <= l) terms++;
if (abs(k) > l) break;
}
cout << terms;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
register int x = 0, f = 1;
register char ch = nc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = nc();
}
while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = nc();
return x * f;
}
inline void write(register int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
int n, a[300005];
long long ans, sm;
long long bl1[5005], bl2[5005];
long long tr1[300005 * 20], tr2[300005 * 20];
void modify(int x) {
for (int i = x / 560; i < 560; ++i) ++bl1[i], bl2[i] += x;
int rb = (x / 560 + 1) * 560;
for (int i = x; i < rb; ++i) ++tr1[i], tr2[i] += x;
}
long long qry1(int x) { return (x >= 560 ? bl1[x / 560 - 1] : 0) + tr1[x]; }
long long qry2(int x) { return (x >= 560 ? bl2[x / 560 - 1] : 0) + tr2[x]; }
long long rqry1(int l, int r) { return qry1(r) - qry1(l - 1); }
long long rqry2(int l, int r) { return qry2(r) - qry2(l - 1); }
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
ans += sm;
ans += 1ll * a[i] * (i - 1);
for (int l = 1, r; l < a[i]; l = r + 1) {
r = a[i] / (a[i] / l);
if (r == a[i]) r = a[i] - 1;
ans -= rqry2(l, r) * (a[i] / l);
}
for (int l = a[i], r = 2 * a[i] - 1, cnt = 1; l <= 300000;
l += a[i], r += a[i], ++cnt)
ans -= rqry1(l, min(r, 300000)) * a[i] * cnt;
modify(a[i]);
sm += a[i];
printf("%lld ", ans);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
long long inf = 1LL << 60;
long long mod = 1000000007;
using namespace std;
int main(void) {
long double n;
cin >> n;
long double ans = n * (n - 1) * (n - 2) * (n - 3) * (n - 4) * n * (n - 1) *
(n - 2) * (n - 3) * (n - 4) / (5 * 4 * 3 * 2);
cout << fixed << setprecision(0) << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool gt(long double a, long double b) { return a > b + 1e-9; }
string a, b;
int fa[26], fb[26];
int main() {
ios::sync_with_stdio(false);
cin >> a >> b;
for (int same = min(((int)(a).size()), ((int)(b).size())); same >= 0;
same--) {
memset(fa, 0, sizeof fa);
memset(fb, 0, sizeof fb);
for (register int i = (0); i < (int)(same); ++i) fb[b[i] - 'a']++;
for (register int i = (0); i < (int)(((int)(a).size())); ++i)
fa[a[i] - 'a']++;
bool ok = true;
for (register int i = (0); i < (int)(26); ++i)
if (fa[i] < fb[i])
ok = false;
else
fa[i] -= fb[i];
if (!ok) continue;
string tmp = b.substr(0, same);
for (register int i = (0); i < (int)(26); ++i)
if (i + 'a' > b[same] && fa[i] > 0) {
fa[i]--;
tmp += char(i + 'a');
break;
}
for (register int i = (0); i < (int)(26); ++i)
while (fa[i]--) tmp += char(i + 'a');
if (tmp > b) {
cout << tmp << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int tf, fy, hn, n, c, i, a[100000];
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
c = 1;
tf = 0;
hn = 0;
fy = 0;
for (i = 0; i < n; i++) {
if (a[i] == 25)
tf++;
else if (a[i] == 50) {
if (tf < 1) {
c = 0;
break;
} else {
tf--;
fy++;
}
} else if (a[i] == 100) {
if (tf >= 1 && fy >= 1) {
tf--;
fy--;
} else if (tf >= 3) {
tf -= 3;
} else {
c = 0;
break;
}
}
}
if (c == 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
int n = s.size();
vector<int> v[26];
for (int i = int(0); i <= int(n - 1); i++) v[s[i] - 'a'].push_back(i);
double ans = 0;
for (int i = int(0); i <= int(25); i++) {
int mx = 0;
for (int j = int(1); j <= int(n - 1); j++) {
int tl = 0;
int cnt[26] = {0};
for (auto it : v[i]) cnt[s[(it + j) % n] - 'a']++;
for (int k = int(0); k <= int(25); k++)
if (cnt[k] == 1) tl++;
mx = max(mx, tl);
}
ans += mx;
}
cout << setprecision(15) << ans / n;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5020;
char bb[MAX], buf[10][MAX];
int an[MAX];
int ss[MAX], sn;
int main() {
for (int i = 0; i < 10; i++) {
scanf("%s", buf[i]);
}
sn = 0;
memset(an, 0, sizeof(an));
int len = 0, n = 0, cur = 0;
for (int i = 0; i < 10; i++) {
if (buf[i][0] == 0)
break;
else {
int l1 = strlen(buf[i]);
for (int j = 0; j < l1; j++) bb[len++] = buf[i][j];
}
}
bb[len] = 0;
for (int i = 0; i < len; i++) {
if (bb[i] == '<') {
if (bb[i + 1] == '/') {
if (bb[i + 3] == 'a') {
sn--;
}
} else {
if (bb[i + 2] == 'a') {
ss[sn++] = cur++;
n = std::max(n, cur);
} else if (bb[i + 2] == 'd') {
an[ss[sn - 1]]++;
}
}
}
}
std::sort(an, an + n);
for (int i = 0; i < n; i++) printf("%d ", an[i]);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long i, j, k;
char x;
for (i = 0; i < t; i++) {
long long n, a, b;
cin >> n >> a >> b;
long long z = n % b;
long long w = n / b;
for (j = 0; j < w * b; j = j + b) {
for (k = 0; k < b; k++) {
x = 'a' + k;
cout << x;
}
}
for (j = 0; j < z; j++) {
x = 'a' + j;
cout << x;
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
template <typename T>
struct fenwick {
int length;
vector<T> tree;
fenwick(int size) {
length = size + 1;
tree.assign(length + 1, 0);
}
fenwick(vector<T>& v) {
length = v.size() + 1;
tree.assign(length + 1, 0);
for (int i = 0; i < v.size(); i++) update(i, v[i]);
}
void update(int i, T val) {
i++;
while (i < length) {
tree[i] += val;
i += i & -i;
}
}
T prefix(int i) {
i++;
T out = 0;
while (i > 0) {
out += tree[i];
i -= i & -i;
}
return out;
}
T query(int a, int b) { return prefix(b) - prefix(a - 1); }
};
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
vector<int> nums(n);
for (int i = 0; i < n; ++i) cin >> nums[i];
fenwick<long long> ff(n + 10);
long long inv = 0;
for (auto i : nums) {
inv += ff.query(i + 1, n + 1);
ff.update(i, 1);
}
if (n % 2) {
cout << (((inv % 2)) ? "Petr" : "Um_nik") << endl;
} else {
cout << (!((inv % 2)) ? "Petr" : "Um_nik") << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline void upd(int &x, int y) { x < y && (x = y); }
const int N = 150005;
string s;
int main() {
cin >> s;
int n = s.size();
if (n == 1) {
cout << 1 << endl;
return 0;
}
int res = 1, ans = 0;
char last = s[0];
for (int i = 1; i < n; ++i) {
if (last != s[i])
res++;
else {
upd(ans, res);
res = 1;
}
last = s[i];
}
if (res) upd(ans, res);
last = s[0];
int l = 1, r = 1;
for (int i = 1; i < n; ++i) {
if (last != s[i])
l++;
else
break;
last = s[i];
}
if (l & 1) {
if (last == 'b')
last = 'w';
else
last = 'b';
}
if (s[n - 1] != last)
r = 0;
else {
for (int i = n - 2; ~i; --i) {
if (last != s[i])
r++;
else
break;
last = s[i];
}
}
if ((l != 1 || r != 1) && l + r <= n) {
upd(ans, l + r);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const int MAXN = 2e5 + 10;
const int MAXM = 1e6 + 10;
const long long mod = 1e9 + 7;
long long a[MAXN];
long long x = 1e9, y = 1e9;
bool judge(long long b, long long c) {
if ((abs(b - c) == 1) || abs(b - c) == y) return true;
return false;
}
int main() {
int n;
scanf("%d", &n);
long long sub = -1;
int flag = 1;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (i > 1) {
long long temp = abs(a[i] - a[i - 1]);
if (temp == 1) continue;
if (sub == -1)
y = temp, sub = temp;
else if (sub != temp)
flag = 0;
}
}
if (!flag) {
puts("NO");
return 0;
}
for (int i = 1; i < n; i++) {
long long x1 = ceil((double)a[i] / y), x2 = ceil((double)a[i + 1] / y);
long long y1 = a[i] - x1 * y + y, y2 = a[i + 1] - x2 * y + y;
long long cnt1 = abs(x1 - x2), cnt2 = abs(y1 - y2);
if (a[i + 1] == a[i]) {
puts("NO");
return 0;
}
if (cnt1 == 0 && cnt2 == 1)
continue;
else if (cnt1 == 1 && cnt2 == 0)
continue;
else {
puts("NO");
return 0;
}
}
puts("YES");
printf("%lld %lld\n", x, y);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100000;
string s;
int n;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
int l = i - 1;
int r = i;
int cr = 1, cl = 1;
while (s[l] != 'L' && l >= 0) {
if (s[l] == 'R') {
cl++;
}
l--;
}
while (s[r] != 'R' && r < n - 1) {
if (s[r] == 'L') {
cr++;
}
r++;
}
cout << max(cr, cl) << " ";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long trojkat(long long d) {
if (d < 0) return 0;
return ((d + 1) * (d + 2)) / 2;
}
long long trojkat_inny(long long d) {
assert(d >= 0);
d++;
long long k = d / 2;
if (d % 2 == 0)
return k * (k + 1);
else
return (k + 1) * (k + 1);
}
long long fragment(long long d, long long g) {
if (g < -d)
return 0;
else if (g >= d)
return trojkat(d);
return trojkat_inny(d + g) - trojkat(g - 1);
}
long long fragment_gora(long long d, long long g) { return fragment(d, -g); }
long long policz(long long a, long long b, long long c, long long l3,
long long l) {
long long d = c - a - b + l3 + 1;
long long e = l - l3;
long long f = a - b - c - l3 + 1;
long long g = a - b + c + l3 - 1;
assert(f <= g);
if (e < d) return 0;
long long srodek = trojkat(e) - trojkat(d - 1);
long long dol = fragment(e, f - 1) - fragment(d - 1, f - 1);
long long gora = fragment_gora(e, g + 1) - fragment_gora(d - 1, g + 1);
assert(srodek >= 0);
assert(dol >= 0);
assert(gora >= 0);
assert(srodek - dol - gora >= 0);
return srodek - dol - gora;
}
long long rozwiaz(long long a, long long b, long long c, long long l) {
long long licz = 0;
for (long long l3 = (0); l3 <= (l); l3++) licz += policz(a, b, c, l3, l);
return licz;
}
void zrob_test() {
long long a, b, c, l;
cin >> a >> b >> c >> l;
cout << rozwiaz(a, b, c, l) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
zrob_test();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pi = pair<int, int>;
const int MAXN = 50005;
const int MAXT = 132000;
pi merge(pi a, pi b) {
if (a < b) swap(a, b);
if (a.first == b.first) a.second = min(a.second, b.second);
return a;
}
int n;
struct seg {
pi tree[MAXT];
int lazy[MAXT];
void lazydown(int p) {
for (int i = 2 * p; i < 2 * p + 2; i++) {
tree[i].first += lazy[p];
lazy[i] += lazy[p];
}
lazy[p] = 0;
}
void init(int s = 0, int e = n, int p = 1) {
lazy[p] = 0;
if (s == e) {
tree[p] = pi(0, s);
return;
}
int m = (s + e) / 2;
init(s, m, 2 * p);
init(m + 1, e, 2 * p + 1);
tree[p] = merge(tree[2 * p], tree[2 * p + 1]);
}
pi query(int s, int e, int ps = 0, int pe = n, int p = 1) {
if (e < ps || pe < s) return pi(-1e9, 0);
if (s <= ps && pe <= e) return tree[p];
lazydown(p);
int pm = (ps + pe) / 2;
return merge(query(s, e, ps, pm, 2 * p),
query(s, e, pm + 1, pe, 2 * p + 1));
}
void add(int s, int e, int x, int ps = 0, int pe = n, int p = 1) {
if (e < ps || pe < s) return;
if (s <= ps && pe <= e) {
tree[p].first += x;
lazy[p] += x;
return;
}
lazydown(p);
int pm = (ps + pe) / 2;
add(s, e, x, ps, pm, 2 * p);
add(s, e, x, pm + 1, pe, 2 * p + 1);
tree[p] = merge(tree[2 * p], tree[2 * p + 1]);
}
} seg;
pi a[MAXN];
auto cmp = [](int x, int y) {
return pi(a[x].second, a[x].first) > pi(a[y].second, a[y].first);
};
auto cmp2 = [](int x, int y) { return a[x].first > a[y].first; };
struct seg2 {
struct node {
int idx, frm;
node operator+(const node &n) const {
if (cmp(idx, n.idx)) return n;
return *this;
}
} tree[MAXT];
int lim;
void init(int n) {
for (lim = 1; lim <= n; lim <<= 1)
;
for (int i = 0; i < lim; i++) {
tree[i + lim] = {n, i};
}
for (int i = lim - 1; i; i--) {
tree[i] = tree[2 * i] + tree[2 * i + 1];
}
}
void update(int x, int v) {
x += lim;
tree[x].idx = v;
while (x > 1) {
x >>= 1;
tree[x] = tree[2 * x] + tree[2 * x + 1];
}
}
pi query(int s, int e) {
node ret = (node){n, -1};
s += lim;
e += lim;
while (s < e) {
if (s % 2 == 1) ret = ret + tree[s++];
if (e % 2 == 0) ret = ret + tree[e--];
s >>= 1;
e >>= 1;
}
if (s == e) ret = ret + tree[s];
return pi(ret.idx, ret.frm);
}
} seg2;
int ans[MAXN];
bool trial(int k) {
vector<priority_queue<int, vector<int>, decltype(cmp)>> lvl(
n, priority_queue<int, vector<int>, decltype(cmp)>(cmp));
priority_queue<int, vector<int>, decltype(cmp2)> pqForLast(cmp2);
vector<int> f(n);
for (int i = 0; i < n; i++) {
f[i] = n - 1;
lvl[n - 1].push(i);
pqForLast.push(i);
}
seg.init();
for (int i = 0; i < n; i++) {
seg.add(i + 1, n, ((int)(lvl[i]).size()) - 1);
}
seg2.init(n);
auto update_node = [&](int x) {
seg2.update(x, ((int)(lvl[x]).size()) ? lvl[x].top() : n);
};
update_node(n - 1);
for (int i = 0; i < n; i++) {
auto val = seg.query(i + 1, n);
if (val.first > -i) return 0;
int lastpos = val.second;
int idx = -1;
while (true) {
auto qq = seg2.query(i, lastpos - 1);
if (f[qq.first] != qq.second) {
lvl[qq.second].pop();
update_node(qq.second);
continue;
}
idx = qq.first;
break;
}
ans[i] = idx;
lvl[f[idx]].pop();
update_node(f[idx]);
seg.add(f[idx] + 1, n, -1);
f[idx] = -1;
if (k + i < n - 1) {
while (((int)(pqForLast).size()) &&
a[pqForLast.top()].first <= a[idx].second) {
int x = pqForLast.top();
pqForLast.pop();
if (f[x] == -1) continue;
f[x] = k + i;
lvl[k + i].push(x);
seg.add(k + i + 1, n - 1, 1);
update_node(k + i);
}
}
}
return 1;
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &a[i].first, &a[i].second);
a[n] = pi(2e9, 2e9);
int s = 1, e = n - 1;
while (s != e) {
int m = (s + e) / 2;
if (trial(m))
e = m;
else
s = m + 1;
}
trial(s);
for (int i = 0; i < n; i++) printf("%d ", 1 + ans[i]);
}
int main() {
int tc = 1;
while (tc--) {
solve();
}
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int ts, kk = 1;
struct D {
D *l, *r;
int cnt;
D() {
l = r = NULL;
cnt = 0;
}
};
int n, m;
pair<int, pair<int, int> > a[100005];
D *tr[10005];
void updt(D *rt, int s, int e, int p) {
if (!rt) return;
if (p <= s && e <= p) {
rt->cnt++;
return;
}
if (!rt->l) rt->l = new D();
if (!rt->r) rt->r = new D();
if (p <= ((s + e) >> 1))
updt(rt->l, s, ((s + e) >> 1), p);
else
updt(rt->r, ((s + e) >> 1) + 1, e, p);
rt->cnt++;
}
int qry(D *c, int s, int e, int st, int ed) {
if (!c) return 0;
if (st <= s && e <= ed) return c->cnt;
if (ed <= ((s + e) >> 1)) return qry(c->l, s, ((s + e) >> 1), st, ed);
if (((s + e) >> 1) < st) return qry(c->r, ((s + e) >> 1) + 1, e, st, ed);
return qry(c->l, s, ((s + e) >> 1), st, ed) +
qry(c->r, ((s + e) >> 1) + 1, e, st, ed);
}
int main() {
int t, i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < m + 1; i++) tr[i] = NULL;
for (i = 0; i < n; i++) {
scanf("%d%d%d", &j, &k, &t);
a[i] = make_pair(-k, pair<int, int>(t, j));
}
sort(a, a + n);
long long int rs = 0;
for (i = 0; i < n; i++) {
int l, r;
l = a[i].second.second + a[i].first;
r = a[i].second.second - a[i].first;
if (l < 1) l = 1;
if (r > 1000000007LL) r = 1000000007LL;
k = a[i].second.first;
for (j = max(1, k - m); j <= min(10005, k + m); j++)
rs += qry(tr[j], 1, 1000000007LL, l, r);
if (!tr[k]) tr[k] = new D();
updt(tr[k], 1, 1000000007LL, a[i].second.second);
}
printf("%lld\n", rs);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n, res;
cin >> n;
if (n == 2 || n == 3) {
cout << -1 << endl;
continue;
}
res = n;
vector<int> o, e;
for (int i = 2; i <= n; i += 2) e.push_back(i);
if (n % 2 == 0) {
for (int i = n - 3; i >= 1; i -= 2) {
o.push_back(i);
if (i == n - 3) o.push_back(n - 1);
}
} else {
for (int i = n - 4; i >= 1; i -= 2) {
if (i == n - 2) continue;
o.push_back(i);
if (i == n - 4) {
o.push_back(n);
o.push_back(n - 2);
}
}
}
for (long long i = 0; i < e.size(); i++) cout << e[i] << " ";
for (long long i = 0; i < o.size(); i++) cout << o[i] << " ";
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int a = (int(k / 2)) * (2 + ((k - 1) * 2));
if (k % 2 == 1) a += k;
if (n % 2 == 1 && k % 2 == 1 && n >= a)
cout << "YES" << endl;
else if (n % 2 == 0 && k % 2 == 0 && n >= a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
const int N = 500005;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
lli n, m, k, u, v, x, ans, curr, T;
vlli c(N);
lli fast_exp(lli base, lli exp) {
lli res = 1;
base = base % 1000000007;
while (exp > 0) {
if (exp % 2) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
exp /= 2;
}
return res % 1000000007;
}
template <class T>
struct DSU {
map<T, T> par;
T comp_sz = n;
T get(T u) {
if (par.find(u) == par.end()) return u;
return par[u] = get(par[u]);
}
void unite(T x, T y) {
T X = get(x), Y = get(y);
if (X == Y) return;
if (rng() % 2)
par[Y] = X;
else
par[X] = Y;
--comp_sz;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
map<lli, DSU<lli>> virus;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= m; i++) {
cin >> u >> v;
x = c[u] ^ c[v];
virus[x].unite(u, v);
}
ans = ((fast_exp(2, k) - virus.size() + 1000000007) * fast_exp(2, n)) %
1000000007;
for (auto i : virus) {
curr = (i.second).comp_sz;
ans = (ans + fast_exp(2, curr)) % 1000000007;
}
cout << ans;
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
const long long MOD = 1e9 + 7;
void print() { cout << endl; }
void printArray() { return; }
void read() { return; }
template <typename T, typename... Args>
void print(T a, Args... arg) {
cout << a << " ";
print(arg...);
}
template <typename T, typename... Args>
void read(T &a, Args &...arg) {
cin >> a;
read(arg...);
}
template <typename T, typename... Args>
void read(vector<T> &v, Args &...arg) {
for (auto &i : v) cin >> i;
read(arg...);
}
template <typename T, typename... Args>
void printArray(vector<T> &v, Args &...arg) {
for (auto i : v) cout << i << " ";
cout << endl;
printArray(arg...);
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1LL) res = res * a;
b >>= 1LL;
a = a * a;
}
return res;
}
long long modPower(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1L) res = (res % MOD * a % MOD) % MOD;
b >>= 1;
a = (a % MOD * a % MOD) % MOD;
}
return res;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInverse(long long b, long long m) {
long long x, y;
long long g = gcdExtended(b, m, &x, &y);
if (g != 1) return -1;
return (x % m + m) % m;
}
long long modDivide(long long a, long long b, long long m = MOD) {
a = a % m;
long long inv = modInverse(b, m);
if (inv == -1)
return -1;
else
return (inv * a) % m;
}
void runCase_() {
string s;
read(s);
string odd = "", even = "";
for (char c : s) {
if ((c - '0') % 2 == 0)
even += c;
else
odd += c;
}
long long n = even.length(), m = odd.length(), i = 0, j = 0;
if (n == 0 || m == 0)
print(s);
else {
string ans = "";
while (i < n && j < m) {
if (even[i] < odd[j])
ans += even[i++];
else
ans += odd[j++];
}
while (i < n) ans += even[i++];
while (j < m) ans += odd[j++];
print(ans);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) runCase_();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
static long long int n, m, a, b, d;
cin >> n >> m >> a >> b;
d = n % m;
cout << min(d * b, a * (m - d)) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long maxn = 1e6 + 100;
const long long inf = 1e15;
long long n, m, k, t;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long q, w, e, a, b, c;
cin >> t;
for (e = 0; e < t; e++) {
cin >> n;
long long cnt8 = (n + 3) / 4;
for (q = 0; q < n - cnt8; q++) {
cout << 9;
}
for (q = 0; q < cnt8; q++) {
cout << 8;
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
regex r("^(1|14|144)*$");
if (regex_match(s, r)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30030;
const int MAXK = 220;
const int inf = 1e9;
int f[MAXN][MAXK][2][5];
int best[MAXK][2][5];
int a[MAXN];
int s[MAXN];
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = (0); i < (n); ++i) scanf("%d", a + i);
s[0] = 0;
for (int i = (0); i < (n); ++i) s[i + 1] = s[i] + a[i];
for (int i = (0); i < (n + 1); ++i)
for (int j = (0); j < (k + 1); ++j)
for (int p = (0); p < (2); ++p)
for (int ps = (0); ps < (5); ++ps) f[i][j][p][ps] = -inf;
for (int j = (0); j < (k + 1); ++j)
for (int p = (0); p < (2); ++p)
for (int ps = (0); ps < (5); ++ps) best[j][p][ps] = -inf;
for (int p = (0); p < (2); ++p)
for (int ps = (0); ps < (5); ++ps) {
f[n][0][p][ps] = (ps - 2) * s[n];
best[0][p][ps] = f[n][0][p][ps];
}
for (int i = n - 1; i >= 0; --i)
for (int j = k; j >= 0; --j) {
int fp = -inf, fn = -inf;
for (int ps = (0); ps < (5); ++ps) {
fp = max(fp, f[i + 1][j][0][ps] - (ps - 2) * s[i + 1]);
fn = max(fn, f[i + 1][j][1][ps] - (ps - 2) * s[i + 1]);
}
if (j > 0) {
bool first = j == k;
bool last = j == 1;
fp = max(fp, !last * -s[i] + best[j - 1][1][2 + !last + !first] +
!first * -s[i]);
fn = max(fn, !last * -s[i] + best[j - 1][1][2 + !last - !first] -
!first * -s[i]);
fp = max(fp, !last * s[i] + best[j - 1][0][2 - !last + !first] +
!first * -s[i]);
fn = max(fn, !last * s[i] + best[j - 1][0][2 - !last - !first] -
!first * -s[i]);
}
for (int ps = (0); ps < (5); ++ps) {
f[i][j][0][ps] = fp + (ps - 2) * s[i];
f[i][j][1][ps] = fn + (ps - 2) * s[i];
}
for (int p = (0); p < (2); ++p)
for (int ps = (0); ps < (5); ++ps)
best[j][p][ps] = max(best[j][p][ps], f[i][j][p][ps]);
}
printf("%d\n", f[0][k][0][2]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
struct gauss {
vector<int> mat, basis;
int reduce(int n) {
for (auto x : mat) {
int msb = 1 << (31 - __builtin_clz(x));
if (n & msb) n ^= x;
}
return n;
}
void add(int n) {
int r = reduce(n);
if (r) {
basis.push_back(n);
mat.push_back(r);
sort(mat.rbegin(), mat.rend());
}
}
bool has(int n) {
n = reduce(n);
return (n == 0);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> S(n);
for (auto &x : S) cin >> x;
sort(S.begin(), S.end());
for (int p = 20; p >= 0; p--) {
int L = 1 << p;
gauss G;
for (auto s : S)
if ((s & (L - 1)) == s) G.add(s);
bool good = true;
for (int k = 0; k < p; k++) {
if (!G.has(1 << k)) {
good = false;
break;
}
}
if (!good) continue;
vector<int> basis = G.basis, code(L);
for (int i = 1; i < L; i++) code[i] = i ^ (i >> 1);
cout << p << endl;
for (int i = 0; i < L; i++) {
int res = 0;
for (int b = 0; b < p; b++)
if (code[i] & (1 << b)) res ^= basis[b];
cout << res << " ";
}
cout << endl;
return 0;
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1e18;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 2;
const int mov[4][2] = {-1, 0, 1, 0, 0, 1, 0, -1};
const int Mov[8][2] = {-1, -1, -1, 0, -1, 1, 0, -1, 0, 1, 1, -1, 1, 0, 1, 1};
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int a[maxn << 1];
long long vis[maxn];
int main(void) {
std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m;
while (cin >> n >> m) {
int k = 0;
int t;
for (int i = 1; i <= n + m; i++) cin >> a[i];
for (int i = 1; i <= n + m; i++) cin >> t, t ? vis[k++] = a[i] : 1;
vis[k] = (int)1e13;
for (int i = 1, j = 0; i <= n + m; j++) {
int cnt = 0;
while (a[i] < vis[j]) cnt++, i++;
i++;
while (a[i] - vis[j] <= vis[j + 1] - a[i] && i <= n + m) cnt++, i++;
cout << cnt << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, n, i;
cin >> d;
cin >> n;
int a[n];
int x, sum = 0;
for (i = 0; i < n - 1; i++) {
cin >> x;
sum += d - x;
}
cin >> x;
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f[100050];
int main() {
int n;
int ans = 1;
int x = 0;
while (~scanf("%d", &n)) {
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
scanf("%d", &x);
f[x] = f[x - 1] + 1;
ans = max(ans, f[x]);
}
printf("%d\n", n - ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> G[N][10];
vector<int> vi, a0, a1;
bool vis[N];
int rk[N], pre[N], num[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u][w].push_back(v);
G[v][w].push_back(u);
}
vis[n - 1] = 1;
vi.push_back(n - 1);
for (int i = 0; i < (int)vi.size(); ++i) {
int u = vi[i];
for (int j = 0; j < (int)G[u][0].size(); ++j) {
int v = G[u][0][j];
if (vis[v]) continue;
vis[v] = 1;
pre[v] = u;
num[v] = 0;
vi.push_back(v);
}
}
int RK = 1;
for (int i = 0, j = 0; i < (int)vi.size(); i = j) {
for (int k = 0; k <= 9; ++k) {
++RK;
for (j = i; j < vi.size() && rk[vi[i]] == rk[vi[j]]; ++j) {
int u = vi[j];
int sz = G[u][k].size();
for (int x = 0; x < sz; ++x) {
int v = G[u][k][x];
if (vis[v]) continue;
vis[v] = 1;
pre[v] = u;
num[v] = k;
rk[v] = RK;
vi.push_back(v);
}
}
}
}
int now = 0;
while (pre[now]) {
a1.push_back(now);
now = pre[now];
}
a1.push_back(now);
for (int i = (0); i < ((int)a1.size() - 1); ++i) {
a0.push_back(num[a1[i]]);
}
reverse(a0.begin(), a0.end());
int p = 0;
while (p < (int)a0.size() - 1 && !a0[p]) {
++p;
}
for (int i = (p); i < ((int)a0.size()); ++i) printf("%d", a0[i]);
puts("");
printf("%d\n", (int)a1.size());
for (int i = (0); i < ((int)a1.size()); ++i) printf("%d ", a1[i]);
puts("");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
class vec {
public:
int x, y;
vec() : x(), y() {}
vec(int tx, int ty) : x(tx), y(ty) {}
vec operator-(const vec &t) const { return vec(x - t.x, y - t.y); }
long long operator*(const vec &t) const {
return (long long)x * t.y - (long long)y * t.x;
}
bool operator<(const vec &t) const {
if (x != t.x) return x < t.x;
return y < t.y;
}
double len() { return sqrt((long long)x * x + (long long)y * y); }
bool operator!=(const vec &t) const { return x != t.x || y != t.y; }
};
vector<vec> convex, pt, stk;
pair<double, int> mx;
int n;
const int MAX = 100000;
int main() {
scanf("%d", &n);
for (int i = 1, x, y, v; i <= n; i++) {
scanf("%d%d%d", &x, &y, &v);
if (x < v) {
pt.push_back(vec(0, max(y - v + x, 0)));
pt.push_back(vec(0, min(y + v - x, MAX)));
} else
pt.push_back(vec(x - v, y));
if (y < v) {
pt.push_back(vec(max(x - v + y, 0), 0));
pt.push_back(vec(min(x + v - y, MAX), 0));
} else
pt.push_back(vec(x, y - v));
if (x + v > MAX) {
pt.push_back(vec(MAX, max(y - v + MAX - x, 0)));
pt.push_back(vec(MAX, min(y + v - MAX + x, MAX)));
} else
pt.push_back(vec(x + v, y));
if (y + v > MAX) {
pt.push_back(vec(max(x - v + MAX - y, 0), MAX));
pt.push_back(vec(min(x + v - MAX + y, MAX), MAX));
} else
pt.push_back(vec(x, y + v));
}
sort(pt.begin(), pt.end());
for (int i = 0; i < pt.size(); i++) {
if (!stk.empty() && pt[i].x == stk.back().x) continue;
while (stk.size() > 1 &&
(stk.back() - stk[stk.size() - 2]) * (pt[i] - stk.back()) <= 0)
stk.pop_back();
stk.push_back(pt[i]);
}
swap(convex, stk);
for (int i = pt.size() - 1; i >= 0; i--) {
if (!stk.empty() && pt[i].x == stk.back().x) continue;
while (stk.size() > 1 &&
(stk.back() - stk[stk.size() - 2]) * (pt[i] - stk.back()) <= 0)
stk.pop_back();
stk.push_back(pt[i]);
}
if (stk.front() != convex.back()) convex.push_back(stk.front());
convex.insert(convex.end(), stk.begin() + 1, stk.end() - 1);
if (stk.back() != convex.front()) convex.push_back(stk.back());
mx = make_pair(0, 0);
for (int i = 0; i < convex.size(); i++) {
vec v1 = convex[i], v2 = convex[(i + 1) % convex.size()],
v3 = convex[(i + 2) % convex.size()];
double l1 = (v2 - v1).len(), l2 = (v3 - v1).len(), l3 = (v3 - v2).len();
mx = max(mx, make_pair(l1 * l2 * l3 / (4 * ((v2 - v1) * (v3 - v1))), i));
}
printf("%d %d\n", convex[mx.second].x, convex[mx.second].y);
printf("%d %d\n", convex[(mx.second + 1) % convex.size()].x,
convex[(mx.second + 1) % convex.size()].y);
printf("%d %d\n", convex[(mx.second + 2) % convex.size()].x,
convex[(mx.second + 2) % convex.size()].y);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, s, p;
cin >> k >> n >> s >> p;
int y = (s > n) ? s : n;
int paperperperson = (y % s == 0) ? y / s : (y / s) + 1;
int paper = k * paperperperson;
int pack = (paper % p == 0) ? paper / p : (paper / p) + 1;
cout << pack << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long g, l, r, x, m, menor, resposta = -1;
cin >> g;
l = g;
r = g * 8;
while (l <= r) {
m = (l + r) / 2;
menor = 0;
x = 0;
for (long long i = 2; i <= cbrt(m); i++) {
x += m / (i * i * i);
menor = max(menor, m - m % (i * i * i));
}
if (g == x) {
resposta = menor;
break;
} else if (g < x) {
r = m - 1;
} else {
l = m + 1;
}
}
cout << resposta << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const size_t ioSize = 1 << 21;
char iBuf[ioSize], *iS, *iE;
inline char getc() {
return iS == iE ? iE = iBuf + fread(iS = iBuf, 1, ioSize, stdin),
iS == iE ? EOF : *iS++ : *iS++;
}
template <typename T>
void readi(T &x) {
char c;
for (c = getc(); !isdigit(c); c = getc())
;
x = c ^ '0';
for (c = getc(); isdigit(c); c = getc()) (x *= 10) += c ^ '0';
}
void readc(char &c) {
while (c = getc(), !isupper(c))
;
}
const size_t maxN = 100005;
std::map<int, int> X1[maxN], X2[maxN], Y1[maxN], Y2[maxN];
int N, M, Q;
int X[maxN], Y[maxN], X_1[maxN], Y_1[maxN];
char Dir[maxN];
int to0[maxN];
std::vector<std::tuple<int, int, int>> rowLine[maxN], colLine[maxN];
int To[51][maxN], toX[51][maxN], toY[51][maxN];
long long Step[51][maxN];
int qX[maxN], qY[maxN];
char qDir[maxN];
long long qT[maxN];
int qto0[maxN];
std::vector<std::pair<int, int *>> points[4][maxN];
namespace segTree {
int Cover[1 << 18 | 1];
inline void clear() { Cover[1] = 0; }
inline void cover(int i, int v) { Cover[i] = v; }
inline void pushdown(int i) {
if (~Cover[i]) {
cover(i << 1, Cover[i]);
cover(i << 1 | 1, Cover[i]);
Cover[i] = -1;
}
}
void modify(int i, int l, int r, int tl, int tr, int v) {
if (l >= tl && r <= tr) {
cover(i, v);
return;
}
pushdown(i);
int m = l + r >> 1;
if (tl <= m) modify(i << 1, l, m, tl, tr, v);
if (tr > m) modify(i << 1 | 1, m + 1, r, tl, tr, v);
}
int query(int i, int l, int r, int pos) {
if (l == r) return Cover[i];
pushdown(i);
int m = l + r >> 1;
return pos <= m ? query(i << 1, l, m, pos) : query(i << 1 | 1, m + 1, r, pos);
}
} // namespace segTree
int main() {
readi(N), readi(M);
for (int i = 1, x1, y1, x2, y2; i <= N; ++i) {
readi(x1), readi(y1), readi(x2), readi(y2);
X[i] = x1, Y[i] = y1;
X_1[i] = std::min(x1, x2), Y_1[i] = std::min(y1, y2);
if (y1 == y2) {
Dir[i] = x1 < x2 ? 'R' : 'L';
X1[y1].emplace(std::min(x1, x2), i);
X2[y1].emplace(std::max(x1, x2), i);
rowLine[y1].emplace_back(std::min(x1, x2), std::max(x1, x2), i);
if (Dir[i] == 'L')
points[0][x1].emplace_back(y1, to0 + i);
else
points[1][x1].emplace_back(y1, to0 + i);
} else {
Dir[i] = y1 < y2 ? 'U' : 'D';
Y1[x1].emplace(std::min(y1, y2), i);
Y2[x2].emplace(std::max(y1, y2), i);
colLine[x1].emplace_back(std::min(y1, y2), std::max(y1, y2), i);
if (Dir[i] == 'U')
points[2][y1].emplace_back(x1, to0 + i);
else
points[3][y1].emplace_back(x1, to0 + i);
}
}
readi(Q);
for (int i = 1; i <= Q; ++i) {
readi(qX[i]), readi(qY[i]), readc(qDir[i]), readi(qT[i]);
auto it = X2[qY[i]].lower_bound(qX[i]);
if (it != X2[qY[i]].end()) {
if (X_1[it->second] <= qX[i]) qDir[i] = Dir[it->second];
}
it = Y2[qX[i]].lower_bound(qY[i]);
if (it != Y2[qX[i]].end()) {
if (Y_1[it->second] <= qY[i]) qDir[i] = Dir[it->second];
}
if (qDir[i] == 'L')
points[0][qX[i]].emplace_back(qY[i], qto0 + i);
else if (qDir[i] == 'R')
points[1][qX[i]].emplace_back(qY[i], qto0 + i);
else if (qDir[i] == 'U')
points[2][qY[i]].emplace_back(qX[i], qto0 + i);
else
points[3][qY[i]].emplace_back(qX[i], qto0 + i);
}
for (int i = 0; i <= M; ++i) {
for (auto x : points[0][i]) *(x.second) = segTree::query(1, 0, M, x.first);
for (auto x : colLine[i])
segTree::modify(1, 0, M, std::get<0>(x), std::get<1>(x), std::get<2>(x));
}
segTree::clear();
for (int i = M; ~i; --i) {
for (auto x : points[1][i]) *(x.second) = segTree::query(1, 0, M, x.first);
for (auto x : colLine[i])
segTree::modify(1, 0, M, std::get<0>(x), std::get<1>(x), std::get<2>(x));
}
segTree::clear();
for (int i = 0; i <= M; ++i) {
for (auto x : points[3][i]) *(x.second) = segTree::query(1, 0, M, x.first);
for (auto x : rowLine[i])
segTree::modify(1, 0, M, std::get<0>(x), std::get<1>(x), std::get<2>(x));
}
segTree::clear();
for (int i = M; ~i; --i) {
for (auto x : points[2][i]) *(x.second) = segTree::query(1, 0, M, x.first);
for (auto x : rowLine[i])
segTree::modify(1, 0, M, std::get<0>(x), std::get<1>(x), std::get<2>(x));
}
for (int i = 1; i <= N; ++i) {
if (Dir[i] == 'L') {
auto it = X2[Y[i]].lower_bound(X[i]);
if (it != X2[Y[i]].begin()) {
--it;
if (!to0[i] || it->first > X[to0[i]]) {
to0[i] = it->second;
To[0][i] = it->second;
toX[0][i] = it->first;
toY[0][i] = Y[i];
Step[0][i] = X[i] - toX[0][i];
} else {
To[0][i] = to0[i];
toX[0][i] = X[to0[i]];
toY[0][i] = Y[i];
Step[0][i] = X[i] - toX[0][i];
}
} else {
To[0][i] = to0[i];
toX[0][i] = X[to0[i]];
toY[0][i] = Y[i];
Step[0][i] = X[i] - toX[0][i];
}
} else if (Dir[i] == 'R') {
auto it = X1[Y[i]].upper_bound(X[i]);
if (it != X1[Y[i]].end()) {
if (!to0[i] || it->first < X[to0[i]]) {
to0[i] = it->second;
To[0][i] = it->second;
toX[0][i] = it->first;
toY[0][i] = Y[i];
Step[0][i] = -X[i] + toX[0][i];
} else {
To[0][i] = to0[i];
toX[0][i] = X[to0[i]];
toY[0][i] = Y[i];
Step[0][i] = -X[i] + toX[0][i];
}
} else {
To[0][i] = to0[i];
toX[0][i] = X[to0[i]];
toY[0][i] = Y[i];
Step[0][i] = -X[i] + toX[0][i];
}
} else if (Dir[i] == 'U') {
auto it = Y1[X[i]].upper_bound(Y[i]);
if (it != Y1[X[i]].end()) {
if (!to0[i] || it->first < Y[to0[i]]) {
to0[i] = it->second;
To[0][i] = it->second;
toX[0][i] = X[i];
toY[0][i] = it->first;
Step[0][i] = -Y[i] + toY[0][i];
} else {
To[0][i] = to0[i];
toX[0][i] = X[i];
toY[0][i] = Y[to0[i]];
Step[0][i] = -Y[i] + toY[0][i];
}
} else {
To[0][i] = to0[i];
toX[0][i] = X[i];
toY[0][i] = Y[to0[i]];
Step[0][i] = -Y[i] + toY[0][i];
}
} else {
auto it = Y2[X[i]].lower_bound(Y[i]);
if (it != Y2[X[i]].begin()) {
--it;
if (!to0[i] || it->first > Y[to0[i]]) {
to0[i] = it->second;
To[0][i] = it->second;
toX[0][i] = X[i];
toY[0][i] = it->first;
Step[0][i] = Y[i] - toY[0][i];
} else {
To[0][i] = to0[i];
toX[0][i] = X[i];
toY[0][i] = Y[to0[i]];
Step[0][i] = Y[i] - toY[0][i];
}
} else {
To[0][i] = to0[i];
toX[0][i] = X[i];
toY[0][i] = Y[to0[i]];
Step[0][i] = Y[i] - toY[0][i];
}
}
}
for (int i = 1; i != 50; ++i)
for (int j = 1; j <= N; ++j) {
if (Step[i - 1][j] > (1LL << 50)) continue;
To[i][j] = To[i - 1][To[i - 1][j]];
Step[i][j] = Step[i - 1][j] + Step[i - 1][To[i - 1][j]] -
std::abs(toX[i - 1][j] - X[To[i - 1][j]] + toY[i - 1][j] -
Y[To[i - 1][j]]);
toX[i][j] = toX[i - 1][To[i - 1][j]];
toY[i][j] = toY[i - 1][To[i - 1][j]];
}
for (int i = 1; i <= Q; ++i) {
int curi, curx = qX[i], cury = qY[i];
long long curT = qT[i];
char curdir = qDir[i];
int tox, toy, toi = qto0[i];
if (curdir == 'L') {
auto it = X2[cury].lower_bound(curx);
if (it != X2[cury].begin()) {
--it;
if (!toi || it->first > X[toi]) {
toi = it->second;
tox = it->first;
toy = cury;
} else {
tox = X[toi];
toy = cury;
}
} else {
if (!toi) {
printf("%lld %d\n", std::max(0LL, curx - curT), cury);
continue;
}
tox = X[toi];
toy = cury;
}
if (curx - tox > curT) {
printf("%lld %d\n", curx - curT, cury);
continue;
}
curT -= curx - tox;
} else if (curdir == 'R') {
auto it = X1[cury].upper_bound(curx);
if (it != X1[cury].end()) {
if (!toi || it->first < X[toi]) {
toi = it->second;
tox = it->first;
toy = cury;
} else {
tox = X[toi];
toy = cury;
}
} else {
if (!toi) {
printf("%lld %d\n", std::min(static_cast<long long>(M), curx + curT),
cury);
continue;
}
tox = X[toi];
toy = cury;
}
if (tox - curx > curT) {
printf("%lld %d\n", curx + curT, cury);
continue;
}
curT -= tox - curx;
} else if (curdir == 'U') {
auto it = Y1[curx].upper_bound(cury);
if (it != Y1[curx].end()) {
if (!toi || it->first < Y[toi]) {
toi = it->second;
tox = curx;
toy = it->first;
} else {
tox = curx;
toy = Y[toi];
}
} else {
if (!toi) {
printf("%d %lld\n", curx,
std::min(static_cast<long long>(M), cury + curT));
continue;
}
tox = curx;
toy = Y[toi];
}
if (toy - cury > curT) {
printf("%d %lld\n", curx, cury + curT);
continue;
}
curT -= toy - cury;
} else {
auto it = Y2[curx].lower_bound(cury);
if (it != Y2[curx].begin()) {
--it;
if (!toi || it->first > Y[toi]) {
toi = it->second;
tox = curx;
toy = it->first;
} else {
tox = curx;
toy = Y[toi];
}
} else {
if (!toi) {
printf("%d %lld\n", curx, std::max(0LL, cury - curT));
continue;
}
tox = curx;
toy = Y[toi];
}
if (cury - toy > curT) {
printf("%d %lld\n", curx, cury - curT);
continue;
}
curT -= cury - toy;
}
curi = toi, curx = tox, cury = toy;
for (int d = 49; ~d; --d)
if (To[d][curi] &&
Step[d][curi] - std::abs(curx - X[curi] + cury - Y[curi]) <= curT) {
curT -= Step[d][curi] - std::abs(curx - X[curi] + cury - Y[curi]);
curx = toX[d][curi], cury = toY[d][curi];
curi = To[d][curi];
}
curdir = Dir[curi];
if (curdir == 'L')
printf("%lld %d\n", std::max(0LL, curx - curT), cury);
else if (curdir == 'R')
printf("%lld %d\n", std::min(static_cast<long long>(M), curx + curT),
cury);
else if (curdir == 'U')
printf("%d %lld\n", curx,
std::min(static_cast<long long>(M), cury + curT));
else
printf("%d %lld\n", curx, std::max(0LL, cury - curT));
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000006;
int OGR[MAXN][3];
void NIE() {
puts("IMPOSSIBLE");
exit(0);
}
vector<int> LE[MAXN], PR[MAXN], ANS;
int dfs(int u, int mus) {
for (typeof(LE[u].begin()) it = LE[u].begin(); it != LE[u].end(); ++it)
if (*it <= u) NIE();
for (typeof(PR[u].begin()) it = PR[u].begin(); it != PR[u].end(); ++it)
if (*it <= u) NIE();
int le = -1, ri = MAXN;
for (typeof(LE[u].begin()) it = LE[u].begin(); it != LE[u].end(); ++it)
le = max(le, *it);
int tam = le == -1 ? u : dfs(u + 1, le);
ANS.push_back(u);
for (typeof(PR[u].begin()) it = PR[u].begin(); it != PR[u].end(); ++it)
ri = min(ri, *it);
if (ri == MAXN && mus <= tam) return tam;
if (ri <= tam) NIE();
for (typeof(PR[u].begin()) it = PR[u].begin(); it != PR[u].end(); ++it)
mus = max(mus, *it);
return dfs(tam + 1, mus);
}
int main() {
char temp[123];
int c, n;
scanf("%d%d", &n, &c);
for (int i = 0; i < c; ++i) {
scanf("%d%d %s", &OGR[i][0], &OGR[i][1], temp);
OGR[i][2] = temp[0] == 'L';
}
for (int i = 0; i < c; ++i)
for (int j = 0; j < 2; ++j) OGR[i][j]--;
for (int i = 0; i < c; ++i)
if (OGR[i][2])
LE[OGR[i][0]].push_back(OGR[i][1]);
else
PR[OGR[i][0]].push_back(OGR[i][1]);
dfs(0, n - 1);
for (typeof(ANS.begin()) it = ANS.begin(); it != ANS.end(); ++it)
printf("%d ", *it + 1);
puts("");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, rem[100004], cost[100004], t, d, kind, num, dif, total;
struct s {
int price, idx;
} v[100004];
queue<s> q;
bool cmp(s a, s b) {
if (a.price == b.price) return a.idx < b.idx;
return a.price < b.price;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> rem[i];
v[i].idx = i;
}
for (int i = 1; i <= n; i++) {
cin >> cost[i];
v[i].price = cost[i];
}
sort(v + 1, v + n + 1, cmp);
for (int i = 1; i <= n; i++) q.push(v[i]);
for (int i = 1; i <= m; i++) {
cin >> kind >> num;
total = 0;
if (num <= rem[kind]) {
rem[kind] -= num;
cout << cost[kind] * num << '\n';
} else {
total = rem[kind] * cost[kind];
dif = num - rem[kind];
rem[kind] = 0;
while (!q.empty() && dif > 0) {
if (rem[q.front().idx] == 0) {
q.pop();
continue;
}
if (dif <= rem[q.front().idx]) {
rem[q.front().idx] -= dif;
cout << dif * q.front().price + total << '\n';
dif = 0;
} else {
dif -= rem[q.front().idx];
total += q.front().price * rem[q.front().idx];
rem[q.front().idx] = 0;
q.pop();
}
}
if (dif > 0) cout << 0 << '\n';
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
if (N < 3) {
printf("-1");
return 0;
}
printf("6\n15\n10\n");
for (int i = 4; i <= N; i++) printf("%d\n", 30 * (i - 3));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dp[101000][110] = {0};
struct query {
int l;
int r;
int k;
query() {}
query(int _l, int _r, int _k) : l(_l), r(_r), k(_k) {}
bool operator<(query a) const { return r > a.r; }
};
int mypow(int x, int n) {
int a = x, ans = 1;
while (n) {
if (n & 1) ans = 1LL * ans * a % 1000000007;
n >>= 1;
a = 1LL * a * a % 1000000007;
}
return ans;
}
int rev(int x) { return mypow(x, 1000000007 - 2); }
int c(int n, int k) {
if (k < 0 || n < k) return 0;
if (k == 0 || n == k) return 1;
if (dp[n][k]) return dp[n][k];
return dp[n][k] = (c(n - 1, k - 1) + c(n - 1, k)) % 1000000007;
}
bool cmp(query a, query b) { return a.l > b.l; }
int a[101000], add[110] = {0};
query q[101000], p[101000];
int main() {
int n, m, i, j, t, s;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) scanf("%d%d%d", &q[i].l, &q[i].r, &q[i].k);
for (i = 0; i < m; i++) p[i] = q[i];
sort(q, q + m);
sort(p, p + m, cmp);
t = 0;
s = 0;
for (i = n - 1; i >= 0; i--) {
for (j = 1; j < 110; j++) {
if (!add[j]) break;
add[j - 1] -= add[j];
if (add[j - 1] < 0) add[j - 1] += 1000000007;
}
while (t < m && q[t].r > i) {
for (j = 0; j <= q[t].k; j++) {
add[j] += c(q[t].k + q[t].r - q[t].l - j, q[t].k - j);
add[j] %= 1000000007;
}
t++;
}
while (s < m && p[s].l - 2 == i) {
add[p[s].k]--;
s++;
}
a[i] += add[0];
a[i] %= 1000000007;
}
for (i = 0; i < n; i++) {
printf("%d", a[i]);
if (i == n - 1)
putchar('\n');
else
putchar(' ');
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const long long N = 2e5 + 5, NN = (1LL << 10) + 5, mod = 998244353;
bool isprime(long long n) {
for (int i = 2; i <= n / i; i++)
if (n % i == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<pair<int, pair<int, int>>> v;
int a, b, c;
vector<int> vis(n + 2, 0);
for (int(i) = 0; i < (k); i++) {
cin >> a >> b >> c;
vis[b] = 1;
}
int idx = -1;
for (int(i) = 1; i <= (n); i++)
if (!vis[i]) {
idx = i;
break;
}
for (int(i) = 0; i < (n); i++) {
if (i + 1 == idx) continue;
cout << idx << " " << i + 1 << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<pair<pair<int, int>, char>, int> M;
int t;
string s;
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
if (fopen(""
".inp",
"r")) {
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
cin >> t;
while (t--) {
cin >> s;
int n = s.size();
s = ' ' + s;
M.clear();
int u = 1, v = 1;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
pair<pair<int, int>, char> k = {{u, v}, s[i]};
if (M[k] == 1)
ans += 1;
else
ans += 5;
M[k] = 1;
if (s[i] == 'S') {
u += 1;
k = {{u, v}, 'N'};
M[k] = 1;
}
if (s[i] == 'N') {
u -= 1;
k = {{u, v}, 'S'};
M[k] = 1;
}
if (s[i] == 'W') {
v += 1;
k = {{u, v}, 'E'};
M[k] = 1;
}
if (s[i] == 'E') {
v -= 1;
k = {{u, v}, 'W'};
M[k] = 1;
}
}
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y, sum = 0;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
sum += y;
}
sum /= n;
sum += 5;
printf("%.3f", sum);
return 0;
}
| 14 |
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define vvi vector<vector<int>>
#define ld long double
#define mod 1000000007
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vpii vector<pair<int,int>>
#define all(x) x.begin(),x.end()
#define sz(a) (int)(a.size())
#define vi vector<int>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define SS stringstream
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) { cerr << name << " : " << arg1 << '\n'; }
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
// const int dirx[4] = {0, 0, -1, 1};
// const int diry[4] = { -1, 1, 0, 0};
// 0 -> l, 1 - > r, 2 -> u , 3 -> down
void FASTIO()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
const int mxN = 2e3 + 100;
int n, m, k, q;
string s;
int a[mxN][mxN];
int fr[11];
int fc[11];
int lc[11];
int lr[11];
int ans[mxN];
void fillRow()
{
for (int x = 0; x < 10; x++)
{
for (int i = 1; i <= n; i++)
{
vi pos;
for (int j = 1; j <= m; j++)
{
if (a[i][j] == x)
pos.pb(j);
}
if (sz(pos) == 0)
continue;
int base = pos.back() - pos[0];
ans[x] = max(ans[x], abs(i - 1) * base);
ans[x] = max(ans[x], abs(i - n) * base);
ans[x] = max(ans[x], abs(fr[x] - i) * max(pos.back() - 1, m - pos[0]));
ans[x] = max(ans[x], abs(lr[x] - i) * max(pos.back() - 1, m - pos[0]));
}
}
}
void fillCol()
{
for (int x = 0; x < 10; x++)
{
for (int j = 1; j <= n; j++)
{
vi pos;
for (int i = 1; i <= n; i++)
{
if (a[i][j] == x)
pos.pb(i);
}
if (sz(pos) == 0)
continue;
int base = pos.back() - pos[0];
ans[x] = max(ans[x], abs(j - 1) * base);
ans[x] = max(ans[x], abs(j - m) * base);
ans[x] = max(ans[x], abs(fc[x] - j) * max(pos.back() - 1, n - pos[0]));
ans[x] = max(ans[x], abs(lc[x] - j) * max(pos.back() - 1, n - pos[0]));
}
}
}
void test_case()
{
cin >> n;
m = n;
for (int i = 1; i <= n; i++)
{
string s;
cin >> s;
for (int j = 1; j <= n; j++)
{
a[i][j] = s[j - 1] - '0';
}
}
for(int i = 0; i < 11; i++)
fr[i] = lr[i] = fc[i] = lc[i] = -1;
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
if (fr[a[i][j]] == -1)
fr[a[i][j]] = i;
}
}
for (int i = n; i >= 1; i--)
{
for (int j = 1; j <= m; j++)
{
if (lr[a[i][j]] == -1)
lr[a[i][j]] = i;
}
}
for (int j = 1; j <= m; j++)
{
for (int i = 1; i <= n; i++)
{
if (fc[a[i][j]] == -1)
fc[a[i][j]] = j;
}
}
for (int j = m; j >= 1; j--)
{
for (int i = 1; i <= n; i++)
{
if (lc[a[i][j]] == -1)
lc[a[i][j]] = j;
}
}
for (int i = 0; i < 10; i++)
ans[i] = 0;
fillRow();
fillCol();
for (int i = 0; i < 10; i++)
cout << ans[i] << " ";
cout << '\n';
}
int32_t main()
{
FASTIO();
int t;
t = 1;
cin >> t;
for (int i = 1; i <= t; i++)
{
//cout << "Case #" << i << ": ";
test_case();
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int f[N], tot = 0;
char a[N], ans[N];
stack<char> s;
int main() {
scanf("%s", a + 1);
int n = strlen(a + 1);
f[n + 1] = 100;
for (int i = n; i >= 1; i--) {
f[i] = min(a[i] - '0', f[i + 1]);
}
for (int i = 1; i <= n; i++) {
while (!s.empty()) {
int x = s.top() - '0';
if (x <= f[i]) {
ans[++tot] = s.top();
s.pop();
} else
break;
}
if (f[i] == a[i] - '0') {
ans[++tot] = a[i];
} else {
s.push(a[i]);
}
}
while (!s.empty()) {
ans[++tot] = s.top();
s.pop();
}
puts(ans + 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[205];
bool vis[205];
vector<int> g[205];
vector<int> cycle;
vector<vector<int>> ans;
struct Edge {
int u, v;
long long cap, flow;
Edge() {}
Edge(int u, int v, long long cap) : u(u), v(v), cap(cap), flow(0) {}
};
struct Dinic {
int N;
vector<Edge> E;
vector<vector<int>> g;
vector<int> d, pt;
Dinic(int N) : N(N), E(0), g(N), d(N), pt(N) {}
void AddEdge(int u, int v, long long cap) {
if (u != v) {
E.emplace_back(Edge(u, v, cap));
g[u].emplace_back(E.size() - 1);
E.emplace_back(Edge(v, u, 0));
g[v].emplace_back(E.size() - 1);
}
}
bool BFS(int S, int T) {
queue<int> q({S});
fill(d.begin(), d.end(), N + 1);
d[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == T) break;
for (int k : g[u]) {
Edge &e = E[k];
if (e.flow < e.cap && d[e.v] > d[e.u] + 1) {
d[e.v] = d[e.u] + 1;
q.emplace(e.v);
}
}
}
return d[T] != N + 1;
}
long long DFS(int u, int T, long long flow = -1) {
if (u == T || flow == 0) return flow;
for (int &i = pt[u]; i < g[u].size(); ++i) {
Edge &e = E[g[u][i]];
Edge &oe = E[g[u][i] ^ 1];
if (d[e.v] == d[e.u] + 1) {
long long amt = e.cap - e.flow;
if (flow != -1 && amt > flow) amt = flow;
if (long long pushed = DFS(e.v, T, amt)) {
e.flow += pushed;
oe.flow -= pushed;
return pushed;
}
}
}
return 0;
}
long long MaxFlow(int S, int T) {
long long total = 0;
while (BFS(S, T)) {
fill(pt.begin(), pt.end(), 0);
while (long long flow = DFS(S, T)) total += flow;
}
return total;
}
};
const int M = 2e4;
bool isPrime[M + 5];
int factor[M + 5];
void getPrime() {
for (int i = 0; i <= M; i++) isPrime[i] = 1;
isPrime[0] = isPrime[1] = 0;
for (int i = 2; i * i <= M; i++) {
if (isPrime[i]) {
for (int j = i * i; j <= M; j += i) {
isPrime[j] = 0;
if (factor[j] == 0) factor[j] = i;
}
}
}
for (int i = 2; i <= M; i++)
if (factor[i] == 0) factor[i] = i;
}
void dfs(int u) {
vis[u] = 1;
cycle.push_back(u);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v]) continue;
dfs(v);
}
}
vector<int> odd, even;
int main() {
getPrime();
int n;
scanf("%d", &n);
Dinic dinic(n + 2);
int source = 0, sink = n + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] % 2 == 1) {
odd.push_back(i);
dinic.AddEdge(source, i, 2);
} else {
even.push_back(i);
dinic.AddEdge(i, sink, 2);
}
}
for (int i = 0; i < odd.size(); i++) {
for (int j = 0; j < even.size(); j++) {
if (isPrime[a[odd[i]] + a[even[j]]]) {
dinic.AddEdge(odd[i], even[j], 1);
}
}
}
int flow = dinic.MaxFlow(source, sink);
if (odd.size() != even.size() || flow != 2 * even.size())
printf("Impossible\n");
else {
for (int i = 0; i < odd.size(); i++) {
int u = odd[i];
for (int j = 0; j < dinic.g[u].size(); j++) {
int idx = dinic.g[u][j];
if (dinic.E[idx].flow == 1) {
g[dinic.E[idx].u].push_back(dinic.E[idx].v);
g[dinic.E[idx].v].push_back(dinic.E[idx].u);
}
}
}
for (int i = 0; i < odd.size(); i++) {
int u = odd[i];
if (vis[u]) continue;
cycle.clear();
dfs(u);
ans.push_back(cycle);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j]);
printf("\n");
}
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
const double pi = 4 * atan(1);
double px[5000], py[5000];
int id[600][10];
int main() {
int N, i, j, np = 0;
double R, d, x, y, al, xx, yy;
scanf("%d", &N);
R = 5 / sin(pi / 5);
d = 2 * R * sin(2 * pi / 5);
x = -4500;
y = 0;
for (i = 0; i < N; i++) {
al = pi / 2;
for (j = 0; j < 5; j++) {
xx = x + R * cos(al);
yy = y + R * sin(al);
if (i && j == 1) {
id[i][j] = id[i - 1][4];
} else {
px[np] = xx;
py[np] = yy;
np++;
id[i][j] = np;
}
al += pi * 2 / 5;
}
x += d;
}
printf("%d\n", np);
for (i = 0; i < np; i++) printf("%.10lf %.10lf\n", px[i], py[i]);
for (i = 0; i < N; i++)
for (j = 0; j < 5; j++) printf("%d%c", id[i][j], j == 4 ? '\n' : ' ');
for (i = N - 1; i >= 0; i--) printf("%d ", id[i][4]);
for (i = 0; i < N; i++)
printf("%d %d %d %d ", id[i][1], id[i][3], id[i][0], id[i][2]);
printf("%d\n", id[N - 1][4]);
return 0;
}
| 15 |
#include <bits/stdc++.h>
const int N = 155, oo = 1000000007;
int n, m, ans, f[N][N][4], g[N][N][4];
int rec(int k, int x1, int x2, int y1, int y2) {
if (x1 > x2 || y1 > y2) return 0;
return (0LL + f[x2][y2][k] + f[x1 - 1][y1 - 1][k] - f[x1 - 1][y2][k] -
f[x2][y1 - 1][k]) %
oo;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 0; k <= 3; k++)
f[i][j][k] = (0LL + f[i][j][k] + f[i - 1][j][k] + f[i][j - 1][k] -
f[i - 1][j - 1][k]) %
oo;
memset(g, 0, sizeof(g));
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
for (int k = 0; k <= 3; k++)
g[i][j][0] = (0LL + g[i][j][0] +
rec(k, 1, i - (k & 1), j + ((k & 2) > 0), n)) %
oo;
for (int k = 1; k <= 3; k++)
if (k & 1)
g[i][j][1] =
(0LL + g[i][j][1] + rec(k, i, j, j + (k == 3), n)) % oo;
for (int k = 2; k <= 3; k++)
g[i][j][2] = (0LL + g[i][j][2] + rec(k, 1, i - (k == 3), i, j)) % oo;
g[i][j][3] = (0LL + g[i][j][3] + rec(3, i, j, i, j)) % oo;
}
memcpy(f, g, sizeof(f));
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) ++f[i][j][3];
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = 0; k <= 3; k++) ans = (0LL + ans + f[i][j][k]) % oo;
}
printf("%d\n", (ans + oo) % oo);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, x, y, z, m, q, h, r, timer, mx;
int a[100500], tin[100500], tout[100500], w[100500], lvl[100500],
up[100500][20];
vector<pair<int, int> > g[100500];
vector<int> f;
int l = 18;
void dfs(int v, int lv, int p) {
tin[v] = ++timer;
lvl[v] = lv;
up[v][0] = p;
for (int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i].first;
int val = g[v][i].second;
if (to != p) {
w[to] = w[v] + val;
dfs(to, lv + 1, v);
}
}
tout[v] = ++timer;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = l; i >= 0; --i)
if (!upper(up[a][i], b)) a = up[a][i];
return up[a][0];
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x >> y;
if (x != -1) {
g[i].push_back(make_pair(x, y));
g[x].push_back(make_pair(i, y));
} else {
f.push_back(i);
}
}
for (i = 0; i < f.size(); i++) g[0].push_back(make_pair(f[i], 0));
dfs(0, 0, 0);
cin >> q;
for (i = 0; i < q; i++) {
int test, x, y;
scanf("%d %d %d", &test, &x, &y);
if (x == y) {
cout << "NO" << endl;
continue;
}
if (test == 2) {
int lc = lca(x, y);
if (w[x] - w[lc] == 0 && w[y] - w[lc] == lvl[y] - lvl[lc] &&
!upper(y, x) && lc != 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
if (upper(x, y) && w[x] - w[y] == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 100;
long long n, m, k, a[5005][5005];
pair<long long, long long> rows[5005], col[5005];
int main() {
cin >> n >> m >> k;
for (long long i = 1; i <= k; i++) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
rows[x].first = y;
rows[x].second = i;
}
if (t == 2) {
col[x].first = y;
col[x].second = i;
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (rows[i].second > col[j].second)
cout << rows[i].first << " ";
else
cout << col[j].first << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m;
while (cin >> n >> m) {
int k = 0;
int t;
vector<int> a(n + m + 1);
vector<long long> vis(m);
for (int i = 1; i <= n + m; i++) cin >> a[i];
for (int i = 1; i <= n + m; i++) cin >> t, t ? vis[k++] = a[i] : 1;
vis[k] = (int)1e18;
for (int i = 1, j = 0; i <= n + m; j++) {
int cnt = 0;
while (a[i] < vis[j]) cnt++, i++;
i++;
while (a[i] - vis[j] <= vis[j + 1] - a[i] && i <= n + m) cnt++, i++;
cout << cnt << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, z, xsum(0), ysum(0), zsum(0);
cin >> n;
while (n--) {
cin >> x >> y >> z;
xsum += x;
ysum += y;
zsum += z;
}
if (xsum == 0 && ysum == 0 && zsum == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10;
int a[M];
int b[M];
int vis[M];
map<int, int> mp;
int tree[M];
int lowerbit(int x) { return x & (-x); }
void add(int x, int y) {
for (int i = x; i < M; i += lowerbit(i)) {
tree[i] += y;
}
}
long long int query(int x) {
long long int ans = 0;
for (int i = x; i > 0; i -= lowerbit(i)) {
ans = ans + (long long int)tree[i];
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
mp.clear();
for (int i = 1; i <= n; ++i) {
cin >> a[i];
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; ++i) {
if (mp.count(b[i]) == 0) mp[b[i]] = i;
}
long long int ans = 0;
add(mp[a[1]], 1);
for (int i = 2; i <= n; ++i) {
long long int z = query(mp[a[i]] - 1);
long long int z1 = i - 1 - query(mp[a[i]]);
ans = ans + min(z1, (long long int)z);
add(mp[a[i]], 1);
}
for (int i = 1; i <= n; ++i) {
add(mp[a[i]], -1);
}
cout << ans << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void ask(long long x) {}
long long tr;
vector<long long> que;
long long ask() {
printf("%d ", que.size());
for (int i = 0; i < que.size(); i++) printf(" %lld", que[i]);
printf("\n");
fflush(stdout);
int x = 0;
scanf("%d", &x);
if (x == -1) exit(0);
if (x == -2) assert(0);
return x;
}
long long calc(int q, long long x) {
if (q == 1) {
return min(x * 2 - 1, x + 9999);
}
if (x >= 10000) {
if (q == 2) return x + 10001 * 10001 - 2;
}
long long cs, now;
cs = x, now = cs;
for (int i = 1; i <= min(10000ll, cs) + 1; i++) {
long long tmp = calc(q - 1, now);
now = tmp + 2;
}
return now - 2;
}
void dfs(int q, long long x) {
if (q == 1) {
que.clear();
for (long long i = x; i <= min(x * 2ll - 1, x + 9999ll); i++)
que.push_back(i);
ask();
return;
}
if (x >= 10000) {
if (q == 2) {
que.clear();
for (int i = 1; i <= 10000; i++) que.push_back(x + i * 10001ll - 1);
int tmp = ask();
dfs(q - 1, x + tmp * 10001);
return;
}
}
long long cs, now;
cs = x, now = cs;
que.clear();
for (int i = 1; i <= min(10000ll, cs) + 1; i++) {
long long tmp = calc(q - 1, now);
if (i <= min(10000ll, cs)) que.push_back(tmp + 1);
now = tmp + 2;
}
long long tmp = ask();
if (tmp == 0)
dfs(q - 1, x);
else
dfs(q - 1, que[tmp - 1] + 1);
}
int main() { dfs(5, 1); }
| 22 |
#include <bits/stdc++.h>
using namespace std;
bool pri[100000 + 5];
int np, prime[2000], ans, a, b;
void init() {
int i, j, k, times, base;
np = 0;
prime[++np] = 2;
for (i = 0; i < 3000; i++) {
memset(pri, true, sizeof(pri));
for (j = 2; j <= np; j++) {
if (prime[j] <= (i + 1) * 100000 / prime[j]) {
times = i * 100000 / prime[j];
base = times * prime[j];
if (base <= i * 100000) base += prime[j];
if (!(base & 1)) base += prime[j];
base = max(base, prime[j] * prime[j]);
for (k = base; k <= (i + 1) * 100000; k += (prime[j] << 1)) {
pri[k - i * 100000] = 0;
}
}
}
if (i == 0) pri[1] = 0;
for (j = 1; j <= 100000; j += 2) {
if (pri[j]) {
prime[++np] = i * 100000 + j;
if (!(1 & (prime[np] >> 1))) {
if (a <= prime[np] && prime[np] <= b) ans++;
}
if (prime[np] <= (i + 1) * 100000 / prime[np]) {
for (k = prime[np] * prime[np]; k <= (i + 1) * 100000;
k += (prime[np] << 1)) {
pri[k - i * 100000] = 0;
}
} else {
if (prime[np] > 300000000 / prime[np]) np--;
}
}
}
}
}
int main() {
while (scanf("%d%d", &a, &b) != EOF) {
ans = 0;
init();
if (a <= 2 && 2 <= b) ans++;
printf("%d\n", ans);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& _a4, C _b4) {
_a4 = min(_a4, _b4);
}
template <class C>
void maxi(C& _a4, C _b4) {
_a4 = max(_a4, _b4);
}
template <class TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char* sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[";
for (auto& vv : V) os << vv << ",";
os << "]";
return os;
}
struct SuffixAutomaton {
vector<map<char, long long>> edges;
vector<long long> link;
vector<long long> length;
long long last;
vector<bool> is_terminal;
SuffixAutomaton(string s) {
edges.push_back(map<char, long long>());
link.push_back(-1);
length.push_back(0);
last = 0;
for (long long i = 0; i < s.size(); i++) {
edges.push_back(map<char, long long>());
length.push_back(i + 1);
link.push_back(0);
long long r = edges.size() - 1;
long long p = last;
while (p >= 0 && edges[p].find(s[i]) == edges[p].end()) {
edges[p][s[i]] = r;
p = link[p];
}
if (p != -1) {
long long q = edges[p][s[i]];
if (length[p] + 1 == length[q]) {
link[r] = q;
} else {
edges.push_back(edges[q]);
length.push_back(length[p] + 1);
link.push_back(link[q]);
long long qq = edges.size() - 1;
link[q] = qq;
link[r] = qq;
while (p >= 0 && edges[p][s[i]] == q) {
edges[p][s[i]] = qq;
p = link[p];
}
}
}
last = r;
}
is_terminal.resize(((long long)(edges).size()));
long long p = last;
while (p > 0) {
is_terminal[p] = 1;
p = link[p];
}
}
void calc(long long k) {
vector<long long> res1(((long long)(edges).size())),
res2(((long long)(edges).size()));
vector<long long> vis(((long long)(edges).size()));
function<void(long long)> dfs = [&](long long i) {
if (vis[i]) return;
vis[i] = 1;
if (is_terminal[i]) res1[i]++;
for (auto edge : edges[i]) {
dfs(edge.second);
res1[i] += res1[edge.second];
res2[i] += res2[edge.second];
}
res2[i] += res1[i];
};
dfs(0);
long long ak = 0;
res1[0] = 0;
while (1) {
if (res1[ak] >= k) break;
k -= res1[ak];
for (auto edge : edges[ak]) {
if (res2[edge.second] >= k) {
cout << edge.first;
ak = edge.second;
break;
} else
k -= res2[edge.second];
}
}
cout << "\n";
}
};
string s;
long long k;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
cin >> s >> k;
if (k > ((long long)(s).size()) * (((long long)(s).size()) + 1) / 2) {
cout << "No such line.\n";
return 0;
}
SuffixAutomaton SA(s);
SA.calc(k);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
int k;
int f1 = 0, f2 = 0, f3 = 0;
vector<int> a, b, c, ab, bc, ca, abc;
for (int i = 1; i <= n; i++) {
cin >> k >> s;
sort(s.begin(), s.end());
{
if (s.size() == 1) {
if (s[0] == 'A') {
a.push_back(k);
f1 = 1;
} else if (s[0] == 'B') {
b.push_back(k);
f2 = 1;
} else {
c.push_back(k);
f3 = 1;
}
} else if (s.size() == 2) {
if (s[0] == 'A' && s[1] == 'B') {
ab.push_back(k);
f1 = 1;
f2 = 1;
} else if (s[0] == 'B' && s[1] == 'C') {
bc.push_back(k);
f2 = 1;
f3 = 1;
} else {
ca.push_back(k);
f1 = 1;
f3 = 1;
}
} else {
abc.push_back(k);
f1 = 1;
f2 = 1;
f3 = 1;
}
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
sort(ab.begin(), ab.end());
sort(bc.begin(), bc.end());
sort(ca.begin(), ca.end());
sort(abc.begin(), abc.end());
vector<int> v;
int ans;
if (f1 == 1 && f2 == 1 && f3 == 1) {
if (a.size() >= 1 && b.size() >= 1 && c.size() >= 1) {
v.push_back(a[0] + b[0] + c[0]);
}
if (a.size() >= 1 && bc.size() >= 1) {
v.push_back(a[0] + bc[0]);
}
if (b.size() >= 1 && ca.size() >= 1) {
v.push_back(b[0] + ca[0]);
}
if (c.size() >= 1 && ab.size() >= 1) {
v.push_back(c[0] + ab[0]);
}
if (ab.size() >= 1 && bc.size() >= 1) {
v.push_back(ab[0] + bc[0]);
}
if (ab.size() >= 1 && ca.size() >= 1) {
v.push_back(ab[0] + ca[0]);
}
if (bc.size() >= 1 && ca.size() >= 1) {
v.push_back(ca[0] + bc[0]);
}
if (bc.size() >= 1 && a.size() >= 1 && b.size() >= 1) {
v.push_back(a[0] + bc[0] + b[0]);
}
if (ca.size() >= 1 && a.size() >= 1 && b.size() >= 1) {
v.push_back(a[0] + ca[0] + b[0]);
}
if (bc.size() >= 1 && a.size() >= 1 && c.size() >= 1) {
v.push_back(a[0] + bc[0] + c[0]);
}
if (ab.size() >= 1 && a.size() >= 1 && c.size() >= 1) {
v.push_back(a[0] + ab[0] + c[0]);
}
if (ab.size() >= 1 && c.size() >= 1 && b.size() >= 1) {
v.push_back(c[0] + ab[0] + b[0]);
}
if (ca.size() >= 1 && b.size() >= 1 && c.size() >= 1) {
v.push_back(ca[0] + c[0] + b[0]);
}
if (abc.size() >= 1) {
v.push_back(abc[0]);
}
sort(v.begin(), v.end());
cout << v[0] << endl;
} else {
cout << "-1" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
int gcd(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
int main() {
int n, i, g, max, val;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
g = a[0];
max = a[0];
for (i = 1; i < n; i++) {
if (a[i] > max) {
max = a[i];
}
g = gcd(g, a[i]);
}
val = max / g - n;
if (val % 2 == 0) {
printf("Bob\n");
} else {
printf("Alice\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, mod;
cin >> a >> b >> mod;
for (int j = 0; j < min(a + 1, mod); j++) {
long long theta = 1ll * j * 1e9;
theta %= mod;
theta = mod - theta;
theta %= mod;
if (theta <= b) continue;
cout << 1 << endl;
cout.width(9);
cout.fill('0');
cout << j << endl;
return 0;
}
puts("2");
}
| 10 |
#include <bits/stdc++.h>
int min[100010 << 2], R[100010 << 2], F[100010 << 2], G[100010 << 2];
inline void set(int x, int a, int b) {
if (min[x] >= a) {
min[x] = b;
F[x] = b;
if (!G[x]) G[x] = a;
}
}
inline void update(int &x, int &y, int &z) {
if (z > x)
y = x, x = z;
else if (z < x && z > y)
y = z;
}
inline void pushUp(int x) {
min[x] = R[x] = -1 << 30;
update(min[x], R[x], min[x << 1]);
update(min[x], R[x], R[x << 1]);
update(min[x], R[x], min[x << 1 | 1]);
update(min[x], R[x], R[x << 1 | 1]);
}
inline void pushDown(int x) {
if (F[x]) {
set(x << 1, G[x], F[x]);
set(x << 1 | 1, G[x], F[x]);
F[x] = 0;
G[x] = 0;
}
}
inline void build(int x, int l, int r) {
if (l == r) {
min[x] = l;
R[x] = -1 << 30;
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushUp(x);
}
inline void modify(int x, int l, int r, int _l, int _r, int a, int b) {
if (min[x] < a) return;
if (_l <= l && r <= _r && R[x] < a) {
set(x, a, b);
return;
}
pushDown(x);
int mid = (l + r) >> 1;
if (_l <= mid) modify(x << 1, l, mid, _l, _r, a, b);
if (_r > mid) modify(x << 1 | 1, mid + 1, r, _l, _r, a, b);
pushUp(x);
}
inline int Query(int x, int l, int r, int t) {
if (l == r) return min[x];
pushDown(x);
int mid = (l + r) >> 1;
if (t <= mid)
return Query(x << 1, l, mid, t);
else
return Query(x << 1 | 1, mid + 1, r, t);
}
int n, m, q, left[100010], ans[100010];
struct query {
int l, r, id;
inline friend bool operator<(const query &a, const query &b) {
return a.r < b.r;
}
} Q[100010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, l, r; i <= m; i++) scanf("%d%d", &l, &r), left[r] = l;
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d%d", &Q[i].l, &Q[i].r), Q[i].id = i;
std::sort(Q + 1, Q + q + 1);
build(1, 1, n);
for (int i = 1, cur = 1; i <= n; i++) {
if (left[i]) modify(1, 1, n, 1, left[i], left[i], i);
while (cur <= q && Q[cur].r == i)
ans[Q[cur].id] = Query(1, 1, n, Q[cur].l), cur++;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
static const int MOD = 1000000007;
static const long long MODL = 1000000000000000003LL;
static const double eps = 1e-8;
template <class T>
inline T MIN(const T x, const T y) {
return (x < y) ? x : y;
}
template <class T>
inline T MAX(const T x, const T y) {
return (x > y) ? x : y;
}
template <class T>
inline void UPDMIN(T &x, const T y) {
if (x > y) x = y;
}
template <class T>
inline void UPDMAX(T &x, const T y) {
if (x < y) x = y;
}
template <class T>
inline int SIZE(const T &x) {
return (int)x.size();
}
template <class T>
inline int LENGTH(const T &x) {
return (int)x.length();
}
template <class T1, class T2>
inline pair<T1, T2> MP(const T1 &x, const T2 &y) {
return make_pair(x, y);
}
inline int BINT(const int x) { return 1 << x; }
inline long long BLLD(const int x) { return 1LL << x; }
inline int BINT_TEST(const int s, const int x) { return (s & BINT(x)) != 0; }
inline int BLLD_TEST(const long long s, const int x) {
return (s & BLLD(x)) != 0LL;
}
template <class T>
inline T LOWBIT(const T x) {
return (x ^ (x - 1)) & x;
}
template <class T>
inline int BITCOUNT(const T x) {
return (!x) ? x : (1 + BITCOUNT(x & (x - 1)));
}
const double PI = acos(-1.0);
const double EPS = 1e-5;
template <class T>
inline T SQR(const T x) {
return x * x;
}
template <class T1, class T2>
inline T1 POW(const T1 x, const T2 y) {
if (!y)
return 1;
else if ((y & 1) == 0) {
return SQR(POW(x, y >> 1));
} else
return POW(x, y ^ 1) * x;
}
template <class T>
inline T GCD(const T x, const T y) {
if (x < 0) return GCD(-x, y);
if (y < 0) return GCD(x, -y);
return (!y) ? x : GCD(y, x % y);
}
template <class T>
inline T LCM(const T x, const T y) {
if (x < 0) return LCM(-x, y);
if (y < 0) return LCM(x, -y);
return x * (y / GCD(x, y));
}
template <class T>
inline T EEA(const T a, const T b, T &x, T &y) {
if (a < 0) {
T d = EEA(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EEA(a, -b, x, y);
y = -y;
return d;
}
if (!b) {
x = 1;
y = 0;
return a;
} else {
T d = EEA(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > FACTORIZE(T x) {
vector<pair<T, int> > ret;
if (x < 0) x = -x;
for (T i = 2; x > 1;) {
if (x % i == 0) {
int count = 0;
for (; x % i == 0; x /= i) count++;
ret.push_back(MP(i, count));
}
i++;
if (i > x / i) i = x;
}
return ret;
}
template <class T>
inline int ISPRIME(const T x) {
if (x <= 1) return 0;
for (T i = 2; SQR(i) <= x; i++)
if (x % i == 0) return 0;
return 1;
}
template <class T>
inline T EULARFUNCTION(T x) {
vector<pair<T, int> > f = FACTORIZE(x);
for (typename vector<pair<T, int> >::iterator it = f.begin(); it != f.end();
it++) {
x = x / it->first * (it->first - 1);
}
return x;
}
template <class T>
inline T INVERSEE(const T a, const T b = MOD) {
T x, y;
EEA(a, b, x, y);
return x ? x : 1;
}
template <class T>
inline T MOD_STD(const T x, const T m = MOD) {
return (x % m + m) % m;
}
template <class T>
inline void MOD_STD(T *x, const T m = MOD) {
*x = (*x % m + m) % m;
}
template <class T>
inline T MOD_ADD(const T x, const T y, const T m = MOD) {
return (x + y) % m;
}
template <class T>
inline void MOD_ADD(T *x, const T y, const T m = MOD) {
*x = (*x + y) % m;
}
template <class T>
inline T MOD_MUL(const T x, const T y, const T m = MOD) {
return (T)((1LL * x * y) % m);
}
template <class T>
inline void MOD_MUL(T *x, const T y, const T m = MOD) {
*x = (T)((1LL * (*x) * y) % m);
}
template <class T1, class T2>
inline T1 MOD_POW(const T1 x, const T2 y, const T1 m = MOD) {
if (y == 0)
return 1 % m;
else if ((y & 1) == 0) {
T1 z = MOD_POW(x, y >> 1, m);
return MOD_MUL(z, z, m);
} else
return MOD_MUL(MOD_POW(x, y ^ 1, m), x, m);
}
inline long long MODL_MUL(long long x, long long y, const long long m = MOD) {
if (x < y) swap(x, y);
long long z = 0LL;
while (y > 0) {
if (y & 1) {
MOD_ADD(&z, x, m);
}
MOD_ADD(&x, x, m);
y >>= 1;
}
return z;
}
inline long long MODL_POW(const long long x, const long long y,
const long long m = MOD) {
if (y == 0LL)
return 1LL % m;
else if ((y & 1) == 0LL) {
long long z = MODL_POW(x, y >> 1, m);
return MODL_MUL(z, z, m);
} else
return MODL_MUL(MODL_POW(x, y ^ 1, m), x, m);
}
template <class T>
class MATX {
private:
unsigned long hig, wid;
T *data;
void __init() {
this->data = (T *)malloc(sizeof(T) * this->hig * this->wid);
memset(this->data, 0, sizeof(T) * this->hig * this->wid);
}
public:
MATX() {
this->hig = this->wid = 1;
__init();
}
MATX(const unsigned long _len) {
this->hig = this->wid = _len;
__init();
}
MATX(const unsigned long _hig, const unsigned long _wid) {
this->hig = _hig;
this->wid = _wid;
__init();
}
MATX(const MATX &rhs) {
this->hig = rhs.hig;
this->wid = rhs.wid;
this->data = (T *)malloc(sizeof(T) * this->hig * this->wid);
for (unsigned long x = 0; x < this->hig; x++)
for (unsigned long y = 0; y < this->wid; y++)
this->data[x * this->wid + y] = rhs.at(x, y);
}
~MATX() { free(this->data); }
T &operator()(const unsigned long x, const unsigned long y) {
if (x >= this->hig || y >= this->wid) return (*(T *)NULL);
return this->data[x * wid + y];
}
MATX &operator=(const MATX &rhs) {
if (this->hig != rhs.hig || this->wid != rhs.wid) {
free(this->data);
this->hig = rhs.hig;
this->wid = rhs.wid;
this->data = (T *)malloc(sizeof(T) * this->hig * this->wid);
}
for (unsigned long x = 0; x < this->hig; x++)
for (unsigned long y = 0; y < this->wid; y++)
this->data[x * this->wid + y] = rhs.at(x, y);
return *this;
}
const MATX operator+(const MATX &opn) const {
MATX ret(*this);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
ret.data[x * ret.wid + y] += opn.at(x, y);
return ret;
}
const MATX operator-(const MATX &opn) const {
MATX ret(*this);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
ret.data[x * ret.wid + y] -= opn.at(x, y);
return ret;
}
const MATX operator*(const MATX &opn) const {
MATX ret(this->hig, opn.wid);
const unsigned long len = MIN(this->wid, opn.hig);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
for (unsigned long z = 0; z < len; z++)
ret.data[x * ret.wid + y] += this->at(x, z) * opn.at(z, y);
return ret;
}
const MATX mul(const MATX &opn) const { return *this * opn; }
template <class T2>
const MATX mul(const MATX &opn, const T2 m) const {
MATX ret(this->hig, opn.wid);
const unsigned long len = MIN(this->wid, opn.wid);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
for (unsigned long z = 0; z < len; z++)
MOD_ADD(&ret.data[x * ret.wid + y],
MOD_MUL(this->at(x, z), opn.at(z, y), m), m);
return ret;
}
MATX &operator+=(const MATX &rhs) {
*this = *this + rhs;
return *this;
}
MATX &operator-=(const MATX &rhs) {
*this = *this - rhs;
return *this;
}
MATX &operator*=(const MATX &rhs) {
*this = *this * rhs;
return *this;
}
const MATX pow(const unsigned long p) const {
MATX buff(*this), ret(this->hig, this->wid);
ret.set_one();
if (p > 0)
for (unsigned long i = 1;; i <<= 1) {
if (p & i) ret *= buff;
buff *= buff;
if (i > (p >> 1)) break;
}
return ret;
}
template <class T2>
const MATX pow(const unsigned long p, const T2 m) const {
MATX buff(*this), ret(this->hig, this->wid);
ret.set_one();
if (p > 0)
for (unsigned long i = 1;; i <<= 1) {
if (p & i) ret = ret.mul(buff, m);
buff = buff.mul(buff, m);
if (i > (p >> 1)) break;
}
return ret;
}
const T at(const unsigned long x, const unsigned long y) const {
if (x >= this->hig || y >= this->wid) return 0;
return this->data[x * wid + y];
}
void show() const {
for (unsigned long x = 0; x < this->hig; x++) {
for (unsigned long y = 0; y < this->wid; y++)
cout << this->at(x, y) << " ";
cout << endl;
}
}
void set_one() {
for (unsigned long x = 0; x < this->hig; x++)
for (unsigned long y = 0; y < this->wid; y++)
this->data[x * this->wid + y] = (x == y) ? 1 : 0;
}
};
template <class T>
class complex_t {
public:
T r, i;
complex_t(T x = 0.0, T y = 0.0) {
this->r = x;
this->i = y;
}
complex_t operator+(const complex_t &opn) const {
return complex_t(this->r + opn.r, this->i + opn.i);
}
complex_t operator-(const complex_t &opn) const {
return complex_t(this->r - opn.r, this->i - opn.i);
}
complex_t operator*(const complex_t &opn) const {
return complex_t(this->r * opn.r - this->i * opn.i,
this->r * opn.i + this->i * opn.r);
}
};
template <class T>
void fast_fourier_trans(complex_t<T> f[], const int len, const int is_dft) {
for (int i = 1, j = len >> 1; i < len - 1; i++) {
if (i < j) swap(f[i], f[j]);
int k = len >> 1;
while (j >= k) {
j -= k;
k >>= 1;
}
if (j < k) j += k;
}
for (int h = 2; h <= len; h <<= 1) {
complex_t<T> wn(cos(is_dft ? (-2 * PI / h) : (2 * PI / h)),
sin(is_dft ? (-2 * PI / h) : (2 * PI / h)));
for (int i = 0; i < len; i += h) {
complex_t<T> wm(1.0, 0.0);
for (int j = i; j < i + (h >> 1); j++) {
complex_t<T> u = f[j];
complex_t<T> t = wm * f[j + (h >> 1)];
f[j] = u + t;
f[j + (h >> 1)] = u - t;
wm = wm * wn;
}
}
}
if (!is_dft) {
for (int i = 0; i < len; i++) f[i].r /= len * 1.0;
}
}
class MILLERRABIN {
private:
static const int prime_table[12];
int witness(long long a, long long d, long long s, long long n) {
long long r = MODL_POW(a, d, n);
if (r == 1 || r == n - 1) return 0;
for (int i = 0; i < s - 1; i++) {
r = MODL_MUL(r, r, n);
if (r == 1) return 1;
if (r == n - 1) return 0;
}
return 1;
}
public:
int test(const long long n) {
if (n <= 2LL) return 0;
long long p = n - 1LL, s = 0LL;
while (!(p & 1)) {
p >>= 1;
s++;
}
for (int i = 0; i < 12 && this->prime_table[i] < n; i++) {
if (witness(this->prime_table[i], p, s, n)) return 0;
}
return 1;
}
};
const int MILLERRABIN::prime_table[12] = {2, 3, 5, 7, 11, 13,
17, 19, 23, 29, 31, 37};
template <class T>
inline int fsign(const T x) {
if (x > -eps && x < eps) return 0;
return (x < 0.0) ? -1 : 1;
}
template <class T>
class point_t {
public:
T x, y;
point_t() {
this->x = 0.0;
this->y = 0.0;
}
point_t(const T _x, const T _y) {
this->x = _x;
this->y = _y;
}
point_t operator-(const point_t &rhs) const {
return point_t(this->x - rhs.x, this->y - rhs.y);
}
T operator^(const point_t &rhs) const {
return this->x * rhs.y - this->y * rhs.x;
}
T operator*(const point_t &rhs) const {
return this->x * rhs.x + this->y * rhs.y;
}
bool operator<(const point_t &rhs) const {
if (fsign(this->y - rhs.y) != 0) return fsign(this->y - rhs.y) < 0;
return fsign(this->x - rhs.x) < 0;
}
T cross(const point_t &p, const point_t &q) const {
return (p - *this) ^ (q - *this);
}
void rotate(const double radian) {
T x0 = x, y0 = y;
T sinr = sin(radian);
T cosr = cos(radian);
x = x0 * cosr - y0 * sinr;
y = x0 * sinr + y0 * cosr;
}
void rotate(const point_t &p, const double radian) {
T x0 = x - p.x, y0 = y - p.y;
T sinr = sin(radian);
T cosr = cos(radian);
x = x0 * cosr - y0 * sinr + p.x;
y = x0 * sinr + y0 * cosr + p.y;
}
T dist2(const point_t &lhs, const point_t &rhs) const {
return (lhs - rhs) * (lhs - rhs);
}
T dist2(const point_t &rhs) const { return (*this - rhs) * (*this - rhs); }
T dist(const point_t &lhs, const point_t &rhs) const {
return sqrt((lhs - rhs) * (lhs - rhs));
}
T dist(const point_t &rhs) const {
return sqrt((*this - rhs) * (*this - rhs));
}
};
template <class T>
class segment_t {
public:
point_t<T> p, q;
segment_t() {
this->p.x = this->p.y = 0.0;
this->q.x = this->q.y = 0.0;
}
template <class T2>
segment_t(const point_t<T2> &_p, const point_t<T2> &_q) {
this->p.x = _p.x;
this->p.y = _p.y;
this->q.x = _q.x;
this->q.y = _q.y;
}
segment_t(const T px, const T py, const T qx, const T qy) {
this->p.x = px;
this->p.y = py;
this->q.x = qx;
this->q.y = qy;
}
T length() const { return this->p.dist(this->q); }
T length2() const { return this->p.dist2(this->q); }
int contain(const point_t<T> &pnt, const int ignore_endpoint = 0) const {
if (ignore_endpoint) {
return fsign((this->p - pnt) ^ (this->q - pnt)) == 0 &&
fsign((pnt.x - this->p.x) * (pnt.x - this->q.x)) < 0 &&
fsign((pnt.y - this->p.y) * (pnt.y - this->q.y)) < 0;
} else {
return fsign((this->p - pnt) ^ (this->q - pnt)) == 0 &&
fsign((pnt.x - this->p.x) * (pnt.x - this->q.x)) <= 0 &&
fsign((pnt.y - this->p.y) * (pnt.y - this->q.y)) <= 0;
}
}
int intersection(const segment_t &sa, const segment_t &sb,
const int ignore_endpoint = 0) const {
if (!ignore_endpoint) {
if (sa.contain(sb.p) || sa.contain(sb.q) || sb.contain(sa.p) ||
sb.contain(sa.q))
return 1;
}
return fsign(sa.p.cross(sa.q, sb.p)) * fsign(sa.p.cross(sa.q, sb.q)) < 0 &&
fsign(sb.p.cross(sb.q, sa.p)) * fsign(sb.p.cross(sb.q, sa.q)) < 0;
}
int intersection(const segment_t &rhs, const int ignore_endpoint = 0) const {
return this->intersection(*this, rhs, ignore_endpoint);
}
};
template <class T>
static int compare_pas(const void *x, const void *y, void *z) {
const point_t<T> *p1 = (point_t<T> *)x;
const point_t<T> *p2 = (point_t<T> *)y;
const point_t<T> *p0 = (point_t<T> *)z;
int sgn = fsign(((*p1) - (*p0)) ^ ((*p2) - (*p0)));
if (sgn != 0) return -sgn;
return fsign(p0->dist2(*p1) - p0->dist2(*p2));
}
template <class T>
void polar_angle_sort(point_t<T> *pnts, const int n) {
int p = 0;
for (int i = 1; i < n; i++) {
if (pnts[p] < pnts[i]) p = i;
}
swap(pnts[0], pnts[p]);
qsort_r(pnts + 1, n - 1, sizeof(point_t<T>), compare_pas<T>, pnts);
}
template <class T>
void graham(point_t<T> *pnts, const int n, int *idx, int &m) {
polar_angle_sort(pnts, n);
m = 0;
if (n < 3) return;
idx[m++] = 0;
idx[m++] = 1;
for (int i = 2; i < n; i++) {
while (m > 1 &&
fsign(pnts[idx[m - 2]].cross(pnts[idx[m - 1]], pnts[i])) <= 0)
m--;
idx[m++] = i;
}
}
const int inf = 0x3f3f3f3f;
int n, m;
int foo[32], til;
char a[110000], ans[110000];
int check(const int iap) {
const char cap = 'a' + iap;
int lst = -inf, buf = -inf;
for (int i = 0; i < 26; i++) foo[i] = 0;
for (int i = 0; i < n; i++) {
if (a[i] < cap) {
foo[a[i] - 'a']++;
lst = i;
} else if (a[i] == cap) {
buf = i;
}
if (i >= m - 1 && lst <= i - m) {
if (buf <= i - m) return 0;
foo[iap]++;
lst = buf;
}
}
til = 0;
for (int i = 0; i < 26; i++) {
for (; foo[i]; foo[i]--) {
ans[til++] = 'a' + i;
}
}
ans[til++] = 0;
return 1;
}
void core_entry() {
int lef = 0, rig = 26;
while (lef <= rig) {
int mid = (lef + rig) >> 1;
if (check(mid)) {
if (mid == lef || !check(mid - 1)) {
printf("%s\n", ans);
return;
}
rig = mid - 1;
} else
lef = mid + 1;
}
}
int main() {
while (scanf("%d", &m) != EOF) {
scanf("%s", a);
n = strlen(a);
core_entry();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
int l = a[0].first;
int r = a[0].second;
int cnt = 0;
for (int i = 1; i < n; i++) {
if (a[i].first > l && a[i].second < r)
cnt++;
else {
l = a[i].first;
r = a[i].second;
}
}
cout << cnt << "\n";
}
| 7 |
#include <bits/stdc++.h>
int A[1 << 12], n;
int B[1 << 12];
char buf[100];
void fwt(bool inv = false) {
const int U = 1 << n;
for (int i = 0; i < n; ++i) {
const int mid = 1 << i;
if (buf[i] == 'A' || buf[i] == 'a') {
if (!inv) {
for (int j = 0; j < U; j += mid << 1)
for (int k = j; k != j + mid; ++k) B[k] += B[k + mid];
} else {
for (int j = 0; j < U; j += mid << 1)
for (int k = j; k != j + mid; ++k) B[k] -= B[k + mid];
}
}
if (buf[i] == 'O' || buf[i] == 'o') {
if (!inv) {
for (int j = 0; j < U; j += mid << 1)
for (int k = j; k != j + mid; ++k) B[k + mid] += B[k];
} else {
for (int j = 0; j < U; j += mid << 1)
for (int k = j; k != j + mid; ++k) B[k + mid] -= B[k];
}
}
if (buf[i] == 'X' || buf[i] == 'x') {
if (!inv) {
for (int j = 0; j < U; j += mid << 1)
for (int k = j; k != j + mid; ++k) {
const int x = B[k], y = B[k + mid];
B[k] += y;
B[k + mid] = x - y;
}
} else {
for (int j = 0; j < U; j += mid << 1)
for (int k = j; k != j + mid; ++k) {
const int x = B[k], y = B[k + mid];
B[k] = x + y >> 1;
B[k + mid] = x - y >> 1;
}
}
}
}
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
int T, t, Q;
std::cin >> n >> T >> Q;
while (T-- > 0) std::cin >> t, ++A[t];
const int U = 1 << n;
while (Q-- > 0) {
std::cin >> buf, std::reverse(buf, buf + n);
memcpy(B, A, U << 2);
fwt();
for (int i = 0; i != U; ++i) B[i] *= B[i];
fwt(true);
int mask = 0;
for (int i = 0; i != n; ++i)
if (buf[i] >= 'a' && buf[i] <= 'z') mask |= 1 << i;
std::cout << B[mask] << std::endl;
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1e18;
const long double pai = acos(-1);
long long n, MX = 4294967295;
string s[100009];
long long N[100009];
long long en[100009];
long long num[109], here[100009];
long long val[109][100009];
long long mx[109];
void out() {
cout << "OVERFLOW!!!" << endl;
exit(0);
}
bool OverFlow(long long x, long long y) { return x > inf / y; }
void fill() {
for (long long i = 1; i <= 100; i++) {
val[i][0] = 1;
long long j = 1;
while (j <= 1e5) {
val[i][j] = val[i][j - 1] * i;
if (val[i][j] > MX) {
mx[i] = j;
break;
}
j++;
mx[i] = j;
}
}
}
int main() {
fill();
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == "for") cin >> N[i];
}
stack<long long> st;
for (long long i = 0; i < n; i++) {
if (s[i] == "add") continue;
if (s[i] == "for") {
st.push(i);
} else {
long long x = st.top();
st.pop();
en[x] = i;
}
}
for (long long i = 0; i < n; i++) {
if (s[i] != "for") continue;
here[i] = N[i];
here[en[i]] = -N[i];
}
long long crnt = 0;
for (long long i = 0; i < n; i++) {
if (here[i] > 0) num[here[i]]++;
if (here[i] < 0) num[-here[i]]--;
if (s[i] != "add") continue;
long long X = 1;
for (long long j = 1; j <= 100; j++) {
if (num[j] >= mx[j]) out();
if (OverFlow(X, val[j][num[j]])) out();
X *= val[j][num[j]];
if (X > MX) out();
}
crnt += X;
if (crnt > MX) out();
}
cout << crnt << endl;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define deb(x) cerr<<"["<<#x<<": "<<x<<"]"<<endl;
#define F first
#define S second
#define debp(x) cerr<<"["<<#x<<": "<<x.F<<" , "<<x.S<<"]"<<endl;
#define debv(v) cerr<<"{"<<#v<<":";for(auto i:v)cerr<<" "<<i;cerr<<"}"<<endl;
#define get(v) for(auto &i:v) cin>>i;
#define print(v) for(auto i:v) cout<<i<<" ";
#define trav(v) for(auto it=v.begin();it!=v.end();it++)
#define sz(x) x.size()
#define For(n) for(auto i=0;i<n;i++)
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define per(i,a,b) for(auto i=a;i>=b;i--)
#define vll vector<ll>
#define vi vector<int>
#define all(x) x.begin(),x.end()
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define pb push_back
#define mp make_pair
#define MOD 1000000007
const ll INF = 1e17;
const int nax = 2e5 + 5;
void solve() {
int n ;
cin >> n ;
vi a(n);
get(a);
vi ans(n,0);
int temp = 0;
for(int i = n - 1; i >= 0; i--) {
temp = max(temp, a[i]);
if(temp != 0) {
ans[i] = 1;
temp--;
}
}
print(ans);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, l;
scanf("%d %d", &k, &l);
if (l == 1) return printf("YES \n -1\n"), 0;
int tmp = 1;
for (int i = 1; tmp <= l; i++) {
tmp *= k;
if (tmp == l) return printf("YES \n %d\n", i - 1), 0;
if (l % tmp != 0) return printf("NO \n"), 0;
}
return printf("NO \n"), 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z;
char a[505][505];
bool r[505], c[505];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> x;
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i < x - 1; i++) {
for (int j = 1; j < x - 1; j++) {
if (a[i][j] == 'X' && a[i - 1][j - 1] == 'X' && a[i - 1][j + 1] == 'X' &&
a[i + 1][j - 1] == 'X' && a[i + 1][j + 1] == 'X') {
z++;
}
}
}
cout << z << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, i, j, c = 0, m, n, a, b;
string s = "aeiou", ss = "aeiou";
cin >> k;
for (i = 5; i < k; i++) {
if (k % i == 0) {
a = i;
break;
}
}
b = k / a;
if (a < 5 || b < 5) {
cout << -1;
return 0;
}
for (i = 0; i < 10000; i += 1) s += ss;
for (i = 0; i < b; i++) {
for (j = i; j < a + i; j++) cout << s[j];
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5, LMX = 19;
int n, q, p[MX], a[MX], inv[MX], lvl[MX];
vector<int> adj[MX];
int cn = 1, ini[MX], st[2 * MX][LMX];
void dfs(int u) {
ini[u] = cn;
st[cn][0] = u;
cn++;
for (int v : adj[u]) {
dfs(v);
st[cn][0] = u;
cn++;
}
}
int LCA(int i, int j) {
i = ini[i], j = ini[j];
if (i > j) swap(i, j);
int k = log2(j - i + 1);
if (lvl[st[i][k]] < lvl[st[j - (1 << k) + 1][k]]) return st[i][k];
return st[j - (1 << k) + 1][k];
}
bool samePath(int x, int a, int b, int y) {
int lca = LCA(x, y);
int f = LCA(x, a);
int g = LCA(y, a);
if (f != lca) swap(f, g);
if (f != lca || g != a) return 0;
f = LCA(x, b);
g = LCA(y, b);
if (f != lca) swap(f, g);
if (f != lca || g != b) return 0;
return 1;
}
struct ST {
int x, y;
bool ex;
};
int stpos[MX], mx = 0;
ST mex[4 * MX], res, aux;
void merge(ST &in, ST &a, ST &b) {
if (!a.ex || !b.ex) {
in.ex = 0;
return;
}
vector<int> v = {a.x, a.y, b.x, b.y};
sort(v.begin(), v.end());
do
if (samePath(v[0], v[1], v[2], v[3])) {
in.x = v[0], in.y = v[3], in.ex = 1;
return;
}
while (next_permutation(v.begin(), v.end()));
in.ex = 0;
}
void build(int i, int j, int pos) {
if (i == j) {
mex[pos].x = mex[pos].y = inv[i];
mex[pos].ex = 1;
stpos[i] = pos;
return;
}
int m = (i + j) / 2;
build(i, m, pos * 2);
build(m + 1, j, pos * 2 + 1);
merge(mex[pos], mex[pos * 2], mex[pos * 2 + 1]);
}
void update(int x, int k) {
int pos = stpos[x];
mex[pos].x = k;
mex[pos].y = k;
pos /= 2;
while (pos) {
merge(mex[pos], mex[pos * 2], mex[pos * 2 + 1]);
pos /= 2;
}
}
void query(int i, int j, int pos) {
if (i == j) return;
int m = (i + j) / 2;
if (mex[pos * 2].ex) {
if (res.ex) {
merge(aux, res, mex[pos * 2]);
if (aux.ex) {
mx = m;
res = aux;
query(m + 1, j, pos * 2 + 1);
} else {
query(i, m, pos * 2);
}
} else {
mx = m;
res = mex[pos * 2];
query(m + 1, j, pos * 2 + 1);
}
} else {
query(i, m, pos * 2);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]++;
inv[a[i]] = i;
}
for (int i = 2; i <= n; i++) {
cin >> p[i];
adj[p[i]].push_back(i);
lvl[i] = lvl[p[i]] + 1;
}
dfs(1);
for (int j = 1; (1 << j) <= cn; j++)
for (int i = 1; i + (1 << j) - 1 < cn; i++)
if (lvl[st[i][j - 1]] < lvl[st[i + (1 << (j - 1))][j - 1]])
st[i][j] = st[i][j - 1];
else
st[i][j] = st[i + (1 << (j - 1))][j - 1];
build(1, n, 1);
cin >> q;
while (q--) {
int t, i, j;
cin >> t;
if (t == 1) {
cin >> i >> j;
swap(inv[a[i]], inv[a[j]]);
swap(a[i], a[j]);
update(a[i], inv[a[i]]);
update(a[j], inv[a[j]]);
} else {
if (mex[1].ex)
cout << n << '\n';
else {
res.ex = 0;
query(1, n, 1);
cout << mx << '\n';
}
}
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
char c[7][51];
int b[7];
int v[7];
bool judge() {
if (v[b[1]] + v[b[6]] - 1 != v[b[3]] || v[b[2]] + v[b[5]] - 1 != v[b[4]])
return false;
if (c[b[1]][v[b[1]] - 1] != c[b[4]][0] ||
c[b[4]][v[b[4]] - 1] != c[b[6]][0] ||
c[b[5]][v[b[5]] - 1] != c[b[6]][v[b[6]] - 1] ||
c[b[2]][v[b[2]] - 1] != c[b[3]][0] ||
c[b[3]][v[b[3]] - 1] != c[b[5]][0] || c[b[1]][0] != c[b[2]][0])
return false;
if (c[b[3]][v[b[1]] - 1] != c[b[4]][v[b[2]] - 1]) return false;
return true;
}
char ans[101][51][51];
int main() {
for (int i = 1; i <= 6; i++) {
cin >> c[i];
b[i] = i;
}
for (int i = 1; i <= 6; i++) {
v[i] = strlen(c[b[i]]);
}
int s = 0;
do {
if (judge() == true) {
s++;
for (int i = 0; i <= v[b[4]] - 1; i++) {
for (int j = 0; j <= v[b[3]] - 1; j++) {
ans[s][i][j] = '.';
}
}
for (int i = 0; i < v[b[1]]; i++) ans[s][0][i] = c[b[1]][i];
for (int i = 0; i < v[b[2]]; i++) ans[s][i][0] = c[b[2]][i];
for (int i = 0; i < v[b[3]]; i++) ans[s][v[b[2]] - 1][i] = c[b[3]][i];
for (int i = 0; i < v[b[4]]; i++) ans[s][i][v[b[1]] - 1] = c[b[4]][i];
for (int i = 0; i < v[b[5]]; i++)
ans[s][v[b[2]] - 1 + i][v[b[3]] - 1] = c[b[5]][i];
for (int i = 0; i < v[b[6]]; i++)
ans[s][v[b[4]] - 1][v[b[1]] - 1 + i] = c[b[6]][i];
}
} while (next_permutation(b + 1, b + 1 + 6));
int r = 0, minx = 1;
if (s == 0) {
cout << "Impossible";
return 0;
} else {
for (int i = 2; i <= s; i++) {
for (int j = 0; j <= 30; j++) {
r = strcmp(ans[i][j], ans[minx][j]);
if (r < 0) {
minx = i;
break;
} else if (r > 0) {
break;
}
}
}
}
for (int i = 0; i < 31; i++) {
cout << ans[minx][i] << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, b, a, mxa, arr[maxn];
int main() {
scanf("%d %d %d", &n, &b, &a);
mxa = a;
for (int i = 0; i < n; ++i) scanf("%d", arr + i);
int i = 0;
for (; i < n; ++i) {
if (arr[i] == 1 && a < mxa && b > 0) {
++a, --b;
} else if (a > 0) {
--a;
} else if (b > 0) {
--b;
} else {
break;
}
}
printf("%d\n", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 1000 + 5;
int n;
bool h[N];
pair<int, int> a[N];
int main() {
ios ::sync_with_stdio(0);
cin >> n;
long long ans = linf;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
for (int i = 1; i <= 1000; i++) {
memset(h, 0, sizeof(h));
int cnt = 0;
long long sum = 0;
bool flag = 1;
for (int j = 1; j <= n; j++) {
if (a[j].second > i) {
flag &= a[j].first <= i;
cnt++;
sum += a[j].second;
} else {
sum += a[j].first;
h[j] = 1;
}
}
if (flag and cnt <= n / 2) {
vector<int> v;
for (int j = 1; j <= n; j++)
if (h[j] and a[j].first <= i and a[j].second < a[j].first)
v.push_back(a[j].first - a[j].second);
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int j = 0; j <= min((int)v.size() - 1, n / 2 - cnt - 1); j++)
sum -= v[j];
ans = min(ans, sum * i);
}
}
cout << ans << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char a[5010][5010];
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%s", a[i]);
vector<int> b(1, 0);
for (i = 1; i < n; i++) {
int l = 0, r = i - 1;
while (l < i && a[i][b[l]] == '0') l++;
while (r >= 0 && a[i][b[r]] == '1') r--;
if (l == r + 1)
b.insert(b.begin() + l, i);
else {
printf("%d %d %d\n", b[l] + 1, b[r] + 1, i + 1);
break;
};
};
if (i == n) printf("-1\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long query(long long t, long long i, long long j, long long k) {
cout << t << " " << i << " " << j << " " << k << endl;
long long ans;
cin >> ans;
if (t == 2) ans *= -1;
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<pair<long long, long long> > up, down;
for (long long i = 3; i <= n; i++) {
long long area = query(1, 1, 2, i);
long long sign = query(2, 1, 2, i);
if (sign == 1)
down.push_back(make_pair(area, i));
else
up.push_back(make_pair(area, i));
}
sort(down.begin(), down.end());
list<long long> l;
l.push_back(1);
l.push_back(2);
auto it = l.begin();
for (auto p : down) {
long long i = p.second;
if (query(2, *it, i, *next(it)) == -1)
l.insert(next(it), i), it++;
else
l.insert(it, i), it--;
}
vector<long long> ans(l.begin(), l.end());
sort(up.begin(), up.end());
l.clear();
l.push_back(1);
l.push_back(2);
it = l.begin();
for (auto p : up) {
long long i = p.second;
if (query(2, *it, i, *next(it)) == 1)
l.insert(next(it), i), it++;
else
l.insert(it, i), it--;
}
l.pop_front();
l.pop_back();
for (auto i = l.rbegin(); i != l.rend(); i++) ans.push_back(*i);
cout << "0 ";
for (long long first : ans) cout << first << " ";
cout << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long mpow(long long base, long long exp) {
base %= mod;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result;
}
bool f(int x, int y) { return x > y; }
int gcdExtended(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
void modInverse(int a, int m) {
int x, y;
int g = gcdExtended(a, m, &x, &y);
if (g != 1)
cout << "Inverse doesn't exist";
else {
int res = (x % m + m) % m;
cout << "Modular multiplicative inverse is " << res;
}
}
int binomialCoeff(int n, int k) {
int res = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int k;
cin >> k;
for (int i = 0; i < n; i++) {
if (i > 0) cout << " ";
if (k > 0)
cout << (2 * i + 2) << " " << (2 * i + 1);
else
cout << (2 * i + 1) << " " << (2 * i + 2);
k--;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int DIV = 1000000007;
int main(int argc, char* argv[]) {
FILE* f = stdin;
int n, x, y, x1 = -2000, y1 = -2000, x2 = -2000, y2 = -2000;
fscanf(f, "%d\n", &n);
for (int i = 0; i < n; i++) {
fscanf(f, "%d %d\n", &x, &y);
if (i == 0) {
x1 = x;
y1 = y;
} else {
if (x != x1) x2 = x;
if (y != y1) y2 = y;
}
}
if (x1 > -2000 && x2 > -2000 && y1 > -2000 && y2 > -2000)
printf("%d", abs(x2 - x1) * abs(y2 - y1));
else
printf("-1");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[10010];
int main() {
int n, suma = 0, sumb = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x == 100) suma++;
if (x == 200) sumb++;
}
if (suma == 0 || sumb == 0) {
if (suma == 0 && sumb % 2 == 0) {
cout << "YES";
return 0;
}
if (suma % 2 == 0 && sumb == 0) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
if (suma % 2 == 0 && sumb % 2 == 1) {
cout << "YES";
return 0;
}
if (suma % 2 == 0 && sumb % 2 == 0) {
cout << "YES";
return 0;
}
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1005;
bool visit[M];
long long int dist[M];
vector<pair<int, int> > g1[M], g2[M];
int n, m, t, quant;
void calc(int second) {
memset(visit, 0, sizeof visit);
fill_n(dist, M, 1e15);
dist[second] = 0;
priority_queue<pair<long long int, int> > q;
q.push(make_pair(0, second));
while (!q.empty()) {
pair<long long int, int> p = q.top();
q.pop();
long long int cost = p.first;
int u = p.second;
if (!visit[u]) {
visit[u] = true;
for (int i = 0; i < g1[u].size(); i++) {
int v = g1[u][i].first;
long long int c = g1[u][i].second;
if (dist[u] + c < dist[v]) {
dist[v] = dist[u] + c;
q.push(make_pair(-dist[v], v));
}
}
}
}
for (int i = 1; i <= n; i++) {
if (i == second) continue;
if (dist[i] <= t) g2[second].push_back(make_pair(i, quant));
}
}
long long int dijkstra(int second, int d) {
memset(visit, 0, sizeof visit);
fill_n(dist, M, 1e15);
dist[second] = 0;
priority_queue<pair<long long int, int> > q;
q.push(make_pair(0, second));
while (!q.empty()) {
pair<long long int, int> p = q.top();
q.pop();
long long int cost = p.first;
int u = p.second;
if (u == d) return -cost;
if (!visit[u]) {
visit[u] = true;
for (int i = 0; i < g2[u].size(); i++) {
int v = g2[u][i].first;
long long int c = g2[u][i].second;
if (dist[u] + c < dist[v]) {
dist[v] = dist[u] + c;
q.push(make_pair(-dist[v], v));
}
}
}
}
return -1;
}
int main() {
int a, b;
scanf("%d %d", &n, &m);
scanf("%d %d", &a, &b);
for (int i = 0; i < m; i++) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
g1[x].push_back(make_pair(y, w));
g1[y].push_back(make_pair(x, w));
}
for (int i = 1; i <= n; i++) {
scanf("%d %d", &t, &quant);
calc(i);
}
cout << dijkstra(a, b);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 10;
void solve() {
long long n, k;
cin >> n >> k;
vector<bool> vis(2 * n + 1, false);
vector<pair<long long, long long>> a;
for (long long i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
if (x > y) {
swap(x, y);
}
a.push_back({x, y});
vis[x] = true;
vis[y] = true;
}
vector<long long> unvis;
for (long long i = 1; i <= 2 * n; i++) {
if (!vis[i]) {
unvis.push_back(i);
}
}
for (long long i = 0, j = n - k; i < n - k; i++, j++) {
a.push_back({unvis[i], unvis[j]});
}
sort(a.begin(), a.end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (a[j].first < a[i].second && a[j].second > a[i].second) ans++;
}
}
cout << ans << "\n";
;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int n, m;
int bl;
int a[100005], nex[100005], steps[100005], b[100005];
int main() {
scanf("%d%d", &n, &m);
bl = sqrt(n);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]), b[i] = i / bl;
for (int i = (n - 1); i >= 0; i--) {
int x = i + a[i];
if (x >= n)
nex[i] = -1, steps[i] = 1;
else if (b[i] == b[x])
nex[i] = nex[x], steps[i] = 1 + steps[x];
else
nex[i] = x, steps[i] = 1;
}
while (m--) {
int type, x, y, z;
scanf("%d", &type);
if (type == 0) {
scanf("%d%d", &x, &y);
x--;
a[x] = y;
if (x + y >= n)
nex[x] = -1, steps[x] = 1;
else if (b[x] == b[x + y])
nex[x] = nex[x + y], steps[x] = 1 + steps[x + y];
else
nex[x] = x + y, steps[x] = 1;
while (x > 0 and b[x] == b[x - 1]) {
x--;
y = a[x];
if (x + y >= n)
nex[x] = -1, steps[x] = 1;
else if (b[x] == b[x + y])
nex[x] = nex[x + y], steps[x] = 1 + steps[x + y];
else
nex[x] = x + y, steps[x] = 1;
}
} else {
scanf("%d", &x);
x--;
int ans = 0, cur = x;
while (x != -1) {
ans += steps[x];
cur = x;
x = nex[x];
}
while (cur < n) x = cur, cur = cur + a[cur];
printf("%d %d\n", x + 1, ans);
}
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int tavan(int x, int y) {
int res = 1;
while (y) {
res *= y % 2 ? x : 1;
res %= ((int)1e9 + 7);
x *= x;
x %= ((int)1e9 + 7);
y /= 2;
}
return res;
}
int n, m, a[((int)301 * 1000)], even, odd, ans;
vector<int> bad, v_even, v_odd, now_even, now_odd;
set<int> s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (s.count(a[i]))
bad.push_back(i), ans++;
else {
s.insert(a[i]);
if (a[i] % 2 == 0)
even++, now_even.push_back(i);
else
odd++, now_odd.push_back(i);
}
}
for (int i = 1; i <= min(m, (int)4e5); i++) {
if (s.count(i)) continue;
if (i % 2 == 0)
v_even.push_back(i);
else
v_odd.push_back(i);
}
for (auto u : bad) {
if (even <= odd) {
if (!v_even.size()) return cout << -1, 0;
a[u] = v_even.back();
v_even.pop_back();
even++;
} else {
if (!v_odd.size()) return cout << -1, 0;
a[u] = v_odd.back();
v_odd.pop_back();
odd++;
}
}
while (even < odd) {
if (!now_odd.size() || !v_even.size()) return cout << -1, 0;
a[now_odd.back()] = v_even.back();
now_odd.pop_back();
v_even.pop_back();
odd--;
even++;
ans++;
}
while (even > odd) {
if (!now_even.size() || !v_odd.size()) return cout << -1, 0;
a[now_even.back()] = v_odd.back();
now_even.pop_back();
v_odd.pop_back();
even--;
odd++;
ans++;
}
cout << ans << "\n";
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 11 |
Subsets and Splits