solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
int n, m;
std::cin >> n >> m;
std::vector<int> a;
std::vector<long long> c;
a.resize(n);
c.resize(n);
for (long long i = 0; i < n; i++) {
std::cin >> a[i];
a[i];
}
for (long long i = 0; i < n; i++) {
std::cin >> c[i];
}
std::vector<int> t, d;
t.resize(m);
d.resize(m);
for (long long j = 0; j < m; j++) {
std::cin >> t[j] >> d[j];
t[j]--;
}
std::vector<int> cheapest;
cheapest.resize(n);
std::iota(cheapest.begin(), cheapest.end(), 0);
std::sort(cheapest.begin(), cheapest.end(), [&](int a, int b) -> bool {
if (c[a] < c[b])
return true;
else if (c[b] < c[a])
return false;
else
return a < b;
});
int chi = 0;
for (long long j = 0; j < m; j++) {
long long cost = 0;
if (a[t[j]] >= d[j]) {
a[t[j]] -= d[j];
cost += d[j] * c[t[j]];
} else {
if (chi == n) {
cost = 0;
} else {
cost += a[t[j]] * c[t[j]];
d[j] -= a[t[j]];
a[t[j]] = 0;
while (chi < n && d[j] != 0) {
long long min = std::min(a[cheapest[chi]], d[j]);
cost += min * c[cheapest[chi]];
d[j] -= min;
a[cheapest[chi]] -= min;
if (a[cheapest[chi]] == 0) chi++;
}
if (d[j] != 0) {
cost = 0;
}
}
}
std::cout << cost << std::endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int x, y;
int main() {
cin >> a >> b;
for (int i = 0; i <= a.size() - 1; i++)
if (a[i] == '1') x++;
for (int i = 0; i <= b.size() - 1; i++)
if (b[i] == '1') y++;
if (x + (x % 2) >= y)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, i, j;
cin >> n;
long long a[n], b[n];
long long loc[n + 1];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] != 0) loc[a[i]] = -1;
}
for (i = 0; i < n; i++) {
cin >> b[i];
if (b[i] != 0) loc[b[i]] = i;
}
sort(a, a + n);
long long tmp = b[n - 1];
long long st = 1;
if (tmp != 0) {
j = n - 1;
while (tmp > 0) {
if (b[j] != tmp) break;
j--;
tmp--;
}
if ((tmp == 0)) {
if (b[n - 1] == n)
st = n + 1;
else if ((loc[b[n - 1] + 1] == -1))
st = b[n - 1] + 1;
}
}
long long ans = 0;
long long t1 = 0;
long long rep = 0;
for (i = st; i < n + 1; i++) {
if ((loc[i] == -1) || (loc[i] - t1 <= i - 2 - st + 1))
continue;
else {
if (st != 1) {
ans = 0;
st = 1;
t1 = 0;
rep = 1;
break;
}
if (i == 1) {
ans += loc[i] - t1 + 1;
t1 += loc[i] - t1 + 1;
} else {
ans += loc[i] - t1 - i + 2;
t1 += loc[i] - t1 - i + 2;
}
}
}
if (rep == 1) {
for (i = st; i < n + 1; i++) {
if ((loc[i] == -1) || (loc[i] - t1 <= i - 2))
continue;
else {
if (i == 1) {
ans += loc[i] - t1 + 1;
t1 += loc[i] - t1 + 1;
} else {
ans += loc[i] - t1 - i + 2;
t1 += loc[i] - t1 - i + 2;
}
}
}
}
ans += n - st + 1;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e3 + 5;
int a[N], dp[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= k; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1, j = 1; i <= n; i++, j = i) {
while (j > 0 && (a[i] - a[j]) <= 5) {
j--;
}
for (int l = 1; l <= k; l++) {
dp[i][l] = max(dp[i - 1][l], dp[j][l - 1] + i - j);
}
}
int ans = 0;
for (int i = 1; i <= k; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool comp(string &a, string &b) { return a.size() < b.size(); }
int main() {
int n, an = 1;
cin >> n;
string s[n];
for (int a = 0; a < n; a++) cin >> s[a];
sort(s, s + n, comp);
for (int a = 1; a < n; a++) {
bool ok = 0;
for (int b = 0; b <= (s[a].size() - s[a - 1].size()); b++)
if (s[a].substr(b, s[a - 1].size()) == s[a - 1]) ok = 1;
if (ok == 0) an = 0;
}
if (an) {
cout << "YES\n";
for (int a = 0; a < n; a++) cout << s[a] << "\n";
} else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long fib[48];
int nFib;
unsigned long long generate() {
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i < 48; ++i) fib[i] = fib[i - 1] + fib[i - 2];
return fib[48 - 1];
}
int main(void) {
generate();
unsigned long long n;
cin >> n;
unsigned long long* p = upper_bound(fib, fib + 48, n) - 1;
if (p - 4 >= fib)
cout << *(p - 4) << " " << *(p - 3) << " " << *(p - 1) << endl;
else
cout << "0 0 " << *p << endl;
return EXIT_SUCCESS;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char s[1007][1007];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> s[i][j];
}
}
if (n < 3) {
cout << "0";
} else {
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (s[i][j] == 'X' && s[i - 1][j + 1] == 'X' &&
s[i + 1][j - 1] == 'X' && s[i - 1][j - 1] == 'X' &&
s[i + 1][j + 1] == 'X') {
res++;
}
}
}
cout << res;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int mod = 1e9 + 7;
inline int read() {
char c = getchar();
int t = 0, f = 1;
while ((!isdigit(c)) && (c != EOF)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c) && (c != EOF)) {
t = (t << 3) + (t << 1) + (c ^ 48);
c = getchar();
}
return t * f;
}
int n, k;
int mu[maxn], p[maxn], cnt, vis[maxn];
void get() {
mu[1] = 1;
for (int i = 2; i <= k; i++) {
if (!vis[i]) {
p[++cnt] = i;
mu[i] = -1;
}
for (int j = 1; j <= cnt && 1ll * i * p[j] <= k; j++) {
vis[i * p[j]] = 1;
mu[i * p[j]] = mu[i] * mu[p[j]];
if (i % p[j] == 0) {
mu[i * p[j]] = 0;
break;
}
}
}
}
inline int ksm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return ans;
}
int pw[maxn], b[maxn * 2];
int main() {
n = read(), k = read();
for (int i = 1; i <= k; i++) pw[i] = ksm(i, n);
get();
for (int x = 1; x <= k; x++) {
for (int i = 1; i * x <= k; i++) {
b[i * x] = (b[i * x] + 1ll * pw[i] * (mod + mu[x]) % mod) % mod;
b[i * x] = (b[i * x] - 1ll * pw[i - 1] * (mod + mu[x]) % mod) % mod;
if (b[i * x] < 0) b[i * x] += mod;
}
}
int ans = 0;
for (int i = 1; i <= k; i++) {
b[i] = (b[i] + b[i - 1]) % mod;
ans = (ans + (b[i] ^ i) % mod) % mod;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 1000000000000000000;
void solve() {
long long n, m;
cin >> n >> m;
m++;
long long k = 0;
for (int i = 32; i >= 0 && (k ^ n) < m; i--) {
if ((n & ((long long)1 << i)) && (m & ((long long)1 << i))) {
continue;
} else if ((n & ((long long)1 << i)) && !(m & ((long long)1 << i))) {
break;
} else if (!(n & ((long long)1 << i)) && (m & ((long long)1 << i))) {
k |= (1 << i);
}
}
cout << k << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void solve() {
int n, x, p;
cin >> n >> x >> p;
int gt = n - x, lt = x - 1;
long long cnt = 1;
int l = 0, r = n;
while (l < r) {
int m = l + (r - l) / 2;
if (m <= p) {
if (m < p) cnt = cnt * lt-- % 1000000007LL;
l = m + 1;
} else {
cnt = cnt * gt-- % 1000000007LL;
r = m;
}
}
for (int i = 1; i <= lt + gt; ++i) cnt = cnt * i % 1000000007LL;
cout << cnt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e5;
const long long int mod = 1e3 + 2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
string t = "RGB";
long long int ans = maxn;
for (long long int i = 0; i < (n - k + 1); ++i) {
for (long long int st = 0; st < 3; ++st) {
long long int count = 0;
for (long long int j = 0; j < k; ++j) {
if (s[i + j] != t[(st + j) % 3]) count++;
}
ans = min(count, ans);
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 100500;
const int MAXN = 6;
set<long long> used;
int n;
int l[MAXN];
int r[MAXN];
long double ans = 0.0L;
int p[MAXN];
bool was[MAXN];
int q[MAXN];
void solve(int cnt0) {
if (cnt0 > 1) {
int L = 0, R = INF;
for (int i = int(0); i < int(n); ++i)
if (q[i] == 0) {
L = max(L, l[i]);
R = min(R, r[i]);
}
for (int mx = int(L); mx < int(R + 1); ++mx) {
long double cur = mx * 1.0L;
for (int i = int(0); i < int(n); ++i)
if (q[i] > 0)
cur *= max(0.0L,
(min(mx - 1, r[i]) - l[i] + 1) * 1.0L / (r[i] - l[i] + 1));
else if (q[i] == 0)
cur *= 1.0L / (r[i] - l[i] + 1);
ans += cur;
}
} else {
int L = 0, R = INF;
for (int i = int(0); i < int(n); ++i)
if (q[i] == 1) {
L = max(L, l[i]);
R = min(R, r[i]);
}
for (int mx = int(L); mx < int(R + 1); ++mx) {
long double cur = mx * 1.0L;
for (int i = int(0); i < int(n); ++i)
if (q[i] == 0)
cur *= max(0.0L,
(r[i] - max(mx + 1, l[i]) + 1) * 1.0L / (r[i] - l[i] + 1));
else if (q[i] == 2)
cur *= max(0.0L,
(min(mx - 1, r[i]) - l[i] + 1) * 1.0L / (r[i] - l[i] + 1));
else if (q[i] == 1)
cur *= 1.0L / (r[i] - l[i] + 1);
ans += cur;
}
}
}
void gen(int pos) {
if (pos == n) {
for (int i = int(0); i < int(n); ++i) {
q[i] = p[i];
was[i] = false;
}
for (int i = int(0); i < int(n); ++i) {
int j = -1;
for (int k = int(0); k < int(n); ++k)
if (!was[k] && (j == -1 || q[j] > q[k])) j = k;
if (j == -1) break;
int tmp = q[j];
for (int k = int(0); k < int(n); ++k)
if (!was[k] && q[k] == tmp) {
q[k] = i;
was[k] = true;
}
}
int cnt0 = 0, mx = 0;
for (int i = int(0); i < int(n); ++i) {
if (q[i] == 0) cnt0++;
mx = max(mx, q[i]);
}
if (cnt0 > 1 && mx > 1) return;
long long num = 0;
for (int i = int(0); i < int(n); ++i) num = num * 3 + q[i];
if (!used.count(num)) {
used.insert(num);
solve(cnt0);
}
return;
}
for (int i = int(0); i < int(min(3, n)); ++i) {
p[pos] = i;
gen(pos + 1);
}
}
int main() {
cout << fixed << setprecision(10);
scanf("%d", &n);
for (int i = int(0); i < int(n); ++i) scanf("%d%d", &l[i], &r[i]);
used.clear();
gen(0);
cout << (double)ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int BIGINT = 0x0FFFFFFF;
const int MAXN = 1001;
const long long MOD = 1000000007ll;
long long dp[MAXN][MAXN];
void init(int n, int k) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = -1;
}
long long ans(int n, int k) {
if (n <= 0) return 0;
if (k == 0) return 1;
if (dp[n][k] != -1) return dp[n][k];
long long s = 0;
for (int i = 1; i <= n; i++) s += ((n - i + 1) * ans(i - 2, k - 1)) % MOD;
return dp[n][k] = s % MOD;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
init(max(n, m), k);
cout << (ans(n, k) * ans(m, k)) % MOD << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7;
const int MAX = 1e5 + 3;
const long long INF = 1e9 + 7;
struct str {
int x, y, i, r;
};
str a[N], w[N];
int t[N];
bool cmp(str a, str b) {
return (a.r < b.r) || (a.r == b.r && a.x + a.y <= b.x + b.y);
}
bool cmp1(str a, str b) { return (a.r < b.r) || (a.r == b.r && a.i < b.i); }
bool cmpi(str a, str b) { return a.i < b.i; }
bool cmpxy(str a, str b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }
void add(int i, int l, int r, int x, int z) {
if (x < l || x >= r) return;
if (l == r - 1) {
t[i] = max(t[i], z);
return;
}
int m = (l + r) / 2;
add(i * 2 + 1, l, m, x, z);
add(i * 2 + 2, m, r, x, z);
t[i] = max(t[i * 2 + 1], t[i * 2 + 2]);
}
int ret(int i, int l, int r, int a, int b) {
if (b <= l || a >= r) return 0;
if (a <= l && r <= b) return t[i];
int m = (l + r) / 2;
return max(ret(i * 2 + 1, l, m, a, b), ret(i * 2 + 2, m, r, a, b));
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].y;
a[i].r = a[i].y - a[i].x;
a[i].i = i;
}
for (int i = 0; i < n; i++) {
cin >> w[i].r;
w[i].i = i;
}
sort(a, a + n, cmp);
sort(w, w + n, cmp1);
for (int i = 0; i < n; i++)
if (a[i].r != w[i].r)
return cout << "NO", 0;
else
a[i].i = w[i].i + 1;
sort(a, a + n, cmpxy);
for (int i = 0; i < n; i++) {
if (ret(0, 0, MAX, 0, a[i].y + 1) > a[i].i) return cout << "NO", 0;
add(0, 0, MAX, a[i].y, a[i].i);
}
sort(a, a + n, cmpi);
cout << "YES\n";
for (int i = 0; i < n; i++) cout << a[i].x << " " << a[i].y << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace bit {
int tree[434543];
void upd(int x, int y) {
if (x)
for (; x < 434543; x += x & -x) tree[x] += y;
}
int ask(int x) {
int y = 0;
for (; x; x -= x & -x) y += tree[x];
return y;
}
}; // namespace bit
int n, m;
int dist(int x, int y);
namespace lct {
int ch[434543][2];
int col[434543];
int tag[434543];
int rev[434543];
int siz[434543];
int pa[434543];
int nroot(int x) { return ch[pa[x]][0] == x or ch[pa[x]][1] == x; }
void up(int x) { siz[x] = siz[ch[x][0]] + siz[ch[x][1]] + (x > 0); }
void flip(int x) {
swap(ch[x][0], ch[x][1]);
rev[x] ^= 1;
}
void down(int x) {
if (!x) return;
if (rev[x]) flip(ch[x][0]), flip(ch[x][1]);
if (tag[x])
tag[ch[x][0]] = tag[ch[x][1]] = col[ch[x][0]] = col[ch[x][1]] = tag[x];
tag[x] = rev[x] = 0;
}
void rotate(int x) {
int y = pa[x], z = pa[y];
if (nroot(y)) ch[z][ch[z][1] == y] = x;
int d = ch[y][1] == x;
int w = ch[x][d ^ 1];
ch[y][d] = w;
if (w) pa[w] = y;
pa[x] = z, pa[y] = x;
ch[x][d ^ 1] = y;
up(y);
up(x);
}
void splay(int x) {
vector<int> dj;
int xx = x;
while (nroot(x)) dj.push_back(x), x = pa[x];
dj.push_back(x);
x = xx;
for (int i = dj.size() - 1; ~i; i--) down(dj[i]);
while (nroot(x)) {
int y = pa[x], z = pa[y];
if (nroot(y)) {
if ((ch[y][1] == x) ^ (ch[z][1] == y))
rotate(x);
else
rotate(y);
}
rotate(x);
}
}
void access(int x, int cc) {
for (int y = 0; x; y = x, x = pa[x]) {
splay(x);
ch[x][1] = 0;
up(x);
bit::upd(col[x], -siz[x]);
col[x] = tag[x] = cc;
bit::upd(col[x], siz[x]);
ch[x][1] = y;
up(x);
}
}
void out(int x) {
if (!x) return;
down(x);
out(ch[x][0]);
cout << x << " ";
out(ch[x][1]);
}
void makeroot(int x, int cc) {
access(x, cc);
splay(x);
flip(x);
}
int query(int x) {
splay(x);
int cc = col[x];
return bit::ask(cc) - siz[ch[x][0]];
}
void link(int x, int y) { pa[x] = y; }
}; // namespace lct
vector<int> v[434543];
void dfs(int x, int p) {
for (int i = 0; i < v[x].size(); i++) {
if (v[x][i] != p) dfs(v[x][i], x), lct::link(v[x][i], x);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y), v[y].push_back(x);
}
dfs(1, 0);
int tot = 1;
lct::col[1] = 1;
for (int i = 2; i <= n; i++) lct::makeroot(i, ++tot);
memset(bit::tree, 0, sizeof bit::tree);
for (int i = 1; i <= n; i++) lct::splay(i), bit::upd(lct::col[i], 1);
char ctrl[213];
while (m--) {
scanf("%s", ctrl);
if (ctrl[0] == 'u') {
int x;
scanf("%d", &x);
lct::makeroot(x, ++tot);
} else if (ctrl[0] == 'w') {
int x;
scanf("%d", &x);
printf("%d\n", lct::query(x));
} else if (ctrl[0] == 'c') {
int x, y;
scanf("%d%d", &x, &y);
if (lct::query(x) < lct::query(y))
printf("%d\n", x);
else
printf("%d\n", y);
} else
puts("Where is the trust among people these days?");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string str;
cin >> str;
int length = str.length();
int l = 0, r = 0, u = 0, d = 0;
for (int i = 0; i < length; i++) {
if (str[i] == 'L') {
l++;
} else if (str[i] == 'R') {
r++;
} else if (str[i] == 'U') {
u++;
} else if (str[i] == 'D') {
d++;
}
}
int l1 = min(l, r);
int l2 = min(d, u);
if (l1 == 0 && l2 > 0) {
cout << "2\nUD\n";
continue;
}
if (l2 == 0 && l1 > 0) {
cout << "2\nLR\n";
continue;
}
string s1(l1, 'L');
string s2(l2, 'U');
string s3(l1, 'R');
string s4(l2, 'D');
int len = 2 * l1 + 2 * l2;
cout << len << "\n";
if (len == 0) {
cout << "\n";
} else {
cout << s1 << s2 << s3 << s4 << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
double x[4], y[4], d;
int main() {
int n, i, j;
x[2] = 10 * sin(54 * pi / 180);
d = x[2] * 2;
y[2] = 10 * cos(54 * pi / 180);
x[3] = 10 * cos(72 * pi / 180);
x[1] = d - x[3];
y[1] = y[3] = -10 * sin(72 * pi / 180);
scanf("%d", &n);
printf("%d\n", 4 * n + 1);
for (i = 0; i < n; i++)
for (j = 0; j < 4; j++) printf("%.15f %.15f\n", d * i + x[j], y[j]);
printf("%.15f %.15f\n", d * i, 0.0);
for (i = 0; i < n; i++)
printf("%d %d %d %d %d\n", 4 * i + 1, 4 * i + 3, 4 * i + 5, 4 * i + 2,
4 * i + 4);
for (i = 0; i < n; i++) printf("%d ", 4 * i + 1);
while (i--)
printf("%d %d %d %d ", 4 * i + 5, 4 * i + 4, 4 * i + 3, 4 * i + 2);
puts("1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct my_delimiters : ctype<char> {
my_delimiters() : ctype<char>(get_table()) {}
static mask const* get_table() {
static mask rc[table_size];
rc['('] = ctype_base::space;
rc[')'] = ctype_base::space;
rc['.'] = ctype_base::space;
rc[','] = ctype_base::space;
rc[' '] = ctype_base::space;
rc['\n'] = ctype_base::space;
return &rc[0];
}
};
struct Widget {
string name;
int type;
long long height;
long long width;
vector<string> children;
long long border;
long long spacing;
};
int n;
unordered_map<string, Widget> widgets;
void dfs(const string& name) {
for (const auto& child : widgets[name].children)
if (widgets[child].type != 3) dfs(child);
Widget& me = widgets[name];
if (me.type == 0) {
} else if (me.type == 1) {
if (me.children.empty())
me.width = 0, me.height = 0;
else {
long long total_children_width = 0;
long long max_height = 0;
for (const string& child : me.children)
total_children_width += widgets[child].width,
max_height = max(max_height, widgets[child].height);
me.width = total_children_width +
((long long)me.children.size() - 1) * me.spacing +
2 * me.border;
me.height = max_height + 2 * me.border;
}
} else if (me.type == 2) {
if (me.children.empty())
me.width = 0, me.height = 0;
else {
long long total_children_height = 0;
long long max_width = 0;
for (const string& child : me.children)
total_children_height += widgets[child].height,
max_width = max(max_width, widgets[child].width);
me.width = max_width + 2 * me.border;
me.height = total_children_height +
((long long)me.children.size() - 1) * me.spacing +
2 * me.border;
}
} else {
cout << "FAIL" << endl;
exit(1);
}
me.type = 3;
}
int main() {
ios::sync_with_stdio(0);
cin.imbue(locale(cin.getloc(), new my_delimiters));
cin >> n;
string line;
while (cin >> line)
if (line == "Widget") {
Widget w;
w.type = 0;
cin >> line;
w.name = move(line);
cin >> w.width >> w.height;
widgets[w.name] = move(w);
} else if (line == "HBox") {
Widget w;
w.type = 1;
cin >> line;
w.name = move(line);
w.border = 0;
w.spacing = 0;
widgets[w.name] = move(w);
} else if (line == "VBox") {
Widget w;
w.type = 2;
cin >> line;
w.name = move(line);
w.border = 0;
w.spacing = 0;
widgets[w.name] = move(w);
} else {
Widget& w = widgets[line];
cin >> line;
if (line == "pack") {
cin >> line;
w.children.push_back(line);
} else if (line == "set_border") {
cin >> w.border;
} else if (line == "set_spacing") {
cin >> w.spacing;
} else {
cout << "FAIL" << endl;
return 1;
}
}
for (const auto& pr : widgets)
if (pr.second.type != 3) dfs(pr.first);
vector<string> names;
for (const auto& pr : widgets) names.push_back(pr.first);
sort(names.begin(), names.end());
for (const string& name : names)
cout << name << ' ' << widgets[name].width << ' ' << widgets[name].height
<< endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[2002];
bool use[2002];
int siz = 0;
vector<pair<int, int> > g;
inline void dfs(int b) {
use[b] = true;
for (int i = 0; i < v[b].size(); i++) {
if (use[v[b][i]] == false) {
dfs(v[b][i]);
}
}
g.push_back(make_pair(siz, b));
siz++;
}
vector<int> r[2002];
int countt = 0;
inline void dfs2(int b) {
use[b] = false;
countt++;
for (int i = 0; i < r[b].size(); i++) {
if (use[r[b][i]]) {
dfs2(r[b][i]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int a;
scanf("%d", &a);
if (a) {
v[i].push_back(j);
r[j].push_back(i);
}
}
}
dfs(0);
sort(g.begin(), g.end());
dfs2(g.back().second);
if (countt == n) {
puts("YES");
} else {
puts("NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long inf = std::numeric_limits<long long>::max();
const long long mod = 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
stack<int> s;
vector<int> g[1100];
int xx, yy;
bool done;
void dfs(int v, int p) {
if (done) return;
for (auto i : g[v]) {
if (i == p) continue;
if (i == yy || done) {
done = true;
break;
}
s.push(i);
dfs(i, v);
if (!done) s.pop();
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 1100; i++) g[i].clear();
while (!s.empty()) s.pop();
set<int> x, y;
xx = yy = 0;
done = false;
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x1, y1;
cin >> x1 >> y1;
x1--, y1--;
g[x1].push_back(y1);
g[y1].push_back(x1);
}
int k1, k2;
cin >> k1;
for (int i = 0; i < k1; i++) {
int v;
cin >> v;
v--;
x.insert(v);
}
cin >> k2;
for (int i = 0; i < k2; i++) {
int v;
cin >> v;
v--;
y.insert(v);
}
yy = *y.begin();
cout << "B " << yy + 1 << endl;
cin >> yy;
yy--;
xx = *x.begin();
s.push(xx);
if (x.find(yy) != x.end()) {
cout << "C " << yy + 1 << endl;
continue;
}
dfs(xx, -1);
while (!s.empty() && x.find(s.top()) == x.end()) s.pop();
cout << "A " << s.top() + 1 << endl;
int ccc;
cin >> ccc;
ccc--;
if (y.find(ccc) == y.end()) {
cout << "C -1" << endl;
} else {
cout << "C " << s.top() + 1 << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int ub(int x, int j) {
int l = j, r = v.size() - 1, mid;
while (l <= r) {
mid = (l + r) / 2;
if (v[mid] <= x)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
int lb(int x, int j) {
int l = j, r = v.size() - 1, mid;
while (l <= r) {
mid = (l + r) / 2;
if (v[mid] < x)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long int gcd, i, h, l, r, j, k, x, y, z, x1, y1, x2, y2, n, m, root, t,
sum, size, ind, ans1 = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
v.resize(n);
long long int ans = 0;
int po[28];
po[0] = 1;
for (i = 1; i < 28; i++) po[i] = po[i - 1] * 2;
for (i = 0; i < 28 - 2; i++) {
for (j = 0; j < n; j++) v[j] = (a[j] % po[i + 1]);
sort(v.begin(), v.end());
sum = 0;
for (j = 0; j < n; j++) {
sum += (ub(po[i + 1] - 1 - v[j], j + 1) - lb(po[i] - v[j], j + 1));
sum += (ub(po[i + 2] - 2 - v[j], j + 1) -
lb(po[i + 1] + po[i] - v[j], j + 1));
}
if (sum & 1) ans += po[i];
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[100009];
int main() {
bool flag = true;
int n, f[100009], m, g[100009], h[100009];
unordered_map<int, vector<int>> ma;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> f[i];
if (ma.find(f[i]) != ma.end()) {
ma[f[i]].push_back(i);
} else {
vector<int> v;
v.push_back(i);
ma.emplace(f[i], v);
}
}
m = ma.size();
for (unordered_map<int, vector<int>>::iterator i = ma.begin(); i != ma.end();
i++) {
bool b = false;
for (int j = 0; j < i->second.size(); j++) {
if (i->second[j] == i->first) {
b = true;
break;
}
}
if (b == false) {
flag = false;
cout << -1;
return 0;
}
}
int num = 1;
for (unordered_map<int, vector<int>>::iterator i = ma.begin(); i != ma.end();
i++) {
for (int j = 0; j < i->second.size(); j++) {
g[i->second[j]] = num;
}
h[num] = i->first;
num++;
}
cout << m << endl;
for (int i = 1; i <= n; i++) {
cout << g[i] << ' ';
}
cout << endl;
for (int j = 1; j <= m; j++) {
cout << h[j] << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prime[(long long int)10e3 + 1];
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
vector<long long int> primeFactors(long long int n) {
vector<long long int> result;
if (n % 2 == 0) {
result.push_back(2);
while (n % 2 == 0) {
n = n / 2;
}
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
if (n % i == 0) {
result.push_back(i);
while (n % i == 0) {
n = n / i;
}
}
}
if (n > 2) result.push_back(n);
return result;
}
vector<long long int> printDivisors(long long int n) {
vector<long long int> div;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
div.push_back(i);
} else {
div.push_back(i);
div.push_back(n / i);
}
}
}
sort(div.begin(), div.end());
return div;
}
vector<int> SieveOfEratosthenes(int n) {
vector<int> u;
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) u.push_back(p);
return u;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int product(long long int num, long long int result[],
long long int size) {
long long int m = 0;
long long int i = 0;
long long int ans;
for (i = 0; i < size; i++) {
ans = num * result[i] + m;
m = ans / 10;
result[i] = ans % 10;
}
while (m != 0) {
result[size] = m % 10;
m /= 10;
size++;
}
return size;
}
void factorial(long long int n) {
long long int result[159];
result[0] = 1;
long long int i, size = 1;
for (i = 2; i <= n; i++) {
size = product(i, result, size);
}
for (i = size - 1; i >= 0; i--) {
cout << result[i];
}
}
long long int findGCD(vector<long long int> arr, long long int n) {
long long int result = arr[0];
for (int i = 1; i < n; i++) {
result = gcd(arr[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
void swap(long long int &a, long long int &b) {
long long int temp = a;
a = b;
b = temp;
}
bool isPrime(long long int n) {
bool flag = true;
for (long long int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
flag = false;
break;
}
}
return flag;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i;
cin >> n;
long long int number;
long long int sum = n;
while (n != 1) {
if (n % 2 == 0) {
sum += (n / 2);
n /= 2;
} else if (isPrime(n)) {
n = 1;
sum += 1;
} else {
long long int a, b;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
a = i;
b = n / i;
}
}
n = max(a, b);
sum += max(a, b);
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int l = 1, h, i, n, x, t, q, y = -1, z = 0, a = 0, b = 0, c = 0, k,
sum = 0, m, d = 0, r, w, j, ans = INT_MAX, s, mini = INT_MAX,
maxi = INT_MAX;
queue<int> que;
bool cou;
float kl;
cin >> t;
vector<bool> sie(1000001, 0);
char cg;
string str, std;
while (t--) {
cin >> n;
mini = INT_MAX;
vector<int> vec(n + 1);
for (i = 1; i < n + 1; ++i) cin >> vec[i];
map<int, int> mp;
for (i = 1; i < n + 1; ++i) {
if (mp[vec[i]] == 0)
mp[vec[i]] = i;
else {
mini = (mini < i - mp[vec[i]] + 1 ? mini : i - mp[vec[i]] + 1);
mp[vec[i]] = i;
}
}
if (mini == INT_MAX)
cout << -1;
else
cout << mini;
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int a = n % 7;
if (a <= 2)
cout << n / 7 * 2 << " " << n / 7 * 2 + a << endl;
else if (a <= 5)
cout << n / 7 * 2 << " " << n / 7 * 2 + 2 << endl;
else
cout << n / 7 * 2 + 1 << " " << n / 7 * 2 + 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int S, T, pt, ans, w;
int mn[205][205];
int f[205][205], g[205][205];
int dis[205], sum[205];
int vis[205];
int q[205], tmd;
vector<int> all, out;
bool build(int S) {
int h = 0, t = 1, i;
q[1] = S;
for (i = 1; i <= N; i++) dis[i] = -1;
dis[S] = 0;
while (h < t) {
int x = q[++h];
for (i = 1; i <= N; i++)
if (f[x][i]) {
int y = i;
if (dis[y] < 0) dis[y] = dis[x] + 1, q[++t] = y;
if (y == T) return 1;
}
}
return 0;
}
int dinic(int x, int low) {
if (x == T) return low;
int w = 0, res, i;
for (i = 1; i <= N; i++)
if (f[x][i]) {
int y = i;
if (dis[y] == dis[x] + 1 && (res = dinic(y, min(low - w, f[x][i]))))
f[x][i] -= res, f[i][x] += res, w += res;
}
if (!w) dis[x] = -1;
return w;
}
void Query(int x, int fr) {
int i, f1 = 0, r1 = 0;
memset(dis, 0, sizeof(dis));
q[++r1] = x, dis[x] = 1;
while (f1 < r1) {
x = q[++f1];
for (i = 1; i <= N; i++)
if (!dis[i] && f[x][i] && f[i][x]) {
dis[i] = 1;
q[++r1] = i;
}
}
}
void Work(vector<int> poly) {
if (poly.size() < 2) return;
int i, j, tmp, get = 0;
int fr, to;
vector<int> x, y;
x.clear(), y.clear();
memcpy(f, g, sizeof(f));
memset(dis, 0, sizeof(dis));
memset(sum, 0, sizeof(sum));
pt = sum[0] = N;
S = poly[0], T = poly[1];
memset(vis, 0, sizeof(vis));
while (build(S)) get += dinic(S, 0x7fffffff);
for (i = 1; i <= N; i++) vis[i] = (dis[i] < 0);
for (i = 1; i <= N; i++)
if (vis[i])
x.push_back(i);
else
y.push_back(i);
for (i = 0; i < x.size(); i++)
for (j = 0; j < y.size(); j++)
mn[x[i]][y[j]] = mn[y[j]][x[i]] = min(mn[x[i]][y[j]], get);
x.clear(), y.clear();
for (i = 0; i < poly.size(); i++)
if (vis[poly[i]])
x.push_back(poly[i]);
else
y.push_back(poly[i]);
Work(x), Work(y);
}
void Dfs(vector<int> all) {
if (all.size() < 2) {
out.push_back(all[0]);
return;
}
int i, tmp, best = 0x7fffffff, get = 0;
vector<int> x, y;
x.clear(), y.clear();
memset(vis, 0, sizeof(vis));
T = all[all.size() - 1];
for (i = 0; i < all.size() - 1; i++)
if (mn[all[i]][T] < best) S = all[i], best = mn[S][T];
memcpy(f, g, sizeof(f));
memset(dis, 0, sizeof(dis)), memset(sum, 0, sizeof(sum));
pt = sum[0] = N;
memset(vis, 0, sizeof(vis));
while (build(S)) get += dinic(S, 0x7fffffff);
for (i = 1; i <= N; i++) vis[i] = (dis[i] < 0);
ans += get;
for (i = 0; i < all.size(); i++)
if (vis[all[i]])
x.push_back(all[i]);
else
y.push_back(all[i]);
Dfs(x), Dfs(y);
}
int main() {
int i, j;
int fr, to, dts, get;
srand(time(0));
scanf("%d %d", &N, &M);
for (i = 1; i <= M; i++) {
scanf("%d %d %d", &fr, &to, &dts);
f[fr][to] += dts, f[to][fr] += dts;
}
memcpy(g, f, sizeof(g));
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++) mn[i][j] = 0x7fffffff;
for (i = 1; i <= N; i++) all.push_back(i);
random_shuffle(all.begin(), all.end());
memset(mn, 63, sizeof(mn));
Work(all);
Dfs(all);
printf("%d\n", ans);
for (i = 1; i <= N; i++) printf("%d%c", out[i - 1], (i == N) ? '\n' : ' ');
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void fail() {
cout << "NO";
exit(0);
}
long long dijsktra(vector<vector<long long>> &adj,
vector<vector<long long>> &ww, long long src, long long t,
long long flag) {
long long n = adj.size();
vector<long long> dis(n, 100000000000000);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
pq.push({0, src});
dis[src] = 0;
while (!pq.empty()) {
long long u = pq.top().second, d = pq.top().first;
pq.pop();
for (auto &v : adj[u]) {
long long newDist;
if (ww[u][v] != 0) {
newDist = dis[u] + ww[u][v];
} else {
newDist = dis[u] + flag;
}
if (dis[v] > newDist) {
pq.push({newDist, v});
dis[v] = newDist;
}
}
}
return dis[t];
}
bool updateEdges(vector<vector<long long>> &adj, vector<vector<long long>> &ww,
long long src, long long L, long long t) {
long long n = adj.size();
vector<long long> dis(n, 100000000000000), par(n, -1);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
pq.push({0, src});
dis[src] = 0;
while (!pq.empty()) {
long long u = pq.top().second, d = pq.top().first;
pq.pop();
for (auto &v : adj[u]) {
long long newDist;
if (ww[u][v] != 0) {
newDist = dis[u] + ww[u][v];
} else {
newDist = dis[u] + 1;
}
if (dis[v] > newDist) {
pq.push({newDist, v});
dis[v] = newDist;
par[v] = u;
}
}
}
if (dis[t] == L) {
long long cur = t;
while (cur != src) {
long long curPar = par[cur];
if (ww[cur][curPar] == 0) {
ww[cur][curPar] = ww[curPar][cur] = 1;
}
cur = par[cur];
}
return true;
}
long long cur = t;
while (cur != src) {
long long curPar = par[cur];
if (ww[cur][curPar] == 0) {
ww[cur][curPar] = ww[curPar][cur] = (L - dis[t]) + 1;
return false;
}
cur = par[cur];
}
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, L, second, t;
cin >> n >> m >> L >> second >> t;
vector<vector<long long>> adj(n);
vector<vector<long long>> ww(n, vector<long long>(n));
for (long long i = 0; i < m; i++) {
long long u, v, wgt;
cin >> u >> v >> wgt;
adj[u].push_back(v);
adj[v].push_back(u);
ww[u][v] = ww[v][u] = wgt;
}
long long dijDist = dijsktra(adj, ww, second, t, 100000000000000);
if (dijDist < L) fail();
if (dijDist == L) {
cout << "YES\n";
for (long long u = 0; u < adj.size(); u++) {
for (auto &v : adj[u]) {
if (u > v) continue;
cout << u << " " << v << ' ' << (ww[u][v] == 0 ? L : ww[u][v]) << '\n';
}
}
return 0;
}
dijDist = dijsktra(adj, ww, second, t, 1);
if (dijDist > L) fail();
while (!updateEdges(adj, ww, second, L, t))
;
cout << "YES\n";
for (long long u = 0; u < adj.size(); u++) {
for (auto &v : adj[u]) {
if (u > v) continue;
cout << u << " " << v << ' ' << (ww[u][v] == 0 ? L : ww[u][v]) << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.);
long double calc(long double len, int n) {
long double alpha = 2 * PI / n;
long double a2 = (PI - alpha) * 0.5;
long double h = tan(a2) * len * 0.5;
long double c = sqrt(h * h + len * len / 4);
long double hh = sqrt(len * len - c * c);
long double area = len * h * 0.5 * n;
return area * hh / 3;
}
void solve() {
long double a, b, c;
cin >> a >> b >> c;
printf("%.20f\n", (double)(calc(a, 3) + calc(b, 4) + calc(c, 5)));
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::unordered_map;
using std::unordered_set;
using std::vector;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ull = unsigned long long;
using ld = long double;
template <typename T>
void _dbg(const char* s, T h) {
cerr << s << " = " << h << "\n";
}
template <typename T, typename... Ts>
void _dbg(const char* s, T h, Ts... t) {
int b = 0;
while (((b += *s == '(') -= *s == ')') != 0 || *s != ',') cerr << *s++;
cerr << " = " << h << ",";
_dbg(s + 1, t...);
}
struct init {
init() {
cin.tie(0);
std::iostream::sync_with_stdio(0);
cout << std::fixed << std::setprecision(10);
cerr << std::fixed << std::setprecision(5);
}
~init() {}
} init;
template <typename T, typename U>
void upx(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
void upn(T& x, U y) {
if (x > y) x = y;
}
const ll N = 22;
ll a[N];
ll b[N];
ll second = 0;
vector<pll> ans;
void solve(ll x, ll y, ll c);
void solverev(ll x, ll y, ll c) {
ll t = 6 - x - y;
if (c) {
solverev(x, t, c - 1);
for (ll i = 0; i < (b[c]); ++i) ans.emplace_back(x, y);
solverev(t, y, c - 1);
} else {
for (ll i = 0; i < (b[c]); ++i) ans.emplace_back(x, y);
}
}
void solve(ll x, ll y, ll c) {
ll t = 6 - x - y;
if (c) {
if (b[c] == 1) {
solverev(x, y, c);
} else {
solverev(x, y, c - 1);
for (ll i = 0; i < (b[c]); ++i) ans.emplace_back(x, t);
solverev(y, x, c - 1);
for (ll i = 0; i < (b[c]); ++i) ans.emplace_back(t, y);
solve(x, y, c - 1);
}
} else {
for (ll i = 0; i < (b[c] - 1); ++i) ans.emplace_back(x, t);
ans.emplace_back(x, y);
for (ll i = 0; i < (b[c] - 1); ++i) ans.emplace_back(t, y);
}
}
int32_t main() {
ll n;
cin >> n;
map<ll, ll> m;
for (ll i = 0; i < (n); ++i) {
cin >> a[i];
m[a[i]]++;
}
for (auto p : m) b[second++] = p.second;
solve(1, 3, second - 1);
cout << ans.size() << '\n';
for (pll p : ans) cout << p.first << ' ' << p.second << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void sort(int a[], int n) {
int tmp;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[j] > a[i]) {
tmp = a[j];
a[j] = a[i];
a[i] = tmp;
}
}
}
}
int main() {
int n, s = 0, k = 0, maxim;
cin >> n;
int a[n], max[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
max[i] = 1;
}
sort(a, n);
for (int i = 0; i < n; i++) {
if (i > 0) {
if (a[i] == a[i - 1])
max[k]++;
else if (max[k] == 1 || a[i] != a[i - 1])
k++;
if (a[i] != a[i - 1]) s++;
} else
s++;
}
sort(max, n);
maxim = max[0];
cout << maxim << ' ' << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int popcount(T n);
template <>
int popcount(unsigned int n) {
return n ? __builtin_popcount(n) : 0;
}
template <>
int popcount(int n) {
return n ? __builtin_popcount(n) : 0;
}
template <>
int popcount(unsigned long long n) {
return n ? __builtin_popcountll(n) : 0;
}
template <>
int popcount(long long n) {
return n ? __builtin_popcountll(n) : 0;
}
template <class T>
void max_swap(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void min_swap(T& a, const T& b) {
a = min(a, b);
}
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
bool valid_pos(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
template <class T>
void print(T a, int n, const string& deli = ", ") {
cout << "{ ";
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n) cout << deli;
}
cout << " }";
}
template <class T>
void print(const vector<T>& v, const string& deli = ", ") {
print(v, v.size(), deli);
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
map<string, int> best;
for (int i = 0; i < n; ++i) {
string s;
int t;
cin >> s >> t;
max_swap(best[s], t);
}
vector<pair<int, string> > v;
for (__typeof__((best).begin()) it = (best).begin(); it != (best).end(); ++it)
v.push_back(pair<int, string>(it->second, it->first));
sort((v).begin(), (v).end(), greater<pair<int, string> >());
cout << v.size() << endl;
int score[] = {99, 90, 80, 50, -1};
const char* cate[] = {"pro", "hardcore", "average", "random", "noob"};
int ue = 0;
for (int i = 0; i < v.size(); ++i) {
if (i > 0 && v[i].first < v[i - 1].first) ue = i;
int p = (v.size() - ue) * 100 / v.size();
int r = -1;
for (int j = 0; j < 5 && r == -1; ++j)
if (p >= score[j]) r = j;
cout << v[i].second << " " << cate[r] << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[200000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
cout << a[i] + a[i + 1] << " ";
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100003];
int main() {
int n, cnt = 1, tmp = -1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) {
if (a[i] == a[i - 1]) {
cnt++;
} else {
if (tmp == -1) {
tmp = cnt;
cnt = 1;
} else if (cnt != tmp) {
puts("NO");
return 0;
} else {
cnt = 1;
continue;
}
}
}
if (tmp == -1 || (tmp != -1 && cnt == tmp)) {
puts("YES");
} else {
puts("NO");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[1000];
int main() {
long long int n, k, sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n);
int i;
for (i = 0; i <= n && sum <= k; i++) sum += a[i].first;
i--;
cout << i << endl;
for (int j = 0; j < i; j++) cout << a[j].second << ' ';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
bool found = false;
int c = 1;
for (int i = 0; i < x.size(); i++) {
if (x.substr(i, 3) == "WUB") {
if (found && c == 1) {
cout << ' ';
c++;
} else
c++;
i += 2;
} else {
cout << x[i];
found = true;
c = 1;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2000000000, maxn = 100100;
struct Segment_tree {
long long minv[maxn << 2], minf[maxn << 2];
inline void pushup(long long p) {
minv[p] = min(minv[(p << 1)], minv[(p << 1 | 1)]);
if (minv[p] == minv[(p << 1)])
minf[p] = minf[(p << 1)];
else
minf[p] = minf[(p << 1 | 1)];
}
inline void Modify(long long p, long long l, long long r, long long x,
long long to) {
if (l == r) return (void)(minv[p] = to, minf[p] = l);
long long mid = (l + r) >> 1;
if (x <= mid)
Modify((p << 1), l, mid, x, to);
else
Modify((p << 1 | 1), mid + 1, r, x, to);
pushup(p);
}
} s;
long long a[maxn], c[maxn], n, m;
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%lld", a + i);
for (long long i = 1; i <= n; i++) scanf("%lld", c + i);
for (long long i = 1; i <= n; i++) s.Modify(1, 1, n, i, c[i]);
for (long long i = 1; i <= m; i++) {
long long t, d;
scanf("%lld%lld", &t, &d);
long long ans = 0;
long long now = t, nowpri = c[t];
if (nowpri == inf) now = s.minf[1], nowpri = c[now];
while (nowpri < inf && d) {
long long res = min(d, a[now]);
a[now] -= res;
d -= res;
ans += nowpri * res;
if (a[now] == 0) s.Modify(1, 1, n, now, inf), c[now] = inf;
now = s.minf[1];
nowpri = c[now];
}
if (d) ans = 0;
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long int INF = pow(10, 10);
using namespace std;
map<int, int> primefacs(long long x) {
map<int, int> facs;
long long myx = x;
for (int i = 2; i < int(sqrt(x)) + 1; i++) {
if (x % i == 0) {
int cnt = 0;
while (x % i == 0) {
cnt += 1;
x = x / i;
}
facs.insert({i, cnt});
}
}
if (x >= 2) {
facs.insert({x, 1});
}
return facs;
}
const int M = 1010;
int n, a[M], l[M], r[M];
void solution() {
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> r[i];
for (int i = 0; i < n; i++) a[i] = (n - l[i] - r[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) l[i] -= (a[j] > a[i]);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) r[i] -= (a[j] > a[i]);
for (int i = 0; i < n; i++)
if (l[i] != 0 || r[i] != 0) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << a[i] << " ";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int p = 1;
while (p--) {
solution();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int p = 0, t = 1;
for (i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
t++;
} else {
if (t > p) {
p = t;
}
t = 1;
}
}
if (t > p) {
p = t;
}
if (n % 2 == 0) {
if (p <= n / 2)
cout << "YES";
else
cout << "NO";
} else {
if (p <= (n + 1) / 2)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
write(x);
puts("");
}
set<int> s;
queue<int> q;
int ans[1000010], cnt = 0;
vector<int> Ans[1000010];
set<int>::iterator it;
bool vis[1000010], viss[1000010];
int nedge = 0, p[2000010], nex[2000010], head[2000010], n, m;
int rk[1000010], Cnt;
inline void addedge(int a, int b) {
p[++nedge] = b;
nex[nedge] = head[a];
head[a] = nedge;
}
inline void bfs() {
for (int i = 1; i <= n; i++)
if (!vis[i]) {
vis[i] = 1;
q.push(i);
ans[++cnt] = 1;
Ans[cnt].push_back(i);
s.erase(i);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int k = head[now]; k; k = nex[k]) viss[p[k]] = 1;
Cnt = 0;
for (it = s.begin(); it != s.end(); it++)
if (!viss[*it]) {
int k = *it;
ans[cnt]++;
Ans[cnt].push_back(k);
vis[k] = 1;
q.push(k);
rk[++Cnt] = k;
} else
viss[*it] = 0;
for (int i = 1; i <= Cnt; i++) s.erase(rk[i]);
}
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
addedge(x, y);
addedge(y, x);
}
for (int i = 1; i <= n; i++) s.insert(i);
bfs();
writeln(cnt);
for (int i = 1; i <= cnt; i++) {
write(ans[i]);
putchar(' ');
for (int j = 0; j < ans[i]; j++) write(Ans[i][j]), putchar(' ');
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
long long int fastpow(long long int a, long long int n, long long int temp) {
if (n == 0) return (1);
if (n == 1) return ((a * temp) % 1000000007);
if (n & 1) temp = (temp * a) % 1000000007;
return (fastpow((a * a) % 1000000007, n / 2, temp));
}
char dum;
vector<vector<int> > adj(50001);
int seen[50001], ans[50001];
void dfs(int v) {
for (int i = 0; i < adj[v].size(); i++) {
if (!seen[adj[v][i]]) {
seen[adj[v][i]] = 1;
ans[adj[v][i]] = v;
dfs(adj[v][i]);
}
}
}
int main() {
int n, r1, r2, x;
scanf("%d", &n);
scanf("%d", &r1), scanf("%d", &r2);
for (int i = 1; i < n + 1; i++) {
if (i == r1) continue;
scanf("%d", &x);
adj[i].push_back(x);
adj[x].push_back(i);
}
memset(seen, 0, sizeof(seen));
seen[r2] = 1;
dfs(r2);
for (int i = 1; i < n + 1; i++) {
if (i == r2) continue;
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<pair<int, int>> A;
void solve(int l, int r) {
if (l == r) return;
int mid = (l + r) / 2, m = (r - l + 1) / 2;
solve(l, mid), solve(mid + 1, r);
for (int i = l; i <= mid; i++) A.emplace_back(i, i + m);
}
int main() {
cin >> N;
int b = 0;
for (int i = 0; i < (int)30; i++)
if (N & (1 << i)) b = i;
solve(0, (1 << b) - 1);
solve(N - 1 - ((1 << b) - 1), N - 1);
cout << A.size() << '\n';
for (auto &e : A) cout << e.first + 1 << ' ' << e.second + 1 << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int mod_pow(long long int a, long long int b, long long int m) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int sum1 = a[0], sum3 = a[n - 1];
long long int s = 0, e = n - 1, ans = -1;
while (s < e) {
if (sum1 == sum3) ans = sum1;
if (sum1 > sum3) {
e--;
sum3 += a[e];
} else {
s++;
sum1 += a[s];
}
}
if (ans != -1)
cout << ans;
else
cout << 0;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int q;
q = 1;
while (q--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long A[4], sum;
char ans[1000005];
long long Solve(long long x) {
long long sq = 8 * x + 1;
long long root = sqrt(sq);
if (root * root != sq) return -1;
return (root + 1) / 2;
}
inline int fail() { return 0 * printf("Impossible\n"); }
int main() {
for (int i = 0; i < 4; ++i) {
scanf("%lld", A + i);
sum += A[i];
}
if (!A[0] && !A[1] && !A[2]) {
int ret = Solve(A[3]);
if (ret == -1)
return fail();
else
cout << string(ret, '1') << '\n';
return 0;
}
if (!A[1] && !A[2] && !A[3]) {
int ret = Solve(A[0]);
if (ret == -1)
return fail();
else
cout << string(ret, '0') << '\n';
return 0;
}
int numZero = Solve(A[0]), numOne = Solve(A[3]), numTotal;
if (numZero == -1 || numOne == -1) return fail();
numTotal = numZero + numOne;
if (Solve(sum) != numTotal) return fail();
for (int i = 0; i < numTotal; ++i) {
if (A[1] > 0 && A[1] >= numOne) {
if (numOne == 0 || numZero == 0) return fail();
ans[i] = '0';
--numZero;
A[1] -= numOne;
} else if (A[1] > 0) {
if (numOne == 0) return fail();
ans[i] = '1';
--numOne;
} else if (A[1] == 0) {
int cur = i;
while (numOne--) ans[cur++] = '1';
while (numZero--) ans[cur++] = '0';
break;
}
}
printf("%s\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int readint() {
int x = 0, f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
(s = getchar());
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
(s = getchar());
}
return x * f;
}
map<int, int> _xor, fa;
int findset(int x) {
if (!fa.count(x)) return x;
int tmp = findset(fa[x]);
_xor[x] ^= _xor[fa[x]];
fa[x] = tmp;
return fa[x];
}
int main() {
int q = readint();
int last = 0;
while (q--) {
int op = readint();
if (op == 1) {
int l = readint(), r = readint(), x = readint();
l ^= last, r ^= last, x ^= last;
if (l > r) swap(l, r);
l--;
int fl = findset(l), fr = findset(r);
if (fl != fr) {
fa[fr] = fl;
_xor[fr] = _xor[l] ^ _xor[r] ^ x;
}
} else {
int l = readint(), r = readint();
l ^= last, r ^= last;
if (l > r) swap(l, r);
l--;
int fl = findset(l), fr = findset(r);
if (fl != fr) {
last = 1;
puts("-1");
} else {
last = _xor[l] ^ _xor[r];
printf("%d\n", last);
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int X[4], Y[4], R[4];
long long hypot2(long long x, long long y) { return x * x + y * y; }
long long square(long long x) { return x * x; }
bool inter(int i, int j) {
long long d2 = hypot2(X[i] - X[j], Y[i] - Y[j]);
if (d2 >= square(R[i] + R[j])) return false;
if (R[i] < R[j]) return d2 > square(R[j] - R[i]);
return d2 > square(R[i] - R[j]);
}
bool inside(int i, int j) {
long long d2 = hypot2(X[i] - X[j], Y[i] - Y[j]);
return R[j] > R[i] and d2 <= square(R[j] - R[i]);
}
bool valid[4];
int main() {
for (int i = 0; i < 4; i += 2) {
cin >> X[i] >> Y[i];
X[i + 1] = X[i];
Y[i + 1] = Y[i];
cin >> R[i];
cin >> R[i + 1];
}
int ans = 0;
valid[0] = not inter(0, 2) and not inter(0, 3) and
(not inside(0, 3) or inside(0, 2));
valid[1] = not inter(1, 2) and not inter(1, 3) and
(not inside(1, 3) or inside(1, 2));
valid[2] = not inter(2, 0) and not inter(2, 1) and
(not inside(2, 1) or inside(2, 0));
valid[3] = not inter(3, 0) and not inter(3, 1) and
(not inside(3, 1) or inside(3, 0));
for (int i = 0; i < 4; ++i) ans += valid[i];
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k, m;
cin >> n >> k >> m;
vector<array<int, 2>> b;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (b.empty() || b.back()[0] != x) {
b.push_back({x, 0});
}
b.back()[1]++;
if (b.back()[1] == k) b.pop_back();
}
n = b.size();
ll len = 0;
for (auto x : b) len += x[1];
if (b.size() == 0 || m == 1) {
cout << len << '\n';
return 0;
}
ll r = 0, er = 0;
for (int i = 0; i < n; i++) {
if (b[n - 1 - i][0] != b[i][0]) break;
int sum = b[n - 1 - i][1] + b[i][1];
er += sum / k * k;
sum %= k;
if (sum) break;
r++;
}
if (r == n) {
cout << len * (m % 2) << '\n';
return 0;
} else if (2 * r + 1 == n) {
ll sum = b[r][1] * m;
sum %= k;
if (sum)
cout << len - b[r][1] + sum << '\n';
else
cout << 0 << '\n';
return 0;
} else {
assert(2 * r < n);
cout << len * m - er * (m - 1) << '\n';
return 0;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int lsone(int n) { return (n & -n); }
long long int pow1(long long int a, long long int b) {
if (b == 0)
return 1ll;
else if (b == 1)
return a;
else {
long long int x = pow1(a, b / 2);
x *= x;
x %= 1000000007;
if (b % 2) {
x *= a;
x %= 1000000007;
}
return x;
}
}
int n, m, col[4][110000], a, b, comp[110000], compm[4][110000],
compans1[110000], compans2[110000];
char c;
vector<vector<pair<int, int> > > graph(110000);
void invert() {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < graph[i].size(); j++) {
graph[i][j].second ^= 1;
}
}
}
void dfs(int index, int mode, int set, int component) {
if (col[mode][index] != -1) return;
col[mode][index] = set;
comp[index] = component;
compm[mode][component] += set;
for (pair<int, int> edge : graph[index]) {
if (col[mode][edge.first] != -1) {
int res = col[mode][edge.first] ^ set ^ edge.second;
if (res != 3) compm[mode][component] = 1e9;
continue;
}
dfs(edge.first, mode, set ^ 3 ^ edge.second, component);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
memset(col, -1, sizeof(col));
for (int i = 1; i <= m; i++) {
cin >> a >> b >> c;
if (c == 'R') {
graph[a].push_back(make_pair(b, 2));
graph[b].push_back(make_pair(a, 2));
} else {
graph[a].push_back(make_pair(b, 3));
graph[b].push_back(make_pair(a, 3));
}
}
int numcomp = 1;
for (int i = 1; i <= n; i++) {
if (col[0][i] == -1) {
dfs(i, 0, 0, numcomp);
dfs(i, 1, 1, numcomp);
numcomp++;
}
}
invert();
numcomp = 1;
for (int i = 1; i <= n; i++) {
if (col[2][i] == -1) {
dfs(i, 2, 0, numcomp);
dfs(i, 3, 1, numcomp);
numcomp++;
}
}
int ans1 = 0, ans2 = 0;
for (int i = 1; i < numcomp; i++) {
int curr = min({compm[0][i], compm[1][i]});
if (curr > n) {
ans1 = 1e9;
break;
}
ans1 += curr;
for (int j = 0; j < 2; j++) {
if (curr == compm[j][i]) {
compans1[i] = j;
break;
}
}
}
for (int i = 1; i < numcomp; i++) {
int curr = min({compm[2][i], compm[3][i]});
if (curr > n) {
ans2 = 1e9;
break;
}
ans2 += curr;
for (int j = 2; j < 4; j++) {
if (curr == compm[j][i]) {
compans2[i] = j;
break;
}
}
}
int ans = min(ans1, ans2);
if (ans > n) {
cout << -1 << "\n";
return 0;
}
cout << ans << "\n";
if (ans1 == ans) {
for (int i = 1; i <= n; i++) {
if (col[compans1[comp[i]]][i]) cout << i << " ";
}
} else {
for (int i = 1; i <= n; i++) {
if (col[compans2[comp[i]]][i]) cout << i << " ";
}
}
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, soln;
cin >> s;
soln = s;
for (int i = 0, idx = (n - 1) / 2; i < n; i++) {
soln[idx] = s[i];
if ((n + i) % 2 == 0)
idx += (i + 1);
else if ((n + i) % 2 == 1)
idx -= (i + 1);
}
cout << soln << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll bin(ll a[],ll l,ll r,ll x){
ll m=(l+r)/2;
if(l>=r)return -1;
if(a[m]==x)return m;
if(a[m]>x)return bin(a,l,m-1,x);
return bin(a,m+1,r,x);
}
ll exp(ll a,ll b){
if(b==0)return 1;
ll res=exp(a,b/2);
if(b%2==0)return res*res;
return res*res*a;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
int t;
cin>>t;
while(t--){
ll n,cnt=0;
cin>>n;
ll l=n;
bool flag=false;
while(l){
if(l%2!=0&&l!=1){
flag=true;
break;
}
l/=2;
}
cout<<(flag?"YES\n":"NO\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
long long int ceil1(long long int n, long long int k) {
if (n % k) return n / k + 1;
return n / k;
}
long long int pow1(long long int n, long long int k) {
long long int ans = 1;
while (k != 0) {
if (k % 2) ans = (ans * n) % mod;
n = (n * n) % mod;
k = k / 2;
}
return ans;
}
bool ispal(string s) {
long long int i = 0;
long long int j = s.size() - 1;
while (i < j) {
if (s[i] != s[j]) return false;
i++;
j--;
}
return true;
}
long long int gcdd(long long int a, long long int b) {
if (b == 0) return a;
return gcdd(b, a % b);
}
long long int fact(long long int n) {
if (n == 1 || n == 0)
return 1;
else
return (n * fact(n - 1)) % mod;
}
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
a.push_back(i);
while (n % i == 0) n /= i;
}
}
if (n > 1) a.push_back(n);
vector<long long int> f(60);
vector<long long int> inv(60);
f[0] = 1;
for (long long int i = 1; i < 60; i++) {
f[i] = (f[i - 1] * i) % mod;
}
inv[59] = pow1(f[59], mod - 2);
for (long long int i = 58; i >= 0; i--) {
inv[i] = (inv[i + 1] * (i + 1)) % mod;
}
long long int q;
cin >> q;
while (q--) {
long long int u, v;
cin >> u >> v;
long long int ans1 = 1, ans2 = 1, t1 = 0, t2 = 0;
for (auto x : a) {
long long int pa = 0, pb = 0;
while (u % x == 0) {
pa++;
u /= x;
}
while (v % x == 0) {
pb++;
v /= x;
}
if (pa < pb) {
t1 += pb - pa;
ans1 = (ans1 * inv[pb - pa]) % mod;
} else if (pb < pa) {
t2 += pa - pb;
ans2 = (ans2 * inv[pa - pb]) % mod;
}
}
ans1 = (ans1 * f[t1]) % mod;
ans2 = (ans2 * f[t2]) % mod;
ans1 = (ans1 * ans2) % mod;
cout << ans1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int q = 1;
while (q--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 1010;
long long find(const long long &l, const long long &r, const long long &what,
const long long &res) {
if (((r - l) >> 1) == what && res == 0) {
return (l + r) >> 1;
}
long long mid = (l + r) >> 1;
map<long long, long long> now;
map<long long, long long, greater<long long> > dis;
dis[(r - l) >> 1] += 1;
now[mid - l] = 1;
while ((int((now).size()))) {
map<long long, long long> nxt;
for (auto u : now)
if (u.first) {
dis[(u.first - 1) >> 1] += u.second;
nxt[(u.first - 1) >> 1] += u.second;
nxt[u.first >> 1] += u.second;
}
now = nxt;
}
long long tmp = dis[what];
if (tmp > res) return find(l, mid - 1, what, res);
return find(mid + 1, r, what, res - tmp);
}
long long work(long long n, long long K) {
if (K == 1) return 1;
if (K == 2) return n;
n -= 2;
K -= 3;
map<long long, long long> now;
map<long long, long long, greater<long long> > dis;
now[n] = 1;
while ((int((now).size()))) {
map<long long, long long> nxt;
for (auto u : now)
if (u.first) {
dis[(u.first - 1) >> 1] += u.second;
nxt[(u.first - 1) >> 1] += u.second;
nxt[u.first >> 1] += u.second;
}
now = nxt;
}
for (auto u : dis) {
if (u.second > K) {
return find(0, n - 1, u.first, K) + 2;
}
K -= u.second;
}
assert(0);
return -1;
}
int main() {
long long n, K;
cin >> n >> K;
cout << work(n, K) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int T, n;
int a[233333];
map<int, int> cnt, L, R;
map<int, vector<int> > pos;
int main() {
ios_base::sync_with_stdio(false);
cin >> T;
while (T--) {
cin >> n;
cnt.clear();
L.clear();
R.clear();
pos.clear();
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
pos[a[i]].push_back(i);
R[a[i]] = i;
if (!L[a[i]]) L[a[i]] = i;
}
int ans = 1;
int cur = 0, last = 0;
cnt[-1] = 0;
cnt[1000000007] = 0;
for (auto it = cnt.begin(); it != cnt.end(); ++it) {
if (it->second == 0) continue;
int num = it->first;
if (L[num] > last) {
cur += it->second;
} else {
auto zz = lower_bound(pos[num].begin(), pos[num].end(), last);
cur += pos[num].end() - zz;
ans = max(ans, cur);
auto tmp = it;
--tmp;
int ls = tmp->first;
auto tt = lower_bound(pos[ls].begin(), pos[ls].end(), L[num]);
cur = tt - pos[ls].begin();
cur += it->second;
}
last = R[num];
}
ans = max(ans, cur);
cout << n - ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
long long res = 2 * c;
if (a - 1 == b || b - 1 == a || a == b)
res += a + b;
else if (a > b)
res += 2 * b + 1;
else
res += 2 * a + 1;
printf("%lld\n", res);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int base = (int)1e9 + 7;
int f[30001][101][2];
int n, l, a[101][2], b[101][2];
void add(int &x, int y) { x = (x + y) % base; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> l;
for (int i = 1; i <= n; ++i) {
cin >> a[i][0] >> b[i][0];
a[i][1] = b[i][0];
b[i][1] = a[i][0];
}
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; ++i) {
add(f[a[i][0]][i][0], 1);
if (a[i][0] == a[i][1]) continue;
add(f[a[i][1]][i][1], 1);
}
for (int i = 0; i <= l; ++i)
for (int j = 1; j <= n; ++j)
for (int isTurn = 0; isTurn <= 1; ++isTurn) {
if (f[i][j][isTurn] == 0) continue;
for (int next = 1; next <= n; ++next) {
if (j == next) continue;
for (int turn = 0; turn <= 1; ++turn) {
if (turn == 1)
if (a[next][turn] == a[next][1 - turn]) break;
if (a[j][isTurn] != b[next][turn]) continue;
add(f[i + a[next][turn]][next][turn], f[i][j][isTurn]);
}
}
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int isTurn = 0; isTurn <= 1; ++isTurn) add(ans, f[l][i][isTurn]);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 17;
int N;
pair<int, int> elems[MAXN];
int cnt[MAXN];
int ans[MAXN];
int main() {
scanf("%d", &N);
for (int i = 0; i < (int)(N); ++i) {
int x;
scanf("%d", &x);
elems[i] = make_pair(x, i);
cnt[x]++;
}
for (int i = 2; i < MAXN; i++)
if (cnt[i] > cnt[i - 1]) {
printf("-1\n");
return 0;
}
sort(elems, elems + N);
for (int i = 0, j; i < N; i = j) {
int lvl = 0;
for (j = i; j < N && elems[j].first == elems[i].first; j++)
ans[elems[j].second] = ++lvl;
}
printf("%d\n", *max_element(ans, ans + N));
for (int i = 0; i < (int)(N); ++i) printf("%d ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string a[2006];
int row[2006], cal[2006];
int w[2006];
int main() {
int n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
int t = cal[j] + row[i];
if ((t % 2 == 0 && a[i][j] == '1') || (a[i][j] == '0' && t % 2 == 1)) {
cal[j]++;
row[i]++;
ans++;
w[j]++;
w[i]++;
}
}
}
for (int i = 0; i < 2006; i++) row[i] = cal[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = n - 1; j > i; j--) {
int t = cal[j] + row[i];
if ((t % 2 == 0 && a[i][j] == '1') || (a[i][j] == '0' && t % 2 == 1)) {
cal[j]++;
row[i]++;
ans++;
w[j]++;
w[i]++;
}
}
}
for (int i = 0; i < n; i++)
if ((a[i][i] == '1' && w[i] % 2 == 0) || (a[i][i] == '0' && w[i] % 2 == 1))
ans++;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<long long> even;
long long sze = s.size();
for (long long i = 0; i < sze; i++) {
if (((int)s[i]) % 2 == 0) even.push_back(i);
}
if (even.size() == 0)
cout << -1 << endl;
else {
long long cnt = 0;
while (cnt < even.size() - 1) {
if (s[even[cnt]] < s[sze - 1]) {
swap(s[even[cnt]], s[sze - 1]);
break;
}
cnt++;
}
if (cnt == even.size() - 1) swap(s[even[cnt]], s[sze - 1]);
cout << s << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
template <typename T, typename T2>
inline void _max(T &a, T2 b) {
a = max((T)a, (T)b);
}
template <typename T, typename T2>
inline void _min(T &a, T2 b) {
a = min((T)a, (T)b);
}
const int MAX = 110;
int n, m;
set<pair<int, int> > a, b;
void clear() { a.clear(), b.clear(); }
void read() {
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
a.insert(pair<int, int>(x, y));
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
b.insert(pair<int, int>(x, y));
}
}
void solve() {
vector<int> posAns;
for (int x = 1; x <= 9; x++) {
set<int> ap, bp;
for (auto &p : a) {
if (p.first == x) ap.insert(p.second);
if (p.second == x) ap.insert(p.first);
}
for (auto &p : b) {
if (p.first == x) bp.insert(p.second);
if (p.second == x) bp.insert(p.first);
}
int canBe = ap.size() > 1 && bp.size() || bp.size() > 1 && ap.size();
if (ap.size() == 1 && bp.size() == 1) canBe |= *ap.begin() != *bp.begin();
if (canBe) posAns.push_back(x);
}
if (posAns.size() == 1) return void(printf("%d\n", posAns[0]));
int theyKnow = 1;
for (auto &p : a) {
if (find(posAns.begin(), posAns.end(), p.first) == posAns.end() ||
find(posAns.begin(), posAns.end(), p.second) == posAns.end())
continue;
int np = 0;
for (auto &q : b)
if (p != q)
if (p.first == q.first || p.first == q.second || p.second == q.first ||
p.second == q.second)
np++;
theyKnow &= np == 1;
}
for (auto &p : b) {
if (find(posAns.begin(), posAns.end(), p.first) == posAns.end() ||
find(posAns.begin(), posAns.end(), p.second) == posAns.end())
continue;
int np = 0;
for (auto &q : a)
if (p != q)
if (p.first == q.first || p.first == q.second || p.second == q.first ||
p.second == q.second)
np++;
theyKnow &= np == 1;
}
printf("%d\n", theyKnow ? 0 : -1);
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
clear();
read();
solve();
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void read(long long &x) {
char ch = getchar();
long long f = 0;
x = 0;
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
if (f) x = -x;
}
const long long N = 5e4 + 5;
long long k, p, n, m, s[N];
pair<long long, long long> q[N];
struct mat {
long long a[2][2];
void clear() { memset(a, 0, sizeof(a)); }
mat operator*(const mat &x) const {
mat t;
t.clear();
for (long long i = 0; i < 2; ++i)
for (long long j = 0; j < 2; ++j)
for (long long k = 0; k < 2; ++k) {
(t.a[i][j] = (t.a[i][j] + a[i][k] * x.a[k][j]) % p);
}
return t;
}
void print() {
puts("");
for (long long i = 0; i < 2; ++i) {
for (long long j = 0; j < 2; ++j) printf("%d ", a[i][j]);
puts("");
}
}
} res, qwq, mt[N], pre[N], suf[N];
struct tree {
mat c[N << 2];
void build(long long p, long long l, long long r) {
if (l == r) {
c[p] = mt[l];
return;
}
long long mid(l + r >> 1);
build((p << 1), l, mid), build((p << 1 | 1), mid + 1, r);
c[p] = c[(p << 1)] * c[(p << 1 | 1)];
}
mat query(long long p, long long l, long long r, long long ql, long long qr) {
if (ql <= l && r <= qr) return c[p];
long long mid(l + r >> 1), ok = 0;
mat res;
if (ql <= mid) ok = 1, res = query((p << 1), l, mid, ql, qr);
if (qr > mid) {
if (ok)
res = res * query((p << 1 | 1), mid + 1, r, ql, qr);
else
res = query((p << 1 | 1), mid + 1, r, ql, qr);
}
return res;
}
} T;
void Pow(long long y) {
qwq = pre[n - 1];
for (; y; y >>= 1, qwq = qwq * qwq)
if (y & 1) res = res * qwq;
}
void calc(long long l, long long r) {
if (l > r) return;
long long t1 = l % n, w1 = l / n;
long long t2 = r % n, w2 = r / n;
if (w1 != w2) {
res = res * suf[t1];
Pow(w2 - w1 - 1);
res = res * pre[t2];
} else
res = res * T.query(1, 0, n - 1, t1, t2);
}
signed main() {
read(k), read(p), read(n);
for (long long i = 0; i < n; ++i) read(s[i]);
read(m);
for (long long i = 1; i <= m; ++i) read(q[i].first), read(q[i].second);
sort(q + 1, q + m + 1);
for (long long i = 0; i < n; ++i) {
mt[i].a[1][0] = 1, mt[i].a[1][1] = s[i];
mt[i].a[0][1] = i ? s[i - 1] : s[n - 1];
}
suf[n - 1] = mt[n - 1], pre[0] = mt[0];
T.build(1, 0, n - 1);
res.a[0][1] = (k > 0);
for (long long i = 1; i < n; ++i) pre[i] = pre[i - 1] * mt[i];
for (long long i = n - 2; i >= 0; --i) suf[i] = mt[i] * suf[i + 1];
long long la = 1;
q[0].first = -100;
for (long long i = 1; i <= m; ++i) {
if (q[i].first >= k) break;
calc(la, q[i].first - 1);
qwq.clear();
qwq.a[1][0] = 1;
qwq.a[1][1] = q[i].second;
if (q[i - 1].first + 1 == q[i].first)
qwq.a[0][1] = q[i - 1].second;
else
qwq.a[0][1] = s[(q[i].first - 1) % n];
res = res * qwq;
la = q[i].first + 1;
if (q[i].first + 1 != q[i + 1].first && la < k) {
qwq.a[0][1] = q[i].second, qwq.a[1][1] = s[la % n];
res = res * qwq, ++la;
}
}
calc(la, k - 1);
return printf("%lld\n", res.a[0][1] % p), 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool vmin(T& a, T b) {
return (a > b) ? (a = b, true) : (false);
}
template <typename T>
bool vmax(T& a, T b) {
return (a < b) ? (a = b, true) : (false);
}
template <typename T>
T smax(T x) {
return x;
}
template <typename T, typename... K>
T smax(T a, const K&... args) {
return max(a, smax(args...));
}
template <typename T>
T smin(T x) {
return x;
}
template <typename T, typename... K>
T smin(T a, const K&... args) {
return min(a, smin(args...));
}
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& z) {
os << "(" << z.first << ", " << z.second << ')';
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& a) {
bool isfirst = true;
os << "{";
for (auto z : a) {
if (!isfirst) {
os << ", ";
}
os << z;
isfirst = false;
}
os << '}';
return os;
}
const int inf = (signed)(~0u >> 2);
const long long llf = (signed long long)(~0ull >> 2);
template <typename T>
int vsize(vector<T>& x) {
return (signed)x.size();
}
template <typename T>
int discrete(T* a, int* b, int n) {
vector<T> v(a + 1, a + n + 1);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; i++)
b[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
return v.size();
}
mt19937 rng(time(NULL));
int randint(int l, int r) { return rng() % (r - l + 1) + l; }
void solve() {
int n, Mod;
cin >> n >> Mod;
vector<int> p(40, 0);
for (int c = 0; (1 << c) <= n; c++) {
int l = 1 << c, r = (1 << (c + 1)) - 1;
p[c] = min(n, r) - l + 1;
}
int ans = 1;
for (auto x : p) {
ans = 1ll * ans * (x + 1) % Mod;
}
ans -= 1;
if (ans < 0) ans += Mod;
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void solve() {
int t;
cin >> t;
vector<long long> arr(t);
for (auto &it : arr) cin >> it;
if (arr.front() < arr.back())
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
int n;
cin >> n;
while (n--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long rint() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline long long gcd(long long a, long long b) {
return (b) ? gcd(b, a % b) : a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long pow(long long a, long long b, long long q) {
long long rtn = 1;
while (b) {
if (b & 1) rtn = rtn * a % q;
a = a * a % q;
b >>= 1;
}
return rtn;
}
inline long long mysqrt(long long n) {
long long x = sqrt(n);
while (x * x < n) x++;
while (x * x > n) x--;
return x;
}
int main() {
int a = rint(), b = rint(), n = rint();
int minn = max(0, n - b), maxx = min(n, a);
cout << maxx - minn + 1 << "\n";
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, x, y;
cin >> n >> x >> y;
string s;
cin >> s;
vector<long long> prefs(n);
vector<bool> ready(n);
for (long long i = n - 1; i > -1; --i) {
long long k = n - 1 - i;
if (k)
prefs[k] = prefs[k - 1] + (s[i] - '0');
else
prefs[k] = s[i] - '0';
ready[k] = s[i] - '0';
}
if (ready[y])
cout << prefs[x - 1] - 1;
else
cout << prefs[x - 1] + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
int alpha[26] = {0};
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.length(); j++) alpha[int(s[j] - 'a')]++;
}
int flag = 0;
for (int i = 0; i < 26; i++) {
if (alpha[i] % n) {
flag = 1;
break;
}
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int INF = 1e9 + 7;
struct node {
int l, r;
node(int _l = 0, int _r = 0) : l(_l), r(_r){};
void operator+=(node x) {
l = min(l + x.l, INF);
r = min(r + x.r, INF);
}
int get() { return min(l, r); }
} val[N];
int root[N], rev[N];
pair<int, int> getRoot(int u) {
if (u == root[u]) {
return make_pair(u, 0);
} else {
pair<int, int> tmp = getRoot(root[u]);
root[u] = tmp.first;
rev[u] ^= tmp.second;
return make_pair(root[u], rev[u]);
}
}
int n, k;
vector<int> adj[N];
string s;
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
val[i] = node(1, 0);
root[i] = i;
rev[i] = 0;
int c;
cin >> c;
while (c--) {
int x;
cin >> x;
adj[x].push_back(i);
}
}
int curAns = 0;
for (int i = 1; i <= n; i++) {
int t = (s[i - 1] - '0') ^ 1;
if (adj[i].size() == 1) {
pair<int, int> u = getRoot(adj[i][0]);
curAns -= val[u.first].get();
val[u.first] += node((u.second == t) * INF, (u.second != t) * INF);
curAns += val[u.first].get();
}
if (adj[i].size() == 2) {
pair<int, int> u = getRoot(adj[i][0]);
pair<int, int> v = getRoot(adj[i][1]);
if (u.first != v.first) {
curAns -= val[u.first].get();
curAns -= val[v.first].get();
if (u.first > v.first) swap(u, v);
if (u.second ^ v.second ^ t) {
rev[v.first] = 1;
swap(val[v.first].l, val[v.first].r);
}
root[v.first] = u.first;
val[u.first] += val[v.first];
curAns += val[u.first].get();
}
}
cout << curAns << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int read() {
register 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 = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
const int Size = 100005;
int n, m, cnt, head[Size], a[Size];
struct Edge {
int v, next;
} w[Size << 1];
void AddEdge(int u, int v) {
w[++cnt].v = v;
w[cnt].next = head[u];
head[u] = cnt;
}
int tot, ans[Size << 2];
bool vis[Size];
void dfs(int x, int fa) {
vis[x] = true;
ans[++tot] = x;
a[x] = !a[x];
for (int i = head[x]; i; i = w[i].next) {
int nxt = w[i].v;
if (!vis[nxt] && nxt != fa) {
dfs(nxt, x);
ans[++tot] = x;
a[x] ^= 1;
}
}
if (a[x]) {
ans[++tot] = fa;
ans[++tot] = x;
a[fa] = !a[fa];
a[x] = !a[x];
}
}
int main() {
n = read();
m = read();
for (register int i = 1; i <= m; i++) {
int u = read();
int v = read();
AddEdge(u, v);
AddEdge(v, u);
}
int s = 0;
for (register int i = 1; i <= n; i++) {
a[i] = read();
if (!s && a[i]) s = i;
}
dfs(s, 0);
for (register int i = 1; i <= n; i++) {
if (a[i] && !vis[i]) {
printf("-1");
return 0;
}
}
if (tot > 2 && !ans[tot - 1]) {
tot -= 3;
}
printf("%d\n", tot);
for (register int i = 1; i <= tot; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main(void) {
int n, i, count;
while (~scanf("%d", &n)) {
i = 0, count = 0;
while (i <= n) {
i += 2;
count++;
}
i -= 2;
count--;
if (i == n) {
printf("%d\n", count);
while (count--) {
printf("2 ");
}
putchar('\n');
} else {
if (n - i == 1) {
i -= 2;
}
printf("%d\n", count);
count--;
while (count--) {
printf("2 ");
}
printf("%d\n", 3);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
bool minimize(X &x, const Y &y) {
X eps = 1e-9;
if (x > y + eps) {
x = y;
return true;
} else
return false;
}
template <class X, class Y>
bool maximize(X &x, const Y &y) {
X eps = 1e-9;
if (x + eps < y) {
x = y;
return true;
} else
return false;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
struct SegmentTree {
private:
vector<int> tree, lazy;
int n;
void pushDown(int i) {
for (int j = (2 * i), _b = (2 * i + 1); j <= _b; j++) {
tree[j] += lazy[i];
lazy[j] += lazy[i];
}
lazy[i] = 0;
}
void update(int i, int l, int r, int u, int v, int c) {
if (l > v || r < u || l > r || v < u) return;
if (u <= l && r <= v) {
tree[i] += c;
lazy[i] += c;
return;
}
pushDown(i);
int m = (l + r) >> 1;
update(2 * i, l, m, u, v, c);
update(2 * i + 1, m + 1, r, u, v, c);
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
}
public:
SegmentTree(int n = 0) {
this->n = n;
if (n > 0) {
tree.assign(4 * n + 7, 0);
lazy.assign(4 * n + 7, 0);
}
}
void update(int l, int r, int c) { update(1, 1, n, l, r, c); }
int firstNegative(void) {
pushDown(1);
if (tree[1] >= 0) return -1;
int i = 1, l = 1, r = n;
while (true) {
if (l == r) return r;
pushDown(i);
int m = (l + r) >> 1;
if (tree[2 * i + 1] < 0) {
i = 2 * i + 1;
l = m + 1;
} else {
i = 2 * i;
r = m;
}
}
}
};
int numDish, numPerson, numQuery;
int dishes[1000100], people[1000100];
void process(void) {
SegmentTree myit(1000100);
scanf("%d%d", &numDish, &numPerson);
for (int i = (1), _b = (numDish); i <= _b; i++) {
int x;
scanf("%d", &x);
dishes[i] = x;
myit.update(1, x, -1);
}
for (int i = (1), _b = (numPerson); i <= _b; i++) {
int x;
scanf("%d", &x);
people[i] = x;
myit.update(1, x, 1);
}
scanf("%d", &numQuery);
for (int love = 0, _n = (numQuery); love < _n; love++) {
int t, u, c;
scanf("%d%d%d", &t, &u, &c);
if (t == 1) {
int ___prev = dishes[u];
dishes[u] = c;
if (___prev < c) myit.update(___prev + 1, c, -1);
if (___prev > c) myit.update(c + 1, ___prev, 1);
} else {
int ___prev = people[u];
people[u] = c;
if (___prev < c) myit.update(___prev + 1, c, 1);
if (___prev > c) myit.update(c + 1, ___prev, -1);
}
printf("%d\n", myit.firstNegative());
}
}
int main(void) {
process();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e7 + 7;
int main() {
long long n, q1;
cin >> n >> q1;
queue<pair<int, int>> q;
vector<int> timer(n + 1), mapi(n + 1);
int total = 0, count = 0;
vector<int> inValid(n + 1);
while (q1--) {
int x1, x2;
cin >> x1 >> x2;
if (x1 == 1) {
q.push({x2, ++timer[x2]});
total++;
mapi[x2]++;
} else if (x1 == 2) {
total -= mapi[x2];
mapi[x2] = 0;
inValid[x2] = timer[x2];
} else {
if (count < x2) {
for (int i = 0; i < x2 - count; ++i) {
if (q.empty()) continue;
int x = q.front().first;
int y = q.front().second;
q.pop();
if (y > inValid[x] && mapi[x] > 0) {
mapi[x]--;
total--;
}
}
count = x2;
}
}
cout << total << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0, b, c, n, x1, x2, y1, y2;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x1 >> x2 >> y1 >> y2;
b = (abs(x1 - y1) + 1);
c = (abs(x2 - y2) + 1);
a += b * c;
}
cout << a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 100000000;
const long long MOD1 = 1000000007;
const long long MOD2 = 1000000009;
const int N = 1001000;
char a[N], b[N];
int n, m, nextt[N], t;
void getnext() {
int k = -1, j = 0;
nextt[0] = -1;
while (j < m) {
if (k == -1 || b[j] == b[k])
nextt[++j] = ++k;
else
k = nextt[k];
}
}
int kmp(int st) {
getnext();
int i, j;
for (i = st, j = 0; i < n; ++i) {
while (j > 0 && b[j] != a[i]) j = nextt[j];
if (a[i] == b[j]) ++j;
if (j == m) return m;
}
return j;
}
int main() {
int st = 0;
scanf("%d", &t);
scanf("%s", a);
n = strlen(a);
for (int i = 1; i < t; ++i) {
scanf("%s", b);
m = strlen(b);
int x = kmp(max(st - m, 0));
for (int i = x; i < m; ++i) {
a[n++] = b[i];
}
st = n;
}
a[n] = '\n';
printf("%s\n", a);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char h[1100][1100], v[1100][1100];
int board[1100][1100];
int main() {
int H, W, K;
int i, j, cnt;
scanf("%d%d%d ", &H, &W, &K);
for (i = 0; i < H; i++) {
for (j = 0; j < W - 1; j++) scanf("%c ", &h[i][j]);
if (i == H - 1) continue;
for (j = 0; j < W; j++) scanf("%c ", &v[i][j]);
}
if (K == 1) {
cnt = 0;
for (i = 0; i < H; i++)
for (j = 0; j < W - 1; j++)
if (h[i][j] == 'N') cnt++;
for (i = 0; i < H - 1; i++)
for (j = 0; j < W; j++)
if (v[i][j] == 'N') cnt++;
if (cnt * 4 > H * (W - 1) + (H - 1) * W)
puts("NO");
else {
puts("YES");
for (i = 0; i < H; i++, puts("1"))
for (j = 0; j < W - 1; j++) printf("%d ", 1);
}
return 0;
}
if (W > H) {
for (i = 0; i < H; i++) {
board[i][0] = 1;
for (j = 0; j < W - 1; j++) {
if (h[i][j] == 'E')
board[i][j + 1] = board[i][j];
else
board[i][j + 1] = 3 - board[i][j];
}
if (!i) continue;
cnt = 0;
for (j = 0; j < W; j++) {
if (v[i - 1][j] == 'E') {
if (board[i][j] == board[i - 1][j]) cnt++;
} else {
if (board[i][j] != board[i - 1][j]) cnt++;
}
}
if (cnt * 2 >= W) continue;
for (j = 0; j < W; j++) board[i][j] = 3 - board[i][j];
}
} else {
for (j = 0; j < W; j++) {
board[0][j] = 1;
for (i = 0; i < H - 1; i++) {
if (v[i][j] == 'E')
board[i + 1][j] = board[i][j];
else
board[i + 1][j] = 3 - board[i][j];
}
if (!j) continue;
cnt = 0;
for (i = 0; i < H; i++) {
if (h[i][j - 1] == 'E') {
if (board[i][j] == board[i][j - 1]) cnt++;
} else {
if (board[i][j] != board[i][j - 1]) cnt++;
}
}
if (cnt * 2 >= H) continue;
for (i = 0; i < H; i++) board[i][j] = 3 - board[i][j];
}
}
puts("YES");
for (i = 0; i < H; i++) {
for (j = 0; j < W - 1; j++) printf("%d ", board[i][j]);
printf("%d\n", board[i][W - 1]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const long long oo = 1ll << 62;
int n, g[maxn][2], a[maxn];
long long f[maxn][2];
bool del[maxn];
vector<int> ans;
inline bool upd(long long &x, long long y) { return x < y ? 0 : (x = y, 1); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), f[i][0] = f[i][1] = oo;
f[0][0] = 0;
f[0][1] = oo;
for (int i = 1; i <= n; ++i) {
if (upd(f[i][0], a[i] + min(f[i - 1][0], f[i - 1][1]))) g[i][0] = 1;
if (i > 1 &&
upd(f[i][0], max(a[i], a[i - 1]) + min(f[i - 2][0], f[i - 2][1])))
g[i][0] = 2;
if (upd(f[i][1], f[i - 1][0])) g[i][1] = 0;
}
for (int i = n, j = f[n][1] < f[n][0]; i;) {
if (!g[i][j])
--i, j = 0;
else if (g[i][j] == 1)
del[i] = 1, --i, j = f[i][1] <= f[i][0];
else
del[i] = del[i - 1] = 1, i -= 2, j = f[i][1] <= f[i][0];
}
for (int i = 1; i <= n; ++i) {
if (del[i]) {
int j = i;
while (j + 1 <= n && del[j + 1]) ++j;
while (i <= j) {
if (!a[i])
++i;
else {
if (!a[i + 1]) {
if (a[i - 1]) ans.push_back(i - 1);
++i;
} else {
int x = min(a[i], a[i + 1]);
ans.push_back(i);
a[i] -= x;
a[i + 1] -= x;
}
}
}
--i;
}
}
printf("%d\n", ans.size());
for (int i : ans) printf("%d\n", i);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, p, x, y;
cin >> n >> k >> p;
x = (n - 1) * 2 * k + n - 1;
y = n * p;
cout << x << " " << y;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int iin() {
int x;
scanf("%d", &x);
return x;
}
inline long long int lin() {
long long int x;
scanf("%lld", &x);
return x;
}
const long long int N = 1e6 + 85;
const long long int M = 1e3 + 85;
const long long int mod = 1e9 + 7;
const long long int pinf = LLONG_MAX;
const long long int minf = LLONG_MIN;
int dp[85][69][85];
int f(int n, int m, int k) {
if (dp[n][m][k] or n * m == k or !k) return dp[n][m][k];
int ans = 1e9;
for (int i = 1; i < n; i++)
for (int j = 0; j <= k; j++)
((ans) = min((ans), (m * m + f(i, m, j) + f(n - i, m, k - j))));
for (int i = 1; i < m; i++)
for (int j = 0; j <= k; j++)
((ans) = min((ans), (n * n + f(n, i, j) + f(n, m - i, k - j))));
return dp[n][m][k] = ans;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
cout << f(a, b, c) << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 10;
int n, k, a[N], l[N], r[N], ans;
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
if (a[i] % k != a[i - 1] % k) {
cout << -1 << '\n';
return 0;
}
}
for (int i = 0; i < n; i++) {
a[i] /= k;
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
l[i] = l[i - 1] + i * (a[i] - a[i - 1]);
}
for (int i = n - 2; i >= 0; i--) {
r[i] = r[i + 1] + (n - i - 1) * (a[i + 1] - a[i]);
}
ans = l[0] + r[0];
cout << ans << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
putchar('\n');
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int N = 100005;
const long long sj = 6e9, inf = 9e18;
long long a[N], c[N];
pair<long long, int> q[N << 1];
int n;
inline void change(int pos, long long de) {
for (int i = pos; i < N; i += i & -i) c[i] += de;
}
inline long long ask(int pos) {
long long ans = 0;
for (int i = pos; i; i -= i & -i) ans += c[i];
return ans;
}
pair<long long, long long> Get(long long x) {
int qq = 0;
for (int i = 1; i <= n; i++) {
q[++qq] = make_pair(a[i - 1], -i);
q[++qq] = make_pair(a[i] - x, i);
c[i] = 0;
}
long long sum = 0, ans = 0;
sort(&q[1], &q[qq + 1]);
for (int i = 1; i <= qq; i++)
if (q[i].second < 0)
change(-q[i].second, 1);
else {
long long t = ask(q[i].second);
sum += t;
ans += t * a[q[i].second];
}
for (int i = 1; i <= n; i++) c[i] = 0;
for (int i = 1; i <= qq; i++)
if (q[i].second < 0)
change(-q[i].second, q[i].first);
else
ans -= ask(q[i].second);
return make_pair(sum, ans);
}
pair<long long, long long> dp[N], Dp[N], cf[N];
long long mn[N];
pair<long long, long long> askf(int pos) {
pos = n - pos;
pair<long long, long long> ans = make_pair(-inf, 0);
for (int i = pos; i; i -= i & -i) ans = max(ans, cf[i]);
return ans;
}
void chf(int pos, pair<long long, long long> de) {
pos = n - pos;
for (int i = pos; i <= n; i += i & -i) cf[i] = max(cf[i], de);
}
bool cmp(long long a, long long b) { return a > b; }
pair<long long, long long> get(long long x) {
for (int i = 1; i <= n; i++) cf[i] = make_pair(-inf, 0);
chf(0, dp[0]);
for (int i = 1; i <= n; i++) {
int pos = lower_bound(&mn[0], &mn[i], a[i] - x, cmp) - mn;
dp[i] = askf(pos);
if (pos)
dp[i] = max(dp[i], make_pair(Dp[pos - 1].first + a[i] - x,
Dp[pos - 1].second + 1));
if (i < n) chf(i, dp[i]);
mn[i] = min(mn[i - 1], a[i]);
Dp[i] = max(Dp[i - 1], make_pair(dp[i].first - mn[i], dp[i].second));
}
pair<long long, long long> ttt = Get(x);
dp[n].first += ttt.second - ttt.first * x;
dp[n].second += ttt.first;
return dp[n];
}
int main() {
n = read();
long long k = read();
for (int i = 1; i <= n; i++) a[i] = read() + a[i - 1];
long long l = -sj, r = sj;
while (l < r) {
long long mid = (l + r) >> 1;
mid++;
if (get(mid).second >= k)
l = mid;
else
r = mid - 1;
}
cout << get(l).first + k * l << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
int sum = 0;
while (cin >> c) {
if (c == 'A')
sum++;
else if (c == '1')
sum += 10;
else
sum += c - 48;
}
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int z[MAXN];
char s[MAXN];
bool ar[MAXN];
set<int> st;
int main() {
#pragma warning(disable : 4996)
memset(ar, 0, sizeof(ar));
int n, m, len;
scanf("%d%d %s", &n, &m, s);
len = strlen(s);
for (int i = 1, l = 0, r = 0; i < len; i++) {
if (i <= r) {
z[i] = min(r - i + 1, z[i - l]);
}
while (z[i] + i < len && s[z[i]] == s[z[i] + i]) z[i]++;
if (z[i] + i > r) {
r = z[i] + i - 1;
l = i;
}
}
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
x--;
if (x + len - 1 >= n) {
printf("0");
return 0;
}
auto it = st.lower_bound(x);
if (it != st.end()) {
int d = *it - x + 1;
if (z[len - d] != d) {
printf("0");
return 0;
}
}
st.insert(x + len - 1);
}
int r = -1;
for (int i : st) {
for (int j = i; j > r && i - j + 1 <= len; j--) ar[j] = 1;
r = i;
}
long long int ans = 1, mod = 1e9 + 7;
for (int i = 0; i < n; i++) {
if (ar[i] == 0) {
ans = (ans * 26) % mod;
}
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[2600], y[2600];
string a[60];
bool valid(int y, int x1, int y1, int x, int x2, int y2) {
for (int i = min(x1, x2); i <= max(x1, x2); i++) {
if (a[i][y] != 'B') {
return false;
}
}
for (int i = min(y1, y2); i <= max(y1, y2); i++) {
if (a[x][i] != 'B') {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int k = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < m; j++) {
if (a[i][j] == 'B') {
x[k] = i;
y[k] = j;
k++;
}
}
}
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
if (valid(y[i], x[i], y[i], x[j], x[j], y[j])) {
continue;
}
if (valid(y[j], x[i], y[i], x[i], x[j], y[j])) {
continue;
}
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
namespace _buff {
const size_t BUFF = 1 << 19;
char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
char getc() {
if (ib == ie) {
ib = ibuf;
ie = ibuf + fread(ibuf, 1, BUFF, stdin);
}
return ib == ie ? -1 : *ib++;
}
} // namespace _buff
LL read() {
using namespace _buff;
LL ret = 0;
bool pos = true;
char c = getc();
for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
assert(~c);
}
if (c == '-') {
pos = false;
c = getc();
}
for (; c >= '0' && c <= '9'; c = getc()) {
ret = (ret << 3) + (ret << 1) + (c ^ 48);
}
return pos ? ret : -ret;
}
const size_t N = 1e5 + 5;
const size_t M = 3e5 + 5;
const size_t V = N << 5;
const int INF = 1e9;
int rt, seg[V], lc[V], rc[V], tot;
void clean() {
rt = tot = 0;
memset(lc, 0, sizeof lc);
memset(rc, 0, sizeof rc);
fill(begin(seg), end(seg), -INF);
}
void pushup(int x) { seg[x] = max(seg[lc[x]], seg[rc[x]]); }
void push(int &x, int tl, int tr, int p, int val) {
if (!x) x = ++tot;
if (tl + 1 == tr) {
if (val > seg[x]) {
seg[x] = val;
}
return;
}
int mid = (tl + tr) >> 1;
if (p < mid) {
push(lc[x], tl, mid, p, val);
} else {
push(rc[x], mid, tr, p, val);
}
pushup(x);
}
int query(int x, int tl, int tr, int l, int r) {
if (tl >= r || tr <= l || !x) return -INF;
if (l <= tl && tr <= r) {
return seg[x];
}
int mid = (tl + tr) >> 1;
return max(query(lc[x], tl, mid, l, r), query(rc[x], mid, tr, l, r));
}
int n, arr[N], ans[M];
vector<pair<int, int> > que[N], upd[N];
int main() {
n = read();
generate_n(arr, n, read);
int m = read();
for (int i = 0; i < m; ++i) {
int l = read() - 1, r = read();
que[l].emplace_back(r, i);
}
int N = *max_element(arr, arr + n) + 1;
clean();
for (int i = 0; i < n; ++i) {
{
int lb = 0;
while (lb <= arr[i]) {
int id = query(rt, 0, N, lb, arr[i] + 1);
if (id < 0) break;
upd[id].emplace_back(arr[i] - arr[id], i);
lb = (arr[i] + arr[id]) / 2 + 1;
}
}
{
int rb = N - 1;
while (arr[i] <= rb) {
int id = query(rt, 0, N, arr[i], rb + 1);
if (id < 0) break;
upd[id].emplace_back(arr[id] - arr[i], i);
rb = (arr[i] + arr[id] - 1) / 2;
}
}
push(rt, 0, N, arr[i], i);
}
clean();
for (int i = n; i--;) {
for (auto [val, pos] : upd[i]) {
push(rt, 0, n, pos, -val);
}
for (auto [r, id] : que[i]) {
ans[id] = -query(rt, 0, n, i, r);
}
}
for (int i = 0; i < m; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long a, num;
} s[1000050];
bool cmp(node a, node b) { return a.a < b.a; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%I64d%I64d", &s[i].a, &s[i].num);
}
sort(s, s + n, cmp);
for (int i = 1; i < n; ++i) {
long long now = s[i - 1].num;
for (int j = s[i - 1].a; j < s[i].a; ++j) {
now = (now + 3) / 4;
if (now == 1) break;
}
if (now > s[i].num) s[i].num += now - s[i].num;
}
long long ans = s[n - 1].a + 1;
long long now = (s[n - 1].num + 3) / 4;
while (now != 1) {
ans++;
now = (now + 3) / 4;
}
printf("%I64d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int N = 1e6 + 5;
inline int read() {
int x = 0, rev = 0, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') rev = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return rev ? -x : x;
}
int n, lst, cnt = 1, id[N], nxt[N], c[N][26], fail[N], len[N], f[N], g[N],
diff[N];
char s[N], ss[N];
int extend(int x, int n) {
int p = lst;
while (s[n - len[p] - 1] != s[n]) p = fail[p];
if (!c[p][x]) {
int now = ++cnt, k = fail[p];
len[now] = len[p] + 2;
while (s[n - len[k] - 1] != s[n]) k = fail[k];
fail[now] = c[k][x], c[p][x] = now;
diff[now] = len[now] - len[fail[now]];
if (diff[now] == diff[fail[now]])
nxt[now] = nxt[fail[now]];
else
nxt[now] = fail[now];
}
return lst = c[p][x];
}
int main() {
scanf("%s", ss + 1), n = strlen(ss + 1);
for (int i = 1, j = 0; i <= n; i += 2) s[i] = ss[++j];
for (int i = 2, j = n + 1; i <= n; i += 2) s[i] = ss[--j];
fail[0] = fail[1] = 1, len[1] = -1, f[0] = 1;
for (int i = 1; i <= n; i++) id[i] = extend(s[i] - 'a', i);
for (int i = 1; i <= n; i++) {
for (int j = id[i]; j; j = nxt[j]) {
g[j] = f[i - len[nxt[j]] - diff[j]];
if (diff[j] == diff[fail[j]]) (g[j] += g[fail[j]]) %= 1000000007;
if (!(i & 1)) (f[i] += g[j]) %= 1000000007;
}
}
printf("%d\n", f[n]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
cin >> s;
int i = 0;
if (n == 1) {
cout << s[0];
return 0;
} else {
cout << '1';
for (i = 0; i < n; i++) {
if (s[i] == '0') cout << s[i];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a;
int main() {
scanf("%lld", &n);
a = 1;
while (n > a) {
n = n - a;
a++;
}
printf("%lld\n", n);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long n;
cin >> n;
string a, b;
cin >> a >> b;
long long cnt00 = 0, cnt01 = 0, cnt10 = 0, cnt11 = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == '0' && b[i] == '0')
cnt00++;
else if (a[i] == '0' && b[i] == '1')
cnt01++;
else if (a[i] == '1' && b[i] == '0')
cnt10++;
else if (a[i] == '1' && b[i] == '1')
cnt11++;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (b[i] == '0') {
if (a[i] == '0')
ans += cnt11 + cnt10;
else
ans += cnt01;
}
}
cout << ans << endl;
return 0;
}
struct Query {
long long L, R, idx;
};
bool compare(long long a0, long long a1) { return (a0 > a1); }
long long power(long long x, long long y, long long p) {
long long ans = 1;
x = x % p;
while (y > 0) {
if (y & 1) ans = (ans * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return ans;
}
long long x, y, g;
void extendedEuclid(long long a, long long b) {
if (b == 0) {
g = a;
x = 1;
y = 0;
} else {
extendedEuclid(b, a % b);
long long temp = x;
x = y;
y = temp - (a / b) * y;
}
}
long long moduloInverse(long long a, long long p) {
extendedEuclid(a, p);
if (g == 1 && p != 1)
return (x + p) % p;
else
return -1;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, f[10], i, j, temp;
scanf("%d", &n);
char *s;
s = (char *)malloc(n + 2);
scanf("%s", s);
for (i = 1; i <= 9; i++) {
scanf("%d", &f[i]);
}
for (i = 0;; i++) {
if (((int)s[i] - 48) < f[(int)s[i] - 48]) {
temp = i;
break;
} else if (i == (n - 1)) {
temp = n - 1;
break;
}
}
for (i = temp; i < n; i++) {
if (((int)s[i] - 48) > f[(int)s[i] - 48]) {
break;
}
s[i] = (char)(f[(int)s[i] - 48] + 48);
}
puts(s);
free(s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double dp[85][85][85], ans[85][85], H1, H2, H3;
int l[85], r[85], i, j, n, k, t1, t2, a[1005], cnt, Cnt, X1, X2;
const double eps = 1e-13;
int cmp(int i, int j) { return i < j; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
a[++Cnt] = l[i];
a[++Cnt] = r[i];
}
sort(a + 1, a + Cnt + 1, cmp);
for (i = 1; i <= n; i++) {
for (j = 2; j <= Cnt; j++)
if (a[j] <= r[i] && a[j - 1] >= l[i]) {
dp[0][0][0] = (a[j] - a[j - 1]) / (r[i] - l[i] + 0.0);
X1 = X2 = 0;
for (cnt = 0, k = 1; k <= n; k++)
if (i != k) {
if (a[j] <= r[k] && a[j - 1] >= l[k]) {
cnt++;
for (t1 = 0; t1 <= cnt; t1++)
for (t2 = 0; t2 <= cnt - t1; t2++) dp[cnt][t1][t2] = 0;
H1 = (a[j - 1] - l[k]) / (r[k] - l[k] + 0.0);
H2 = (r[k] - a[j]) / (r[k] - l[k] + 0.0);
H3 = (a[j] - a[j - 1]) / (r[k] - l[k] + 0.0);
for (t1 = 0; t1 < cnt; t1++)
for (t2 = 0; t2 < cnt - t1; t2++)
if (dp[cnt - 1][t1][t2] > eps) {
dp[cnt][t1 + 1][t2] += dp[cnt - 1][t1][t2] * H1;
dp[cnt][t1][t2 + 1] += dp[cnt - 1][t1][t2] * H2;
dp[cnt][t1][t2] += dp[cnt - 1][t1][t2] * H3;
}
} else if (a[j - 1] >= r[k])
X1++;
else
X2++;
}
for (t1 = 0; t1 <= cnt; t1++)
for (t2 = 0; t2 <= cnt - t1; t2++)
for (k = t1 + X1 + 1; k <= n - t2 - X2; k++)
ans[i][k] += dp[cnt][t1][t2] / (n - t1 - t2 - X1 - X2 + 0.0);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) printf("%.10f ", (double)ans[i][j]);
printf("\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long inf = 1e18;
int n;
int h[N], t[N];
vector<int> g[N];
vector<long long> f[N];
vector<long long> tmp;
void dfs(int x, int fa) {
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] == fa) {
swap(g[x][i], g[x][g[x].size() - 1]);
g[x].pop_back();
break;
}
random_shuffle(g[x].begin(), g[x].end());
int S = min((int)g[x].size(), 300);
f[x].resize(S * 2 + 1, inf);
f[x][S] = 0;
int cnt = 0;
for (auto u : g[x]) {
dfs(u, x);
tmp.resize(S * 2 + 1);
for (auto& u : tmp) u = inf;
int SS = g[u].size();
if (h[x] >= h[u]) {
long long v = f[u][SS];
if (SS) v = min(v, f[u][SS - 1]);
for (int i = -S; i <= S; i++) {
if (i > 0) {
tmp[i - 1 + S] = min(tmp[i - 1 + S], f[x][i + S] + v + t[u] + t[x]);
} else if (i != -S) {
tmp[i - 1 + S] = min(tmp[i - 1 + S], f[x][i + S] + v + t[u]);
}
tmp[i + S] = min(tmp[i + S], f[x][i + S] + v + t[u] + t[x]);
}
}
if (h[x] <= h[u]) {
long long v = f[u][SS];
if (SS) v = min(v, f[u][SS + 1]);
for (int i = -S; i <= S; i++) {
if (i < 0) {
tmp[i + 1 + S] = min(tmp[i + 1 + S], f[x][i + S] + v + t[u] + t[x]);
} else if (i != S) {
tmp[i + 1 + S] = min(tmp[i + 1 + S], f[x][i + S] + v + t[u]);
}
tmp[i + S] = min(tmp[i + S], f[x][i + S] + v + t[u] + t[x]);
}
}
f[x] = tmp;
}
}
int main() {
srand(12314);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
printf("%lld\n", f[1][min((int)g[1].size(), 300)]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int x, y, t, d;
int ans;
int main() {
int i;
cin >> x >> y >> t >> d;
for (i = 1; i <= t - 2; i++) {
if (x > y) swap(x, y);
ans += x;
x += d;
}
ans += x;
ans += y;
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int ans = 0;
int a, b, c;
int arr[3];
cin >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
a = arr[2];
b = arr[1];
c = arr[0];
if (a != 0) {
ans++;
a--;
}
if (b != 0) {
ans++;
b--;
}
if (c != 0) {
ans++;
c--;
}
if (a > 0 && c > 0) {
ans++;
a--;
c--;
}
if (a > 0 && b > 0) {
ans++;
a--;
b--;
}
if (b > 0 && c > 0) {
ans++;
b--;
c--;
}
if (a > 0 && b > 0 && c > 0) {
ans++;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int>* sets = new set<int>[n];
bool fl = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (fl)
sets[j].insert(i * n + j + 1);
else
sets[n - j - 1].insert(i * n + j + 1);
}
fl = !fl;
}
for (int i = 0; i < n; i++) {
for (set<int>::iterator it = sets[i].begin(); it != sets[i].end(); it++)
cout << *it << " ";
cout << "\n";
}
delete[] sets;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int nextint() {
int a;
scanf("%d", &a);
return a;
}
char s[1000000];
int n, hcnt, scnt, lasth;
int getNext(int i, char c) {
while (i < n && s[i] != c) i++;
return i;
}
int getTime(int k) {
int res = 0;
int i = -1;
int lastsid = hcnt - k - 1;
int last = 0;
if (lastsid == -1)
last = n - 1;
else
while (lastsid + 1) {
if (s[last] == 'S') {
if (lastsid == 0) break;
lastsid--;
}
last++;
}
last = max(last, lasth);
int ret = 1 + last * 2;
while (getNext(i, 'H') != n) {
i++;
for (; i <= lasth; i++) {
res++;
ret = min(ret, res + (last - i) * 2);
if (s[i] == 'S') k++;
if (s[i] == 'H') {
if (k > 0)
k--;
else
break;
}
}
int nh = getNext(i, 'H');
int ns = getNext(i, 'S');
if (nh == n) return min(ret, res);
int target = ns;
int cur = nh;
for (i++; i <= target; i++) {
if (i == target) {
res += (target - cur) * 3;
ret = min(ret, res + (last - cur) * 2);
break;
}
if (s[i] == 'H') target = getNext(target + 1, 'S');
}
}
return min(res, ret);
}
int main() {
n = nextint();
int t = nextint();
scanf("%s", s);
hcnt = count(s, s + n, 'H');
scnt = count(s, s + n, 'S');
for (int i = 0; i < n; i++)
if (s[i] == 'H') lasth = i;
int lo = max(0, hcnt - scnt), hi = hcnt;
while (lo < hi) {
int c = (lo + hi) / 2;
int tt = getTime(c);
if (tt <= t)
hi = c;
else
lo = c + 1;
}
if (getTime(hcnt) > t)
cout << -1 << endl;
else
cout << lo << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct line {
long long a, b, i;
long double x;
line(long long _a, long long _b, long double _x = -1e18) {
a = _a;
b = _b;
x = _x;
}
line(){};
};
long double inter(line p, line q) { return (q.a - p.a + 0.0) / (p.b - q.b); }
long long INF = 1e16;
struct my_tree {
vector<vector<line> > tree;
vector<vector<line> > tree2;
vector<line> a;
long long n;
my_tree(vector<line> &_a) {
a = _a;
n = _a.size();
tree.resize(4 * n);
tree2.resize(4 * n);
build(0, 0, n);
}
void build(long long v, long long l, long long r) {
if (l + 1 == r) {
add(v, a[l]);
tree2[v].push_back(a[l]);
return;
}
long long m = (l + r) / 2;
build(2 * v + 1, l, m);
build(2 * v + 2, m, r);
long long v1 = 0, v2 = 0;
tree[v].clear();
tree2[v].clear();
while (v1 < tree2[2 * v + 1].size() && v2 < tree2[2 * v + 2].size()) {
if ((tree2[2 * v + 1][v1].b < tree2[2 * v + 2][v2].b) ||
(tree2[2 * v + 1][v1].a > tree2[2 * v + 2][v2].a &&
tree2[2 * v + 1][v1].b == tree2[2 * v + 2][v2].b)) {
tree2[v].push_back(tree2[2 * v + 1][v1]);
v1++;
} else {
tree2[v].push_back(tree2[2 * v + 2][v2]);
v2++;
}
}
while (v1 < tree2[2 * v + 1].size()) {
tree2[v].push_back(tree2[2 * v + 1][v1]);
v1++;
}
while (v2 < tree2[2 * v + 2].size()) {
tree2[v].push_back(tree2[2 * v + 2][v2]);
v2++;
}
for (long long i = 0; i < tree2[v].size(); i++) {
add(v, tree2[v][i]);
}
return;
}
void add(long long v, line p) {
if (!tree[v].empty() && p.b == tree[v].back().b) {
if (p.a <= tree[v].back().a) return;
tree[v].pop_back();
}
while (!tree[v].empty() && inter(p, tree[v].back()) < tree[v].back().x) {
tree[v].pop_back();
}
if (!tree[v].empty()) p.x = inter(p, tree[v].back());
tree[v].push_back(p);
}
pair<long long, long long> get_min(long long v, long long x) {
long long l = 0, r = (long long)tree[v].size();
while (l + 1 < r) {
long long m = (l + r) / 2;
if (tree[v][m].x <= x) {
l = m;
} else {
r = m;
}
}
return {tree[v][l].a + tree[v][l].b * x, tree[v][l].i};
}
pair<long long, long long> getAns(long long v, long long l, long long r,
long long L, long long R, long long t) {
if (r <= L || l >= R) {
return {-1e18, -1e18};
}
if (l >= L && r <= R) {
return get_min(v, t);
}
long long m = (l + r) / 2;
return max(getAns(2 * v + 1, l, m, L, R, t),
getAns(2 * v + 2, m, r, L, R, t));
}
};
signed main() {
ios::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q;
cin >> n >> q;
vector<line> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].a >> a[i].b;
a[i].i = i;
}
my_tree tree(a);
for (long long i = 0; i < q; i++) {
long long l, r, t;
cin >> l >> r >> t;
cout << tree.getAns(0, 0, n, l - 1, r, t).second + 1 << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << 1 + (n + (a - 1 + b) % n) % n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
cin >> t;
while (t--) {
cin >> n;
long long counter = 0;
long long e = 0;
for (int i = 0; i < (int)(1000000); ++i) {
e = pow(2, i) + e;
n -= e * (e + 1) / 2;
if (n < 0) {
cout << i << endl;
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int i, j, k;
int a = 1000000, b = 0;
int p, q;
cin >> n;
j = sqrt(n);
for (i = 1; i <= j + 1; i++) {
if (n % i == 0) {
p = n / i;
q = i;
if (abs(p - q) < abs(a - b)) {
a = max(p, q);
b = min(p, q);
}
}
}
cout << b << " " << a;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long ans, a[2000001], n, fac[2000001];
long long fast_pow(long long a, int b) {
if (b == 0) return 1;
if (b & 1)
return fast_pow(a * a % 998244353, b / 2) * a % 998244353;
else
return fast_pow(a * a % 998244353, b / 2);
}
long long C(int a, int b) {
long long mul = 1;
for (int i = a - b + 1; i <= a; ++i) mul = mul * i % 998244353;
for (int i = 1; i <= b; ++i)
mul = mul * fast_pow(i, 998244353 - 2) % 998244353;
return mul;
}
int main() {
cin >> n;
for (int i = 1; i <= 2 * n; ++i) cin >> a[i];
sort(a + 1, a + 2 * n + 1);
for (int i = n + 1; i <= 2 * n; ++i) ans = (ans + a[i]) % 998244353;
for (int i = 1; i <= n; ++i) ans = (ans - a[i]) % 998244353;
printf("%lld\n",
(ans * C(2 * n - 1, n - 1) % 998244353 * 2 % 998244353 + 998244353) %
998244353);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005];
int main() {
int i, j, n;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]), b[i] = a[i];
if (n <= 2) {
puts("-1");
return 0;
}
sort(b, b + n);
for (i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) continue;
swap(a[i], a[i + 1]);
for (j = 0; j < n && a[j] == b[j]; j++)
;
if (j == n) {
swap(a[i], a[i + 1]);
continue;
}
for (j = 0; j < n && a[j] == b[n - j - 1]; j++)
;
if (j == n) {
swap(a[i], a[i + 1]);
continue;
}
printf("%d %d\n", i + 1, i + 2);
return 0;
}
puts("-1");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60 + 2;
const int C = 1e4 + 10;
const int XX = 1e5;
int n[2], y[2][MAXN];
bool mark[2][XX];
vector<bitset<MAXN * 2>> vec;
bitset<MAXN * 2> temp;
bitset<MAXN * 2> get(pair<int, int> p) {
bitset<MAXN << 1> ret;
for (int w = 0; w < 2; w++)
for (int i = 0; i < n[w]; i++) {
int id = w * MAXN + i;
int y2 = y[w][i] + (p.second - y[w][i]) * 2;
if (y2 < 0 || y2 >= XX) continue;
if (mark[!w][y2]) ret[id] = 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n[0] >> n[1];
for (int w = 0; w < 2; w++)
for (int i = 0; i < n[w]; i++)
cin >> y[w][i], y[w][i] += C, y[w][i] <<= 1, mark[w][y[w][i]] = 1;
int ans = 0;
for (int i = 0; i < n[0]; i++)
for (int j = 0; j < n[1]; j++) {
pair<int, int> p(0, y[0][i] + y[1][j] >> 1);
vec.push_back(get(p));
}
for (auto &x : vec)
for (auto &y : vec) {
temp = x | y;
ans = max(ans, (int)temp.count());
}
cout << ans << "\n";
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.