solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
char str[100005];
int main() {
scanf("%s", str);
int n = strlen(str);
int sharp = 0, lastsharp;
for (int i = (0); i < (n); i++) {
if (str[i] == '#') {
lastsharp = i;
sharp++;
str[i] = ')';
}
}
int open = 0, openbeyond = 0;
bool fail = 0;
for (int i = (0); i < (lastsharp + 1); i++) {
if (str[i] == '(')
open++;
else {
if (open)
open--;
else
fail = 1;
}
}
for (int i = (lastsharp + 1); i < (n); i++) {
if (str[i] == '(')
openbeyond++;
else {
if (openbeyond <= 0) {
if (open)
open--;
else
fail = 1;
} else
openbeyond--;
}
}
int need = open + openbeyond + 1;
if (fail || openbeyond > 0 || need < 1) {
puts("-1");
return 0;
}
for (int i = (0); i < (sharp - 1); i++) puts("1");
printf("%d\n", need);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int N;
long long mini, maxi;
int sz[MAXN];
vector<pair<int, int> > e[MAXN];
void dfs(int u, int fa) {
int v, t;
sz[u] = 1;
for (int i = 0; i < e[u].size(); i++) {
v = e[u][i].first;
t = e[u][i].second;
if (v == fa) {
continue;
}
dfs(v, u);
sz[u] += sz[v];
if (sz[v] & 1) {
mini += t;
}
maxi += (long long)min(sz[v], 2 * N - sz[v]) * t;
}
}
int main() {
int T;
int u, v, t;
while (~scanf("%d", &T)) {
while (T--) {
scanf("%d", &N);
for (int i = 0; i <= 2 * N; i++) {
e[i].clear();
}
for (int i = 0; i < 2 * N - 1; i++) {
scanf("%d%d%d", &u, &v, &t);
e[u].push_back(pair<int, int>(v, t));
e[v].push_back(pair<int, int>(u, t));
}
mini = maxi = 0;
dfs(1, 0);
printf("%lld %lld\n", mini, maxi);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<ll> arr(n);
for (ll& i : arr) cin >> i;
if (n == 1) {
cout << 1 << ' ' << 1 << endl;
cout << -arr[0] << endl;
cout << 1 << ' ' << 1 << endl;
cout << 0 << endl;
cout << 1 << ' ' << 1 << endl;
cout << 0 << endl;
} else {
cout << 1 << ' ' << n << endl;
for (auto i : arr) cout << -i * n << ' ';
cout << endl;
cout << 1 << ' ' << n - 1 << endl;
for (int i = 0; i < arr.size() - 1; i++) cout << arr[i] * (n - 1) << ' ';
cout << endl;
cout << n << ' ' << n << endl;
cout << -(arr.back() - arr.back() * n) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
int vis[maxn];
int n, k, root, sum;
int home[maxn];
vector<int> one, two;
vector<int> g[maxn];
int find_Root(int u) {
int sum = home[u] ? 1 : 0;
for (int i = 0; i < g[u].size(); i++) {
int nt = g[u][i];
if (!vis[nt]) {
vis[nt] = 1;
sum += find_Root(nt);
}
}
if (sum >= k && root == -1) root = u;
return sum;
}
void solve(int u) {
if (home[u]) {
if (one.size() < k)
one.push_back(u);
else
two.push_back(u);
}
for (int i = 0; i < g[u].size(); i++) {
int nt = g[u][i];
if (!vis[nt]) {
vis[nt] = 1;
solve(nt);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < 2 * k; i++) {
int x;
scanf("%d", &x);
home[x] = 1;
}
memset(vis, 0, sizeof(vis));
vis[1] = 1, root = -1;
find_Root(1);
memset(vis, 0, sizeof(vis));
vis[root] = 1;
solve(root);
printf("1\n%d\n", root);
for (int i = 0; i < one.size(); i++)
printf("%d %d %d\n", one[i], two[i], root);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1e9 + 7;
const int N = 109;
int ans[N], on[N], loc[N], a[N][N];
int n, m, k;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int j = 1; j <= m; j++) {
memset(on, 0, sizeof(on));
for (int i = 1; i <= n; i++)
if (ans[i] == 0 && a[i][j]) {
if (loc[a[i][j]])
ans[i] = j;
else
on[a[i][j]]++;
}
for (int i = 1; i <= n; i++)
if (ans[i] == 0 && a[i][j]) {
if (on[a[i][j]] >= 2) ans[i] = j, loc[a[i][j]] = 1;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, t = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return x * t;
}
int n;
char ch[20];
struct Line {
int v, next;
} e[1001000 << 1];
int h[1001000], cnt = 1;
inline void Add(int u, int v) {
e[cnt] = (Line){v, h[u]};
h[u] = cnt++;
}
int p[1001000], c[1001000], fa[1001000], tag[1001000];
void dfs(int u, int ff) {
fa[u] = ff;
int son[5], tot = 0;
for (int i = h[u]; i; i = e[i].next)
if (e[i].v != ff) son[++tot] = e[i].v, dfs(e[i].v, u);
;
if (p[u] == 0) return;
if (p[u] == 1) c[u] = c[son[1]] & c[son[2]];
if (p[u] == 2) c[u] = c[son[1]] ^ 1;
if (p[u] == 3) c[u] = c[son[1]] | c[son[2]];
if (p[u] == 4) c[u] = c[son[1]] ^ c[son[2]];
if (p[u] == 1) {
int x = son[1], y = son[2];
if (c[x] == 0) tag[y] = 1;
if (c[y] == 0) tag[x] = 1;
}
if (p[u] == 3) {
int x = son[1], y = son[2];
if (c[x] == 1) tag[y] = 1;
if (c[y] == 1) tag[x] = 1;
}
}
void dfs2(int u, int ff) {
tag[u] |= tag[ff];
for (int i = h[u]; i; i = e[i].next)
if (e[i].v != ff) dfs2(e[i].v, u);
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", ch);
if (ch[0] == 'A') {
p[i] = 1;
int u = read(), v = read();
Add(i, u);
Add(i, v);
Add(u, i);
Add(v, i);
}
if (ch[0] == 'I') {
p[i] = 0;
c[i] = read();
}
if (ch[0] == 'N') {
p[i] = 2;
int u = read();
Add(i, u);
Add(u, i);
}
if (ch[0] == 'O') {
p[i] = 3;
int u = read(), v = read();
Add(i, u);
Add(i, v);
Add(u, i);
Add(v, i);
}
if (ch[0] == 'X') {
p[i] = 4;
int u = read(), v = read();
Add(i, u);
Add(i, v);
Add(u, i);
Add(v, i);
}
}
dfs(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; ++i)
if (p[i] == 0)
if (tag[i]) {
putchar(48 + c[1]);
} else
putchar(48 + c[1] ^ 1);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 2 * 1000010;
vector<int> v;
int main() {
string a, b;
cin >> a >> b;
int uno = 0, dos = 0;
for (int i = 0; i < a.size(); ++i)
if (a[i] == '1') uno++;
for (int i = 0; i < b.size(); ++i)
if (b[i] == '1') dos++;
if (uno % 2) uno++;
if (uno >= dos)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll cnt1e[3333], cnt2e[3333], cnt1i[3333], cnt2i[3333];
set<int> lk;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int len = 1; len <= 9; len++) {
for (int x = 0; x < (1 << len); x++) {
int res = 0;
for (int i = 0; i < len; i++) {
if (x & (1 << i))
res = res * 10 + 4;
else
res = res * 10 + 7;
}
lk.insert(res);
}
}
lk.insert(1000000001);
int amt = lk.size();
int pl, pr, vl, vr, k;
cin >> pl >> pr >> vl >> vr >> k;
int pre = 0, cur = 0;
for (auto R : lk) {
int L = pre;
cnt1i[cur] += max(0, min(pr, R - 1) - max(pl, L) + 1);
cnt1e[cur] += max(0, min(pr, R) - max(pl, L + 1) + 1);
pre = R;
cur++;
}
pre = 0, cur = 0;
for (auto R : lk) {
int L = pre;
cnt2i[cur] += max(0, min(vr, R - 1) - max(vl, L) + 1);
cnt2e[cur] += max(0, min(vr, R) - max(vl, L + 1) + 1);
pre = R;
cur++;
}
ll tot = 0;
for (int i = 0; i <= amt; i++) {
tot += cnt1e[i] * cnt2i[i + k];
tot += cnt2e[i] * cnt1i[i + k];
}
if (k == 1) {
for (auto x : lk)
if (x >= vl && x <= vr && x >= pl && x <= pr) tot--;
}
cout << fixed << setprecision(12)
<< (double)tot / (double)((ll)(vr - vl + 1) * (ll)(pr - pl + 1)) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
template <class T>
bool inside(T a, T b, T c) {
return (b >= a && b <= c);
}
const long long INF64 = (long long)1E16;
int distsq2d(int x1, int y1, int x2, int y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
double dist2d(double x1, double y1, double x2, double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
double dist3d(double x1, double y1, double z1, double x2, double y2,
double z2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2) + sqr(z1 - z2));
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double LOG(long long N, long long B) { return (log10l(N)) / (log10l(B)); }
string itoa(long long a) {
if (a == 0) return "0";
string ret;
for (long long i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
int isvowel(char s) {
s = tolower(s);
if (s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u') return 1;
return 0;
}
int isupper(char s) {
if (s >= 'A' and s <= 'Z') return 1;
return 0;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
int check(int N, int pos) { return (N & (1 << pos)); }
int toggle(int N, int pos) {
if (check(N, pos)) return N = reset(N, pos);
return N = Set(N, pos);
}
void pbit(int N) {
printf("(");
for (int i = 10; i >= 0; i--) {
bool x = check(N, i);
cout << x;
}
puts(")");
}
long long sum = 0;
long long c[100002];
long long r[100002];
long long a[100002];
long long b[100002];
int main() {
long long n, m, mod;
cin >> n >> m >> mod;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= m; i++) c[i] = c[i - 1] + b[i];
sum = c[m];
int dd = 0;
for (int i = 1; i <= n; i++) {
int top = i;
if (i > m) top = m;
if (i > m) dd--;
if (i <= n - m + 1) dd++;
a[i] += c[top] - c[top - dd];
}
for (int i = 1; i <= n; i++) {
if (i > 1) printf(" ");
cout << a[i] % mod;
}
puts("");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> v(n);
for (int &i : v) cin >> i;
m--;
vector<vector<int>> t(m, vector<int>(n));
vector<unordered_map<int, int>> pos(n);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> t[i][j];
pos[i][t[i][j]] = j;
}
}
long long ans = n;
vector<int> id(m);
int i = 0;
while (i < n) {
for (int j = 0; j < m; j++) id[j] = pos[j][v[i]];
int it = i + 1;
while (it < n) {
bool flag = true;
for (int j = 0; j < m; j++) {
int next_id = pos[j][v[it]];
if (next_id != id[j] + 1)
flag = false;
else
id[j] = next_id;
}
if (!flag) break;
it++;
}
long long delta = it - i;
ans += (delta * (delta - 1)) / 2;
i = it;
}
cout << ans << '\n';
exit(0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, id;
int c[N];
int b[N];
int a[N];
bool luk[N];
vector<pair<int, int>> ans;
map<int, set<int>> mp;
bool lucky(int x) {
while (x) {
int rem = x % 10;
if (rem != 4 && rem != 7) return 0;
x /= 10;
}
return 1;
}
bool sorted() {
for (int i = 1; i < n; i++)
if (b[i] > b[i + 1]) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (lucky(a[i])) {
luk[i] = 1;
id = i;
}
mp[a[i]].insert(i);
c[i] = b[i] = a[i];
}
sort(a + 1, a + 1 + n);
if (!id && !sorted()) return cout << -1, 0;
for (int i = n; i >= 1; i--) {
if (b[i] == a[i] && id != i) {
mp[b[i]].erase(i);
continue;
}
if (i != id) {
mp[b[i]].erase(i);
mp[b[id]].erase(id);
mp[b[i]].insert(id);
mp[b[id]].insert(i);
swap(b[i], b[id]);
ans.push_back({i, id});
id = i;
}
int idx = *mp[a[i]].rbegin();
if (idx != id) {
mp[a[i]].erase(idx);
mp[b[id]].erase(id);
mp[b[id]].insert(idx);
swap(b[id], b[idx]);
ans.push_back({idx, id});
id = idx;
}
}
cout << ans.size() << "\n";
for (auto x : ans) cout << x.first << " " << x.second << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 100;
const int mod = (int)1e9 + 7;
int n, m, mx, ans[5050];
int main() {
scanf("%d%d", &n, &m);
mx = (n - 1) * (n - 1) / 4;
if (m == 0) {
for (auto i = (1); i <= (n); ++i)
printf("%d ", n * (i * 13 + 29) + 1000000);
return 0;
}
if (n < 3 || m > mx) return puts("-1"), 0;
for (auto i = (1); i <= (n); ++i) ans[i] = i;
int pos = 0;
for (auto i = (1); i <= (n); ++i)
if ((i - 1) * (i - 1) / 4 >= m) {
pos = i;
break;
}
for (auto i = (pos + 1); i <= (n); ++i) ans[i] = n * (i * 13 + 29) + 1000000;
m -= (pos - 2) * (pos - 2) / 4;
ans[pos] = 2 * pos - 2 * m - 1;
for (auto i = (1); i <= (n); ++i) printf("%d ", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, l, r, dp[5555][5555], w[5555][5555];
int main() {
cin >> s;
for (int i = 1; i <= s.size(); i++) dp[i][i] = 1, w[i][i] = 1;
for (int len = 2; len <= s.size(); len++)
for (int j = 1; j <= s.size() - len + 1; j++) {
l = j;
r = j + len - 1;
dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1];
if (s[l - 1] == s[r - 1] && (l + 1 > r - 1 || w[l + 1][r - 1])) {
w[l][r] = 1, dp[l][r]++;
}
}
cin >> n;
while (n--) {
cin >> l >> r;
cout << dp[l][r] << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
int n, half, ans = INF;
map<int, pair<int, int> > color;
int main() {
scanf("%d", &n);
half = (n + 1) / 2;
for (int i = 0; i < n; i++) {
int c1, c2;
scanf("%d%d", &c1, &c2);
color[c1].first++;
if (c1 != c2) color[c2].second++;
}
for (map<int, pair<int, int> >::iterator it = color.begin();
it != color.end(); it++) {
int cnt1 = (*it).second.first;
int cnt2 = (*it).second.second;
if (cnt1 + cnt2 < half) continue;
if (cnt1 >= half) {
puts("0");
return 0;
}
int locAns = half - cnt1;
ans = min(ans, locAns);
}
if (ans == INF)
puts("-1");
else
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, ans = 0;
cin >> n;
while (n--) {
cin >> a >> b;
if (a != b) ans = 1;
}
if (ans)
cout << "Happy Alex\n";
else
cout << "Poor Alex\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> y(n);
{
string buf;
cin >> buf;
for (int i = 0; i < n; i++) {
y[i] = buf[i] - '0';
}
}
vector<int> divs;
vector<int> div(n + 1);
div[0] = -1;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
divs.push_back(i);
for (int j = i; j <= n; j += i) {
div[j] = i;
}
}
}
vector<int> vec(n + 1);
for (auto d : divs) {
bool isok = true;
for (int i = 0; i < d; i++) {
int sum = 0;
for (int j = i; j < n; j += d) {
sum ^= y[j];
}
isok = isok && (sum == 0);
}
if (isok) {
vec[d] = true;
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
res += vec[div[i]];
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n;
char s[N];
long long f[N][2], ans;
void sol() {
for (int i = 0; i < n; ++i) {
f[i + 1][0] = f[i + 1][1] = 0;
if (s[i] == 'A')
f[i + 1][0] = f[i][0] + f[i][1];
else
f[i + 1][0] = f[i][1];
if (s[i + 1] == 'A') {
if (s[i] == 'B') f[i + 1][1] = f[i][0];
} else
f[i + 1][1] = f[i][1];
}
}
int main() {
scanf("%s", s), n = strlen(s), s[n] = s[0];
f[0][0] = 1, sol(), ans += f[n][0];
f[0][0] = 0;
f[0][1] = 1, sol(), ans += f[n][1];
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
priority_queue<long long int, vector<long long int>, greater<long long int>>
huff;
int n;
long long int t;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
huff.push(t);
}
t = 0;
if (!(n % 2)) {
t += huff.top();
huff.pop();
t += huff.top();
huff.pop();
huff.push(t);
}
long long int s;
while (huff.size() > 2) {
s = 0;
s += huff.top();
huff.pop();
s += huff.top();
huff.pop();
s += huff.top();
huff.pop();
huff.push(s);
t += s;
}
cout << t;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
auto ma = [&](pair<int, long long> &a, pair<int, long long> b) {
if (a.first < b.first)
a = b;
else if (a.first == b.first && a.second < b.second)
a = b;
};
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d %d", &n, &m);
vector<int> b(n + 1), w(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
vector<vector<int>> v(n + 1);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].emplace_back(y);
v[y].emplace_back(x);
}
vector<int> sz(n + 1);
vector<pair<int, long long>> tmp(n + 1);
vector<vector<pair<int, long long>>> dp(
n + 1, vector<pair<int, long long>>(n + 1));
function<void(int, int)> dfs = [&](int u, int f) {
sz[u] = 1;
dp[u][1] = {0, w[u] - b[u]};
for (auto x : v[u]) {
if (x == f) continue;
dfs(x, u);
for (int i = 1; i <= sz[u] + sz[x]; i++) tmp[i] = {-1, 0};
for (int i = 1; i <= sz[u]; i++)
for (int j = 1; j <= sz[x]; j++) {
ma(tmp[i + j],
{dp[u][i].first + dp[x][j].first + (dp[x][j].second > 0),
dp[u][i].second});
ma(tmp[i + j - 1], {dp[u][i].first + dp[x][j].first,
dp[u][i].second + dp[x][j].second});
}
for (int i = 1; i <= sz[u] + sz[x]; i++) dp[u][i] = tmp[i];
sz[u] += sz[x];
}
};
dfs(1, 0);
printf("%d\n", dp[1][m].first + (dp[1][m].second > 0));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a1, a2, b1, b2, c1, c2;
cin >> n;
cin >> a1 >> a2;
cin >> b1 >> b2;
cin >> c1 >> c2;
int c = n - a2 - b2;
int a = n - b1 - c1;
int b = n - a2 - c1;
if (c >= c1 && c <= c2) {
cout << a2 << " " << b2 << " " << c << endl;
} else if (b >= b1 && b <= b2) {
cout << a2 << " " << b << " " << c1 << endl;
} else if (a >= a1 && a <= a2)
cout << a << " " << b1 << " " << c1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> ans;
for (int i = 0; i < n; i++) {
int l;
cin >> l;
if (i <= 1)
ans.push_back(l);
else {
int s = (int)ans.size();
if (abs(ans[s - 1] - ans[s - 2]) + abs(ans[s - 1] - l) <=
abs(ans[s - 2] - l)) {
ans.pop_back();
}
ans.push_back(l);
}
}
cout << (int)ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int z;
cin >> z;
while (z--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, m, ans = 0, l[1001], r[1001], t[1001], c[1001];
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &l[i], &r[i], &t[i], &c[i]);
}
int j1[n];
for (int i = 1; i <= n; i++) j1[i] = -1;
for (int i = 1; i <= n; i++) {
int max = 0;
int min = 10000;
for (int j = 0; j < m; j++) {
if (l[j] <= i && r[j] >= i) {
if (t[j] < min) {
min = t[j];
max = c[j];
j1[i] = j;
}
}
}
}
for (int i = 1; i <= n; i++)
if (j1[i] != -1) ans += c[j1[i]];
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, L = 19;
long long ans;
int n, _n, m, k, st, s[N], t[N], lca[N];
int tms, dfn[N], siz[N], lgn, ft[L][N], son[N], dep[N], dis[N];
vector<int> a[N], b[N];
vector<pair<int, int>> e[N];
set<pair<int, int>> _e[N];
struct Fenwick {
int f[N];
void modify(int u, int x) {
for (int i = u; i <= n; i += i & -i) {
f[i] += x;
}
}
int query(int u) {
int res = 0;
for (int i = u; i >= 1; i ^= i & -i) {
res += f[i];
}
return res;
}
int query(int l, int r) { return query(r) - query(l - 1); }
} fw;
void dfs(int u, int fa) {
ft[0][u] = fa;
dfn[u] = ++tms;
siz[u] = 1;
for (int i = 1; i <= lgn; i++) {
ft[i][u] = ft[i - 1][ft[i - 1][u]];
}
for (auto i : e[u]) {
int v = i.first, w = i.second;
if (v == fa) {
continue;
}
dep[v] = dep[u] + 1;
dis[v] = dis[u] + w;
dfs(v, u);
siz[u] += siz[v];
if (son[u] == 0) {
son[u] = v;
}
}
}
int findLca(int u, int v) {
if (dep[u] < dep[v]) {
swap(u, v);
}
int x = dep[u] - dep[v];
for (int i = lgn; i >= 0; i--) {
if (x >> i & 1) {
u = ft[i][u];
}
}
if (u == v) {
return u;
}
for (int i = lgn; i >= 0; i--) {
if (ft[i][u] != ft[i][v]) {
u = ft[i][u];
v = ft[i][v];
}
}
return ft[0][u];
}
int climb(int u, int v, int x) {
if (x <= 0) {
return u;
}
x = dis[v] - dis[u] - x;
u = v;
if (x < 0) {
return -1;
}
for (int i = lgn; i >= 0; i--) {
if (dis[u] - dis[ft[i][v]] <= x) {
v = ft[i][v];
}
}
return v;
}
struct Treap {
int ls[N], rs[N], siz[N], val[N], key[N];
inline void newNode(int u) {
ls[u] = rs[u] = 0;
siz[u] = 1;
key[u] = rand();
}
inline void pushUp(int u) { siz[u] = siz[ls[u]] + siz[rs[u]] + 1; }
void split(int u, int x, int y, int &l, int &r) {
if (u == 0) {
l = r = 0;
return;
}
if (x < val[u] || (x == val[u] && y < u)) {
r = u;
split(ls[u], x, y, l, ls[r]);
} else {
l = u;
split(rs[u], x, y, rs[l], r);
}
pushUp(u);
}
int merge(int l, int r) {
if (l == 0 || r == 0) {
return l + r;
}
if (key[l] < key[r]) {
rs[l] = merge(rs[l], r);
pushUp(l);
return l;
} else {
ls[r] = merge(l, ls[r]);
pushUp(r);
return r;
}
}
void insert(int &rt, int u) {
int l, r;
split(rt, val[u], u, l, r);
newNode(u);
rt = merge(merge(l, u), r);
}
void erase(int &rt, int u) {
int l, mid, r;
split(rt, val[u], u - 1, l, r);
split(r, val[u], u, mid, r);
rt = merge(l, r);
}
int query(int &rt, int u) {
int l, mid, r;
split(rt, dfn[u], 0, l, r);
split(r, dfn[u] + ::siz[u], 0, mid, r);
int res = siz[mid];
rt = merge(merge(l, mid), r);
return res;
}
void calc(int &rt, int u, int p) {
if (u == 0) {
return;
}
calc(rt, ls[u], p);
calc(rt, rs[u], p);
int v = climb(lca[u], t[u], k - dis[p] + dis[lca[u]]);
if (v == -1) {
return;
}
ans += query(rt, v) - (lca[u] == v ? query(rt, son[v]) : 0);
}
void go(int &rt, int u) {
if (u == 0) {
return;
}
go(rt, ls[u]);
go(rt, rs[u]);
insert(rt, u);
}
} tr;
int solve(int u) {
for (auto i : a[u]) {
int v = climb(u, s[i], k);
if (v > 0) {
ans += fw.query(dfn[v], dfn[v] + siz[v] - 1);
}
v = climb(u, t[i], k);
if (v > 0) {
ans += fw.query(dfn[v], dfn[v] + siz[v] - 1);
}
}
for (auto i : a[u]) {
fw.modify(dfn[s[i]], 1);
fw.modify(dfn[t[i]], 1);
}
int rt = 0;
for (auto i : b[u]) {
tr.val[i] = dfn[t[i]];
tr.calc(rt, i, u);
tr.go(rt, i);
}
for (auto i : e[u]) {
int v = i.first;
if (v == ft[0][u]) {
continue;
}
int _rt = solve(v);
if (tr.siz[rt] < tr.siz[_rt]) {
swap(rt, _rt);
}
tr.calc(rt, _rt, u);
tr.go(rt, _rt);
}
for (auto i : a[u]) {
tr.erase(rt, i);
}
return rt;
}
int main() {
cin >> _n >> m >> k;
n = _n;
for (int i = 1; i < _n; i++) {
int u, v;
cin >> u >> v;
_e[u].insert({v, 1});
_e[v].insert({u, 1});
}
for (int u = 1; u <= _n; u++) {
if (_e[u].size() < 4) {
continue;
}
e[0].clear();
for (auto i : _e[u]) {
e[0].push_back(i);
}
int fa = 0;
for (auto i : e[0]) {
int v = i.first, w = i.second, r = fa > 0 ? ++n : u;
_e[v].erase({u, w});
_e[u].erase({v, w});
_e[v].insert({r, w});
_e[r].insert({v, w});
if (fa > 0) {
_e[fa].insert({r, 0});
_e[r].insert({fa, 0});
}
fa = r;
}
}
lgn = log(n) / log(2) + 1e-7;
for (int u = 1; u <= n; u++) {
for (auto i : _e[u]) {
e[u].push_back(i);
}
if (e[u].size() == 1) {
st = u;
}
}
dfs(st, 0);
for (int i = 1; i <= m; i++) {
cin >> s[i] >> t[i];
lca[i] = findLca(s[i], t[i]);
if (dfn[s[i]] > dfn[t[i]]) {
swap(s[i], t[i]);
}
if (dfn[t[i]] < dfn[son[lca[i]]] + siz[son[lca[i]]]) {
swap(s[i], t[i]);
}
a[lca[i]].push_back(i);
b[s[i]].push_back(i);
}
solve(st);
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int INFINITE = 0x3f3f3f3f;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
typedef vector<int> VI;
typedef vector<VI> VII;
typedef vector<string> VS;
long long n, k, d1, d2;
bool c1() {
long long x3 = (long long)(k - d1 - 2 * d2) / 3;
long long x2 = x3 + d2, x1 = x3 + d1 + d2;
if (x1 < 0 || x2 < 0 || x3 < 0) return false;
if (x1 + x2 + x3 != k) return false;
long long rem = n - k;
rem -= 2 * d1 + d2;
return ((rem >= 0) && (rem % 3 == 0));
}
bool c2() {
long long x2 = (long long)(k - d1 - d2) / 3;
long long x1 = x2 + d1, x3 = x2 + d2;
if (x1 < 0 || x2 < 0 || x3 < 0) return false;
if (x1 + x2 + x3 != k) return false;
if (d1 < d2) d1 ^= d2 ^= d1 ^= d2;
long long rem = n - k;
rem -= 2 * d1 - d2;
return ((rem >= 0) && (rem % 3 == 0));
}
bool c3() {
long long x1 = (long long)(k - 2 * d1 + d2) / 3;
long long x2 = x1 + d1, x3 = x1 + d1 - d2;
if (x1 < 0 || x2 < 0 || x3 < 0) return false;
if (x1 + x2 + x3 != k) return false;
long long rem = n - k;
rem -= d1 + d2;
return ((rem >= 0) && (rem % 3 == 0));
}
bool c4() {
long long x1 = (long long)(k - 2 * d1 - d2) / 3;
long long x2 = x1 + d1, x3 = x1 + d1 + d2;
if (x1 < 0 || x2 < 0 || x3 < 0) return false;
if (x1 + x2 + x3 != k) return false;
long long rem = n - k;
rem -= d1 + 2 * d2;
return ((rem >= 0) && (rem % 3 == 0));
}
void solve() {
cin >> n >> k >> d1 >> d2;
if (c1() || c2() || c3() || c4())
cout << "yes\n";
else
cout << "no\n";
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int c[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool check(int a[], int b[]) {
if (b[1] > 12) return 0;
if (c[b[1]] < b[0]) return 0;
if (b[2] + 18 != a[2]) return b[2] + 18 < a[2];
if (b[1] != a[1]) return b[1] < a[1];
return b[0] <= a[0];
}
int main() {
int i, j, k, n;
int a[10], b[10];
while (scanf("%2d.%2d.%2d", &a[0], &a[1], &a[2]) != EOF) {
scanf("%2d.%2d.%2d", &b[0], &b[1], &b[2]);
sort(b, b + 3);
int flag = 0;
do {
c[2] = b[2] % 4 == 0 ? 29 : 28;
if (check(a, b)) {
flag = 1;
break;
}
} while (next_permutation(b, b + 3));
if (flag)
puts("YES");
else
puts("NO");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
queue<long long> q[3];
long long t[3];
int main() {
int c[3];
for (int i = (0); i < (3); ++i) scanf("%d", &c[i]);
for (int i = (0); i < (3); ++i) {
int d;
scanf("%d", &d);
t[i] = d;
}
long long res = 0;
int n;
scanf("%d", &n);
for (int i = (0); i < (3); ++i) {
int k = min(c[i], n);
for (int j = (0); j < (k); ++j) q[i].push(0);
}
for (int i = (0); i < (n); ++i) {
int w;
scanf("%d", &w);
long long time = w;
for (int j = (0); j < (3); ++j) {
long long cur = q[j].front();
q[j].pop();
cur = max(cur, time);
time = cur + t[j];
q[j].push(time);
}
res = max(res, time - w);
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char buf[16];
int a[100005];
vector<int> bc[16];
long long sum[16][16];
int dig[100005];
const long long MOD = 998244353ll;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", buf);
int dg = strlen(buf);
sscanf(buf, "%d", a + i);
bc[dg].push_back(a[i]);
dig[i] = dg;
}
vector<int> stk;
for (int dg1 = 1; dg1 <= 10; dg1++) {
for (int dg2 = 1; dg2 <= 10; dg2++) {
for (int x : bc[dg2]) {
long long cur = 0ll;
for (int i = 0; i < dg2; i++) {
stk.push_back(x % 10);
x /= 10;
}
reverse(stk.begin(), stk.end());
long long cd = 1ll;
int done = 0;
while (!stk.empty()) {
cd %= MOD;
cur += cd * stk.back();
cur %= MOD;
stk.pop_back();
if (done < dg1)
cd *= 100ll;
else
cd *= 10ll;
done++;
}
sum[dg1][dg2] += cur;
sum[dg1][dg2] %= MOD;
}
}
}
long long ans = 0ll;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 10; j++) {
ans += sum[dig[i]][j];
ans %= MOD;
int x = a[i];
for (int k = 0; k < dig[i]; k++) {
stk.push_back(x % 10);
x /= 10;
}
reverse(stk.begin(), stk.end());
long long cd = 10ll;
int done = 0;
long long cur = 0ll;
while (!stk.empty()) {
cd %= MOD;
cur += cd * stk.back();
cur %= MOD;
stk.pop_back();
done++;
if (done < j)
cd *= 100ll;
else
cd *= 10ll;
}
cur %= MOD;
cur *= 1ll * bc[j].size();
cur %= MOD;
ans += cur;
ans %= MOD;
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MN = 1e4 + 11;
struct edge {
int u, v, c, f;
edge(){};
edge(int u, int v, int c) : u(u), v(v), c(c), f(0){};
};
int s, t, d[MN], giter[MN];
vector<int> g[MN];
int edgemax = 0;
edge edges[4 * MN];
void addedge(int u, int v, int c) {
edges[edgemax] = edge(u, v, c);
g[u].push_back(edgemax++);
edges[edgemax] = edge(v, u, 0);
g[v].push_back(edgemax++);
}
int bfs(int k) {
queue<int> q;
memset(d, -1, MN * sizeof(d[0]));
d[s] = 0;
q.push(s);
while (q.size()) {
int u = q.front();
q.pop();
for (int e : g[u]) {
edge &ed = edges[e];
int v = ed.v;
if (d[v] == -1 && ed.f + k <= ed.c) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[t] != -1;
}
long long dfs(int u, int cm, int k) {
if (!cm) return 0;
if (u == t) return cm;
for (int &i = giter[u]; i < (int)g[u].size(); ++i) {
edge &ed = edges[g[u][i]];
if (d[ed.v] < d[u] + 1 || ed.c < ed.f + k) continue;
int d = dfs(ed.v, min(cm, ed.c - ed.f), k);
if (d) {
ed.f += d;
edge &red = edges[g[u][i] ^ 1];
red.f -= d;
return d;
}
}
return 0;
}
long long dinic() {
long long flow = 0;
for (int i = 0; i >= 0; --i) {
while (bfs(1 << i)) {
memset(giter, 0, sizeof(giter));
while (long long k = dfs(s, 1e9, 1 << i)) {
flow += k;
}
}
}
return flow;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
s = 0;
t = MN - 1;
int n, m;
cin >> n >> m;
long long sum = 0;
for (int i = 1; i <= n; ++i) {
long long a;
cin >> a;
assert(a <= 1e9);
addedge(MN / 2 + i, t, a);
}
for (int i = 1; i <= m; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
assert(w <= 1e9);
sum += w;
addedge(s, i, w);
addedge(i, MN / 2 + u, 1e15 + 11);
addedge(i, MN / 2 + v, 1e15 + 11);
}
cout << sum - dinic();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int fact(int n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
double dp[2005][2005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double p;
int t, n;
cin >> n >> p >> t;
dp[0][0] = 1;
double exp = 0;
for (int i = 1; i <= t; i++) {
for (int j = 0; j <= n; j++) {
if (j > i)
dp[i][j] = 0;
else if (j == n)
dp[i][j] = dp[i - 1][j] + (p * dp[i - 1][j - 1]);
else {
dp[i][j] += (1 - p) * dp[i - 1][j];
if (j > 0) dp[i][j] += (p * dp[i - 1][j - 1]);
}
}
}
for (int i = 0; i <= t; i++) {
exp += (i * dp[t][i]);
}
cout << fixed << setprecision(10) << exp;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct segtree {
int sz;
vector<long long> sums;
void init(int n) {
sz = n;
sums.resize(n << 2);
}
void build(vector<long long> &v, int nd, int l, int r) {
if (l == r) {
sums[nd] = v[l];
return;
}
int mid = (l + r) / 2;
build(v, nd << 1, l, mid);
build(v, nd << 1 | 1, mid + 1, r);
sums[nd] = sums[nd << 1] + sums[nd << 1 | 1];
}
void build(vector<long long> &v) { build(v, 1, 1, sz); }
void update(int nd, int l, int r, int pos, int val) {
if (l == pos && r == pos) {
sums[nd] = val;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
update(nd << 1, l, mid, pos, val);
else
update(nd << 1 | 1, mid + 1, r, pos, val);
sums[nd] = sums[nd << 1] + sums[nd << 1 | 1];
}
void update(int pos, int val) { update(1, 1, sz, pos, val); }
long long querysum(int nd, int l, int r, int from, int to) {
if (from <= l && r <= to) return sums[nd];
if (from > r || l > to) return 0LL;
int mid = (l + r) / 2;
return querysum(nd << 1, l, mid, from, to) +
querysum(nd << 1 | 1, mid + 1, r, from, to);
}
long long querysum(int l, int r) { return querysum(1, 1, sz, l, r); }
};
const int N = 200100;
long long n, sum, m, fact[21];
vector<long long> a;
segtree st;
set<long long> s;
int getNum(set<long long> &s, int num) {
for (auto &x : s) {
if (num == 0) return x;
num--;
}
assert(0);
}
vector<long long> get(long long sum) {
int cnt = 0;
s.clear();
for (long long i = n; i >= max(n - 20 + 1, 1LL); i--) {
s.insert(i);
cnt++;
}
vector<long long> v;
while (cnt--) {
int num = sum / fact[cnt];
sum -= num * fact[cnt];
int setter = getNum(s, num);
v.push_back(setter);
if (s.find(setter) != s.end()) s.erase(setter);
}
return v;
}
int main() {
fact[0] = 1;
for (int i = 1; i < 21; i++) fact[i] = fact[i - 1] * i;
scanf("%lld%lld", &n, &m);
a.resize(n + 10);
for (int i = 1; i <= n; i++) a[i] = i;
st.init(n);
st.build(a);
while (m--) {
int type;
scanf("%d", &type);
if (type == 1) {
int l, r;
scanf("%d%d", &l, &r);
printf("%lld\n", st.querysum(l, r));
} else {
long long x;
scanf("%lld", &x);
sum += x;
vector<long long> v = get(sum);
int sz = (int)(v.size());
int cnt = 0;
for (int i = n - sz + 1; i <= n; i++) {
st.update(i, v[cnt]);
cnt++;
}
}
}
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long MOD = 1e9 + 7;
long long p;
pair<string, long long> div(string s) {
long long cur = 0, n = 0;
string ss;
for (int i = 0; i < s.size(); i++) {
cur = cur * 10 + (s[i] - '0');
if (n > 0 || cur >= p) {
n++;
ss += cur / p + '0';
cur %= p;
}
}
return {ss, cur};
}
vector<long long> to_p(string s) {
vector<long long> ans;
while (s.size()) {
auto r = div(s);
s = r.first;
long long x = r.second;
ans.push_back(x);
}
return ans;
}
int dp[3500][3500][2][2];
inline long long calc_W(long long c, long long rm, long long nrm) {
if (rm) return ((p * (c + 1) % MOD) - calc_W(c, !rm, nrm) + MOD) % MOD;
if (c % 2 == 1)
return (((c + 2) * ((c + 1) / 2) % MOD) - (nrm * (c + 1) % MOD) + MOD) %
MOD;
return (((c + 1) * ((c + 2) / 2) % MOD) - (nrm * (c + 1) % MOD) + MOD) % MOD;
}
inline long long calc_w(long long c, long long rm, long long nrm) {
if (rm) return (p - calc_w(c, !rm, nrm) + MOD) % MOD;
return (c + 1 - nrm + MOD) % MOD;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0),
cout << fixed << setprecision(20);
long long alpha;
cin >> p >> alpha;
string A_;
cin >> A_;
vector<long long> A;
A = to_p(A_);
reverse(A.begin(), A.end());
if (alpha > A.size()) {
cout << 0;
return 0;
}
dp[0][0][0][1] = 1;
for (int i = 0; i < A.size(); i++) {
for (int j = 0; j < alpha + 1; j++) {
for (int eq = 0; eq < 2; eq++) {
for (long long rm = 0; rm < 2; rm++) {
dp[i][j][rm][eq] += MOD;
dp[i][j][rm][eq] %= MOD;
long long cur = dp[i][j][rm][eq];
if (cur == 0) continue;
for (long long nrm = 0; nrm < 2; ++nrm) {
long long npw = min((long long)j + nrm, alpha);
if (!eq) {
dp[i + 1][npw][nrm][eq] += (calc_W(p - 1, rm, nrm) * cur) % MOD;
dp[i + 1][npw][nrm][eq] %= MOD;
} else {
if (A[i] != 0) {
dp[i + 1][npw][nrm][!eq] +=
(calc_W(A[i] - 1, rm, nrm) * cur) % MOD;
dp[i + 1][npw][nrm][!eq] %= MOD;
}
dp[i + 1][npw][nrm][eq] += (calc_w(A[i], rm, nrm) * cur) % MOD;
dp[i + 1][npw][nrm][eq] %= MOD;
}
}
}
}
}
}
cout << (dp[A.size()][alpha][0][0] % MOD + dp[A.size()][alpha][0][1] % MOD) %
MOD;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
const int maxm = 1 << 13;
int n;
long long k;
pair<int, long long> dp[maxn][maxm];
int pre[maxn][maxm];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
vector<long long> v;
void get_div(long long k) {
for (long long i = 1; i * i <= k; i++) {
if (k % i == 0) {
long long j = k / i;
v.push_back(i);
if (i != j) v.push_back(j);
}
}
sort(v.begin(), v.end());
}
long long a[maxn], c[maxn];
int main() {
scanf("%d%lld", &n, &k);
get_div(k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
c[i] = gcd(a[i], k);
}
if (k == 1) {
printf("1\n");
int p = 1;
long long minn = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] < minn) minn = a[i], p = i;
}
printf("%d\n", p);
return 0;
}
int m = v.size();
for (int i = 0; i <= n; i++)
for (int j = 0; j < m; j++) dp[i][j] = make_pair((int)1e9, (long long)1e16);
dp[0][0] = make_pair(0, 0);
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) {
if (dp[i][j] > dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
pre[i][j] = j;
}
int t =
lower_bound(v.begin(), v.end(), v[j] / gcd(v[j], c[i])) - v.begin();
if (dp[i][j] >
make_pair(dp[i - 1][t].first + 1, dp[i - 1][t].second + a[i])) {
dp[i][j] =
make_pair(dp[i - 1][t].first + 1, dp[i - 1][t].second + a[i]);
pre[i][j] = t;
}
}
if (dp[n][m - 1].first > n)
printf("-1\n");
else {
printf("%d\n", dp[n][m - 1].first);
int k = m - 1;
bool first = true;
for (int i = n; i >= 1; i--) {
if (pre[i][k] != k) {
if (first) {
printf("%d", i);
first = false;
} else
printf(" %d", i);
}
k = pre[i][k];
}
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
size_t l, r, k, m;
string s;
cin >> s;
cin >> m;
string s2(s.size(), '0');
size_t i = 0;
while (i < m) {
cin >> l;
cin >> r;
cin >> k;
size_t sz = r - l + 1;
for (size_t j = 0; j < sz; ++j) {
size_t newPos = (j + k) % sz;
s2[l - 1 + newPos] = s[l - 1 + j];
}
s.replace(s.begin() + l - 1, s.begin() + r, s2.begin() + l - 1,
s2.begin() + r);
++i;
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int i, ans = 0, r, c;
scanf("%d%d", &r, &c);
char s[c];
for (i = 1; i <= r; i++) {
scanf("%s", s);
}
for (i = 0; i < c; i++) {
if (s[i] == 'B') {
if (i == 0 || s[i - 1] == '.') ans++;
}
}
printf("%d", ans);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i,j,k,l,m,n,t,temp,flag,mod=1000000007,ans,sum,p,q,r,len=200000;
string s;
cin>>t;
while(t--){
cin>>n;
for(i=0,ans=0;i<n;i++){
cin>>temp;
if(temp!=2) ans++;
}
cout<<ans<<"\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
if (n < 26) {
cout << "NO\n";
return 0;
}
int arr[26] = {0};
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] += 32;
if (s[i] >= 'a' && s[i] <= 'z') arr[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (!arr[i]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct RangeMinMaxSum {
int n;
vector<long long> tmin, tmax, tsum;
RangeMinMaxSum(int n) : n(n), tmin(n * 4), tmax(n * 4), tsum(n * 4) {}
void update(int node, int l, int r, int i, long long val) {
if (i < l || i > r) return;
if (l == r && i == l) {
tmin[node] = tmax[node] = tsum[node] = val;
} else {
int c1 = node * 2 + 1, c2 = node * 2 + 2, m = (l + r) / 2;
update(c1, l, m, i, val);
update(c2, m + 1, r, i, val);
tsum[node] = tsum[c1] + tsum[c2];
tmin[node] = min(tmin[c1], tsum[c1] + tmin[c2]);
tmax[node] = max(tmax[c1], tsum[c1] + tmax[c2]);
}
}
void update(int i, long long val) { return update(0, 0, n - 1, i, val); }
pair<long long, pair<long long, long long> > query(int node, int l, int r,
int x, int y) {
if (x <= l && y >= r)
return make_pair(tsum[node], make_pair(tmin[node], tmax[node]));
int c1 = node * 2 + 1, c2 = node * 2 + 2, m = (l + r) / 2;
if (y <= m)
return query(c1, l, m, x, y);
else if (x > m)
return query(c2, m + 1, r, x, y);
pair<long long, pair<long long, long long> > r1 = query(c1, l, m, x, y),
r2 = query(c2, m + 1, r, x, y);
long long mn = min(r1.second.first, r1.first + r2.second.first);
long long mx = max(r1.second.second, r1.first + r2.second.second);
return make_pair(r1.first + r2.first, make_pair(mn, mx));
}
pair<long long, pair<long long, long long> > query(int x, int y) {
return query(0, 0, n - 1, x, y);
}
};
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
RangeMinMaxSum t(n);
int ans = 0;
for (int i = 0, pos = 0; i < s.size(); i++) {
if (s[i] == 'L') {
if (pos > 0) pos--;
} else if (s[i] == 'R') {
pos++;
} else if (s[i] == '(') {
t.update(pos, 1);
} else if (s[i] == ')') {
t.update(pos, -1);
} else
t.update(pos, 0);
pair<long long, pair<long long, long long> > r = t.query(0, n - 1);
if (r.first == 0 && r.second.first == 0)
cout << r.second.second << ' ';
else
cout << -1 << ' ';
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> g[100100];
long long val[100100];
long long pw[100100];
long long out[100100], in[100100];
long long size[100100];
int fa[100100], dep[100100];
pair<long long, long long> p1[100100], p2[100100];
int top;
bool centroid[100100];
int n;
long long mod, K, x, iK;
long long Pow(long long x, long long y) {
if (y == 0) return 1;
long long res = Pow(x, y >> 1);
res = res * res % mod;
if (y & 1) res = res * x % mod;
return res;
}
long long Inv(long long x) { return Pow(x, mod - 2); }
void dfs1(int v, int p) {
size[v] = 1;
fa[v] = p;
if (p)
dep[v] = dep[p] + 1;
else
dep[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == p || centroid[u]) continue;
dfs1(u, v);
size[v] += size[u];
}
}
pair<long long, long long> dfs2(int v, int p, int tot) {
pair<long long, long long> res = make_pair(1e9, 0);
long long sum = 1, mx = 0;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == p || centroid[u]) continue;
res = min(res, dfs2(u, v, tot));
sum += size[u];
mx = max(mx, size[u]);
}
mx = max(mx, tot - sum);
res = min(res, make_pair(mx, 1ll * v));
return res;
}
void dfs3(int v, int fa, long long inv, long long down, long long up, int dep) {
top++;
p1[top] = make_pair(((x - up) * inv % mod + mod) % mod, v);
p2[top] = make_pair(down, v);
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == fa || centroid[u]) continue;
dfs3(u, v, inv * iK % mod, (down + pw[dep + 1] * val[u]) % mod,
(up * K + val[u]) % mod, dep + 1);
}
}
void calc(int l, int r, int c) {
sort(p1 + l, p1 + r + 1);
sort(p2 + l, p2 + r + 1);
for (int i = l, j = l, ii, jj; i <= r; i = ii, j = jj) {
for (ii = i; ii <= r && p1[i].first == p1[ii].first; ii++)
;
for (; j <= r && p2[j].first < p1[i].first; j++)
;
for (jj = j; jj <= r && p1[i].first == p2[jj].first; jj++)
;
if (j != jj) {
for (int k = i; k < ii; k++) out[p1[k].second] += c * (jj - j);
for (int k = j; k < jj; k++) in[p2[k].second] += c * (ii - i);
}
}
}
void solve(int v) {
dfs1(v, 0);
v = dfs2(v, 0, size[v]).second;
centroid[v] = true;
top = 0;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (centroid[u]) continue;
int tt = top;
dfs3(u, 0, iK, (val[u] * K + val[v]) % mod, val[u], 1);
calc(tt + 1, top, -1);
}
top++;
p1[top] = make_pair(x, v);
p2[top] = make_pair(val[v], v);
calc(1, top, 1);
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (centroid[u]) continue;
solve(u);
}
}
int main() {
n = read();
mod = read();
K = read();
x = read();
iK = Inv(K);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * K % mod;
for (int i = 1; i <= n; i++) val[i] = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
g[u].push_back(v);
g[v].push_back(u);
}
solve(1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += 2ll * out[i] * (n - out[i]);
ans += 2ll * in[i] * (n - in[i]);
ans += in[i] * (n - out[i]);
ans += (n - in[i]) * out[i];
}
ans = 1ll * n * n * n - ans / 2;
printf("%I64d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
unordered_map<int, int> nesto;
int res = 0;
vector<int> niz(n);
vector<int> sta = niz;
for (int i = 0; i < n; i++) {
cin >> niz[i];
sta[i] = niz[i];
}
sort(niz.begin(), niz.end());
auto gde = unique(niz.begin(), niz.end());
for (int i = 0; i < n; i++) {
int a = sta[i];
a = lower_bound(niz.begin(), gde, a) - niz.begin();
nesto[a] = max(nesto[a - 1] + 1, 1);
res = max(res, nesto[a]);
}
cout << n - res << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int n;
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
if (n == 1) {
cout << a[0].first << endl;
for (int i = 1; i <= a[0].first; i++) cout << i << ' ';
return 0;
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
a.push_back(make_pair(2, 0));
vector<vector<int>> face(n);
vector<int> current;
int cur = 1;
int center = 1;
face[0].push_back(1);
for (int i = 2; i <= a[0].first; i++) {
cur++;
face[0].push_back(i);
current.push_back(i);
}
for (int i = 1; i < n; i++) {
int sz1 = current.size();
int sz2 = a[i].first;
if (sz1 == 2) {
face[i].push_back(center);
face[i].push_back(current[1]);
cur++;
face[i].push_back(cur);
current.push_back(cur);
continue;
}
int need = max(sz1 - sz2 + 2, a[i + 1].first);
need = min(need, sz1 + sz2 - 4);
if (need % 2 != (sz1 + sz2) % 2) need++;
int common = (sz1 + sz2 + 2 - need) / 2;
for (int j = 0; j < common; j++) {
face[i].push_back(current.back());
current.pop_back();
}
current.push_back((face[i].back()));
for (int j = 0; j < sz2 - common; j++) {
cur++;
face[i].push_back(cur);
current.push_back(cur);
}
current.push_back(face[i][0]);
}
cout << cur << endl;
vector<vector<int>> kek(n);
for (int i = 0; i < n; i++) kek[a[i].second] = face[i];
for (int i = 0; i < n; i++) {
for (auto it : kek[i]) cout << it << ' ';
cout << endl;
}
}
| 12 |
#include<bits/stdc++.h>
#define gc getchar
#define pc putchar
#define N 300005
using namespace std;
template<class T>void read(T&x) {
T f=1;x=0;char c=gc();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=gc();}
while('0'<=c&&c<='9'){x=x*10+c-'0';c=gc();}
x*=f;
}
template<class T>void print(T x,char c) {
if(x<0)pc('-'),x=-x;int s[20],top=0;
while(s[++top]=x%10,x/=10);
while(top)pc(s[top--]+'0');pc(c);
}
int n,m,cnt,blk,B,h[N],a[N],col[N<<1];
struct Edge{int to,next;}e[N<<1];
void Add(int x,int y) {
cnt++;e[cnt].to = y;e[cnt].next = h[x];h[x] = cnt;
}
int dfn[N<<1],st[N],ed[N],step,fa[N],dep[N],siz[N],son[N],top[N];
void dfs1(int x,int f) {
fa[x] = f;dep[x] = dep[f]+1;siz[x] = 1;
for(int i=h[x]; i; i=e[i].next) {
int y = e[i].to;
if(y != f) {
dfs1(y,x);siz[x] += siz[y];
if(siz[y] > siz[son[x]])son[x] = y;
}
}
}
void dfs2(int x,int tp) {
top[x] = tp;dfn[++step] = x;st[x] = step;
if(son[x])dfs2(son[x],tp);
for(int i=h[x]; i; i=e[i].next) {
int y = e[i].to;
if(y != fa[x] && y != son[x])dfs2(y,y);
}
dfn[++step] = x;ed[x] = step;
}
int LCA(int x,int y) {
while(top[x] != top[y]) {
if(dep[top[x]] < dep[top[y]])swap(x,y);
x = fa[top[x]];
}
if(dep[x] < dep[y])return x;
return y;
}
struct query {
int l,r,L,R,id,lca;
bool operator < (const query &b)const {
return l/blk==b.l/blk?l/blk&1?r<b.r:r>b.r:l<b.l;
}
}q[N];
struct change {
int pos,pre,now;
}c[N];
int Ans[N],vst[N],num[N],sum[N],pos[N],L[N],R[N];
void change(int x) {
num[x] ^= 1;
if(num[x])sum[pos[x]]++;
else sum[pos[x]]--;
}
void Move(int x){change(a[x]);}
int ask(int l,int r) {
int p = pos[l],q = pos[r];
if(p == q) {
if(sum[p])for(int i=l; i<=r; ++i)if(num[i])return i;
return -1;
}
if(sum[p])for(int i=l; i<=R[p]; ++i)if(num[i])return i;
if(sum[q])for(int i=L[q]; i<=r; ++i)if(num[i])return i;
for(int i=p+1; i<q; ++i)if(sum[i]) {
for(int j=L[i]; j<=R[i]; ++j)
if(num[j])return j;
}
return -1;
}
int main() {
read(n),read(m);
for(int i=1; i<=n; ++i)read(a[i]);
for(int i=1,x,y; i<n; ++i)read(x),read(y),Add(x,y),Add(y,x);
dfs1(1,0);dfs2(1,0);blk = pow(m,0.5);B = 500;
for(int i=1; i<=600; ++i) {
L[i] = (i-1)*B+1;R[i] = i*B;
for(int j=L[i]; j<=R[i]; ++j)
pos[j] = i;
}
// for(int i=1; i<=2*n; ++i)cerr << dfn[i] << ' ';
// cerr << '\n';
for(int i=1,u,v,l,r,z; i<=m; ++i) {
read(u),read(v),read(l),read(r);
z = LCA(u,v);if(st[u] > st[v])swap(u,v);
if(u == z)q[i] = (query){st[u],st[v],l,r,i};
else q[i] = (query){ed[u],st[v],l,r,i,z};
}
sort(q+1,q+m+1);
for(int i=1,l=1,r=0; i<=m; ++i) {
while(r < q[i].r)Move(dfn[++r]);
while(l > q[i].l)Move(dfn[--l]);
while(r > q[i].r)Move(dfn[r--]);
while(l < q[i].l)Move(dfn[l++]);
if(q[i].lca)Move(q[i].lca);
Ans[q[i].id] = ask(q[i].L,q[i].R);
if(q[i].lca)Move(q[i].lca);
}
for(int i=1; i<=m; ++i)print(Ans[i],'\n');
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
char name[15];
int num, py;
} pe[110];
bool cmp(node a, node b) {
if (a.py == b.py) return a.num < b.num;
return a.py > b.py;
}
int main() {
map<string, int> mp;
mp["rat"] = 5;
mp["woman"] = 4;
mp["child"] = 4;
mp["man"] = 3;
mp["captain"] = 2;
int n, m, i, j, k;
char ss[15];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s %s", pe[i].name, ss);
pe[i].num = i;
pe[i].py = mp[ss];
}
{}
sort(pe, pe + n, cmp);
for (i = 0; i < n; i++) {
puts(pe[i].name);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
void Solve() {
int n;
cin >> n;
arr.resize(n);
int maxN = INT_MIN;
for (int i = 0; i < n; i++) cin >> arr[i], maxN = max(maxN, arr[i]);
sort(arr.begin(), arr.end());
int sol = 0;
for (int dif = 2; dif <= 2 * maxN; dif++) {
int t = 0;
vector<bool> check(n, 1);
for (int i = 0; i < n; i++)
for (int j = n - 1; j >= 0; j--)
if (i != j && check[j] && check[i] && arr[i] + arr[j] == dif)
t++, check[j] = 0, check[i] = 0;
sol = max(t, sol);
}
cout << sol << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) Solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int N = 1e5 + 1;
using namespace std;
int a[N];
int ans;
int n, x;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> x;
if (i == n / 2 || j == n / 2 || i == j || n - i == j + 1) ans += x;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 2e5 + 50;
long long sum[maxn << 3], mx[maxn << 3];
int a[maxn];
void build(int rt, int l, int r) {
if (l == r) {
sum[rt] = mx[rt] = a[l];
} else {
int mid = (l + r) >> 1;
build((rt << 1), l, mid);
build((rt << 1 | 1), mid + 1, r);
sum[rt] = sum[(rt << 1)] + sum[(rt << 1 | 1)];
mx[rt] = max(mx[(rt << 1)], mx[(rt << 1 | 1)]);
}
}
void update(int rt, int l, int r, int pos) {
if (l == r)
sum[rt] = mx[rt] = a[l];
else {
int mid = (l + r) >> 1;
if (pos <= mid)
update((rt << 1), l, mid, pos);
else
update((rt << 1 | 1), mid + 1, r, pos);
sum[rt] = sum[(rt << 1)] + sum[(rt << 1 | 1)];
mx[rt] = max(mx[(rt << 1)], mx[(rt << 1 | 1)]);
}
}
int query(int rt, int l, int r, long long pre) {
if (l == r) {
if (pre == mx[rt]) return l;
return -1;
} else {
int mid = (l + r) >> 1;
if (mx[(rt << 1)] >= pre) {
int g = query((rt << 1), l, mid, pre);
if (g != -1) return g;
}
if (mx[(rt << 1 | 1)] >= pre + sum[(rt << 1)]) {
int g = query((rt << 1 | 1), mid + 1, r, pre + sum[(rt << 1)]);
if (g != -1) return g;
}
return -1;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, Q;
cin >> n >> Q;
for (int i = 1; i <= n; ++i) cin >> a[i];
build(1, 1, n);
while (Q--) {
int pos, val;
cin >> pos >> val;
a[pos] = val;
update(1, 1, n, pos);
cout << query(1, 1, n, 0) << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string pw, cd[10];
cin >> pw;
for (int i = 0; i < 10; i++) cin >> cd[i];
for (int j = 0; j < 8; j++) {
string pw2 = pw.substr(j * 10, 10);
for (int k = 0; k < 10; k++)
if (pw2 == cd[k]) {
cout << k;
break;
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> adj;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int com_leaves = 0;
long long int n;
cin >> n;
long long int a, b;
adj.resize(n + 1);
for (long long int i = 0; i < n - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<long long int> dist(n + 1, 9223372036854775807);
vector<long long int> visi(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1 && visi[i] == 0) {
visi[i] = 1;
long long int cnt = 1;
for (auto x : adj[adj[i][0]]) {
if (x == i) continue;
if (adj[x].size() == 1) {
visi[x] = 1;
cnt++;
}
}
com_leaves += cnt - 1;
}
}
long long int source = 1;
for (int i = 1; i <= n; i++) {
if (visi[i] == 1) source = i;
}
queue<long long int> que;
que.push(source);
dist[source] = 0;
while (!que.empty()) {
long long int x = que.front();
que.pop();
for (auto k : adj[x]) {
if (dist[k] == 9223372036854775807) {
dist[k] = dist[x] + 1;
que.push(k);
}
}
}
long long int fl = 0;
for (int i = 1; i <= n; i++) {
if (visi[i] == 1) {
if (dist[i] % 2 == 1) fl = 1;
}
}
if (fl == 0) {
cout << 1 << " ";
} else
cout << 3 << " ";
cout << n - 1 - com_leaves << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int summ[1000005], fact[1000005], inv[1000005], ans;
int lp[1000005], rp[1000005];
int po(int a, int b) {
int c = a, d = 1;
while (b) {
if (b & 1) d = 1LL * d * c % 1000000007;
c = 1LL * c * c % 1000000007;
b >>= 1;
}
return d;
}
int main() {
scanf("%d %d", &n, &k);
summ[0] = 0;
for (int i = (1); i <= (k + 1); i++)
summ[i] = (summ[i - 1] + po(i, k)) % 1000000007;
fact[0] = 1;
for (int i = (1); i <= (k + 1); i++)
fact[i] = 1LL * fact[i - 1] * i % 1000000007;
for (int i = (0); i <= (k + 1); i++) inv[i] = po(fact[i], 1000000007 - 2);
if (n <= k + 1)
printf("%d\n", summ[n]);
else {
lp[0] = 1;
for (int i = (0); i <= (k + 1); i++)
lp[i + 1] = 1LL * lp[i] * (n - i) % 1000000007;
rp[k + 2] = 1;
for (int i = (k + 1); i >= (0); i--)
rp[i] = 1LL * rp[i + 1] * (n - i) % 1000000007;
for (int i = (0); i <= (k + 1); i++) {
int cur = 1LL * lp[i] * rp[i + 1] % 1000000007;
if ((k + 1 - i) & 1) cur *= -1;
cur = 1LL * cur * inv[i] % 1000000007;
cur = 1LL * cur * inv[k + 1 - i] % 1000000007;
ans = (ans + 1LL * summ[i] * cur) % 1000000007;
}
printf("%d\n", (ans + 1000000007) % 1000000007);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
pair<int, int> a[maxn];
int b[maxn], c[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
if (n == 1) {
cout << "YES\n";
cout << 0 << "\n";
cout << a[0].first;
return 0;
}
sort(a, a + n);
int m = (n + 2) / 3;
for (int i = 0; i < m; i++) {
x = a[i].second;
b[x] = i;
c[x] = a[i].first - b[x];
}
for (int i = m; i < 2 * m; i++) {
x = a[i].second;
c[x] = i;
b[x] = a[i].first - c[x];
}
for (int i = 2 * m; i < n; i++) {
x = a[i].second;
c[x] = 3 * m - i - 1;
b[x] = a[i].first - c[x];
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << "\n";
for (int i = 0; i < n; i++) {
cout << c[i] << " ";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void sfr(int *a) {
char c = 0;
while (c < 33) c = fgetc(stdin);
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = fgetc(stdin);
}
}
inline void sfp(int a) {
char c[1000];
sprintf(c, "%d", a);
puts(c);
}
int main() {
int n;
cin >> n;
;
int m;
cin >> m;
;
int A[n][m];
getchar();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c = '\n';
while (c == '\n') c = getchar();
A[i][j] = (c == '1');
}
}
int B[n];
int mx = 0;
for (int i = n - 1; i >= 0; i--) B[i] = 0;
for (int i = m - 1; i >= 0; i--) {
vector<int> D;
for (int j = 0; j < n; j++) {
if (A[j][i]) {
B[j] = B[j] + 1;
D.push_back(B[j]);
} else {
B[j] = 0;
D.push_back(0);
}
}
sort(D.begin(), D.end());
for (int j = 0; j < n; j++) mx = max(mx, D[j] * (n - j));
}
cout << mx << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool bad[1000001];
int primes[1000001];
int cpr = 0;
void cprime() {
primes[cpr++] = 2;
int i = 3;
for (; i * i <= 100000; i += 2) {
if (!bad[i]) {
primes[cpr++] = i;
for (int j = i * i; j <= 100000; j += i) bad[j] = true;
}
}
for (; i <= 100000; i += 2) {
if (!bad[i]) primes[cpr++] = i;
}
}
int arr[1000001];
int cur[1000001];
int main() {
ios::sync_with_stdio(false);
cprime();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
cur[arr[i]] = i;
}
vector<pair<int, int> > ans;
for (int i = 1; i <= n; ++i) {
while (cur[i] != i) {
int dif = cur[i] - i + 1;
int l = 0, r = cpr - 1;
int st = 0;
while (l <= r) {
int m = l + (r - l) / 2;
if (primes[m] <= dif) {
st = primes[m];
l = m + 1;
} else {
r = m - 1;
}
}
ans.push_back(make_pair(cur[i], cur[i] - st + 1));
int f = arr[cur[i] - st + 1];
cur[arr[cur[i] - st + 1]] = cur[i];
cur[i] = cur[i] - st + 1;
swap(arr[cur[i]], arr[cur[f]]);
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].second << ' ' << ans[i].first << '\n';
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
//#define int int64_t
#define pb push_back
#define endl '\n'
#define pll pair<int,int>
#define vll vector<int>
#define all(a) (a).begin(),(a).end()
#define x first
#define y second
#define sz(x) (int)x.size()
#define hell 1000000007
#define god 100005
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define mi map<int,int>
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b)) / gcd((a),(b))
#define rep(i,a,b) for(int i=a;i<b;i++)
#define ios ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define pq_inc_int priority_queue <int ,vector<int> , greater<int> >
using namespace std;
void solve(){
int n;
cin>>n;
int arr[n];
for(int i=0;i<n;i++)
{
cin>>arr[i];
}
sort(arr,arr+n);
long long count=0;
for(int i=1;i<n;i++)
{
if(arr[i]>arr[0])
count++;
}
cout<<count<<endl;
}
signed main(){
ios
/*#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif */
int test;
cin>>test;
while(test>0){
solve();
test--;
}
return 0;
}
/*Time complexities: */
| 0 |
#include <bits/stdc++.h>
using namespace std;
string a, b, tmp;
int len;
int nxt[2016000];
void make_nxt() {
nxt[0] = 0;
for (int q = 1, k = 0; q < 2 * len + 1; q++) {
while (k > 0 && tmp[q] != tmp[k]) k = nxt[k - 1];
if (tmp[q] == tmp[k]) k++;
nxt[q] = k;
}
}
int main() {
cin >> len >> a >> b;
len--;
reverse(a.begin(), a.end());
for (int i = 0; i < len; i++) {
if (a[i] == 'W')
a[i] = 'E';
else if (a[i] == 'E')
a[i] = 'W';
else if (a[i] == 'S')
a[i] = 'N';
else if (a[i] == 'N')
a[i] = 'S';
}
tmp = a + '#' + b;
make_nxt();
if (nxt[2 * len] != 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool visited[9][9];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(NULL);
string s[2];
for (int i = 0; i < 2; i++) cin >> s[i];
bool visited[2][s[0].size()];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < s[i].size(); j++) visited[i][j] = 0;
}
string s1 = s[0];
string s2 = s[1];
int cnt = 0;
for (int i = 0; i < (s1.size() - 1); i++) {
if (s1[i] == '0' && s2[i] == '0' && s1[i + 1] == '0' && !visited[0][i] &&
!visited[1][i] && !visited[0][i + 1]) {
++cnt;
visited[0][i] = 1;
visited[1][i] = 1;
visited[0][i + 1] = 1;
} else if (s1[i] == '0' && s2[i + 1] == '0' && s1[i + 1] == '0' &&
!visited[0][i] && !visited[0][i + 1] && !visited[1][i + 1]) {
++cnt;
visited[0][i] = 1;
visited[0][i + 1] = 1;
visited[1][i + 1] = 1;
} else if (s1[i] == '0' && s2[i] == '0' && s2[i + 1] == '0' &&
!visited[0][i] && !visited[1][i] && !visited[1][i + 1]) {
++cnt;
visited[0][i] = 1;
visited[1][i] = 1;
visited[1][i + 1] = 1;
} else if (s2[i] == '0' && s1[i + 1] == '0' && s2[i + 1] == '0' &&
!visited[1][i] && !visited[1][i + 1] && !visited[0][i + 1]) {
++cnt;
visited[1][i] = 1;
visited[1][i + 1] = 1;
visited[0][i + 1] = 1;
}
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9) + 7, INF = 0x3fffffff, maxn = 1e5 + 41;
int n, G[222][222], m, q, v[10][2];
pair<int, int> dp[222][222][11];
bool used[222][222][11];
pair<int, int> dfs(int x, int y, int z) {
if (dp[x][y][z] != pair<int, int>(-1, -1)) return dp[x][y][z];
if (used[x][y][z]) return dp[x][y][z] = pair<int, int>(-1, -2);
used[x][y][z] = true;
int u = x + v[G[x][y]][0];
int vs = y + v[G[x][y]][1];
if (u < 0 || u >= n || vs < 0 || vs >= m) {
for (int i = 0; i < 10; i++) {
dp[x][y][i] = pair<int, int>(-1, -2);
}
dp[x][y][G[x][y]] = pair<int, int>(x, y);
return dp[x][y][z];
}
if (G[u][vs] == z) return dp[x][y][z] = pair<int, int>(u, vs);
return dp[x][y][z] = dfs(u, vs, z);
}
void solve(void) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 10; k++) {
dfs(i, j, k);
}
}
}
map<string, bool> mp;
while (q--) {
string str;
cin >> str;
bool ok = false;
if (!mp.count(str)) {
int size = str.size();
int c = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[c - 1] - '0' == G[i][j]) {
pair<int, int> cur(i, j);
while (c < size) {
if (dp[cur.first][cur.second][str[c] - '0'] >
pair<int, int>(-1, -1)) {
cur = dp[cur.first][cur.second][str[c] - '0'];
c++;
} else
break;
}
if (c == size) ok = true;
c = 1;
}
}
if (ok) break;
}
mp[str] = ok;
}
ok = mp[str];
if (ok)
puts("YES");
else
puts("NO");
}
}
int main(void) {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) {
char str[222];
cin >> str;
for (int j = 0; j < m; j++) {
G[i][j] = str[j] - '0';
for (int k = 0; k < 10; k++) {
dp[i][j][k] = pair<int, int>(-1, -1);
}
}
}
for (int i = 0; i < 10; i++) {
scanf("%d%d", &v[i][0], &v[i][1]);
}
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, n, a, b, c = INT_MAX, s = 0;
cin >> n;
string ss;
cin >> ss;
string so[6] = {"GRB", "GBR", "RGB", "RBG", "BRG", "BGR"};
for (i = 0; i < 6; i++) {
s = 0;
for (j = 0; j < ss.size(); j++) {
if (ss[j] != so[i][j % 3]) s++;
}
if (s < c) {
c = s;
a = i;
}
}
cout << c << endl;
for (i = 0; i < ss.size(); i++) cout << so[a][i % 3];
}
| 2 |
#include <bits/stdc++.h>
const int bufSize = 1e6;
inline char nc() {
static char buf[bufSize], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, bufSize, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
inline T read(T& r) {
static char c;
static int flag;
flag = 1, r = 0;
for (c = nc(); !isdigit(c); c = nc())
if (c == '-') flag = -1;
for (; isdigit(c); c = nc()) r = r * 10 + c - 48;
return r *= flag;
}
const int maxn = 500100;
struct node {
int to, next, col;
} E[maxn];
int head[maxn];
inline void add(const int& x, const int& y, const int& col) {
static int tot = 0;
E[++tot].next = head[x], E[tot].col = col, E[tot].to = y, head[x] = tot;
}
int n, m;
int dis[maxn], col[maxn], vis[maxn];
int q[maxn], qh, qt;
int main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) col[i] = -1;
while (m--) {
int a, b, c;
read(a), read(b), read(c), add(b, a, c);
}
qh = 1;
q[++qt] = n;
vis[n] = 1;
while (qt >= qh) {
int u = q[qh++];
if (u == 1) break;
for (int p = head[u]; p; p = E[p].next) {
int v = E[p].to;
if (vis[v]) continue;
if (col[v] == -1)
col[v] = 1 ^ E[p].col;
else if (col[v] == E[p].col)
dis[v] = dis[u] + 1, q[++qt] = v, vis[v] = 1;
}
}
printf("%d\n", vis[1] ? dis[1] : -1);
for (int i = 1; i <= n; ++i) putchar(col[i] ? '1' : '0');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
int n, d, b, a[N];
long long sum[N];
int calc(int mid) {
int h = n / 2 + n % 2, wa = 0, wb = 0, sa, sb, l, r;
for (int i = 1; i <= h; ++i) {
l = i, r = n - i + 1;
sa = sum[(l + 1ll * d * i < n ? l + 1ll * d * i : n)] - 1ll * wa * b,
sb = sum[n] - sum[(0 > n - i - 1ll * d * i ? 0 : n - i - 1ll * d * i)] -
1ll * wb * b;
if (l == r) {
if (sa >= b) ++wa;
} else {
if (wa < mid + n % 2) {
if (sa >= b) ++wa;
}
if (wb < mid) {
if (sb >= b) ++wb;
}
}
}
return wa >= (mid + n % 2) && wb >= mid;
}
int main() {
cin >> n >> d >> b;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), sum[i] = sum[i - 1] + a[i];
int l = 0, r = n / 2, mid, ans = n / 2 + n % 2;
while (l <= r) {
mid = (l + r) >> 1;
if (calc(mid))
l = mid + 1, ans = n / 2 - mid;
else
r = mid - 1;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> start(n), end(n);
for (int i = 0; i < n; ++i) {
cin >> start[i] >> end[i];
}
sort(start.begin(), start.end());
sort(end.begin(), end.end());
int s = 0;
int e = 0;
int ma = 0;
int occ = 0;
int an = 0;
while (s < start.size()) {
if (start[s] < end[e]) {
occ++;
if (ma < occ) {
ma = occ;
an = start[s];
}
s++;
} else {
e++;
occ--;
}
}
cout << an << " " << ma << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int T;
scanf("%d", &T);
while (T--) {
long long n, k;
scanf("%I64d%I64d", &n, &k);
if (n % k <= k / 2)
printf("%I64d\n", n);
else
printf("%lld\n", n - (n % k - k / 2));
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 35005;
int a[MXN], lst[MXN], from[MXN], f[MXN];
int t[4 * MXN], p[4 * MXN];
void build(int lo, int hi, int x = 1) {
p[x] = 0;
if (lo + 1 == hi) {
t[x] = f[lo];
return;
}
int mid = (lo + hi) / 2;
build(lo, mid, 2 * x);
build(mid, hi, 2 * x + 1);
t[x] = max(t[2 * x], t[2 * x + 1]);
}
void prop(int x) {
p[2 * x] += p[x];
t[2 * x] += p[x];
p[2 * x + 1] += p[x];
t[2 * x + 1] += p[x];
p[x] = 0;
}
void add(int l, int r, int lo, int hi, int x = 1) {
if (l >= hi || lo >= r) return;
if (l <= lo && hi <= r) {
t[x]++;
p[x]++;
return;
}
prop(x);
int mid = (lo + hi) / 2;
add(l, r, lo, mid, 2 * x);
add(l, r, mid, hi, 2 * x + 1);
t[x] = max(t[2 * x], t[2 * x + 1]);
}
int get(int l, int r, int lo, int hi, int x = 1) {
if (l >= hi || lo >= r) return -1e9;
if (l <= lo && hi <= r) return t[x];
prop(x);
int mid = (lo + hi) / 2;
return max(get(l, r, lo, mid, 2 * x), get(l, r, mid, hi, 2 * x + 1));
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
from[i] = lst[a[i]];
lst[a[i]] = i;
f[i] = -1e9;
}
for (int i = 1; i <= k; ++i) {
build(0, n + 1);
for (int j = i; j <= n; ++j) {
add(from[j], j, 0, n + 1);
f[j] = get(0, j, 0, n + 1);
}
}
printf("%d\n", f[n]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void prv(vector<int> v, int n) {
for (int i = 0; i < n; i++) cout << v[i] << " ";
}
void swap(int &a, int &b) {
int tm = a;
a = b;
b = tm;
}
vector<int> v[100001];
vector<pair<int, int>> vp;
vector<int> vst;
void solve() {
int n;
cin >> n;
int x;
for (int(i) = (0); (i) < (n); (i)++) {
cin >> x;
if (v[x].size() == 0) vst.push_back(x);
v[x].push_back(i + 1);
}
int l = vst.size(), t, k;
for (int i = 0; i < l; i++) {
k = vst[i];
t = v[k].size();
sort((v[k]).begin(), (v[k]).end());
if (t == 1)
vp.push_back(make_pair(k, 0));
else if (t == 2)
vp.push_back(make_pair(k, v[k][1] - v[k][0]));
else {
int f = 1, d;
d = v[k][1] - v[k][0];
for (int(j) = (1); (j) < (t - 1); (j)++) {
if ((v[k][j + 1] - v[k][j]) != d) {
f = 0;
break;
}
}
if (f) vp.push_back(make_pair(k, d));
}
}
sort((vp).begin(), (vp).end());
cout << vp.size() << "\n";
for (int i = 0; i < vp.size(); i++)
cout << vp[i].first << " " << vp[i].second << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
const int inf = 0x3f3f3f3f;
priority_queue<long long, vector<long long>, greater<long long> > pq;
int main() {
long long ans = 0;
long long sum = 0;
int n, x;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> x;
sum += x;
pq.push(x);
}
while (pq.size() > 1) {
ans += sum;
ans += pq.top();
sum -= pq.top();
pq.pop();
}
ans += pq.top();
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 123;
const int inf = 1e9;
int dp[N][N][15], a[N][N];
char to[N][N][15];
bool vis[N][N][15];
int n, m, k;
int dfs(int y, int x, int curk) {
if (y == 0) return (curk ? -inf : 0);
if (vis[y][x][curk]) return dp[y][x][curk];
vis[y][x][curk] = true;
int go_left = (x == 1 ? -inf : dfs(y - 1, x - 1, (curk + a[y][x]) % k));
int go_right = (x == m ? -inf : dfs(y - 1, x + 1, (curk + a[y][x]) % k));
int ans = a[y][x];
if (go_left > go_right) {
ans += go_left;
to[y][x][curk] = 'L';
} else {
ans += go_right;
to[y][x][curk] = 'R';
}
return dp[y][x][curk] = ans;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
k++;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char x;
scanf(" %c", &x);
a[i][j] = x - '0';
}
int ans = -inf;
for (int i = 1; i <= m; i++) ans = max(ans, dfs(n, i, 0));
if (ans < 0) return puts("-1");
printf("%d\n", ans);
int at;
for (int i = 1; i <= m; i++)
if (dp[n][i][0] == ans) at = i;
printf("%d\n", at);
string sans;
int curk = 0;
for (int i = n; i > 1; i--) {
sans.push_back(to[i][at][curk]);
int z = (to[i][at][curk] == 'L' ? -1 : 1);
curk += a[i][at];
curk %= k;
at += z;
}
printf("%s\n", sans.c_str());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
const double pi = 2 * acos(0.0);
const int N = 2e6 + 5;
int arr[N], freq[N], n, k;
map<int, int> mp;
vector<pair<int, long long> > vec;
vector<int> ans;
bool valid(int m) {
int x = 0;
for (int i = 0; i < vec.size(); i++) {
x += vec[i].first / m;
}
return x >= k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
vec.push_back({it->second, it->first});
}
sort(vec.rbegin(), vec.rend());
int l = 1, r = vec[0].first, mi = 1;
while (l <= r) {
int mid = (l + r) / 2;
if (valid(mid)) {
mi = mid;
l = mid + 1;
} else
r = mid - 1;
}
int j = 0;
for (int i = 0; i < vec.size(); i++) {
while (vec[i].first >= mi && j < k) {
cout << vec[i].second << " ";
vec[i].first -= mi;
j++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, cnt[45], mxx[200010], cntt[45];
long long ote[200010], tbl[45], tmp[200010];
inline int check(int x) {
memset(mxx, 0, sizeof mxx);
for (int i = 0; i <= 40; i++) cntt[i] = cnt[i];
int mx = x;
for (int i = 0; i <= ote[0]; i++) tmp[i] = ote[i];
for (int i = 0; i <= 40 && mx; i++) {
int s = 1;
while (cntt[i] && s <= mx) mxx[s++]++, cntt[i]--;
mx = s - 1;
while (cntt[i]) cntt[i]--, tmp[++tmp[0]] = tbl[i];
}
sort(tmp + 1, tmp + 1 + tmp[0]);
if (tmp[0] > x) return 0;
for (int i = 1; i <= tmp[0]; i++)
if (tmp[tmp[0] - i + 1] >= tbl[mxx[i]]) return 0;
return 1;
}
int main() {
tbl[0] = 1;
for (int i = 1; i <= 40; i++) tbl[i] = tbl[i - 1] << 1;
n = read();
for (int i = 1; i <= n; i++) {
long long xx = read(), fg = 0;
for (int j = 0; j <= 40; j++)
if (tbl[j] == xx) cnt[j]++, fg = 1;
if (!fg) ote[++ote[0]] = xx;
}
sort(ote + 1, ote + 1 + ote[0]);
int L = 1, R = cnt[0], Ans = cnt[0] + 1;
while (L <= R) {
int mid = (L + R) >> 1;
if (check(mid))
R = mid - 1, Ans = mid;
else
L = mid + 1;
}
if (Ans == cnt[0] + 1)
puts("-1");
else {
for (int i = Ans; i <= cnt[0]; i++) printf("%d ", i);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = std::numeric_limits<long long>::max();
long long mod(long long a) {
if (a < 0) {
return -1 * a;
} else {
return a;
}
}
bool isPerfectSquare(long long x) {
if (x >= 0) {
long long sr = sqrt(x);
return (sr * sr == x);
}
return false;
}
bool isPrime(long long n) {
if (n == 0 || n == 1) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int binarySearch(int arr[], int l, int r, int x) {
while (l <= r) {
int m = l + (r - l) / 2;
if (arr[m] == x) return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
bool findPartiion(int arr[], int n) {
int sum = 0;
int i, j;
for (i = 0; i < n; i++) sum += arr[i];
if (sum % 2 != 0) return false;
bool part[sum / 2 + 1];
for (i = 0; i <= sum / 2; i++) {
part[i] = 0;
}
for (i = 0; i < n; i++) {
for (j = sum / 2; j >= arr[i]; j--) {
if (part[j - arr[i]] == 1 || j == arr[i]) part[j] = 1;
}
}
return part[sum / 2];
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long findGCD(long long arr[], long long n) {
long long result = arr[0];
for (long long i = 1; i < n; i++) {
result = gcd(arr[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
long long findlcm(int arr[], int n) {
long long ans = arr[0];
for (int i = 1; i < n; i++) ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
return ans;
}
bool isNumber(string s) {
for (int i = 0; i < s.length(); i++)
if (isdigit(s[i]) == false) return false;
return true;
}
int maxIndex(long long ar[], int n) {
long long m = *max_element(ar, ar + n);
for (size_t i = 0; i < n; ++i) {
if (ar[i] == m) {
return i;
}
}
return -1;
}
int minIndex(long long ar[], int n) {
long long m = *min_element(ar, ar + n);
for (size_t i = 0; i < n; ++i) {
if (ar[i] == m) {
return i;
}
}
return -1;
}
int LCSubStr(string X, string Y, int m, int n) {
int LCSuff[m + 1][n + 1];
int result = 0;
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0)
LCSuff[i][j] = 0;
else if (X[i - 1] == Y[j - 1]) {
LCSuff[i][j] = LCSuff[i - 1][j - 1] + 1;
result = max(result, LCSuff[i][j]);
} else
LCSuff[i][j] = 0;
}
}
return result;
}
void solve() {
string a, b;
cin >> a >> b;
sort(b.begin(), b.end(), greater<int>());
int i = 0, j = 0;
while (true) {
if (b[i] > a[j]) {
a[j] = b[i];
i++;
j++;
} else {
j++;
}
if (i == b.size() || j == a.size()) break;
}
cout << a << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m;
int a[N], b[N];
int rn;
bool check(long long mid) {
for (int i = 1; i <= n; i++) b[i] = a[i];
int cur = rn;
if (cur == 0) return true;
int tm = m;
while (tm--) {
long long t = mid - cur;
if (t < 0) return false;
while (true) {
long long tmp = min(t, (long long)b[cur]);
t -= tmp, b[cur] -= tmp;
if (b[cur] != 0) break;
while (b[cur] == 0) {
cur--;
if (cur == 0) return true;
}
if (t == 0) break;
}
}
return false;
}
void solve() {
long long l = 0, r = 1ll << 60;
long long res;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
res = mid;
} else
l = mid + 1;
}
cout << res << endl;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
rn = 0;
for (int i = 1; i <= n; i++)
if (a[i] != 0) rn = i;
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void build_tree(const vector<int> &arr, int n, vector<int> &tree, int t, int tl,
int tr, int (*fun)(int, int)) {
if (t == 1) tree.resize(4 * n + 200);
if (tl == tr) {
tree[t] = arr[tl];
return;
}
int tm = (tl + tr) / 2;
build_tree(arr, n, tree, 2 * t, tl, tm, fun);
build_tree(arr, n, tree, 2 * t + 1, tm + 1, tr, fun);
tree[t] = (*fun)(tree[2 * t], tree[2 * t + 1]);
}
int find(int n, vector<int> &tree, int l, int r, int t, int tl, int tr,
int (*fun)(int, int)) {
if (tl == l && tr == r) return tree[t];
int tm = (tl + tr) / 2;
if (r <= tm) return find(n, tree, l, r, 2 * t, tl, tm, fun);
if (l > tm) return find(n, tree, l, r, 2 * t + 1, tm + 1, tr, fun);
return (*fun)(find(n, tree, l, tm, 2 * t, tl, tm, fun),
find(n, tree, tm + 1, r, 2 * t + 1, tm + 1, tr, fun));
}
void update(int n, vector<int> &tree, int pos, int val, int t, int tl, int tr,
int (*fun)(int, int)) {
if (tl == tr) {
tree[t] = val;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
update(n, tree, pos, val, 2 * t, tl, tm, fun);
else
update(n, tree, pos, val, 2 * t + 1, tm + 1, tr, fun);
tree[t] = (*fun)(tree[2 * t], tree[2 * t + 1]);
}
int n, k, len;
vector<string> a;
vector<int> suf, owner, cnt, lcp, lcp_tree, ln, scf, scs, scs_tree;
vector<long long> ans;
string s;
bool cmp(int a, int b) { return s[a] < s[b]; }
vector<int> temp, cl;
int cur_cl, step;
bool cmp2(int a, int b) {
if (cl[a] != cl[b]) return cl[a] < cl[b];
a += step;
b += step;
if (a >= len) a -= len;
if (b >= len) b -= len;
return cl[a] < cl[b];
}
void build() {
suf.resize(len);
temp.resize(len);
for (int i = 0; i < len; ++i) suf[i] = i;
sort(suf.begin(), suf.end(), cmp);
cl.resize(len);
cur_cl = 0;
cl[suf[0]] = 0;
for (int i = 1; i < len; ++i) {
if (s[suf[i - 1]] != s[suf[i]]) ++cur_cl;
cl[suf[i]] = cur_cl;
}
for (step = 1; step <= len; step = (step << 1)) {
sort(suf.begin(), suf.end(), cmp2);
cur_cl = 0;
temp[suf[0]] = 0;
for (int i = 1; i < len; ++i) {
if (cmp2(suf[i - 1], suf[i])) ++cur_cl;
temp[suf[i]] = cur_cl;
}
for (int i = 0; i < len; ++i) cl[i] = temp[i];
}
for (int i = 0; i < len; ++i) temp[i] = owner[suf[i]];
for (int i = 0; i < len; ++i) owner[i] = temp[i];
for (int i = 0; i < len; ++i) temp[i] = ln[suf[i]];
for (int i = 0; i < len; ++i) ln[i] = temp[i];
}
void read() {
cin >> n >> k;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
s += (char)'$';
for (int i = 0; i < n; ++i) {
s += a[i];
s += (char)'$';
}
len = (int)s.length();
owner.resize(len);
ln.resize(len);
owner[0] = -1;
for (int i = 1, j = 0, p = 0; i < len; ++i, ++p) {
owner[i] = -1;
if ((int)a[j].length() == p) {
++j;
p = -1;
} else {
owner[i] = j;
ln[i] = (int)a[j].length() - p;
}
}
}
int MIN(int a, int b) { return a < b ? a : b; }
void calcLcp() {
lcp.resize(len - 1);
temp.resize(len);
for (int i = 0; i < len; ++i) temp[suf[i]] = i;
int LCP = 0;
for (int i = 0; i < len; ++i) {
if (temp[i] == len - 1) continue;
if (LCP > 0 && suf[temp[i] + 1] + LCP - 1 < len && i + LCP - 1 < len &&
s[i + LCP - 1] != s[suf[temp[i] + 1] + LCP - 1])
--LCP;
while (suf[temp[i] + 1] + LCP < len && i + LCP < len &&
s[i + LCP] == s[suf[temp[i] + 1] + LCP])
++LCP;
lcp[temp[i]] = LCP;
}
build_tree(lcp, len - 1, lcp_tree, 1, 0, len - 2, MIN);
}
void scanLine() {
scf.resize(len);
scs.resize(len);
cnt.assign(n, 0);
int cntr = 0;
for (int i = 0, j = 0; i < len; ++i) {
scf[i] = scs[i] = -1;
if (owner[i] == -1) continue;
while (j < len && cntr < k) {
if (owner[j] == -1) {
++j;
continue;
}
++cnt[owner[j]];
if (cnt[owner[j]] == 1) ++cntr;
++j;
}
if (cntr < k) {
scf[i] = j - 1;
scs[i] = 0;
} else {
scf[i] = j - 1;
if (cntr > 1)
scs[i] = find(len - 1, lcp_tree, i, j - 2, 1, 0, len - 2, MIN);
else
scs[i] = ln[i];
}
--cnt[owner[i]];
if (cnt[owner[i]] == 0) --cntr;
}
}
int getL(int pos, int plen, int t, int tl, int tr) {
if (lcp_tree[t] >= plen) return tl;
if (tl == tr) return tl + 1;
int tm = (tl + tr) / 2;
if (lcp_tree[2 * t + 1] < plen && pos > tm)
return getL(pos, plen, 2 * t + 1, tm + 1, tr);
else
return getL(pos, plen, 2 * t, tl, tm);
}
bool check(int pos, int plen) {
if (lcp[pos - 1] < plen) return scs[pos] >= plen;
return scs[getL(pos, plen, 1, 0, len - 2)] >= plen;
}
void calcAns() {
ans.assign(n, 0LL);
std::fill(lcp_tree.begin(), lcp_tree.end(), 1000000);
for (int i = 0; i < len; ++i) {
if (owner[i] == -1) continue;
if (k == 1) {
ans[owner[i]] += ln[i];
continue;
}
update(len - 1, lcp_tree, i - 1, lcp[i - 1], 1, 0, len - 2, MIN);
int l = 0, r = ln[i] + 1;
while (r - l > 1) {
int md = (l + r) / 2;
if (check(i, md))
l = md;
else
r = md;
}
ans[owner[i]] += l;
}
for (int i = 0; i < n; ++i) printf("%I64d ", ans[i]);
}
int main() {
read();
build();
calcLcp();
scanLine();
calcAns();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, p1, p2, p3, p4, ans = 0;
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
for (int i = a; i <= b; i++)
if ((((i % p1) % p2) % p3) % p4 == i) ans++;
cout << ans;
return 0;
cout << "jdakfksd";
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int s1 = 0;
int s2 = 0;
int s3 = 0;
while (n--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
s1 = s1 + a;
s2 = s2 + b;
s3 = s3 + c;
}
if (s1 == 0 && s2 == 0 && s3 == 0) {
printf("YES");
} else {
printf("NO");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 23], *p1 = buf, *p2 = buf;
int read() {
static int res;
static char op;
do
op =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 23, stdin), p1 == p2)
? EOF
: *p1++);
while (op > '9' || op < '0');
for (res = 0; op >= '0' && op <= '9';
op = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 23, stdin), p1 == p2)
? EOF
: *p1++))
res = res * 10 + (op ^ 48);
return res;
}
int readstr(char *s) {
static int len;
static char op;
do
op =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 23, stdin), p1 == p2)
? EOF
: *p1++);
while (op != '.' && op != '#');
for (len = 0; op == '.' || op == '#';
op = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 23, stdin), p1 == p2)
? EOF
: *p1++))
s[len++] = op;
return len;
}
char s[3010][3010];
int n, m, f[3010][3010];
int calc(int x1, int y1, int x2, int y2) {
memset(f, 0, sizeof f);
for (int i = x1, j; i <= x2; ++i)
for (j = y1; j <= y2; ++j)
if (s[i][j] == '.')
f[i][j] = (i != x1 || j != y1)
? (f[i - 1][j] + f[i][j - 1]) % 1000000007ll
: 1;
return f[x2][y2];
}
signed main(int argc, char **argv) {
n = read(), m = read();
for (int i = 1; i <= n; ++i) readstr(s[i] + 1);
long long ans =
(1ll * calc(1, 2, n - 1, m) * calc(2, 1, n, m - 1) % 1000000007ll -
1ll * calc(1, 2, n, m - 1) * calc(2, 1, n - 1, m) % 1000000007ll +
1000000007ll) %
1000000007ll;
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
inline long long powmod(long long a, long long first, long long mod) {
a %= mod;
long long t = 1LL;
while (first) {
if (first & 1) t = t * a % mod;
a = a * a % mod;
first >>= 1;
}
return t;
}
const int MAXN = 2e5 + 5;
double exc[MAXN], sum[MAXN], rev[MAXN];
double t[MAXN];
double dp[MAXN][55];
inline double second(int first, int p) {
return dp[first][p] - exc[first] + sum[first] * rev[first];
}
inline double g(int j, int k, int p) {
return (second(j, p) - second(k, p)) / (sum[j] - sum[k]);
}
inline double cal(int l, int i) {
return exc[i] - exc[l] - (rev[i] - rev[l]) * sum[l];
}
int q[MAXN], top, tail;
inline void add(int i, int k) {
while (top < tail - 1 &&
g(i, q[tail - 1], k) < g(q[tail - 1], q[tail - 2], k))
tail--;
q[tail++] = i;
}
inline int getmax(int i, int k) {
while (top < tail - 1 && g(q[top + 1], q[top], k) < rev[i]) top++;
return q[top];
}
int main() {
int n, i, K, k;
scanf("%d%d", &n, &K);
for (i = 1; i <= n; i++) scanf("%lf", &t[i]);
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + t[i];
rev[i] = rev[i - 1] + 1.0 / t[i];
exc[i] = exc[i - 1] + sum[i] / t[i];
}
for (i = 1; i <= n; i++) dp[i][1] = exc[i];
for (k = 2; k <= K; k++) {
top = tail = 0;
q[tail++] = 0;
for (i = 1; i <= n; i++) add(i, k - 1);
for (i = 1; i <= n; i++) {
if (i >= k) {
int l = getmax(i, k - 1);
dp[i][k] = dp[l][k - 1] + cal(l, i);
} else
dp[i][k] = 10000000000000000.0;
}
}
printf("%.10f\n", dp[n][K]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 1;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
void solve() {
int n, k, x;
cin >> n >> k >> x;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long dp[n + 1][x + 1];
memset(dp, -0x3f, sizeof dp);
dp[0][0] = 0;
for (int j = 1; j <= x; j++) {
deque<array<long long, 2>> dq;
dq.push_back({j - 1, dp[j - 1][j - 1]});
for (int i = j; i <= n; i++) {
while (dq.size() && dq.front()[0] < i - k) dq.pop_front();
dp[i][j] = dq.front()[1] + a[i];
while (dq.size() && dp[i][j - 1] >= dq.back()[1]) dq.pop_back();
dq.push_back({i, dp[i][j - 1]});
}
}
long long ans = -1;
for (int i = 0; i < k; i++) {
ans = max(ans, dp[n - i][x]);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc = 1;
for (int t = 1; t <= tc; t++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
bool bo, nul = 0;
vector<int> a, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (x > 0) a.push_back(x);
if (x < 0) b.push_back(x);
if (x == 0) nul = 1;
}
sort(b.begin(), b.end());
bo = !a.empty();
for (int i = 0; i < a.size(); i++) cout << a[i] << " ";
if (!b.empty()) {
if (b.size() == 1 && !bo && nul) {
cout << 0;
return 0;
}
if (bo && b.size() & 1 == 1)
b.erase(b.end() - 1);
else if (!bo && b.size() > 1 && b.size() & 1 == 1)
b.erase(b.end() - 1);
for (int i = 0; i < b.size(); i++) cout << b[i] << " ";
}
if (a.empty() && b.empty()) cout << 0;
fclose(stdin);
fclose(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
long long fac[maxn], inv[maxn];
long long qpow(long long a, int b) {
if (b < 0) return qpow(a, b + mod - 1);
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b = b / 2;
}
return ans;
}
void getFac(int n) {
for (int i = fac[0] = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
inv[n] = qpow(fac[n], mod - 2);
for (int i = n; i >= 1; i--) inv[i - 1] = inv[i] * i % mod;
}
long long getC(long long n, long long m) {
if (n < m || m < 0) return 0;
return fac[n] * inv[n - m] % mod * inv[m] % mod;
}
int main() {
long long n, m, a, b;
scanf("%lld%lld%lld%lld", &n, &m, &a, &b);
getFac(max(n, m));
long long ans = 0;
for (long long i = 0; i <= n - 2; i++) {
ans = (ans + getC(n - 2, i) * getC(m - 1, i) % mod * fac[i] % mod *
qpow(m, n - 2 - i) % mod * qpow(n, n - i - 3) % mod *
(i + 2) % mod) %
mod;
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2001000;
char A[MAXN], B[MAXN];
int N;
int go() {
scanf("%d", &N);
scanf("%s", A);
scanf("%s", B);
int a = 0, b = 0, c = 0;
for (int i = 0; i < 2 * N; ++i) {
if (A[i] == '1' && B[i] == '1')
++c;
else if (A[i] == '1')
++a;
else if (B[i] == '1')
++b;
}
a -= b;
c %= 2;
if (c == 1) {
if (a >= 0)
return 1;
else if (a == -1 || a == -2)
return 0;
else
return -1;
} else {
if (a > 0)
return 1;
else if (a == 0 || a == -1)
return 0;
else
return -1;
}
}
int main() {
int ans = go();
if (ans == -1)
printf("Second\n");
else if (ans == 0)
printf("Draw\n");
else
printf("First\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007ll;
long long dp[107][3007][2];
int a[3007], b[3007];
int main() {
int n, l;
scanf("%d%d", &n, &l);
memset(dp, 0, sizeof dp);
for (int i = 0; i < n; i++) {
scanf("%d%d", a + i, b + i);
dp[i][a[i]][0] = 1;
if (a[i] != b[i]) dp[i][b[i]][1] = 1;
}
for (int j = 1; j <= l; j++) {
for (int i = 0; i < n; i++) {
if (a[i] < j) {
for (int k = 0; k < n; k++)
if (i != k) {
if (a[i] == b[k]) {
dp[i][j][0] += dp[k][j - a[i]][0];
dp[i][j][0] %= mod;
}
if (a[i] == a[k]) {
dp[i][j][0] += dp[k][j - a[i]][1];
dp[i][j][0] %= mod;
}
}
}
if (a[i] != b[i] && b[i] < j) {
for (int k = 0; k < n; k++)
if (i != k) {
if (b[i] == b[k]) {
dp[i][j][1] += dp[k][j - b[i]][0];
dp[i][j][1] %= mod;
}
if (b[i] == a[k]) {
dp[i][j][1] += dp[k][j - b[i]][1];
dp[i][j][1] %= mod;
}
}
}
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
res += (dp[i][l][0] + dp[i][l][1]) % mod;
res %= mod;
}
printf(
"%lld"
"\n",
res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double sqr(double x) { return x * x; }
int main() {
double x0, y0, x1, y1, dx, dy;
scanf("%lf %lf %lf %lf", &x0, &y0, &x1, &y1);
dx = x1 - x0, dy = y1 - y0;
double vm, t;
scanf("%lf %lf", &vm, &t);
double u1, v1, u2, v2;
scanf("%lf %lf %lf %lf", &u1, &v1, &u2, &v2);
double dist = sqrt(sqr(x1 - x0) + sqr(y1 - y0));
double l1 = sqrt(sqr(u1) + sqr(v1));
double l2 = sqrt(sqr(u2) + sqr(v2));
if (dist < 1e-10) {
printf("%.10f\n", 0.0);
return 0;
}
{
double vx = (u1 * dx + v1 * dy) / dist;
double vy = fabs((u1 * dy - v1 * dx) / dist);
vx += sqrt(sqr(vm) - sqr(vy));
double t1 = dist / vx;
if (t1 <= t + 1e-7) {
printf("%f\n", t1);
return 0;
}
}
{
dx -= u1 * t, dy -= v1 * t;
double l = 0.0, r = 1e10;
for (int i = 0; i < 100; i++) {
double m = (l + r) / 2.0;
double tx = dx - m * u2, ty = dy - m * v2;
if (sqrt(sqr(tx) + sqr(ty)) > vm * (t + m))
l = m;
else
r = m;
}
printf("%.10f\n", t + l);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, a1[100005], s1, a2[100005], dfn[100005], sz[100005], s2;
vector<long long> v[100005];
void dfs1(long long x, long long y) {
vector<long long> p;
for (long long i = 0; i < v[x].size(); i++) {
long long h = v[x][i];
if (h == y) continue;
dfs1(h, x);
if (!a1[h]) p.push_back(h);
}
if (p.empty()) return;
for (long long i = 0; i < p.size() - 1; i++) a1[p[i]] = p[i + 1];
a1[p.back()] = x, a1[x] = p.front(), s1 += 2 * p.size();
}
void work1() {
dfs1(1, 0);
if (!a1[1]) a1[1] = a1[v[1][0]], a1[v[1][0]] = 1, s1 += 2;
}
void dfs2(long long x, long long y) {
dfn[++*dfn] = x;
sz[x] = 1;
for (long long i = 0; i < v[x].size(); i++) {
long long h = v[x][i];
if (h == y) continue;
dfs2(h, x);
sz[x] += sz[h];
}
s2 += 2 * min(n - sz[x], sz[x]);
}
void work2() {
dfs2(1, 0);
for (long long i = 1; i <= n; i++) a2[dfn[i]] = dfn[(i + n / 2 - 1) % n + 1];
}
signed main() {
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
work1(), work2();
printf("%lld\n", s2);
for (long long i = 1; i <= n; i++) printf("%lld ", a2[i]);
}
| 6 |
#include <bits/stdc++.h>
int main() {
int t, p;
scanf("%d", &t);
for (p = 1; p <= t; p++) {
long long n;
scanf("%lld", &n);
if (n <= 3) {
printf("%lld\n", n);
continue;
}
long long m = n;
long long base = 1;
while (m > 0) {
m = m / 4;
base = base * 4;
}
base = base / 4;
if (n % 3 == 1) {
printf("%lld\n", base + (n - base) / 3);
continue;
}
long long fi = base + (n - base) / 3;
long long se = base * 2;
m = (n - base) / 3;
long long cur = 1;
while (m > 0) {
if (m % 4 == 1) se += 2 * cur;
if (m % 4 == 2) se += 3 * cur;
if (m % 4 == 3) se += cur;
m = m / 4;
cur = cur * 4;
}
if (n % 3 == 2)
printf("%lld\n", se);
else
printf("%lld\n", fi ^ se);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vec[105];
int ans[105][105][2][26];
int func(int i, int j, int flag, int tw = 0) {
if (vec[i].empty() || vec[i].back().first < tw)
return 1 - flag;
else if (vec[j].empty())
return flag;
else if (vec[i].back().first > vec[j].back().first)
return flag;
int sz = vec[i].size();
if (ans[i][j][flag][tw] != -1) return ans[i][j][flag][tw];
for (int k = 0; k < sz; k++)
if (vec[i][k].first - 'a' >= tw &&
func(j, vec[i][k].second, 1 - flag, vec[i][k].first - 'a') == flag)
return ans[i][j][flag][tw] = flag;
return ans[i][j][flag][tw] = 1 - flag;
}
int main() {
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int arr[n];
for (int i = 0; i < 105; i++)
for (int j = 0; j < 105; j++)
for (int k = 0; k < 26; k++) ans[i][j][0][k] = ans[i][j][1][k] = -1;
for (int i = 0; i < m; i++) {
int a, b;
char ar[2];
cin >> a >> b >> ar;
vec[a].push_back(make_pair(ar[0], b));
}
for (int i = 0; i < 101; i++) sort(vec[i].begin(), vec[i].end());
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (func(i, j, 0) == 0)
cout << "A";
else
cout << "B";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class Node {
private:
typedef Node<T> *pnode;
T val, lazy;
T mi;
int mipos;
bool reverse;
int prior, size;
Node *l, *r;
static void upd_lazy(pnode t, T val) {
if (t) t->lazy += val;
}
static void refresh(pnode t) {
if (t) {
Node<T> *l = t->l, *r = t->r;
pushlazy(l);
pushlazy(r);
t->size = get_size(t->l) + 1 + get_size(t->r);
t->lazy = 0;
t->reverse = false;
if (l and t->val >= l->mi)
t->mi = l->mi, t->mipos = l->mipos;
else
t->mipos = 1 + get_size(l), t->mi = t->val;
if (r and t->mi > r->mi) {
t->mi = r->mi, t->mipos = r->mipos + 1 + get_size(l);
}
}
}
static void pushlazy(pnode t) {
if (!t) return;
if (t->reverse) {
swap(t->l, t->r);
if (t->l) t->l->reverse = not t->l->reverse;
if (t->r) t->r->reverse = not t->r->reverse;
t->reverse = false;
}
if (t->lazy) {
t->val += t->lazy;
t->mi += t->lazy;
if (t->l) t->l->lazy += t->lazy;
if (t->r) t->r->lazy += t->lazy;
t->lazy = 0;
}
}
public:
static void insert_at_pos(pnode &t, T val, int pos) {
Node<T> *l, *r;
split(t, l, r, pos - 1);
append(l, val);
merge(t, l, r);
}
static void append(pnode &t, T val) { merge(t, t, new Node(val)); }
static void delete_at_pos(pnode &t, int pos) {
Node<T> *l, *mid, *r;
split(t, l, r, pos - 1);
split(r, mid, r, 1);
merge(t, l, r);
}
static void split(pnode t, pnode &l, pnode &r, int pos) {
pushlazy(t);
if (!t) return void(l = r = NULL);
int ihave = get_size(t->l) + 1;
if (ihave > pos)
split(t->l, l, t->l, pos), r = t;
else
split(t->r, t->r, r, pos - ihave), l = t;
refresh(t);
}
static int get_size(pnode t) { return t ? t->size : 0; }
static void merge(pnode &t, pnode l, pnode r) {
pushlazy(l);
pushlazy(r);
if (not l or not r)
t = l ? l : r;
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
refresh(t);
}
Node(T _val) {
mi = val = _val;
mipos = 1;
size = 1;
prior = rand();
lazy = 0;
reverse = false;
l = r = 0;
}
static pair<T, int> range_query(pnode t, int ql, int qr) {
if (ql > qr) return {LLONG_MAX, 0};
Node *l, *mid, *r;
split(t, l, mid, ql - 1);
split(mid, t, r, qr - ql + 1);
pair<T, int> ans;
if (t) {
ans = {t->mi, t->mipos};
}
merge(mid, l, t);
merge(t, mid, r);
return ans;
}
static void range_update(pnode t, int ql, int qr, T val) {
if (ql > qr) return;
Node *l, *mid, *r;
split(t, l, mid, ql - 1);
split(mid, t, r, qr - ql + 1);
upd_lazy(t, val);
merge(mid, l, t);
merge(t, mid, r);
}
static void range_reverse(pnode t, int ql, int qr) {
if (ql > qr) return;
Node *l, *mid, *r;
split(t, l, mid, ql - 1);
split(mid, t, r, qr - ql + 1);
rev(t);
merge(mid, l, t);
merge(t, mid, r);
}
static void rev(pnode t) {
pushlazy(t);
if (t) t->reverse = not t->reverse;
}
static void rotate_forward(pnode t, int moves) {
if (not get_size(t)) return;
moves %= get_size(t);
if (moves) {
int newfirst = get_size(t) - moves + 1;
Node<T> *l, *r;
t->split(t, l, r, newfirst - 1);
t->merge(t, r, l);
}
}
static void rotate_subseq_forward(pnode t, int ql, int qr, int moves) {
if (ql > qr) return;
Node *l, *mid, *r;
split(t, l, mid, ql - 1);
split(mid, t, r, qr - ql + 1);
rotate_forward(t, moves);
merge(mid, l, t);
merge(t, mid, r);
}
static void inorder(pnode t) {
pushlazy(t);
if (!t) return;
inorder(t->l);
cout << t->val << " ";
inorder(t->r);
}
};
void solve() {
int n;
cin >> n;
Node<long long> *treap = 0;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
treap->append(treap, x);
}
Node<long long> *l, *temp, *r;
long long ans = 0, iter = 0;
while (treap->get_size(treap)) {
auto [_, pos] = treap->range_query(treap, 1, treap->get_size(treap));
ans += pos;
iter++;
treap->split(treap, l, r, pos - 1);
treap->split(r, temp, r, 1);
treap->merge(treap, r, l);
}
assert(iter == n);
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void coutv(vector<long long> v) {
for (auto it : v) cout << it << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, cnt = 0, cnti = 0;
cin >> n;
vector<long long> a(n);
for (auto &x : a) cin >> x;
for (int i = 0; i < a.size(); i++) {
long long j = i + 1;
if (j & 1 && a[i] & 1) cnt++;
if (j % 2 == 0 && a[i] % 2 == 0) cnti++;
}
if (cnt == cnti) {
cout << cnt << endl;
} else
cout << -1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, x, i;
cin >> n >> a >> b;
x = n / a;
for (i = 0; i <= x; i++) {
if (((long double)(n - i * a) / b) == ((long long)(n - i * a) / b)) {
cout << "YES\n";
cout << i << " " << (n - i * a) / b;
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool check[100005];
vector<int> e[100005];
int n, bit[32], val[100005], num[100005], ans;
void dfs(int x) {
check[x] = 1;
for (int i = 0; i < e[x].size(); ++i) {
if (check[e[x][i]]) continue;
dfs(e[x][i]);
for (int j = 25; j >= 1; --j)
if ((val[x] & val[e[x][i]]) & bit[j]) {
val[x] |= bit[j] - 1;
break;
}
val[x] |= val[e[x][i]];
}
++val[x];
int tmp = 29;
while (!(bit[tmp] & val[x])) --tmp;
ans = max(ans, tmp);
tmp = 0;
while (!(bit[tmp] & val[x])) ++tmp;
num[x] = tmp;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
}
int x;
for (x = 1; x <= n; ++x)
if (e[x].size() == 1) break;
bit[1] = 1;
for (int i = 2; i < 30; ++i) bit[i] = bit[i - 1] * 2;
ans = 0;
dfs(x);
if (ans > 25)
printf("Impossible!\n");
else {
for (int i = 1; i <= n; ++i) printf("%c ", 'Z' + 1 - num[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18;
const int N = 1234;
int n;
int a[N];
int main() {
while (scanf("%d", &n) != EOF) {
int i, j;
int tot = 0;
for (i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
if (x == 1) a[tot++] = i;
}
if (!tot) {
puts("0");
continue;
}
long long ans = 1;
for (i = 1; i < tot; ++i) {
ans *= (a[i] - a[i - 1]);
}
printf("%I64d\n", ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<long long, long long> hi;
long long res = 0;
long long a[1000000], b[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int t;
for (int i = 0; i < n; ++i) {
cin >> t;
hi[t]++;
}
cin >> m;
for (int i = 0; i < m; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) cin >> b[i];
pair<long long, long long> hii = make_pair(0, 0);
for (int i = 0; i < m; ++i) {
if (hii < make_pair(hi[a[i]], hi[b[i]])) {
hii = make_pair(hi[a[i]], hi[b[i]]);
res = i;
}
}
cout << res + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
int ai;
int main() {
cin >> t;
for (int i = 0; i < t; ++i) {
cin >> n;
vector<int> a(n + 1, 0);
int ans = 0;
for (int j = 1; j <= n; ++j) {
cin >> ai;
if (a[ai] == 0)
a[ai] = j;
else if (a[ai] + 1 < j)
ans = 1;
}
if (ans == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct sub {
int dp[5][5];
sub() {
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
dp[i][j] = 200000;
}
dp[i][i] = 0;
}
}
sub operator+(const sub &q) const {
sub r;
for (int i = 0; i < 5; i++) r.dp[i][i] = 200000;
for (int i = 0; i < 5; i++) {
for (int j = i; j < 5; j++) {
for (int k = j; k < 5; k++) {
r.dp[i][k] = min(r.dp[i][k], dp[i][j] + q.dp[j][k]);
}
}
}
return r;
}
};
int n, q;
sub seg[1 << 19];
char s[200005];
void in(int l, int r, int k) {
if (l == r) {
int o = k - (1 << 18) + 1;
if (o >= n) return;
if (s[o] == '2') {
seg[k].dp[0][1] = 0;
seg[k].dp[0][0] = 1;
} else if (s[o] == '0') {
seg[k].dp[1][2] = 0;
seg[k].dp[1][1] = 1;
} else if (s[o] == '1') {
seg[k].dp[2][3] = 0;
seg[k].dp[2][2] = 1;
} else if (s[o] == '7') {
seg[k].dp[3][4] = 0;
seg[k].dp[3][3] = 1;
} else if (s[o] == '6') {
seg[k].dp[3][3] = 1;
seg[k].dp[4][4] = 1;
}
} else {
in(l, (r + l - 1) / 2, k * 2 + 1);
in((l + r + 1) / 2, r, k * 2 + 2);
seg[k] = seg[k * 2 + 1] + seg[k * 2 + 2];
}
}
sub que(int a, int b, int l, int r, int k) {
if (b < l || r < a) {
sub r;
return r;
}
if (a <= l && r <= b) return seg[k];
return que(a, b, l, (l + r - 1) / 2, k * 2 + 1) +
que(a, b, (l + r + 1) / 2, r, k * 2 + 2);
}
int main(void) {
cin >> n >> q >> s;
in(0, (1 << 18) - 1, 0);
for (int i = 0; i < q; i++) {
int a, b;
sub p;
cin >> a >> b;
a--;
b--;
p = que(a, b, 0, (1 << 18) - 1, 0);
if (p.dp[0][4] == 200000)
cout << -1 << endl;
else
cout << p.dp[0][4] << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
int a[N], t[N], r[N], n, m;
bool vis[N], ok[N];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int c = 0;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d %d", &t[i], &r[i]);
c += r[i];
}
if (c == 0) {
int w = 0;
for (int i = 1; i < n; i++) {
if (t[i])
--a[t[i]];
else
++w;
}
for (int i = 1; i <= m; i++) putchar("NY"[a[i] <= w]);
} else {
for (int i = 1; i <= m; i++) vis[i] = 0, ok[i] = 1;
int w = 0;
for (int i = 1; i < n; i++) {
if (r[i] && c) {
c = 0;
for (int j = i; j < n; j++) vis[t[j]] = 1;
int mn = N;
for (int j = 1; j <= m; j++) {
if (vis[j] || a[j] > w) continue;
mn = min(mn, a[j]);
ok[j] = 0;
}
w -= mn;
}
if (t[i])
--a[t[i]];
else
++w;
}
for (int i = 1; i <= m; i++) putchar("NY"[a[i] <= w || !ok[i]]);
}
puts("");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
long long n, ret;
int mod, d;
long long dp[(1 << 18) + 10][110];
vector<int> v;
long long f[20];
int c[10];
int main() {
cin >> n >> mod;
f[0] = 1;
for (int i = (0); i < (18); ++i) f[i + 1] = f[i] * (i + 1);
while (n) {
++c[n % 10];
v.push_back(n % 10);
n /= 10;
++d;
}
for (int i = (0); i < (d); ++i)
if (v[i] != 0) dp[1 << i][v[i] % mod] = 1;
for (int i = 1; i < (1 << d); ++i) {
int mask = i;
for (int j = (0); j < (d); ++j) {
if ((mask >> j) & 1) continue;
for (int k = (0); k < (mod); ++k) {
dp[mask | (1 << j)][(k * 10 + v[j]) % mod] += dp[mask][k];
}
}
}
ret = dp[(1 << d) - 1][0];
for (int i = (0); i < (10); ++i) ret /= f[c[i]];
cout << ret << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int INF = 1e9 + 7;
const long long INFLL = 1e18 + 7;
const long double EPS = 1e-9;
const int MAXN = 1e5 + 17;
mt19937 myRand(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 myRand64(chrono::steady_clock::now().time_since_epoch().count());
signed main(void) {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
int v[n][m], k[n][m];
vector<int> cnt1, cnt2;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> v[i][j];
cnt1.push_back(v[i][j]);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> k[i][j];
cnt2.push_back(k[i][j]);
}
}
sort(cnt1.begin(), cnt1.end());
sort(cnt2.begin(), cnt2.end());
if (cnt1 != cnt2) {
cout << "NO";
return 0;
}
vector<int> a, b;
for (int i = 0; i < m; ++i) {
a.clear(), b.clear();
int x = 0, y = i;
while (x < n && y >= 0) {
a.push_back(v[x][y]);
b.push_back(k[x][y]);
x++, y--;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a != b) {
cout << "NO";
return 0;
}
a.clear(), b.clear();
x = n - 1, y = i;
while (x >= 0 && y < m) {
a.push_back(v[x][y]);
b.push_back(k[x][y]);
x--, y++;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a != b) {
cout << "NO";
return 0;
}
}
for (int i = m; i < n; ++i) {
a.clear(), b.clear();
int x = i, y = 0;
while (x >= 0 && y < m) {
a.push_back(v[x][y]);
b.push_back(k[x][y]);
x--, y++;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a != b) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long gcd(long long a, long long b) { return (a == 0) ? b : gcd(b % a, a); }
vector<long long> v1;
vector<long long> v2;
int main() {
long long n, m, i, j, k;
long long a[501][501], b[501][501];
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> b[i][j];
if (n == 1 && m == 1) {
if (a[1][1] == b[1][1])
cout << "yes";
else
cout << "no";
return 0;
}
for (k = 2; k <= n; k++) {
i = k;
j = 1;
while (i > 0 && j <= m) {
v1.push_back(a[i][j]);
v2.push_back(b[i][j]);
i--, j++;
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (!(v1 == v2)) {
cout << "NO";
return 0;
}
v1.clear();
v2.clear();
}
for (k = 2; k <= m; k++) {
j = k;
i = n;
while (i > 0 && j <= m) {
v1.push_back(a[i][j]);
v2.push_back(b[i][j]);
i--, j++;
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (!(v1 == v2)) {
cout << "no";
return 0;
}
v1.clear();
v2.clear();
}
if (a[1][1] == b[1][1]) cout << "yes" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 1e6 + 5;
long double a[maxn];
long double ans[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> x;
a[i] = x;
}
vector<pair<long double, int> > Q;
for (int i = 1; i <= n; ++i) {
Q.push_back({a[i], i});
while ((int)Q.size() > 1) {
int N = (int)Q.size();
if (Q[N - 1].first < Q[N - 2].first) {
long double t = (Q[N - 1].first * (i - Q[N - 1].second + 1) +
Q[N - 2].first * (Q[N - 1].second - Q[N - 2].second)) /
(i - Q[N - 2].second + 1);
int pos = Q[N - 2].second;
Q.pop_back(), Q.pop_back();
Q.push_back({t, pos});
} else
break;
}
}
for (int i = 0; i < (int)Q.size() - 1; ++i) {
for (int j = Q[i].second; j < Q[i + 1].second; ++j) ans[j] = Q[i].first;
}
for (int j = Q.back().second; j <= n; ++j) ans[j] = Q.back().first;
for (int i = 1; i <= n; ++i)
cout << fixed << setprecision(9) << ans[i] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
struct Hasher {
vector<int> a, h, rev;
int p, mod;
Hasher(const vector<int>& a, int p, int mod) : a(a), p(p), mod(mod) {
build();
}
int bp(int a, int k) {
if (k == 0) return 1;
if (k % 2 == 1) {
return a * (long long)bp(a, k - 1) % mod;
} else {
int q = bp(a, k >> 1);
return q * (long long)q % mod;
}
}
void build() {
rev.resize(a.size() + 1);
h.resize(a.size() + 1);
rev[0] = 1;
h[0] = 0;
int deg = 1;
for (int i = 1; i <= a.size(); i++) {
h[i] = (h[i - 1] + a[i - 1] * (long long)deg) % mod;
deg = deg * (long long)p % mod;
rev[i] = bp(deg, mod - 2);
}
}
int get(int l, int r) {
int ans = h[r + 1] - h[l];
if (ans < 0) ans += mod;
ans = ans * (long long)rev[l] % mod;
return ans;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string t;
cin >> t;
vector<int> a, ra;
vector<int> pos;
for (int i = 0; i < n; i++) {
if (t[i] == '0') {
a.push_back(i % 2);
pos.push_back(i);
ra.push_back(1 - a.back());
}
}
Hasher ha1(a, 31, MOD1);
Hasher ha2(a, 31, MOD2);
Hasher hra1(ra, 31, MOD1);
Hasher hra2(ra, 31, MOD2);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l1, l2, len;
cin >> l1 >> l2 >> len;
l1--, l2--;
int posl_1 = lower_bound(pos.begin(), pos.end(), l1) - pos.begin();
int posr_1 =
upper_bound(pos.begin(), pos.end(), l1 + len - 1) - pos.begin() - 1;
int cnta = max(0, posr_1 - posl_1 + 1);
int posl_2 = lower_bound(pos.begin(), pos.end(), l2) - pos.begin();
int posr_2 =
upper_bound(pos.begin(), pos.end(), l2 + len - 1) - pos.begin() - 1;
int cntb = max(0, posr_2 - posl_2 + 1);
if (cnta != cntb) {
cout << "No\n";
continue;
}
if (!cnta) {
cout << "Yes\n";
continue;
}
int h1 = ha1.get(posl_1, posr_1);
int h2 = ha2.get(posl_1, posr_1);
int da = pos[posl_1] - l1, db = pos[posl_2] - l2;
if (da % 2 != db % 2) {
cout << "No\n";
continue;
}
int h3, h4;
if (pos[posl_1] % 2 == pos[posl_2] % 2) {
h3 = ha1.get(posl_2, posr_2);
h4 = ha2.get(posl_2, posr_2);
} else {
h3 = hra1.get(posl_2, posr_2);
h4 = hra2.get(posl_2, posr_2);
}
if (h3 != h1 || h4 != h2) {
cout << "No\n";
} else {
cout << "Yes\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
float a, b, c, result, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
sum = sum + a;
}
b = n * 100;
result = sum / b;
cout << result * 100;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c;
int a[100010], b[100010], s[100010] = {0};
int main() {
int i, h, t;
scanf("%d%d%d", &n, &m, &c);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d", &b[i]);
s[i] = (s[i - 1] + b[i]) % c;
}
for (i = 1; i <= n; i++) {
if (i <= n - m + 1)
h = 1;
else
h = i - n + m;
if (i >= m)
t = m;
else
t = i;
a[i] = (a[i] + s[t] - s[h - 1] + c) % c;
}
for (i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int INF = 100000000;
int n, v[N][N], dp[N * 2][N][N];
bool valid(int x, int y) {
if (x <= 0 || x > n || y <= 0 || y > n) return false;
return true;
}
bool same(int x1, int y1, int x2, int y2) {
if (x1 == x2 && y1 == y2) return true;
return false;
}
int main() {
memset(dp, 0, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &v[i][j]);
dp[0][1][1] = v[1][1];
for (int i = 1; i <= 2 * n - 2; i++)
for (int x1 = 1; x1 <= n; x1++)
for (int x2 = 1; x2 <= n; x2++) {
int y1 = i + 2 - x1;
int y2 = i + 2 - x2;
int t = 0, ans = -INF;
if (!same(x1, y1, x2, y2))
t = v[x1][y1] + v[x2][y2];
else
t = v[x1][y1];
if (!valid(x1, y1) || !valid(x2, y2)) continue;
if (valid(x1 - 1, y1)) {
if (valid(x2 - 1, y2)) ans = max(ans, t + dp[i - 1][x1 - 1][x2 - 1]);
if (valid(x2, y2 - 1)) ans = max(ans, t + dp[i - 1][x1 - 1][x2]);
}
if (valid(x1, y1 - 1)) {
if (valid(x2 - 1, y2)) ans = max(ans, t + dp[i - 1][x1][x2 - 1]);
if (valid(x2, y2 - 1)) ans = max(ans, t + dp[i - 1][x1][x2]);
}
dp[i][x1][x2] = ans;
}
printf("%d\n", dp[2 * n - 2][n][n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int correct;
int open;
int close;
node() { correct = open = close = 0; }
node operator+(const node& rhs) const {
node ans;
ans.correct = correct + rhs.correct + min(open, rhs.close);
ans.open = rhs.open + max(0, open - rhs.close);
ans.close = close + max(0, rhs.close - open);
return ans;
}
node operator=(const char c) {
correct = 0;
open = (c == '(');
close = (c == ')');
return *this;
}
};
string s;
node seg[4004004];
node build(int id = 1, int l = 0, int r = s.size()) {
if (l == r - 1) return seg[id] = s[l];
int lChild = id * 2;
int rChild = id * 2 + 1;
int mid = (l + r) / 2;
return seg[id] = build(lChild, l, mid) + build(rChild, mid, r);
}
node getAns(int x, int y, int id = 1, int l = 0, int r = s.size()) {
if (x >= r || y <= l) return node();
if (x <= l && y >= r) return seg[id];
int lChild = id * 2;
int rChild = id * 2 + 1;
int mid = (l + r) / 2;
return getAns(x, y, lChild, l, mid) + getAns(x, y, rChild, mid, r);
}
int main() {
int m, l, r;
cin >> s >> m;
build();
while (m--) {
scanf("%d %d", &l, &r);
printf("%d\n", getAns(l - 1, r).correct * 2);
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.