solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int deep, Index, root1, root2;
int fa[100001], d[100001], f[100001], root[100001];
int a[100001], len;
double size[100001];
map<pair<int, int>, double> book;
vector<long long> v1[100001], v2[100001];
struct Edge {
int to, next;
} edge[200001];
int head[100001], cnt;
void add_edge(int u, int v) {
cnt++;
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt;
return;
}
void dfs1(int u, int father, int p) {
v1[p].push_back(u);
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == father) continue;
fa[v] = p;
dfs1(v, u, p);
}
return;
}
void dfs2(int u, int father, int sum, bool w) {
if (w != 0) f[u] = max(f[u], sum);
if (sum >= deep) {
deep = sum;
if (w == 0)
root1 = u;
else if (w == 1)
root2 = u;
}
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == father) continue;
dfs2(v, u, sum + 1, w);
}
return;
}
int main() {
memset(fa, -1, sizeof(fa));
memset(d, -1, sizeof(d));
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
}
for (int i = 1; i <= n; i++) {
if (fa[i] != -1) continue;
fa[i] = ++Index;
dfs1(i, 0, Index);
root[Index] = i;
}
for (int i = 1; i <= Index; i++) {
deep = 0;
dfs2(root[i], 0, 0, 0);
deep = 0;
dfs2(root1, 0, 0, 1);
d[i] = deep;
dfs2(root2, 0, 0, 2);
len = v1[i].size();
for (int j = 0; j < len; j++) a[j] = f[v1[i][j]];
v1[i].clear();
for (int j = 0; j < len; j++) v1[i].push_back(a[j]);
sort(v1[i].begin(), v1[i].end());
a[len] = 0;
for (int j = len - 1; j >= 0; j--) a[j] = a[j + 1] + v1[i][j] + 1;
for (int j = 0; j <= len; j++) v2[i].push_back(a[j]);
}
for (int k = 1; k <= q; k++) {
int x, y;
scanf("%d%d", &x, &y);
x = fa[x], y = fa[y];
if (x == y)
printf("-1\n");
else {
if (book[make_pair(x, y)] > 0)
printf("%.6f\n", book[make_pair(x, y)]);
else {
double ans = 0;
if (v1[x].size() <= v1[y].size()) {
for (int i = 0; i < v1[x].size(); i++) {
long long tmp = lower_bound(v1[y].begin(), v1[y].end(),
max(d[x], d[y]) - v1[x][i] - 1) -
v1[y].begin();
ans += (v2[y][tmp] + v1[x][i] * (v1[y].size() - tmp)) +
tmp * max(d[x], d[y]);
}
} else {
for (int i = 0; i < v1[y].size(); i++) {
long long tmp = lower_bound(v1[x].begin(), v1[x].end(),
max(d[x], d[y]) - v1[y][i] - 1) -
v1[x].begin();
ans += (v2[x][tmp] + v1[y][i] * (v1[x].size() - tmp)) +
tmp * max(d[x], d[y]);
}
}
ans /= (v1[x].size() * v1[y].size());
printf("%.6lf\n", ans);
book[make_pair(x, y)] = ans;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int M = 1e6 + 5;
int n, k;
int ara[N];
int cnt[M];
int vis[M], id = 1;
bool test(int m) {
int collision = 0;
for (int i = 1; i <= n; i++) {
int d = ara[i] % m;
if (vis[d] == id) {
collision++;
} else {
vis[d] = id;
}
if (collision > k) return false;
}
return collision <= k;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> ara[i];
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int d = ((ara[i] - ara[j]) < 0 ? -(ara[i] - ara[j]) : (ara[i] - ara[j]));
cnt[d]++;
}
}
for (int i = 1; i < M; i++) {
for (int j = 2 * i; j < M; j += i) {
cnt[i] += cnt[j];
}
}
for (int i = 1; i < M; i++) {
if (cnt[i] * 2 > k * (k + 1)) continue;
id++;
if (test(i)) {
cout << i << "\n";
return 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
pair<double, double> get(double a, double b, double c, double d) {
return make_pair(min(min(a * c, b * d), min(a * d, b * c)),
max(max(a * c, b * d), max(a * d, b * c)));
}
int main() {
double a, b, c, d;
cin >> a >> b >> c >> d;
double low = 0, high = 1e9, mid;
int t = 1000;
while (t--) {
mid = (low + high) / 2.0;
pair<double, double> x = get(a - mid, a + mid, d - mid, d + mid),
y = get(b - mid, b + mid, c - mid, c + mid);
if (x.first > y.second || y.first > x.second)
low = mid;
else
high = mid;
}
cout << fixed << setprecision(10) << mid << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INFll = 1000000000000000000ll, INF = 0x3f3f3f3f,
_MOD = (1000 * 1000 * 1000 + 7);
const long double EPS = 1e-8;
const long long MAXN = 2 * 100000 + 10;
long long n, m, ans, arr[MAXN];
pair<long long, long long> lr[2 * MAXN], nod[2 * MAXN];
void make_tree() {
for (long long i = 0; i < n; i++)
lr[n + i] = pair<long long, long long>(i, i + 1),
nod[n + i] = pair<long long, long long>(arr[i], arr[i]);
for (long long i = n - 1; i >= 0; i--) {
lr[i] = pair<long long, long long>(lr[(i << 1)].first,
lr[((i << 1) + 1)].second);
nod[i] = pair<long long, long long>(
max(nod[(i << 1)].first, nod[((i << 1) + 1)].first),
nod[(i << 1)].second + nod[((i << 1) + 1)].second);
}
}
void add(long long pos, long long l, long long r, long long x) {
long long lpos = lr[pos].first, rpos = lr[pos].second;
if (lpos >= r || rpos <= l) return;
if (rpos - 1 == lpos) {
long long tmp = nod[pos].second % x;
nod[pos] = pair<long long, long long>(tmp, tmp);
return;
}
if (nod[pos].first < x) return;
add((pos << 1), l, r, x), add(((pos << 1) + 1), l, r, x);
nod[pos] = pair<long long, long long>(
max(nod[(pos << 1)].first, nod[((pos << 1) + 1)].first),
nod[(pos << 1)].second + nod[((pos << 1) + 1)].second);
}
void get(long long pos, long long l, long long r) {
long long lpos = lr[pos].first, rpos = lr[pos].second;
if (lpos >= r || rpos <= l) return;
if (lpos >= l && rpos <= r) {
ans += nod[pos].second;
return;
}
get((pos << 1), l, r), get(((pos << 1) + 1), l, r);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> arr[i];
n = pow(2, ceil(log2(n)));
make_tree();
for (long long i = 0; i < m; i++) {
long long c;
cin >> c;
switch (c) {
long long l, r, x, k;
case 2:
cin >> l >> r >> x;
l--;
add(1, l, r, x);
continue;
case 1:
cin >> l >> r;
l--;
get(1, l, r);
cout << ans << "\n";
ans = 0;
continue;
case 3:
cin >> k >> x;
k--;
long long pos = k + n;
nod[pos] = pair<long long, long long>(x, x);
pos = (pos >> 1);
while (pos) {
nod[pos] = pair<long long, long long>(
max(nod[(pos << 1)].first, nod[((pos << 1) + 1)].first),
nod[(pos << 1)].second + nod[((pos << 1) + 1)].second);
pos = (pos >> 1);
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char a[101];
int b[51];
int main() {
cin >> a;
int leng = strlen(a);
for (int i = 0; i < leng; i += 2) {
b[i / 2] += a[i] - 48;
}
sort(b, b + leng / 2 + 1);
for (int i = 0; i < leng / 2; ++i) cout << b[i] << "+";
cout << b[leng / 2];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b;
while (cin >> a >> b) {
int flag = 0;
if (a > b) swap(a, b);
for (int i = 1; i < a; i++) {
int k = sqrt(a * a - i * i);
if (a * a == k * k + i * i) {
int i1, k1;
k1 = -1 * b * i / a;
i1 = k * b / a;
if (k1 * k1 + i1 * i1 != b * b) continue;
if (k * k1 + i * i1 == 0) {
flag = 1;
cout << "YES" << endl;
cout << "0 0" << endl;
cout << k << ' ' << i << endl;
cout << k1 << ' ' << i1 << endl;
break;
} else
continue;
}
}
if (flag == 0) cout << "NO" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, dad[100005], pri[100005], minpri[100005], ans, u, v;
long long anc(long long n) {
if (dad[n] != 0) {
dad[n] = anc(dad[n]);
return dad[n];
}
return n;
}
void uni(long long x, long long y) {
if (anc(x) == anc(y)) return;
minpri[anc(y)] = min(minpri[anc(y)], minpri[anc(x)]);
dad[anc(x)] = anc(y);
return;
}
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> pri[i], minpri[i] = pri[i];
for (long long i = 0; i < m; i++) {
cin >> u >> v;
uni(u, v);
}
for (long long i = 1; i <= n; i++) {
if (anc(i) == i) ans += minpri[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, i, r;
std::string s;
scanf("%d/n", &n);
for (i = 0; i < n; i++) {
std::cin >> s;
long long y = 0, ans;
int x = s.size() - 4;
for (int j = 0; j < x; j++) {
y *= 10;
y += s[j + 4] - '0';
}
if (x == 1) {
ans = 1990 + y;
if (ans == 1999) ans -= 10;
} else if (x == 2) {
ans = 2000 + y;
if (ans == 2099) ans -= 100;
} else if (x == 3) {
ans = 2000 + y;
if (ans < 2099) ans += 1000;
} else if (x == 4) {
ans = y;
if (ans < 3099) ans += 10000;
} else if (x == 5) {
ans = y;
if (ans < 13099) ans += 100000;
} else if (x == 6) {
ans = y;
if (ans < 113099) ans += 1000000;
} else if (x == 7) {
ans = y;
if (ans < 1113099) ans += 10000000;
} else if (x == 8) {
ans = y;
if (ans < 11113099) ans += 100000000;
} else if (x == 9) {
ans = y;
if (ans < 111113099) ans += 1000000000;
}
printf("%I64d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int powfi(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = (x * x) % p;
}
return res % p;
}
map<int, int> freq, M, lefte;
map<int, int>::iterator it1, it2;
int arr[100005];
int main() {
int i, j, k;
int n;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
freq[arr[i]]++;
if (lefte[arr[i]] == 0) lefte[arr[i]] = i;
}
long long int ans = 0;
for (i = n; i >= 1; i--) {
M[arr[i]]++;
if (lefte[arr[i]] != i) continue;
ans += (M.size() - 1);
}
for (it1 = freq.begin(); it1 != freq.end(); it1++) {
if (it1->second > 1) ans++;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int ckmax(int &a, int b) { return a < b ? a = b, 1 : 0; }
inline int ckmin(int &a, int b) { return a > b ? a = b, 1 : 0; }
int n, a[100100];
set<int> q;
map<int, int> dp;
int main() {
scanf("%d", &n);
scanf("%d", a + 1);
q.insert(a[1]);
dp[a[1]] = 1;
for (int i = 2; i <= n; ++i) {
scanf("%d", a + i);
auto it1 = q.lower_bound(a[i]);
if (it1 == q.begin()) {
dp[a[i]] = dp[*it1] + 1;
printf("%d ", *it1);
} else if (it1 == q.end()) {
it1--;
dp[a[i]] = dp[*it1] + 1;
printf("%d ", *it1);
} else {
int p = *it1;
it1--;
int q = *it1;
if (dp[q] > dp[p]) p = q;
printf("%d ", p);
dp[a[i]] = dp[p] + 1;
}
q.insert(a[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-6;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int m = n;
if (m % 2 != 0) {
m -= 3;
}
m /= 2;
if (n % 2 == 1) {
cout << 7;
}
while (m--) {
cout << 1;
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 1e3;
vector<pair<int, int> > al[Maxn];
vector<pair<int, pair<int, int> > > edge;
int sub[Maxn];
int Edge[Maxn];
long double ans = 0;
int dfs(int v, int p) {
int ret = 1;
for (int i = 0; i < al[v].size(); i++) {
int u = al[v][i].first;
if (u == p) continue;
ret += dfs(u, v);
}
sub[v] = ret;
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
al[--v].push_back(make_pair(--u, w));
al[u].push_back(make_pair(v, w));
edge.push_back(make_pair(w, make_pair(u, v)));
Edge[i] = w;
}
dfs(0, -1);
for (int i = 0; i < n - 1; i++) {
int u = edge[i].second.first, v = edge[i].second.second;
long double w = edge[i].first;
long double num = min(sub[u], sub[v]);
long double t = n - num;
ans += (((t * (t - 1)) / 2) * num) * w * 3;
ans += (((num * (num - 1)) / 2) * t) * w * 3;
}
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int edgenum, newW;
scanf("%d%d", &edgenum, &newW);
int u = edge[--edgenum].second.first, v = edge[edgenum].second.second;
long double w = newW - Edge[edgenum];
Edge[edgenum] = newW;
long double num = min(sub[u], sub[v]);
long double t = n - num;
ans += (((t * (t - 1)) / 2) * num) * w * 3;
ans += (((num * (num - 1)) / 2) * t) * w * 3;
cout << setprecision(9) << fixed
<< (((long double)6 * ans /
((long double)n * ((long double)n - 1) * ((long double)n - 2))) *
(long double)2) /
3
<< endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110000];
map<int, int> mp;
int main() {
long long ans;
int i, j, k, b, n, tot, tmp, z;
scanf("%d%d%d", &k, &b, &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
mp.clear();
mp[0]++;
tot = 0;
ans = 0;
z = 0;
for (i = 0; i < n; i++) {
tot += a[i];
tot %= (k - 1);
if (a[i] == 0)
z++;
else
z = 0;
tmp = (tot + (k - 1) - b) % (k - 1);
if ((b == (k - 1)) || (b == 0)) {
if (b == 0)
ans += z;
else
ans += (mp[tmp] - z);
} else {
ans += mp[tmp];
}
mp[tot]++;
}
printf("%I64d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, an, A[200005];
struct cmp {
bool operator()(const int &a, const int &b) const {
return A[a] ^ A[b] ? A[a] < A[b] : b < a;
}
};
set<int, cmp> Set;
inline int IN() {
char c;
register int x = 0;
for (; (c = getchar()) < 48;)
;
for (; c > 47; (c = getchar())) x = x * 10 + c - 48;
return x;
}
inline void hello() { freopen("ha.in", "r", stdin); }
inline void bye() {
fprintf(stderr, "Ò®!\n");
exit(0);
}
int main() {
n = IN();
a = IN();
b = IN();
c = IN();
if (a > b) swap(a, b);
if (a > c) swap(a, c);
if (b > c) swap(b, c);
for (int _r = n, i = 1; i <= _r; ++i) {
A[i] = IN();
Set.insert(i);
}
for (; Set.size();) {
int i = *Set.rbegin();
set<int, cmp>::iterator j;
++an;
Set.erase(i);
if (a >= A[i]) {
if (Set.size()) Set.erase(Set.begin());
if (Set.size()) Set.erase(Set.begin());
} else if (b >= A[i]) {
A[0] = a;
j = Set.upper_bound(0);
if (j != Set.begin()) Set.erase(--j);
A[0] = c;
j = Set.upper_bound(0);
if (j != Set.begin()) Set.erase(--j);
} else if (c >= A[i]) {
int u = 0, v = 0;
A[0] = a;
j = Set.upper_bound(0);
if (j != Set.begin()) u = *(--j), Set.erase(j);
A[0] = b;
j = Set.upper_bound(0);
if (j != Set.begin()) v = *(--j), Set.erase(j);
if (!u || !v) {
if (u) Set.insert(u);
if (v) Set.insert(v);
A[0] = a + b;
j = Set.upper_bound(0);
if (j != Set.begin()) Set.erase(--j);
}
} else if (a + b >= A[i]) {
A[0] = c;
j = Set.upper_bound(0);
if (j != Set.begin()) Set.erase(--j);
} else if (a + c >= A[i]) {
A[0] = b;
j = Set.upper_bound(0);
if (j != Set.begin()) Set.erase(--j);
} else if (b + c >= A[i]) {
A[0] = a;
j = Set.upper_bound(0);
if (j != Set.begin()) Set.erase(--j);
} else if (a + b + c < A[i])
return puts("-1"), 0;
}
printf("%d\n", an);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i];
if (i != (int)v.size() - 1) os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
long long binpow(long long a, long long b, long long p) {
if (b == 0) return 1;
long long t = binpow(a, b / 2, p);
if (b % 2)
return (((a * t) % p) * t) % p;
else
return ((t * t) % p);
}
void solve() {
int n, q;
string s;
cin >> n >> q >> s;
vector<int> od(n + 1, 0), ev(n + 1, 0);
for (int i = 0; i < n; i++) {
if ((i + 1) % 2) {
od[i + 1] = od[i] + (s[i] == '+' ? 1 : -1);
ev[i + 1] = ev[i];
} else {
ev[i + 1] = ev[i] + (s[i] == '+' ? 1 : -1);
od[i + 1] = od[i];
}
}
42;
while (q--) {
int l, r;
cin >> l >> r;
if (l == r) {
cout << "1\n";
continue;
}
long long x, y;
if (l % 2) {
x = od[r] - od[l - 1], y = ev[r] - ev[l - 1];
} else {
y = od[r] - od[l - 1], x = ev[r] - ev[l - 1];
}
if (x - y == 0)
cout << "0\n";
else if (abs(x - y) % 2 == 1)
cout << "1\n";
else
cout << "2\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m1;
map<long long int, long long int>::iterator itr;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, a, b;
cin >> n >> a >> b;
double x;
vector<double> v;
for (long long int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
long long int z = (n - a - b);
sort(v.begin(), v.end());
if (z > 0) v.erase(v.begin(), v.begin() + z);
if (a < b) swap(a, b);
double sum2 = 0, sum1 = 0;
for (long long int i = 0; i < a; i++) sum1 += v[i];
for (long long int i = a; i < v.size(); i++) sum2 += v[i];
double ans = 1.0 * sum1 / a;
ans += 1.0 * sum2 / b;
printf("%.12lf\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void stress();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
stress();
}
const long long inf = 1e9 + 1;
struct node {
long long sum;
long long p;
node *l, *r;
node() : sum(0), p(inf), l(0), r(0){};
};
void push(node *&t, long long tl, long long mid, long long tr) {
if (t->p != inf) {
if (t->l == 0) t->l = new node();
if (t->r == 0) t->r = new node();
t->l->sum = (mid - tl + 1) * t->p;
t->r->sum = (tr - mid) * t->p;
t->r->p = t->l->p = t->p;
t->p = inf;
}
}
long long getsum(node *&t, long long tl, long long tr, long long l,
long long r) {
if (tl == l && tr == r) return t->sum;
long long mid = tl + tr >> 1;
push(t, tl, mid, tr);
long long ans = 0;
if (l <= mid) ans += getsum(t->l, tl, mid, l, min(r, mid));
if (r > mid) ans += getsum(t->r, mid + 1, tr, max(l, mid + 1), r);
return ans;
}
long long sum(node *t) {
if (!t) return 0;
return t->sum;
}
void update(node *&t, long long tl, long long tr, long long l, long long r,
long long x) {
if (tl == l && tr == r) {
t->sum = (tr - tl + 1) * x;
t->p = x;
return;
}
long long mid = tl + tr >> 1;
push(t, tl, mid, tr);
if (l <= mid) update(t->l, tl, mid, l, min(r, mid), x);
if (r > mid) update(t->r, mid + 1, tr, max(l, mid + 1), r, x);
t->sum = sum(t->l) + sum(t->r);
}
void solveE() {
node *t = new node();
t->p = 0;
long long q;
cin >> q;
set<pair<long long, long long>> events;
while (q--) {
long long type;
cin >> type;
if (type == 1) {
long long T, s;
cin >> T >> s;
events.insert({T, s});
long long to = 1e9;
auto it = events.upper_bound({T, s});
if (it != events.end()) to = it->first - 1;
update(t, 1, 1e9, T, to, s);
} else if (type == 2) {
long long T;
cin >> T;
auto it = events.lower_bound({T, -1e9 - 1});
long long val = 0;
if (it != events.begin()) {
auto it2 = prev(it);
val = it2->second;
}
long long to = 1e9;
if (next(it) != events.end()) {
auto it2 = next(it);
to = it2->first;
}
update(t, 1, 1e9, T, to, val);
events.erase(it);
} else {
long long l, r, v;
cin >> l >> r >> v;
if (getsum(t, 1, 1e9, l, r - 1) > v)
cout << -1;
else {
long long asd = 50;
double ll = l, rr = r;
while (asd--) {
double mid = (ll + rr) / 2;
long long mm = mid;
double val = 0;
if (mm > l) {
val += getsum(t, 1, 1e9, l, mm - 1);
}
double res = mid - mm;
auto it = events.upper_bound({mm, -inf});
long long vv = 0;
if (it != events.begin()) {
it--;
vv = it->second;
}
val += vv * res;
if (val >= v) {
rr = mid;
} else
ll = mid;
}
cout << rr - l << endl;
}
}
}
}
void stress() {
string s;
cin >> s;
if (s.size() % 2 == 1) {
string l = s.substr(0, s.size() / 2);
string r = s.substr((s.size() + 1) / 2, s.size());
if (l != r) {
cout << 2 << endl;
} else {
set<char> sss;
for (auto it : l) sss.insert(it);
if (sss.size() > 1) {
cout << 2;
} else
cout << "Impossible";
}
} else {
string l = s.substr(0, s.size() / 2);
string r = s.substr((s.size() + 1) / 2, s.size());
if (l != r)
cout << 1;
else {
set<char> sss;
for (auto it : l) sss.insert(it);
if (sss.size() > 1) {
s += s;
long long len = s.size() / 2;
for (long long i = 1; i < len; i++) {
bool fl = true;
bool dif = false;
for (long long j = 0; j < len / 2; j++) {
if (s[i + j] != l[j]) dif = true;
if (s[i + j] != s[len + i - j - 1]) fl = false;
}
if (fl && dif) {
cout << 1;
return;
}
}
cout << 2;
} else
cout << "Impossible";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
std::vector<int> adj[100010], level[100010];
int v[100010], par[100010], Level[100010], t = 0, dis[100010], fin[100010];
void dfs(int s, int l) {
if (v[s]) return;
v[s] = 1;
dis[s] = t++;
for (int i = 0; i < adj[s].size(); ++i) {
int t = adj[s][i];
if (!v[t]) {
par[t] = s;
dfs(t, l + 1);
}
}
level[l].push_back(t);
fin[s] = t++;
Level[s] = l;
}
int anch[100010][35];
void sparse_table(int n) {
for (int i = 0; (1 << i) <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (!i)
anch[j][i] = par[j];
else if (anch[j][i - 1] != -1)
anch[j][i] = anch[anch[j][i - 1]][i - 1];
}
}
int parent(int x, int p) {
for (int i = 30; i >= 0; i--) {
if ((p >= (1 << i)) and anch[x][i] != -1) {
p -= (1 << i);
x = anch[x][i];
}
}
return x;
}
int main() {
memset(anch, -1, sizeof anch);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
if (x) adj[x].push_back(i);
}
for (int i = 1; i <= n; ++i)
if (!v[i]) par[i] = -1, dfs(i, 0);
sparse_table(n);
int q;
cin >> q;
while (q--) {
int p, x;
cin >> x >> p;
if (Level[x] < p or par[x] == -1)
printf("0 ");
else {
int l = Level[x];
int P = parent(x, p);
int up = upper_bound(level[l].begin(), level[l].end(), fin[P]) -
level[l].begin();
int lo = lower_bound(level[l].begin(), level[l].end(), dis[P]) -
level[l].begin();
printf("%d ", up - lo - 1);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[300000];
int main() {
int n;
cin >> n;
priority_queue<long long int> que;
for (int i = 0; i < n; ++i) {
long long int temp;
cin >> temp;
que.push(temp);
}
long long int score = 0;
while (que.size() > 1) {
long long int top1 = que.top();
que.pop();
long long int top2 = que.top();
que.pop();
score += (top1 + top2);
que.push(top1 + top2);
}
score += que.top();
cout << score << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long mod) {
long long c = 1;
while (b > 0) {
if (b % 2) c *= a, c %= mod;
b /= 2;
a *= a;
a %= mod;
}
return c;
}
const long long N = (1e5) + 10;
const long long M = 320;
const long long Mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(25);
long long n, k, j, c, r;
long long t;
cin >> n;
string a, b;
long long ans = 0;
cin >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) continue;
if (i < n - 1 && a[i] == b[i + 1] && a[i + 1] == b[i]) {
ans++;
i++;
continue;
}
ans++;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 1E5 + 77;
struct EDGE {
int to, next;
} edges[maxn * 2];
int cEdge = 1, head[maxn];
void addEdge(int from, int to) {
edges[cEdge] = (EDGE){to, head[from]};
head[from] = cEdge++;
}
int F[maxn], G[maxn];
int dfs(int u, int f) {
F[u] = 0;
G[u] = 1;
int maxf = 0, maxf2 = 0, maxg = 0, maxg2 = 0, maxm = 0, maxm2 = 0, ch = 0,
ma = 0;
for (int k = head[u]; k; k = edges[k].next) {
int v = edges[k].to;
if (v == f) continue;
ma = std::max(ma, dfs(v, u));
if (F[v] >= maxf) {
maxf2 = maxf;
maxf = F[v];
} else if (F[v] >= maxf2) {
maxf2 = F[v];
}
if (G[v] >= maxg) {
maxg2 = maxg;
maxg = G[v];
} else if (G[v] >= maxg2) {
maxg2 = G[v];
}
int m = std::max(F[v], G[v]);
if (m >= maxm) {
maxm2 = maxm;
maxm = m;
} else if (m >= maxm2) {
maxm2 = m;
}
++ch;
}
if (ch) {
F[u] += std::max(maxf, maxg) + ch - 1;
G[u] += maxf;
if (ch >= 2) {
ma = std::max(ma, ch - 2 + maxm + maxm2 + (f ? 1 : 0));
return std::max(ma, maxf + maxf2 + 1);
}
ma = std::max(ma, maxm + (f ? 1 : 0));
return std::max(ma, maxf + 1);
}
return 1;
}
int N;
int main() {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int a, b;
scanf("%d%d", &a, &b);
addEdge(a, b);
addEdge(b, a);
}
printf("%d\n", dfs(1, 0));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(__rdtsc());
int n, d, h;
cin >> n >> d >> h;
if (d > 2 * h || d < h || n <= h || n <= d) {
cout << -1 << endl;
return 0;
}
if (d == h) {
if (h == 1) {
if (n == 2)
cout << "1 2" << endl;
else
cout << -1 << endl;
return 0;
}
for (int i = 2; i <= h + 1; i++) cout << (i - 1) << " " << i << endl;
for (int i = h + 2; i <= n; i++) cout << 2 << " " << i << endl;
return 0;
}
for (int i = 1; i <= h; i++) cout << i << " " << i + 1 << endl;
int cur = h + 2;
cout << 1 << " " << cur << endl;
cur++;
while (cur <= d + 1) {
cout << (cur - 1) << " " << cur << endl;
cur++;
}
for (int i = cur; i <= n; i++) cout << 1 << " " << i << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double eps = (1e-9);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(int num, int idx) { return num ^ (1 << idx); }
void FS() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 100009;
int h[N], L[N], R[N];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> h[i], L[i] = h[i], R[i] = h[i];
h[0] = h[n + 1] = 0;
for (int i = 1; i <= n; i++) L[i] = min(L[i - 1] + 1, L[i]);
for (int i = n; i >= 1; i--) R[i] = min(R[i + 1] + 1, R[i]);
int mx = 0;
for (int i = 1; i <= n; i++) {
mx = max(mx, min(L[i], R[i]));
}
cout << mx << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[50010];
int b[50010];
int main() {
int n, r1, r2;
scanf("%d%d%d", &n, &r1, &r2);
r1--;
r2--;
for (int i = 0; i < n; i++) {
if (i != r1) {
scanf("%d", &a[i]);
a[i]--;
b[i] = a[i];
}
}
int r = r2;
for (int i = 0; i < n; i++) {
int t = r;
r = a[t];
b[a[t]] = t;
if (r == r1) {
break;
}
}
for (int i = 0; i < n; i++) {
if (i != r2) {
printf("%d ", (b[i] + 1));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t[110], x, a, b;
cin >> n >> m;
int suma, res = 0, clave = 0;
t[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
t[i] = x + t[i - 1];
}
for (int i = 0; i < m; i++) {
cin >> a >> b;
suma = t[b] - t[a - 1];
if (suma > 0) clave += suma;
}
cout << clave << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<char, int> a, pair<char, int> b) { return a.second > b.second; }
int main() {
int i, j, k;
int n, m, t;
string s;
map<char, int> mp;
map<char, bool> ch;
map<char, int> cnt;
for (i = 'a'; i <= 'j'; i++) mp[i] = -1;
cin >> n;
string a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
ch[a[i][0]] = 1;
}
for (i = 0; i < n; i++) {
k = 1;
s = a[i];
for (j = s.length() - 1; j >= 0; j--) {
cnt[s[j]] += k;
k *= 10;
}
}
map<char, int>::iterator p = cnt.begin();
vector<pair<char, int> > v;
while (p != cnt.end()) {
v.push_back({p->first, p->second});
p++;
}
sort(v.begin(), v.end(), cmp);
j = 1, t = 0;
for (i = 0; i < v.size(); i++) {
if (ch[v[i].first]) {
if (mp[v[i].first] == -1) mp[v[i].first] = j, j++;
} else {
if (mp[v[i].first] == -1) {
if (!t)
mp[v[i].first] = 0, t++;
else
mp[v[i].first] = j, j++;
}
}
}
int sum = 0;
p = cnt.begin();
while (p != cnt.end()) {
sum += (p->second * mp[p->first]);
p++;
}
cout << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Size1[1000010], Size2[1000010], f1[1000010], f2[1000010];
int find1(int x) { return f1[x] ? f1[x] = find1(f1[x]) : x; }
int find2(int x) { return f2[x] ? f2[x] = find2(f2[x]) : x; }
void union1(int x, int y) {
if ((x = find1(x)) != (y = find1(y))) f1[x] = y, Size1[y] += Size1[x];
}
void union2(int x, int y) {
if ((x = find2(x)) != (y = find2(y))) f2[x] = y, Size2[y] += Size2[x];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) Size1[i] = Size2[i] = 1;
for (int i = 1, x, y, z; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
if (z)
union2(x, y);
else
union1(x, y);
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans += (long long)Size1[find1(i)] * Size2[find2(i)] - 1;
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(0), cout.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
if (n % 2 == 1) {
cout << arr[n / 2] << "\n";
} else {
cout << arr[n / 2 - 1] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
bool t[maxn];
int des[maxn];
int cont[maxn];
long long mod = 1e9 + 7;
const long long div5 = 400000003;
long long pows[maxn] = {1, 5};
struct merg {
int nuo, iki, del;
long long val;
bool kaire, desine;
bool operator==(const merg& kitas) { return val == kitas.val; }
merg() {}
merg(int a, int b, long long c, bool d, bool e, int f) {
nuo = a;
iki = b;
val = c;
kaire = d;
desine = e;
del = f;
}
};
int len(const merg& a) { return a.iki - a.nuo + 1 - 2 * a.del; }
merg merge(const merg& a, const merg& b) {
if (a.desine && b.kaire) {
if (len(a) == 1 && len(b) == 1)
return merg(a.nuo, b.iki, 0, 0, 0, a.del + b.del + 1);
if (len(a) == 1)
return merg(a.nuo, b.iki, (b.val - 1 + mod) % mod * div5 % mod,
len(b) == 2 ? b.desine : 0, b.desine, a.del + b.del + 1);
if (len(b) == 1)
return merg(a.nuo, b.iki, (a.val - pows[len(a) - 1] + mod) % mod, a.kaire,
len(a) == 2 ? a.kaire : 0, a.del + b.del + 1);
long long l = (a.val - pows[len(a) - 1] + mod) % mod;
long long r = (b.val - 1 + mod) % mod * pows[len(a) - 2] % mod;
return merg(a.nuo, b.iki, (l + r) % mod, a.kaire, b.desine,
a.del + b.del + 1);
}
if (len(a) == 0)
return merg(a.nuo, b.iki, b.val, b.kaire, b.desine, a.del + b.del);
if (len(b) == 0)
return merg(a.nuo, b.iki, a.val, a.kaire, a.desine, a.del + b.del);
return merg(a.nuo, b.iki, (a.val + b.val * pows[len(a)] % mod) % mod, a.kaire,
b.desine, a.del + b.del);
}
struct node {
merg info;
node *left, *right;
merg get(int a, int b) {
if (a <= info.nuo && b >= info.iki) return info;
if (b < right->info.nuo) return left->get(a, b);
if (a > left->info.iki) return right->get(a, b);
auto aaa = merge(left->get(a, b), right->get(a, b));
return aaa;
}
node(int a, int b) {
if (a == b) {
left = 0;
right = 0;
info = merg(a, b, t[a], t[a], t[a], 0);
} else {
left = new node(a, (a + b) / 2);
right = new node((a + b) / 2 + 1, b);
info = merge(left->info, right->info);
}
}
};
long long powa(long long a, long long p) {
if (p == 1) return a;
long long pk = powa(a * a % mod, p / 2);
if (p % 2) return pk % mod * a % mod;
return pk % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
string tt;
cin >> n >> tt >> q;
for (int i = 0; i < n; ++i) {
t[i] = tt[i] - '0';
}
des[n - 1] = t[n - 1];
for (int i = n - 2; i >= 0; --i) {
des[i] = des[i + 1] + t[i];
}
cont[n - 1] = t[n - 1];
for (int i = n - 2; i >= 0; --i) {
cont[i] = cont[i + 1] + t[i];
if (!t[i]) cont[i] = 0;
}
for (int i = 2; i < n; ++i) {
pows[i] = pows[i - 1] * pows[1] % mod;
}
node medis(0, n - 1);
for (int i = 0; i < q; ++i) {
int l1, l2, len;
cin >> l1 >> l2 >> len;
int a = des[--l1];
int b = des[--l2];
if (l1 + len - 1 < n - 1) a -= des[l1 + len];
if (l2 + len - 1 < n - 1) b -= des[l2 + len];
if (a != b) {
cout << "No\n";
continue;
}
cout << (medis.get(l1, l1 + len - 1) == (medis.get(l2, l2 + len - 1))
? "Yes"
: "No")
<< '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, s[2], s0, s1, a[200005], b[3005][3005], b0, b1, d[200005],
f[200005];
int Pow(int x, int y) {
int s = 1;
for (; y; y >>= 1, x = (long long)x * x % 998244353)
if (y & 1) s = (long long)s * x % 998244353;
return s;
}
int main() {
scanf("%d%d", &n, &m);
b[0][0] = 1;
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 1; i <= n; i++) scanf("%d", d + i);
for (i = 1; i <= n; i++) s[a[i]] += d[i];
for (i = -m; i <= m; i++) f[i + m] = Pow(s[0] + s[1] + i, 998244353 - 2);
for (i = 0; i < m; i++)
for (j = 0; j <= i; j++)
if (b[i][j]) {
k = f[j * 2 - i + m];
b[i + 1][j] = (b[i + 1][j] +
(long long)b[i][j] * k % 998244353 * (s[0] - i + j)) %
998244353;
b[i + 1][j + 1] = (b[i + 1][j + 1] +
(long long)b[i][j] * k % 998244353 * (s[1] + j)) %
998244353;
}
s0 = Pow(s[0], 998244353 - 2);
s1 = Pow(s[1], 998244353 - 2);
for (i = 0; i <= m; i++) {
b0 = (b0 + (long long)i * b[m][m - i]) % 998244353;
b1 = (b1 + (long long)i * b[m][i]) % 998244353;
}
b0 = (998244353 - b0) % 998244353;
for (i = 1; i <= n; i++)
if (a[i])
printf("%d\n",
(d[i] + (long long)b1 * d[i] % 998244353 * s1) % 998244353);
else
printf("%d\n",
(d[i] + (long long)b0 * d[i] % 998244353 * s0) % 998244353);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,abm,mmx,avx,avx2,popcnt")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1& x, const T2& y) {
if (y < x) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1& x, const T2& y) {
if (x < y) x = y;
}
mt19937 rnd(time(0));
int mod = 1000000007;
int mul(int a, int b) { return 1ll * a * b % mod; }
int add(int a, int b) {
if (a + b >= mod) return a + b - mod;
return a + b;
}
int sub(int a, int b) {
if (a - b < 0) return a - b + mod;
return a - b;
}
int binpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
const int MAXN = 2e5 + 228;
int inv(int x) { return binpow(x, mod - 2); }
int fact[MAXN];
int rfact[MAXN];
int cnk(int n, int k) {
if (k < 0 || k > n) return 0;
return mul(fact[n], mul(rfact[k], rfact[n - k]));
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout.precision(20), cout.setf(ios::fixed);
fact[0] = 1;
for (int i = 1; i < MAXN; ++i) fact[i] = mul(fact[i - 1], i);
rfact[MAXN - 1] = inv(fact[MAXN - 1]);
for (int i = MAXN - 2; i >= 0; --i) rfact[i] = mul(rfact[i + 1], i + 1);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
if (n % 2 == 0) {
int am = 0;
for (int bt = 0; bt < n; bt += 2) {
am = add(am, cnk(n, bt));
}
int gl = binpow(2, n);
int ans = 0;
int nw = 1;
for (int fbt = k - 1; fbt >= 0; --fbt) {
ans = add(ans, mul(nw, binpow(gl, fbt)));
nw = mul(nw, am);
}
ans = add(ans, nw);
cout << ans << endl;
} else {
int am = 1;
for (int bt = 0; bt <= n; bt += 2) {
am = add(am, cnk(n, bt));
}
am = binpow(am, k);
cout << am << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<int> a(n), peak(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n - 1; i++) {
if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
peak[i] = 1;
}
}
for (int i = n - 2; i > 0; i--) {
peak[i] += peak[i + 1];
}
int ans = 0, pos;
for (int i = n - 1; i >= 0; i--) {
if (i + k > n) continue;
if (peak[i + 1] - peak[i + k - 1] >= ans) {
ans = peak[i + 1] - peak[i + k - 1];
pos = i + 1;
}
}
cout << ans + 1 << " " << pos << "\n";
}
int main(void) {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char name[10];
scanf("%s", name);
int n, h;
scanf("%d %d", &n, &h);
if (name[0] == 'B') {
printf("%d\n", n);
return 0;
} else {
double ans = n * 1.0;
for (int i = 1; i <= h; i++)
for (int j = 1; j <= n; j++) {
double tmp = 1.0;
tmp *= (n - j);
tmp *= 1 / pow(2, 2 * i);
tmp *= pow(1 - 1 / pow(2, i), j - 1);
tmp *= pow(2, i) - pow(2, i - 1) * (1 + (j - 1) / (pow(2, i) - 1));
ans += tmp;
}
printf("%.10lf\n", ans);
return 0;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1, x2), gn(x3, x4);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
long long a[110];
int main() {
long long p, q;
gn(p, q);
int n;
gn(n);
for (int i = 1; i <= n; i++) gn(a[i]);
for (int i = 1; i <= n; i++) {
double first = 1. * p - 1. * a[i] * q, second = 1. * q;
if (first > second || first < -1e-7) {
puts("NO");
return 0;
}
long long tmp = p - a[i] * q;
p = q;
q = tmp;
}
if (p && q == 0)
puts("YES");
else
puts("NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[109][109];
struct arr {
int val, x, y;
} b[109], c[109];
int main() {
int n, i, j, t1, t2;
char cc;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> cc;
a[i][j] = (cc == '.') ? 1 : 0;
}
}
t1 = 0, t2 = 0;
bool f1, f2;
for (i = 0; i < n; i++) {
f1 = 0;
f2 = 0;
for (j = 0; j < n; j++) {
if (a[i][j] == 1 && !f1) {
t1++;
b[i].val = 1;
b[i].x = i;
b[i].y = j;
f1 = 1;
}
if (a[j][i] == 1 && !f2) {
t2++;
c[i].val = 1;
c[i].x = j;
c[i].y = i;
f2 = 1;
}
}
}
if (t1 == n) {
for (i = 0; i < n; i++) {
cout << b[i].x + 1 << " " << b[i].y + 1 << endl;
}
} else if (t2 == n) {
for (i = 0; i < n; i++) {
cout << c[i].x + 1 << " " << c[i].y + 1 << endl;
}
} else {
cout << "-1";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, num;
stack<int> s;
string str;
int res;
int main() {
cin >> n;
int start = 1;
for (int i = (1); i <= 2 * n; i++) {
cin >> str;
if (str == "add") {
cin >> num;
s.push(num);
} else {
if (s.empty() == false) {
if (s.top() == start)
s.pop();
else {
res++;
while (!s.empty()) s.pop();
}
}
start++;
}
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
long long res = 0, t;
if (e > f) {
t = min(a, d);
res += t * e;
a -= t;
d -= t;
t = min(b, min(c, d));
res += t * f;
b -= t;
c -= t;
d -= t;
} else {
t = min(b, min(c, d));
res += t * f;
b -= t;
c -= t;
d -= t;
t = min(a, d);
res += t * e;
a -= t;
d -= t;
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m;
int main() {
cin >> t;
while (t--) {
cin >> n >> m;
long long sum = (n + 1) * n / 2;
n -= m;
long long sum0 = n / (m + 1);
long long mod = n % (m + 1);
if (mod != 0) {
sum = sum - (1 + sum0 + 1) * (sum0 + 1) / 2 * mod -
(1 + sum0) * sum0 / 2 * (m + 1 - mod);
cout << sum << endl;
} else {
sum -= (1 + sum0) * sum0 / 2 * (m + 1);
cout << sum << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
vector<int> a(n);
int zero = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) zero = i;
}
int pre;
int ze = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
if (ze == 0) {
if (i == 0)
pre = -1;
else
pre = a[i - 1];
}
ze++;
} else {
if (ze > 0) {
for (int j = 1; j <= ze; j++) {
a[i - j] = ((pre) > (a[i]) ? (pre) : (a[i]));
}
ze = 0;
}
}
}
if (ze > 0) {
if (pre == -1) {
cout << "YES" << endl;
for (int i = 0; i < n - 1; i++) printf("%d ", q);
cout << q << endl;
return 0;
}
for (int j = 1; j <= ze; j++) {
a[n - j] = pre;
}
}
vector<int> r(q + 1, -1);
for (int i = 0; i < n; i++) {
r[a[i]] = i;
}
if (r[q] == -1 && zero == -1) {
cout << "NO" << endl;
return 0;
}
stack<int> st;
st.push(-1);
for (int i = 0; i < n; i++) {
if (a[i] > st.top()) {
st.push(a[i]);
} else if (a[i] < st.top()) {
while (st.top() > a[i]) {
if (r[st.top()] > i) {
cout << "NO" << endl;
return 0;
}
st.pop();
}
}
}
cout << "YES" << endl;
if (r[q] == -1) a[zero] = q;
for (int i = 0; i < n - 1; i++) printf("%d ", a[i]);
cout << a[n - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int c[4], x[3], y[3];
for (int i = 0; i < 4; ++i) {
cin >> c[i];
}
for (int i = 0; i < 3; ++i) {
cin >> x[i] >> y[i];
}
if (x[2] - x[1] == 0 && abs(c[0]) + abs(c[1]) > 0) {
return false;
}
if (y[2] - y[1] == 0 && abs(c[2]) + abs(c[3]) > 0) {
return false;
}
int nx = x[0] + c[1] - c[0];
int ny = y[0] + c[3] - c[2];
return (nx >= x[1] && nx <= x[2] && ny >= y[1] && ny <= y[2]);
}
int main() {
int t;
cin >> t;
while (t--) {
bool ok = solve();
cout << (ok ? "Yes" : "No") << "\n";
}
fclose(stdin);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void read(int& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int n, i, j, p, fir, x, top, q[100010];
char c, fc;
bool odd;
void add(char c) {
x = (c == '+');
q[++top] = x;
while (top > 1 && q[top] == q[top - 1]) top -= 2;
}
int main() {
fir = 0;
odd = 0;
for (c = getchar(); c > 32; c = getchar()) {
odd = !odd;
add(c);
}
if ((top == 0))
printf("Yes\n");
else
printf("No\n");
scanf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using tri = std::vector<std::vector<int64_t> >;
tri pascal(int nmax) {
tri t(nmax + 1, {1});
for (int n = 1; n <= nmax; n++) {
for (int r = 1; r < n; r++) t[n].push_back(t[n - 1][r - 1] + t[n - 1][r]);
t[n].push_back(1);
}
return t;
}
int64_t gridPaths(int w, int h, const tri& t) { return t[w + h - 2][w - 1]; }
using cell = std::pair<int, int>;
struct entry {
int64_t paths;
cell loc;
bool down;
};
bool formBasis(std::vector<entry>& e, int64_t max) {
std::sort(e.begin(), e.end(),
[](entry a, entry b) { return a.paths < b.paths; });
int64_t covered = 0;
for (entry x : e) {
int64_t maxNext = covered + 1;
if (x.paths > maxNext) return false;
covered += x.paths;
if (covered >= max) return true;
}
return false;
}
int main() {
const int widths[]{25, 10, 5};
const int H = 50;
const int W = 25 + 10 + 5 + 3;
const int boxHeight = H - 2;
const int64_t nmax = 1000000000000000000;
const auto t = pascal(H * 2);
std::vector<cell> lockDown, lockRight;
std::vector<entry> e;
int col = 0;
for (int width : {25, 10, 5}) {
for (int h = 1; h <= boxHeight; h++)
e.push_back({gridPaths(width, h, t), {boxHeight + 1 - h, col}, false});
for (int w = 1; w <= width; w++)
e.push_back({gridPaths(w, boxHeight, t), {0, col + width + 1 - w}, true});
for (int r = 1; r <= boxHeight; r++) {
lockRight.emplace_back(r, col);
if (col + width < W - 1) lockRight.emplace_back(r, col + width);
}
if (col == 0) lockRight.emplace_back(H - 1, width - 1);
for (int c = col + 1; c <= col + width; c++) {
lockDown.emplace_back(0, c);
if (col != 0) lockDown.emplace_back(boxHeight, c - 1);
}
col += width + 1;
}
if (!formBasis(e, nmax)) throw new std::logic_error(">:[");
int64_t n;
std::cin >> n;
for (auto i = e.crbegin(); i != e.crend(); ++i) {
if (i->paths <= n) {
n -= i->paths;
auto& lockV = i->down ? lockDown : lockRight;
lockV.erase(std::find(lockV.begin(), lockV.end(), i->loc));
}
}
std::cout << H << ' ' << W << '\n'
<< lockRight.size() + lockDown.size() << '\n';
for (cell x : lockRight)
std::cout << x.first + 1 << ' ' << x.second + 1 << ' ' << x.first + 1 << ' '
<< x.second + 2 << '\n';
for (cell x : lockDown)
std::cout << x.first + 1 << ' ' << x.second + 1 << ' ' << x.first + 2 << ' '
<< x.second + 1 << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
void f(int ind1, int ind2, char t);
using namespace std;
char **p;
int n, m;
int main(int argc, char *argv[]) {
cin >> n >> m;
p = new char *[n];
for (int i = 0; i < n; i++) p[i] = new char[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char t;
cin >> t;
p[i][j] = t;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (p[i][j] == '0') continue;
f(i, j, p[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (p[i][j] != '0') printf("%c", p[i][j]);
}
}
return EXIT_SUCCESS;
}
void f(int ind1, int ind2, char t) {
for (int i = 0; i < n; i++) {
if (p[i][ind2] == t && t != '0' && i != ind1) {
p[i][ind2] = '0';
p[ind1][ind2] = '0';
f(i, ind2, t);
}
}
for (int i = 0; i < m; i++) {
if (p[ind1][i] == t && t != '0' && i != ind2) {
p[ind1][i] = '0';
p[ind1][ind2] = '0';
f(ind1, i, t);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template <class T, class R>
ostream& operator<<(ostream& os, pair<T, R>& v) {
os << '(' << v.first << ' ' << v.second << ')' << ' ';
return os;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto i : v) os << i << " ";
return os;
}
template <class T>
ostream& operator<<(ostream& os, set<T>& v) {
for (auto i : v) os << i << " ";
return os;
}
unordered_map<string, string*> some;
struct Node {
Node* parent;
vector<Node*> children;
int wordsCount;
string* word;
Node(Node* parent = nullptr) : parent(parent), wordsCount(0), word(nullptr) {
children.resize(26, nullptr);
}
Node* getChild(char c) {
if (children[c - 'a'] == nullptr) {
children[c - 'a'] = new Node(this);
}
return children[c - 'a'];
}
};
struct Bor {
unordered_set<string> words;
Node* root;
Bor() : root(new Node()) {}
int addWord(string& s) {
bool was = (words.find(s) != words.end());
Node* now = root;
int ans = 0;
int step = 1;
int stepForStep = 1e9;
int len = 0;
bool gg = false;
for (char& x : s) {
len++;
now = now->getChild(x);
stepForStep--;
if (stepForStep == 0) step = 1;
ans += step;
if (!gg && now->wordsCount == 1) {
if (was && len != s.size()) {
ans++;
step = 0;
stepForStep = 1e9;
} else if (now->word != nullptr && now->word->size() != len &&
*now->word == s.substr(0, now->word->size())) {
ans++;
step = 0;
stepForStep = now->word->size() - len + 1;
}
gg = true;
}
}
if (step != 0) {
if (now->word == nullptr) now->word = new string(s);
auto kek = now->word;
while (now != root) {
now->wordsCount += 1;
if (now->wordsCount == 1) now->word = kek;
now = now->parent;
}
if (now->wordsCount == 1) now->word = kek;
now->wordsCount += 1;
}
words.insert(s);
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
int ans = 0;
int count = 0;
Bor bor;
int gl = 0;
int vsego = 0;
while (getline(cin, s)) {
vsego += s.size() + 1;
ans += 1;
string now;
for (char x : s) {
if (x >= 'a' && x <= 'z' || x >= 'A' && x <= 'Z') {
now += x;
} else {
ans++;
if (now != "") {
int cnt = bor.addWord(now);
ans += cnt;
gl += cnt;
now = "";
}
}
}
if (now != "") {
int cnt = bor.addWord(now);
ans += cnt;
gl += cnt;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 2e18;
const int infi = 1e9;
const int mod = 998244353;
auto clk = clock();
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0, lim - 1);
return uid(rang);
}
int powm(long long a, long long b) {
int res = 1;
a %= mod;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
const int N = 3005;
int a[200005], w[200005];
int dp[N][N];
int invert[2 * N];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long sum = 0, good = 0, bad = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i];
if (a[i])
good += w[i];
else
bad += w[i];
sum += w[i];
}
for (int i = 3000 - m; i <= 3000 + m; i++) {
invert[i] = powm(sum + i - 3000, mod - 2);
}
dp[0][0] = 1;
for (int i = 0; i <= m; i++) {
for (int j = 0; i + j < m; j++) {
dp[i + 1][j] = (dp[i + 1][j] +
((dp[i][j] * (good + i)) % mod) * invert[3000 + i - j]) %
mod;
dp[i][j + 1] = (dp[i][j + 1] +
((dp[i][j] * (bad - j)) % mod) * invert[3000 + i - j]) %
mod;
}
}
long long ansg = 0, ansb = 0;
for (int i = 0; i <= m; i++) {
ansg = (ansg + (good + i) * dp[i][m - i]) % mod;
ansb = (ansb + (bad - m + i) * dp[i][m - i]) % mod;
}
ansg = ((ansg * powm(good, mod - 2)) % mod + mod) % mod;
ansb = ((ansb * powm(bad, mod - 2)) % mod + mod) % mod;
for (int i = 1; i <= n; i++) {
if (a[i])
w[i] = (w[i] * ansg) % mod;
else
w[i] = (w[i] * ansb) % mod;
cout << w[i] << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
cout << fixed << setprecision(10);
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimization("O2")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int maxn = 100 * 1000 + 9;
pair<int, int> a[maxn];
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
long long maxi = -3;
long long t = 0;
for (int i = 0; i < n; i++) {
if (a[i].second < a[i - 1].second && i > 0) t = 0;
t++;
maxi = max(maxi, t);
}
cout << n - maxi;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e5 + 10, mod = 1e9 + 9, base = 41, INF = 1e9 + 10, sq = 502;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long n, ind1 = 0, ind2 = 0, ind3 = 0;
cin >> n;
long long m = n;
string s;
cin >> s;
string a;
for (long long i = 0; i < (n); ++i) {
if (s[i] != '.' and a.size() == 0) {
a = s[i];
m = i + 1;
}
if (i > m - 1) {
if (s[i] != a[0]) {
ind2 = i + 1;
a += s[i];
break;
}
}
}
if (a[0] == 'L')
cout << ind2 - 1 << " " << m - 1 << endl;
else {
if (a[1] == '.')
cout << m << " " << ind2 << endl;
else {
for (long long i = ind2; i <= n - 1; i++) {
if (s[i] != a[1]) {
ind3 = i + 1;
break;
}
}
cout << ind3 - 1 << " " << ind2 << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
c_p_c();
long long x;
cin >> x;
while (x--) {
long long a, b;
cin >> a >> b;
if (a == b)
cout << 0 << '\n';
else if (b > a) {
if (a % 2 == 0 && b % 2 == 0) {
cout << 2 << '\n';
} else if (a % 2 == 0 && b % 2 != 0) {
cout << 1 << '\n';
} else if (a % 2 != 0 && b % 2 == 0) {
cout << 1 << '\n';
} else {
cout << 2 << '\n';
}
} else {
if (a % 2 == 0 && b % 2 == 0) {
cout << 1 << '\n';
} else if (a % 2 == 0 && b % 2 != 0) {
cout << 2 << '\n';
} else if (a % 2 != 0 && b % 2 == 0) {
cout << 2 << '\n';
} else {
cout << 1 << '\n';
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ans, a[N], b[N];
bool col[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) col[a[i]] = true;
col[n + 1] = true;
bool flag = col[b[n] + 1];
for (int i = n - b[n] + 1; i <= n; i++)
if (b[i] != i - n + b[n]) flag = false;
if (flag) {
bool t = true;
for (int i = 1; i <= n - b[n]; i++) {
if (!col[b[n] + i]) {
t = false;
break;
}
col[b[i]] = true;
}
if (t) {
printf("%d", n - b[n]);
return 0;
}
}
for (int i = 1; i <= n; i++) col[i] = false;
for (int i = 1; i <= n; i++) col[a[i]] = true;
int cnt = 1, i = 1;
while (cnt != n + 1) {
if (col[cnt]) cnt++;
ans++;
col[b[i]] = true;
i++;
}
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char z, x;
int a, s, d[105][10005], f[105][10005], g, h, j, k, l, i, n, m;
int ways(int i1, int a1) {
int w = 0, e = 0, q = 0, i2, a2, u = 0, p = 0;
a2 = a1 - 1;
for (i2 = a1; i2 <= m; i2++) {
if (i2 == a2 && u == 0 || u == 1) u++;
if (i2 == a2 && u == 2) return 0;
if (a2 == -1) {
a2 = m;
p = 1;
}
if (i2 == m) i2 = 0;
if (d[i1][i2 + 1] == 1) {
w = 1;
}
if (d[i1][a2] == 1 && i2 != a1) e = 1;
if (q < f[i1][i2]) f[i1][i2] = q;
if (q < f[i1][a2]) {
f[i1][a2] = q + 1 - p;
}
if (w + e == 2) break;
q++;
a2--;
if (i2 == a2 && u == 0 || u == 1) u++;
}
return 0;
}
int main() {
cin >> n >> m;
if (n == 1 && m == 1) {
cin >> k;
if (k == 1)
cout << 0;
else
cout << -1;
return 0;
}
for (i = 0; i < 100; i++) {
for (a = 0; a < 10000; a++) {
f[i][a] = 1000 * 1000 * 1000;
}
}
for (i = 0; i < n; i++) {
bool jk = false;
for (a = 0; a < m; a++) {
cin >> z;
if (z == '1') jk = true;
d[i][a] = (int)(z - 48);
}
if (jk == false) {
cout << -1 << endl;
return 0;
}
}
for (i = 0; i < n; i++) {
for (a = 0; a < m; a++) {
if (d[i][a] == 1) ways(i, a);
cout << "";
}
}
k = -1;
for (i = 0; i < m; i++) {
l = 0;
for (a = 0; a < n; a++) {
l = l + f[a][i];
}
if (k == -1 || l < k) k = l;
}
cout << k;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const int N = 8000000 + 10;
const int T = MAXN + 3;
int n, m, rt[MAXN + 10], Q;
pair<int, int> a[MAXN + 10];
int ncnt;
unsigned long long t[N];
void calc_s(const bool &nl, const bool &nr, unsigned long long x, int &ls,
int &rs, int &tag) {
int s = x % T;
ls = x / T / N;
rs = x / T % N;
tag = s - min((nl ? ls : t[ls] % T), (nr ? rs : t[rs] % T));
}
unsigned long long calc(const int &ls, const int &rs, const int &val) {
return (1ull * ls * N + rs) * T + val;
}
void ins(const int &last, int &u, const int &L, const int &R, const int &l,
const int &r) {
if (L == R) {
u = last + 1;
return;
}
t[u = ++ncnt] = t[last];
if (l <= L && R <= r) {
t[u]++;
return;
}
int mid = (L + R) >> 1, ls, rs, val, lson = 0, rson = 0;
calc_s((L == mid), (R == mid + 1), t[u], ls, rs, val);
if (l <= mid) ins(ls, lson, L, mid, l, r);
if (r > mid) ins(rs, rson, mid + 1, R, l, r);
if (!lson) lson = ls;
if (!rson) rson = rs;
val += min(((L == mid) ? lson : t[lson] % T),
((R == mid + 1) ? rson : t[rson] % T));
t[u] = calc(lson, rson, val);
}
int query(const int &u, const int &L, const int &R, const int &l,
const int &r) {
if (L == R) return u;
if (!u) return 0;
if (l <= L && R <= r) return t[u] % T;
int mid = (L + R) >> 1, ls, rs, val, ret = N;
calc_s((L == mid), (mid + 1 == R), t[u], ls, rs, val);
if (l <= mid) ret = min(ret, query(ls, L, mid, l, r));
if (r > mid) ret = min(ret, query(rs, mid + 1, R, l, r));
return ret + val;
}
inline void build() {
for (int i = 1; i <= n; i++)
ins(rt[i - 1], rt[i], 1, n - m + 1, max(1, a[i].second - m + 1),
a[i].second);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first), a[i].second = i;
sort(a + 1, a + 1 + n);
build();
scanf("%d", &Q);
int ans = 0;
for (int i = 1; i <= Q; i++) {
int x, l, r;
scanf("%d%d%d", &l, &r, &x);
x ^= ans;
x = lower_bound(a + 1, a + 1 + n, make_pair(x, 0)) - a;
if (x == 1)
ans = 0;
else
ans = query(rt[x - 1], 1, n - m + 1, l, r);
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
long long a[n], cm[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < d; i++) cm[i] = a[i];
for (int i = d; i < n; i++) cm[i] = a[i] + cm[i - d];
for (int i = 0; i < n; i++) {
cm[i + 1] += cm[i];
cout << cm[i] << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<long long> counts(300000, 0);
long long n;
cin >> n;
string sign, temp;
while (n--) {
cin >> sign >> temp;
reverse(temp.begin(), temp.end());
long long num = 0;
long long start = 0;
for (auto i : temp) {
if ((i - '0') % 2 == 1) {
num += pow(2, start);
}
start++;
}
if (sign == "+") {
counts[num]++;
}
if (sign == "-") {
counts[num]--;
}
if (sign == "?") {
cout << counts[num] << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, i, j, test, p, count;
cin >> test;
for (int k = 0; k < test; k++) {
count = 0;
cin >> n >> m;
char arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (p = 0; p < n; p++) {
if (arr[p][m - 1] == 'R') count++;
}
for (p = 0; p < m; p++) {
if (arr[n - 1][p] == 'D') count++;
}
cout << count << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int INFI = (1 << 29);
const long long INFL = (1LL << 62);
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
cout << (long long)ceil((n * m) / 2.0) << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long casos;
cin >> casos;
while (casos--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 4)
cout << "NO" << endl;
else {
cout << "YES" << endl;
if (n == 4) {
cout << "1 * 2 = 2" << endl;
cout << "2 * 3 = 6" << endl;
cout << "6 * 4 = 24" << endl;
}
if (n == 5) {
cout << "3 * 5 = 15" << endl;
cout << "2 * 4 = 8" << endl;
cout << "15 + 8 = 23" << endl;
cout << "23 + 1 = 24" << endl;
}
if (n > 5) {
cout << "2 * 3 = 6" << endl;
cout << "6 * 4 = 24" << endl;
cout << "6 -1 = 5" << endl;
cout << "5 - 5 = 0" << endl;
for (int i = 7; i <= n; i++) cout << i << " * 0 = 0" << endl;
cout << "24 + 0 = 24" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const long long N = 3e3 + 7;
vector<long long> ad[N];
long long n, m;
long long a[N];
long long dp[N][N];
long long f[N][N];
long long g[N], t[N], sz[N];
void get(long long v, long long p) {
sz[v] = 1;
f[v][1] = a[v];
for (auto u : ad[v])
if (u != p) {
get(u, v);
for (long long i = 0; i < N; i++) t[i] = -1e18;
memset(g, 0, sizeof g);
for (long long i = 1; i <= sz[u]; i++)
for (long long j = 1; j <= sz[v]; j++) {
if (g[i + j] < dp[u][i] + dp[v][j] + (f[u][i] > 0) ||
(g[i + j] == dp[u][i] + dp[v][j] + (f[u][i] > 0) &&
t[i + j] < f[v][j])) {
g[i + j] = dp[u][i] + dp[v][j] + (f[u][i] > 0);
t[i + j] = f[v][j];
}
if (g[i + j - 1] < dp[u][i] + dp[v][j] ||
(g[i + j - 1] == dp[u][i] + dp[v][j] &&
t[i + j - 1] < f[u][i] + f[v][j])) {
g[i + j - 1] = dp[u][i] + dp[v][j];
t[i + j - 1] = f[u][i] + f[v][j];
}
}
sz[v] += sz[u];
for (long long i = 0; i < N; i++) {
dp[v][i] = g[i];
f[v][i] = t[i];
}
}
}
void solve() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
ad[i].clear();
a[i] = 0;
memset(dp[i], 0, sizeof dp[i]);
}
for (long long i = 1; i <= n; i++) {
long long t;
cin >> t;
a[i] -= t;
}
for (long long i = 1; i <= n; i++) {
long long t;
cin >> t;
a[i] += t;
}
for (long long i = 1; i < n; i++) {
long long v, u;
cin >> v >> u;
ad[v].push_back(u);
ad[u].push_back(v);
}
get(1, 0);
cout << dp[1][m] + (f[1][m] > 0) << '\n';
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
os << '{' << p.first << ", " << p.second << '}';
return os;
}
template <typename T>
inline void showArray(T *it1, T *it2) {
cout << "{ ";
while (it1 != it2) {
cout << *it1 << ' ';
++it1;
}
cout << " }" << endl;
}
inline int readInt() {
int n;
char c = getchar(), k = '+';
if (c == '-') {
k = '-';
} else {
n = c - '0';
}
c = getchar();
while (c != ' ' && c != '\n') {
n = n * 10 + c - '0';
c = getchar();
}
if (k == '-') {
n = -n;
}
return n;
}
inline void printInt(int n) {
if (n < 0) {
putchar('-');
n = -n;
}
char st[10], *p;
p = st + 10;
while (n) {
*(--p) = (n % 10) + '0';
n /= 10;
}
if (p == st + 10) {
*(--p) = '0';
}
while (p != st + 10) {
putchar(*p++);
}
}
const bool debug = false;
const int MAXN = 1e3 + 2, INF = 1e9, p = 998244353, g = 3;
const double pi = acos(-1), eps = 1e-9;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<vector<int>> operator*(const vector<vector<int>> &a,
const vector<vector<int>> &b) {
vector<vector<int>> c(a.size(), vector<int>(b[0].size(), 0));
for (size_t i = 0; i < a.size(); ++i) {
for (size_t j = 0; j < b[0].size(); ++j) {
for (size_t k = 0; k < b.size(); ++k) {
c[i][j] = (c[i][j] + (long long)a[i][k] * b[k][j]) % (p - 1);
}
}
}
return c;
}
int fast_pow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) {
res = ((long long)res * a) % p;
}
a = ((long long)a * a) % p;
b >>= 1;
}
return res;
}
int fast_pow(int a, int b, int m) {
int res = 1;
while (b) {
if (b & 1) {
res = ((long long)res * a) % m;
}
a = ((long long)a * a) % m;
b >>= 1;
}
return res;
}
vector<vector<int>> fast_pow(vector<vector<int>> a, int b) {
vector<vector<int>> res(a.size(), vector<int>(a.size(), 0));
for (size_t i = 0; i < a.size(); ++i) res[i][i] = 1;
while (b) {
if (b & 1) {
res = res * a;
}
a = a * a;
b >>= 1;
}
return res;
}
int disc_log(int a, int b) {
int r = sqrt(p) + 1;
map<int, int> value;
int an = fast_pow(a, r);
for (int i = 1, cur = an; i <= r; ++i) {
if (value.find(cur) == value.end()) {
value[cur] = i;
}
cur = ((long long)cur * an) % p;
}
for (int i = 0, cur = b; i <= r; ++i) {
if (value.find(cur) != value.end()) {
int ans = value[cur] * r - i;
if (ans < p) return ans;
}
cur = ((long long)cur * a) % p;
}
return -1;
}
int f(int n) {
int res = n;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
res -= res / i;
}
}
if (n > 1) {
res -= res / n;
}
return res;
}
int solve_mod_eq(int a, int b) {
int d = gcd(a, p - 1);
if (b % d) return -1;
a /= d;
b /= d;
int m = (p - 1) / d;
return ((long long)b * fast_pow(a, f(m) - 1, m)) % m;
}
int k, n, fn;
vector<vector<int>> A;
int main() {
scanf("%d", &k);
A.resize(k, vector<int>(k, 0));
for (int i = 0; i < k; ++i) {
scanf("%d", &A[0][i]);
if (i) A[i][i - 1] = 1;
}
if (debug) {
printf("A:\n");
for (int i = 0; i < k; ++i) {
for (int j = 0; j < k; ++j) {
printf("%d ", A[i][j]);
}
printf("\n");
}
}
scanf("%d %d", &n, &fn);
int hn = disc_log(g, fn) % (p - 1);
if (debug) {
printf("hn = %d\n", hn);
}
if (hn == -1) {
printf("-1\n");
return 0;
}
A = fast_pow(A, n - k);
if (debug) {
printf("A ** n - k:\n");
for (int i = 0; i < k; ++i) {
for (int j = 0; j < k; ++j) {
printf("%d ", A[i][j]);
}
printf("\n");
}
}
int hk = solve_mod_eq(A[0][0], hn);
if (hk == -1) {
printf("-1\n");
return 0;
}
hk = (hk + p - 1) % (p - 1);
if (debug) {
printf("hk = %d\n", hk);
}
printf("%d\n", fast_pow(g, hk));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18L + 5;
const int inf = 1e9 + 5;
struct comp {
bool operator()(pair<int, int> p1, pair<int, int> p2) {
if (p1.first < p2.first) return false;
if (p2.first < p1.first) return true;
return p1.second < p2.second;
};
};
long long min_ops(vector<long long> arr, int n) {
sort(arr.begin(), arr.end());
long long mid = arr[n / 2];
long long mid1 = arr[(n / 2) - 1];
long long res = 0, res1 = 0;
for (int i = 0; i < n; i++) {
res = res + abs(arr[i] - mid);
res1 = res1 + abs(arr[i] - mid1);
}
return min(res, res1);
}
long long power(long long base, long long exponent) {
long long result = 1;
while (exponent != 0) {
result *= base;
--exponent;
}
return result;
}
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
cin >> test;
while (test--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> q;
int h = 1, l = 1;
for (int i = 2; i < n; i++) {
if (a[i] > a[i - 1]) {
l++;
} else {
q.push_back(l);
l = 1;
}
}
q.push_back(l);
int j = 0, last = q[0], sum = 0;
std::vector<int> v;
v.push_back(last);
for (int i = 1; i < q.size(); i++) {
sum = 0;
for (j = 0; j < last; j++) {
if ((i + j) < q.size()) sum += q[i + j];
}
v.push_back(sum);
last = sum;
i = i + j - 1;
}
cout << v.size() << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int x, y;
};
vector<st> v;
bool cmpr(st a, st b) {
if (a.x != b.x)
return a.x < b.x;
else
return a.y < b.y;
}
int main() {
int t;
cin >> t;
while (t--) {
v.clear();
int n;
cin >> n;
v.push_back({0, 0});
map<int, int> mp;
bool b = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (mp[x + y] != 0) b = 1;
v.push_back({x, y});
}
sort(v.begin(), v.end(), cmpr);
int sum1 = v[v.size() - 1].x + v[v.size() - 1].y;
int sum2 = 0;
for (int i = 1; i < v.size(); i++) {
sum2 += abs(v[i].x - v[i - 1].x) + abs(v[i].y - v[i - 1].y);
}
if (sum1 != sum2 || b == 1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i < v.size(); i++) {
int tx = v[i].x - v[i - 1].x;
int ty = v[i].y - v[i - 1].y;
for (int j = 0; j < tx; j++) {
cout << "R";
}
for (int j = 0; j < ty; j++) {
cout << "U";
}
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(1000005);
vector<int> a[MAXN];
bool visited[MAXN];
int dfs(int node) {
visited[node] = 1;
int ret = 1;
for (int i = 0; i < a[node].size(); i++)
if (!visited[a[node][i]]) ret += dfs(a[node][i]);
return ret;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
vector<int> b;
for (int i = 1; i <= n; i++)
if (!visited[i]) b.push_back(min(k, dfs(i)));
if (k == 1) {
printf("%d", max(0, (int)b.size() - 2));
return 0;
}
sort(b.begin(), b.end(), greater<int>());
int now = b[0], l = 0, ans = 0;
vector<int> slot;
slot.push_back(max(0, k - b[0]));
for (int i = 1; i <= (int)(b.size()) - 1; i++) {
if (now + b[i] - 2 >= 0)
now = now + b[i] - 2;
else {
ans++;
while (l < slot.size() && slot[l] <= 0) l++;
if (l < slot.size()) {
now = 1;
slot[l]--;
} else
now = 0;
}
slot.push_back(max(0, k - b[i]));
}
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int t;
string fast_change(string s) {
int que = 4 - s.size();
string ret;
for (int i = 1; i <= que; i++) ret += ('0');
for (int i = 0; i < s.size(); i++) ret += s[i];
return ret;
}
void coutall(int num, int lll) {
for (int i = 1; i < num; i++) cout << "0000:";
if (lll != 0)
cout << "0000:";
else
cout << "0000";
}
int main() {
cin >> t;
while (t--) {
string s;
cin >> s;
vector<string> subst;
int pos = s.find(":");
bool havezer = false;
if (s[0] == ':') s = s.substr(1);
s += ":";
while (pos != -1) {
subst.push_back(s.substr(0, pos));
s = s.substr(pos + 1);
pos = s.find(":");
}
int flg = -1;
for (int i = 0; i < subst.size(); i++)
if (subst[i] == "") {
if (flg != -1) {
subst.erase(subst.begin() + i);
i--;
}
flg = i;
}
if (flg == -1) {
for (int i = 0; i < subst.size() - 1; i++)
cout << fast_change(subst[i]) << ":";
cout << fast_change(subst[subst.size() - 1]);
} else {
int cnt = subst.size() - 1;
for (int i = 0; i < flg; i++) cout << fast_change(subst[i]) << ":";
coutall(8 - cnt, subst.size() - 1 - flg);
for (int i = flg + 1; i < subst.size(); i++) {
if (i != subst.size() - 1)
cout << fast_change(subst[i]) << ":";
else
cout << fast_change(subst[i]);
}
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, Head[500010], Next[500010], Go[500010], Val[500010], Deg[500010],
L[500010], R[500010], V[500010], vis[500010], T, Cnt = 0, St = 0;
long long Ans[500010], F[500010][2], totV = 0;
vector<pair<int, long long> > Sm[500010], G[500010];
bool cmp(int first, int second) { return Deg[first] > Deg[second]; }
bool cmpP(pair<int, long long> first, pair<int, long long> second) {
return Deg[first.first] > Deg[second.first];
}
long long getpre(vector<pair<int, long long> > &A1,
vector<pair<int, long long> > &V, int v) {
long long tot = 0;
for (int s = 0, i = 0, w = 0, nxt; i + 1 < V.size(); i = nxt) {
for (nxt = i; nxt < V.size(); nxt++) {
if (V[nxt].first >= 0 && V[nxt].first != V[i].first) break;
tot += V[nxt].first * V[nxt].second, s += V[nxt].second;
}
int t = lower_bound(A1.begin(), A1.end(),
pair<int, long long>(V[nxt].first, -1e18)) -
A1.begin();
if (t + s >= v) {
t = max(v - s, w);
return (t ? A1[t - 1].second : 0) + tot -
(s + t - v) * max(V[i].first, 0);
}
w = t;
}
}
void DFS(int first, int f) {
vector<pair<int, long long> > V(1, pair<int, long long>(-1, 0));
vis[first] = T + 1, V.push_back(pair<int, long long>(0, 0)),
V.push_back(pair<int, long long>(1e6 + 5, 0));
long long tot = 0, fv = 0;
for (int i = 0, g = G[first][0].first;
i < G[first].size() && Deg[g = G[first][i].first] > T; i++) {
V.push_back(pair<int, long long>(G[first][i].second, -1));
if (g != f)
DFS(G[first][i].first, first), tot += F[g][0],
V.push_back(pair<int, long long>(F[g][1] - F[g][0], 1));
else
fv = G[first][i].second;
}
sort(V.begin(), V.end());
F[first][1] = getpre(Sm[first], V, Deg[first] - T - 1) + fv + tot,
F[first][0] = getpre(Sm[first], V, Deg[first] - T) + tot;
}
int main() {
scanf("%d", &n);
vector<int> S(0);
for (int i = 1, a, b, c; i < n; i++)
scanf("%d%d%d", &L[i], &R[i], &V[i]),
Go[++Cnt] = b = R[i], Next[Cnt] = Head[a = L[i]], Head[a = L[i]] = Cnt,
Val[Cnt] = c = V[i], Deg[b = R[i]]++, Go[++Cnt] = a,
Next[Cnt] = Head[b], Head[b] = Cnt, Val[Cnt] = c, Deg[a]++, totV += c,
G[a].push_back(pair<int, long long>(b, c)),
G[b].push_back(pair<int, long long>(a, c)),
Sm[a].push_back(pair<int, long long>(c, 0)),
Sm[b].push_back(pair<int, long long>(c, 0));
for (int i = 1; i <= n; i++) S.push_back(i);
for (int i = 1; i <= n; i++)
if (Sm[i].size()) {
sort(G[i].begin(), G[i].end(), cmpP), sort(Sm[i].begin(), Sm[i].end()),
Sm[i][0].second = Sm[i][0].first;
for (int j = 1; j < Sm[i].size(); j++)
Sm[i][j].second = Sm[i][j - 1].second + Sm[i][j].first;
}
sort(S.begin(), S.end(), cmp);
for (T = n - 1; T >= 1; T--) {
while (St != S.size() && Deg[S[St]] > T) St++;
long long ans = 0;
for (int i = 0; i < St; i++)
if (vis[S[i]] != T + 1) DFS(S[i], -1), ans += F[S[i]][0];
Ans[T] = ans;
}
Ans[0] = totV;
for (int i = 0; i < n; i++) printf("%lld ", Ans[i]);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, m, n, sum = 0, add = 0;
int a[100000], b[100000];
cin >> n;
if (n < 3)
cout << "No";
else {
cout << "Yes" << endl;
cout << n / 2 << " ";
for (i = 1; i <= n; i++) {
if (i % 2 == 0) {
cout << i << " ";
}
}
cout << endl;
if (n % 2 == 0)
cout << n / 2 << " ";
else
cout << (n / 2) + 1 << " ";
for (i = 1; i <= n; i++) {
if (i % 2 == 1) cout << i << " ";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, sumPar = 0, sumImpa = 0;
cin >> n;
vector<long long> x;
for (int i = 0; i < n; i++) {
long long aux;
cin >> aux;
x.push_back(aux);
if (i % 2 == 0) {
sumPar += aux;
} else {
sumImpa += aux;
}
}
if (n == 1) {
cout << 1 << endl;
return 0;
} else {
long long resp = 0;
long long acuPar = 0, acuImpar = 0;
for (int i = 0; i < n; i++) {
long long par, impar;
if (i % 2 == 0) {
par = sumImpa + acuPar - acuImpar;
impar = sumPar + acuImpar - acuPar - x[i];
acuPar += x[i];
} else {
par = sumImpa + acuPar - acuImpar - x[i];
impar = sumPar + acuImpar - acuPar;
acuImpar += x[i];
}
if (par == impar) resp++;
}
cout << resp;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, v, next;
} a[200010];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
pair<int, int> d[2010];
long long num[2010], dis[2010], h[2010];
long long f[2010][2010][2], sum[2010][2010], s1[2010][2010], s2[2010][2010],
mx[2010], mn[2010];
int cnt[2010][2010], c1[2010][2010], c2[2010][2010], head[2010], lst1[2010],
lst2[2010], n, m, vs, vt, tt, t1, t2, tot;
inline int rd() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
inline void add(int x, int y, int z) {
a[++tot].t = y;
a[tot].v = z;
a[tot].next = head[x];
head[x] = tot;
}
inline void dijkstra(int vs) {
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) dis[i] = 2333333333333333333LL;
dis[vs] = 0;
q.push(pair<long long, long long>(dis[vs], vs));
while (!q.empty()) {
pair<long long, long long> hh = q.top();
q.pop();
int x = hh.second;
if (dis[x] < hh.first) continue;
for (int i = head[x]; i; i = a[i].next) {
int t = a[i].t;
if (dis[t] > dis[x] + a[i].v)
dis[t] = dis[x] + a[i].v, q.push(pair<long long, long long>(dis[t], t));
}
}
tt = 0;
for (int i = 1; i <= n; i++) h[++tt] = dis[i];
sort(h + 1, h + tt + 1);
tt = unique(h + 1, h + tt + 1) - h - 1;
for (int i = 1; i <= n; i++)
dis[i] = lower_bound(h + 1, h + tt + 1, dis[i]) - h;
}
int main() {
n = rd();
m = rd();
vs = rd();
vt = rd();
for (int i = 1; i <= n; i++) num[i] = rd();
for (int i = 1; i <= m; i++) {
int x = rd(), y = rd(), z = rd();
add(x, y, z);
add(y, x, z);
}
dijkstra(vs);
t1 = tt;
for (int i = 1; i <= n; i++) d[i].first = dis[i];
dijkstra(vt);
t2 = tt;
for (int i = 1; i <= n; i++) d[i].second = dis[i];
for (int i = 1; i <= n; i++)
sum[d[i].first][d[i].second] += num[i], cnt[d[i].first][d[i].second]++;
n = t1;
m = t2;
for (int i = 1; i <= n; i++)
for (int j = m; j; j--) c1[i][j] = c1[i][j + 1] + cnt[i][j];
for (int i = n; i; i--)
for (int j = 1; j <= m; j++) c2[i][j] = c2[i + 1][j] + cnt[i][j];
for (int i = 0; i <= m; i++) mx[i] = -2333333333333333333LL, lst1[i] = n + 1;
for (int i = 0; i <= n; i++) mn[i] = 2333333333333333333LL, lst2[i] = m + 1;
for (int i = n; i; i--)
for (int j = m; j; j--) {
s1[i][j] = s1[i][j + 1] + sum[i][j];
s2[i][j] = s2[i + 1][j] + sum[i][j];
}
for (int i = n; i >= 0; i--) {
for (int j = m; j >= 0; j--) {
if (lst1[j] > n)
f[i][j][0] = 0;
else
f[i][j][0] = mx[j];
if (lst2[i] > m)
f[i][j][1] = 0;
else
f[i][j][1] = mn[i];
if (c1[i][j + 1]) {
for (int k = lst1[j] - 1; k >= i; k--)
mx[j] = max(mx[j], f[k][j][1]) + s1[k][j + 1];
lst1[j] = i;
}
if (c2[i + 1][j]) {
for (int k = lst2[i] - 1; k >= j; k--)
mn[i] = min(mn[i], f[i][k][0]) - s2[i + 1][k];
lst2[i] = j;
}
}
}
if (f[0][0][0] > 0)
puts("Break a heart");
else if (f[0][0][0] < 0)
puts("Cry");
else
puts("Flowers");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1000010;
bool prime[1000001];
vector<int> pf;
void SOE() {
int n = 1000000;
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
bool isprime(int c) {
int lim = sqrt(c);
for (int i = 2; i <= lim; i++)
if (c % i == 0) return false;
return true;
}
long long pow1(int i, long long l) {
if (l == 0) return 1;
if (l == 1) return i;
long long ret = pow1(i, l / 2) % mod;
ret = ((ret % mod) * (ret % mod)) % mod;
if (l % 2 == 0)
return ret % mod;
else {
return ((ret % mod) * i) % mod;
}
}
long long setb(long long n, long long i) {
long long a = 1;
return n | (a << i);
}
long long chset(long long n, long long i) {
long long a = 1;
return n & (a << i);
}
long long a[N], n;
void foo() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long x = 0, y = 0;
long long lim = n / 2;
for (int i = 0; i < lim; i++) x += a[i];
for (int i = lim; i < n; i++) y += a[i];
cout << (x * x + y * y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
foo();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k, z;
cin >> n >> k >> z;
long long a[n];
for (auto &x : a) cin >> x;
long long ans = 0;
for (long long i = 0; i <= k; i++) ans += a[i];
long long ind = k, tmp = ans, tmp2 = ans - a[k];
;
for (long long i = 0; i < z && ind >= 2; i++) {
tmp -= a[ind] + a[ind - 1];
ind -= 2;
long long ma = 0;
for (long long j = 0; j < ind; j++) {
ma = max(ma, a[j] + a[j + 1]);
}
ans = max(ans, tmp + ma * (i + 1));
}
ind = k - 1;
for (long long i = 0; i < z && ind >= 1; i++) {
if (i) tmp2 -= a[ind] + a[ind - 1], ind -= 2;
long long ma = 0;
for (long long j = 0; j < ind; j++) {
ma = max(ma, a[j] + a[j + 1]);
}
ans = max(ans, tmp2 + ma * i + (ind >= 1 ? a[ind - 1] : 0));
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cnt;
bool b[310], good[310];
int a[20], mask[310], d[310][110], kd[310], q[100010];
int aw[100010], ax[100010], ay[100010], az[100010];
int main() {
cin >> cnt;
for (int i = 0; i < 30; i++) b[i] = 0;
int need = 0;
for (int i = 0; i < cnt; i++) {
int foo;
cin >> foo;
need |= (1 << foo);
b[foo] = 1;
}
if (cnt > 6) {
cout << 0 << endl;
return 0;
}
int kg = 0;
for (int i = 0; i < 256; i++) {
good[i] = 1;
int x = i;
mask[i] = 0, kd[i] = 0;
while (x > 0) {
d[i][kd[i]++] = x % 10;
if (!b[x % 10]) good[i] = 0;
mask[i] |= (1 << (x % 10));
x /= 10;
}
if (i == 0 && !b[0]) good[i] = 0;
if (i == 0) {
d[i][kd[i]++] = 0;
mask[i] |= (1 << 0);
}
}
int ka = 0;
for (int w = 0; w < 256; w++)
if (good[w])
for (int x = 0; x < 256; x++)
if (good[x])
for (int y = 0; y < 256; y++)
if (good[y]) {
if ((mask[w] | mask[x] | mask[y]) != need) continue;
for (int z = 0; z < 256; z++)
if (good[z]) {
int u = 0;
for (int i = kd[w] - 1; i >= 0; i--) q[u++] = d[w][i];
for (int i = kd[x] - 1; i >= 0; i--) q[u++] = d[x][i];
for (int i = kd[y] - 1; i >= 0; i--) q[u++] = d[y][i];
for (int i = kd[z] - 1; i >= 0; i--) q[u++] = d[z][i];
int ok = 1;
for (int i = 0; i < u - i - 1; i++)
if (q[i] != q[u - i - 1]) {
ok = 0;
break;
}
if (ok) {
aw[ka] = w;
ax[ka] = x;
ay[ka] = y;
az[ka] = z;
ka++;
}
}
}
cout << ka << endl;
for (int i = 0; i < ka; i++)
printf("%d.%d.%d.%d\n", aw[i], ax[i], ay[i], az[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
srand(time(NULL));
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long st = 10000;
long long mod = 1000000007;
long long n;
string s[1111];
long long d[8][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1},
{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
long long b[2][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}};
int r[8][1111][1111];
int cnt[8][1111][1111][4];
pair<long long, long long> B[4][2222];
bool check(long long x) { return (0 <= x && x < n); }
bool check(long long x, long long y) { return check(x) && check(y); }
long long getSum(long long i, long long xl, long long yl, long long xr,
long long yr, long long a) {
long long res = cnt[i][xl][yl][a];
if (check(xr, yr)) res -= cnt[i][xr][yr][a];
return res;
}
void get(long long x, long long y, long long i, long long rad, long long &a2,
long long &a3) {
for (long long j = 0; j < (long long)(4); j++) {
long long xx = x + d[b[i][j]][0] * rad;
long long yy = y + d[b[i][j]][1] * rad;
a2 += getSum(b[i][j], x, y, xx, yy, 2);
a3 += getSum(b[i][j], x, y, xx, yy, 3);
}
if (s[x][y] == '2') a2 -= 3;
if (s[x][y] == '3') a3 -= 3;
}
pair<long long, long long> mul(long long a2, long long a3) {
if (a2 == -1 || a3 == -1) return make_pair(0, 0);
long long x = B[2][a2].first + B[3][a3].first;
long long y = B[2][a2].second * B[3][a3].second;
while (y > mod) {
y /= st;
x++;
}
return make_pair(x, y);
}
int main(void) {
for (long long k = 2; k <= 3; k++) {
B[k][0] = make_pair(0, 1);
for (long long i = 1; i < 2222; i++) {
B[k][i] = B[k][i - 1];
B[k][i].second *= k;
if (B[k][i].second > mod) {
B[k][i].second /= st;
B[k][i].first++;
}
}
}
cin >> n;
for (long long i = 0; i < (long long)(n); i++) {
cin >> s[i];
}
for (long long i = 0; i < (long long)(8); i++) {
long long lx = 0, rx = n - 1, dx = 1;
if (d[i][0] >= 0) {
swap(lx, rx);
dx *= -1;
}
long long ly = 0, ry = n - 1, dy = 1;
if (d[i][1] >= 0) {
swap(ly, ry);
dy *= -1;
}
for (long long x = lx; check(x); x += dx) {
for (long long y = ly; check(y); y += dy) {
long long xx = x + d[i][0];
long long yy = y + d[i][1];
if (!check(xx, yy)) {
r[i][x][y] = (s[x][y] != '0');
cnt[i][x][y][s[x][y] - '0']++;
continue;
}
for (long long j = 0; j < (long long)(4); j++) {
cnt[i][x][y][j] = cnt[i][xx][yy][j];
}
cnt[i][x][y][s[x][y] - '0']++;
if (s[x][y] == '0')
r[i][x][y] = 0;
else
r[i][x][y] = r[i][xx][yy] + 1;
}
}
}
long long first = -1, second = -1, R = -1, I = -1;
long long A2 = -1, A3 = -1;
for (long long x = 0; x < (long long)(n); x++) {
for (long long y = 0; y < (long long)(n); y++) {
if (s[x][y] == '0') continue;
for (long long i = 0; i < (long long)(2); i++) {
int rad = n;
for (long long j = 0; j < (long long)(4); j++) {
rad = min(rad, r[b[i][j]][x][y]);
}
long long a2 = 0, a3 = 0;
get(x, y, i, rad, a2, a3);
if (mul(a2, a3) > mul(A2, A3)) {
first = x;
second = y;
I = i;
R = rad;
A2 = a2;
A3 = a3;
}
}
}
}
if (R == -1) {
cout << 0 << '\n';
return 0;
}
long long sum = 1LL;
for (long long i = 0; i < (long long)(A2); i++) {
sum *= 2;
sum %= mod;
}
for (long long i = 0; i < (long long)(A3); i++) {
sum *= 3;
sum %= mod;
}
cout << sum << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int A[100001];
int binS(int A[], int l, int r, int key) {
if (l >= r) return l;
int mid = (l + r) / 2;
if (A[mid] == key) return mid;
if (key > A[mid]) return binS(A, mid + 1, r, key);
return binS(A, l, mid, key);
}
int main() {
int n, t;
cin >> n;
cin >> A[0];
for (int i = 1; i < n; i++) cin >> t, A[i] = A[i - 1] + t;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> t;
cout << binS(A, 0, n - 1, t) + 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[100];
long long int num1 = 0, num2 = 0;
bool vis[101];
bool dfs(long long int i) {
stack<long long int> s;
s.push(i);
vis[i] = true;
while (!s.empty()) {
long long int ele = s.top();
s.pop();
for (long long int j = 0; j < adj[ele].size(); j++) {
if (adj[ele][j] == num2) return true;
if (!vis[adj[ele][j]]) {
vis[adj[ele][j]] = true;
s.push(adj[ele][j]);
}
}
}
return false;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> num(n + 1, n - 1);
for (long long int i = 01; i < (n * (n - 1)) / 2; i++) {
long long int w, l;
cin >> w >> l;
adj[w].push_back(l);
num[w]--;
num[l]--;
}
for (long long int i = 1; i <= n; i++) {
if (num[i] == 1) {
if (!num1)
num1 = i;
else
num2 = i;
}
}
if (dfs(num1))
cout << num1 << " " << num2;
else
cout << num2 << " " << num1;
}
int main() { solve(); }
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v;
long long w;
};
const int MOD = 1000000007;
long long _MOD = 1000000009;
double EPS = 1e-10;
int INF = INT_MAX / 2;
vector<int> solve(vector<int> a, vector<int> b) {
int N = a.size();
vector<pair<int, int> > ai(N);
for (int i = 0; i < N; i++) ai[i] = pair<int, int>(a[i], i);
sort(ai.rbegin(), ai.rend());
priority_queue<pair<int, int> > pq;
vector<int> p;
for (int t = 0; t < N; t++) {
int i = ai[t].second;
pq.push(pair<int, int>(b[i], i));
if (t % 2 == 0) {
p.push_back(pq.top().second);
pq.pop();
}
}
sort(p.begin(), p.end());
return p;
}
int main() {
int N;
cin >> N;
vector<int> a(N), b(N);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
for (int i = 0; i < N; i++) scanf("%d", &b[i]);
if (N % 2 == 0) a.pop_back(), b.pop_back();
vector<int> p = solve(a, b);
if (N % 2 == 0) p.push_back(N - 1);
cout << p.size() << endl;
for (int i : p) printf("%d ", i + 1);
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct FastReader {
FastReader operator>>(int &x) const {
scanf("%d", &x);
return *this;
}
FastReader operator>>(signed long long &x) const {
scanf("%I64d", &x);
return *this;
}
FastReader operator>>(double &x) const {
scanf("%lf", &x);
return *this;
}
FastReader operator>>(char &x) const {
do {
x = getchar();
} while (x == ' ' || x == '\n');
return *this;
}
FastReader operator>>(char *x) const {
scanf("%s", x);
return *this;
}
} in;
struct FastWriter {
FastWriter operator<<(const int x) const {
printf("%d", x);
return *this;
}
FastWriter operator<<(const signed long long x) const {
printf("%I64d", x);
return *this;
}
FastWriter operator<<(const double x) const {
printf("%lf", x);
return *this;
}
FastWriter operator<<(const char x) const {
putchar(x);
return *this;
}
FastWriter operator<<(const char *x) const {
printf("%s", x);
return *this;
}
FastWriter operator<<(const string x) const { return operator<<(x.c_str()); }
} out;
const int N = 10011, B = 1011, K = 26;
struct Node {
int leaf;
Node *parent, *child[K];
Node(Node *parent = NULL) : parent(parent), leaf(-1) {
for (int i = 0; i < K; i++) child[i] = NULL;
}
};
void trie_insert(Node *root, char *key, int word) {
Node *it;
for (it = root; *key != 0; key++) {
char c = *key;
if (c >= 'A' && c <= 'Z') c ^= ' ';
c -= 'a';
if (it->child[c] == NULL) it->child[c] = new Node(it);
it = it->child[c];
}
it->leaf = word;
}
int n, m;
char s[N], buf[N];
vector<string> w;
Node *trie;
int sp[N];
vector<int> ans;
int main() {
trie = new Node();
in >> n >> s >> m;
for (int i = 0; i < m; i++) {
in >> buf;
w.push_back(string(buf));
trie_insert(trie, buf, i);
}
for (int i = 0; i < n; i++) sp[i] = -1;
for (int i = 0; i < n; i++) {
int j = i;
Node *it = trie;
while (j >= 0 && it != NULL) {
char c = s[j] - 'a';
it = it->child[c], j--;
if (it == NULL) break;
if (it->leaf != -1 && (j < 0 || sp[j] != -1)) {
sp[i] = it->leaf;
break;
}
}
}
int it = n - 1;
while (it >= 0) {
ans.push_back(sp[it]);
it -= w[sp[it]].size();
}
for (int i = (int)ans.size() - 1; i >= 0; i--) {
out << w[ans[i]] << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int n;
int val[maxn], du[maxn];
queue<int> q;
vector<pair<int, int> > v;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", du + i, val + i);
}
for (int i = 0; i < n; i++) {
if (du[i] == 1) q.push(i);
}
while (!q.empty()) {
int z = q.front();
q.pop();
int now = val[z];
if (du[z] <= 0) continue;
if (du[now] >= 1) {
du[z]--;
du[now]--;
v.push_back(make_pair(z, now));
val[now] ^= z;
}
if (du[now] == 1) q.push(now);
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%d %d\n", v[i].first, v[i].second);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
lli n, m, k, u, v, x, ans, curr, T;
vlli c;
lli fast_exp(lli base, lli exp) {
lli res = 1;
base = base % 1000000007;
while (exp > 0) {
if (exp % 2) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
exp /= 2;
}
return res % 1000000007;
}
template <class T>
struct DSU {
map<T, T> par;
T comp_sz = n;
T get(T u) {
if (par.find(u) == par.end()) return u;
return par[u] = get(par[u]);
}
void unite(T x, T y) {
T X = get(x), Y = get(y);
if (X == Y) return;
par[Y] = X;
--comp_sz;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
c.resize(n + 1);
map<lli, DSU<lli>> virus;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= m; i++) {
cin >> u >> v;
x = c[u] ^ c[v];
virus[x].unite(u, v);
}
ans = ((fast_exp(2, k) - virus.size() + 1000000007) * fast_exp(2, n)) %
1000000007;
for (auto i : virus) {
curr = (i.second).comp_sz;
ans = (ans + fast_exp(2, curr)) % 1000000007;
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000");
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const double EPS = 1e-9;
const int INF = 1000000000 + 7;
const long long LINF = INF * 1LL * INF * 1LL;
const double PI = 3.1415926535897932384626433832795;
int N, r1, r2;
int mas[50000 + 10];
int par[50000 + 10];
vector<int> son[50000 + 10];
int main() {
ios_base::sync_with_stdio(false);
cin >> N;
cin >> r1 >> r2;
for (int i = (int)1; i <= N; i++) {
if (i == r1) continue;
cin >> mas[i];
son[mas[i]].push_back(i);
par[i] = mas[i];
}
int pos = r2;
while (mas[pos]) {
par[mas[pos]] = pos;
pos = mas[pos];
}
for (int i = (int)1; i <= N; i++) {
if (i == r2) continue;
cout << par[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int slen[105];
int plen;
int main() {
cin >> n >> k;
string s;
for (int i = 0; i < n; i++) cin >> s, slen[i] = s.length();
cin >> s;
plen = s.length();
slen[n] = 1000;
sort(slen, slen + n + 1);
for (int i = 0; i < n + 1; i++)
if (slen[i] == plen) {
cout << i / k * 5 + (i + 1) << " ";
break;
}
for (int i = 0; i < n + 1; i++)
if (slen[i] > plen) {
cout << (i - 1) / k * 5 + i << endl;
break;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long ff[100100], inv_ff[100100];
int q, n, f, prime[100100], sqr[100100], mu[100100], ans;
vector<int> divi[100100];
long long inv_mod(long long x) {
long long ret = 1LL, y = MOD - 2;
while (y) {
if (y & 1) ret = (ret * x) % MOD;
x = (x * x) % MOD, y >>= 1;
}
return ret;
}
long long C(int x, int y) {
if (y > x) return 0;
return (ff[x] * ((inv_ff[y] * inv_ff[x - y]) % MOD)) % MOD;
}
void precompute() {
inv_ff[0] = 1LL;
ff[0] = 1LL;
for (int i = 1; i <= 100099; i++) {
ff[i] = (ff[i - 1] * i) % MOD;
inv_ff[i] = inv_mod(ff[i]);
prime[i] = 1;
}
for (int i = 1; i <= 100099; i++) {
for (int j = i; j <= 100099; j += i) {
divi[j].push_back(i);
}
}
prime[0] = 0, prime[1] = 0;
for (int i = 2; i <= 100099; i++) {
if (prime[i] == 1) {
for (int j = i + i; j <= 100099; j += i) prime[j] = 0;
}
}
for (int i = 2; i * i <= 100099; i++) {
for (int j = (i * i); j <= 100099; j += (i * i)) sqr[j] = 1;
}
for (int i = 1; i <= 100099; i++) {
if (sqr[i]) continue;
int cnt = 0;
for (__typeof(divi[i].begin()) d(divi[i].begin()); d != divi[i].end(); d++)
if (prime[*d]) cnt++;
mu[i] = (cnt % 2 == 1) ? -1 : 1;
}
return;
}
int main() {
precompute();
scanf("%d", &q);
while (q--) {
scanf("%d%d", &n, &f);
if (n == 1 and f == 1) {
printf("1\n");
continue;
}
if (n > 1 and f == 1) {
printf("0\n");
continue;
}
ans = 0;
for (__typeof(divi[n].begin()) d(divi[n].begin()); d != divi[n].end();
d++) {
ans = ans + mu[*d] * C((n / (*d)) - 1, f - 1);
if (ans < 0)
ans += MOD;
else if (ans >= MOD)
ans -= MOD;
}
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int q, t, l, r, x, last;
map<int, int> fa, Xor;
int find(int x) {
if (fa[x] == x) return x;
int root = find(fa[x]);
Xor[x] ^= Xor[fa[x]];
return fa[x] = root;
}
int main() {
while (scanf("%d", &q) != EOF) {
fa.clear();
Xor.clear();
last = 0;
while (q--) {
scanf("%d%d%d", &t, &l, &r);
if (t == 1) {
scanf("%d", &x);
l ^= last;
r ^= last;
x ^= last;
if (l > r) swap(l, r);
++r;
if (fa.find(l) == fa.end()) fa[l] = l, Xor[l] = 0;
if (fa.find(r) == fa.end()) fa[r] = r, Xor[r] = 0;
int fl = find(l), fr = find(r);
if (fl != fr) {
fa[fl] = fr;
Xor[fl] = Xor[l] ^ Xor[r] ^ x;
}
} else {
l ^= last;
r ^= last;
if (l > r) swap(l, r);
++r;
if (fa.find(l) == fa.end() || fa.find(r) == fa.end()) {
last = 1;
puts("-1");
continue;
}
int fl = find(l), fr = find(r);
if (fl != fr) {
last = 1;
puts("-1");
} else {
last = Xor[l] ^ Xor[r];
printf("%d\n", last);
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x, y, x2, y2;
int v;
vector<int> mass1, mass2;
int check1(int ind) {
if (ind == -1 || ind == (int)mass1.size()) {
return 1e9;
}
return abs(mass1[ind] - x) + abs(x2 - mass1[ind]) + (y2 - y + v - 1) / v;
}
int check2(int ind) {
if (ind == -1 || ind == (int)mass2.size()) {
return 1e9;
}
return abs(mass2[ind] - x) + abs(x2 - mass2[ind]) + (y2 - y);
}
signed main() {
int n, m, c1, c2;
cin >> n >> m >> c1 >> c2 >> v;
mass1.resize(c2);
mass2.resize(c1);
for (int i = 0; i < c1; i++) {
cin >> mass2[i];
}
for (int i = 0; i < c2; i++) {
cin >> mass1[i];
}
int q;
cin >> q;
while (q--) {
cin >> x >> y >> x2 >> y2;
swap(x, y);
swap(x2, y2);
if (x > x2) {
swap(x, x2);
}
if (y > y2) {
swap(y, y2);
}
int ans = 1e9;
if (y == y2) {
ans = x2 - x;
}
int l1 = lower_bound(mass1.begin(), mass1.end(), x) - mass1.begin();
ans = min(ans, check1(l1));
ans = min(ans, check1(l1 - 1));
l1 = lower_bound(mass1.begin(), mass1.end(), x2) - mass1.begin();
ans = min(ans, check1(l1));
ans = min(ans, check1(l1 - 1));
l1 = lower_bound(mass2.begin(), mass2.end(), x) - mass2.begin();
ans = min(ans, check2(l1));
ans = min(ans, check2(l1 - 1));
l1 = lower_bound(mass2.begin(), mass2.end(), x2) - mass2.begin();
ans = min(ans, check2(l1));
ans = min(ans, check2(l1 - 1));
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,inline,unroll-loops,fast-math")
using namespace std;
int a[16];
int f[16][1 << 16 | 1], g[16][1 << 16 | 1], h[1 << 16 | 1];
int p[16];
int main(void) {
int t, n;
int i, j, k, s, l;
vector<int> y, x;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (l = 0; l < n; l++) {
for (s = 0; s < (1 << n); s++)
if (__builtin_popcount(s) == l) {
x.clear();
y.clear();
x.push_back(0);
for (i = 0; i < n; i++) (s & (1 << i) ? y : x).push_back(i);
for (i = 0; i < (1 << y.size()); i++)
for (j = h[i] = 0; j < (signed)y.size(); j++)
if (i & (1 << j)) h[i] += a[y[j]];
for (i = 0; i < (1 << y.size()); i++) f[0][i] = INT_MAX;
f[0][0] = 0;
for (i = 1; i < (signed)x.size(); i++)
for (j = 0; j < (1 << y.size()); j++) {
f[i][j] = INT_MAX;
if (a[x[i]] > f[i - 1][j]) {
f[i][j] = a[x[i]];
g[i][j] = 0;
} else
for (k = j; k; k = (k - 1) & j)
if (a[x[i]] + h[k] > f[i - 1][j ^ k] &&
a[x[i]] + h[k] < f[i][j]) {
f[i][j] = a[x[i]] + h[k];
g[i][j] = k;
}
}
if (f[x.size() - 1][(1 << y.size()) - 1] != INT_MAX) break;
}
if (s < (1 << n)) break;
}
printf("%d\n", l);
for (i = 0; i < n; i++) p[i] = i;
for (i = (signed)x.size() - 1, k = (1 << y.size()) - 1; i > 0; i--) {
for (j = 0; j < (signed)y.size(); j++)
if (g[i][k] & (1 << j)) {
printf("%d %d\n", p[y[j]] + 1, p[x[i]] + 1);
for (l = y[j]; l < n; l++) p[l]--;
}
k ^= g[i][k];
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], flag = 0, last = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (flag == 0 && a[i] == 1) flag = 1;
if (a[i] == 1) last = i;
}
if (flag == 0)
cout << "0";
else {
int i = 0, ans = 0;
while (i < n) {
if (i == last) {
ans++;
break;
}
if (a[i] == 0)
i++;
else if (a[i] == 1) {
ans++;
if (i != last && a[i + 1] == 0) ans++;
i++;
}
}
cout << ans;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 500001;
const long long inf = 1e18;
int n, m, arr[maxx], brr[maxx], cst[maxx];
long long fen[maxx], dp[maxx];
map<int, vector<int> > mp;
set<pair<int, int> > st;
void add(int in, int val) {
while (in <= n) {
fen[in] += val;
in += (in & -in);
}
}
long long get(int in) {
long long ret = 0;
while (in > 0) {
ret += fen[in];
in -= (in & -in);
}
return ret;
}
long long query(int l, int r) { return get(r) - get(l - 1); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> arr[i], mp[arr[i]].push_back(i), st.insert({arr[i], i});
for (int i = 1; i <= n; i++) cin >> cst[i], dp[i] = -inf;
cin >> m;
for (int i = 1; i <= m; i++) cin >> brr[i];
for (auto it : mp[brr[1]]) dp[it] = cst[it];
while (!st.empty() && (*st.begin()).first <= brr[1]) {
int x = (*st.begin()).second;
if (cst[x] > 0) add(x, cst[x]);
st.erase(st.begin());
}
for (int i = 1; i < m; i++) {
int x = brr[i], y = brr[i + 1];
vector<int> cur;
for (auto it : mp[x]) cur.push_back(it);
for (auto it : mp[y]) cur.push_back(it);
sort(cur.begin(), cur.end());
long long bst = -inf;
int lst = 0;
for (auto it : cur) {
bst += query(lst + 1, it);
lst = it;
if (arr[it] == x)
bst = max(bst, dp[it]);
else
dp[it] = bst + cst[it];
}
while (!st.empty() && (*st.begin()).first <= y) {
int x = (*st.begin()).second;
if (cst[x] > 0) add(x, cst[x]);
st.erase(st.begin());
}
}
long long res = -inf;
for (int i = 1; i <= n; i++) {
if (arr[i] == brr[m] && dp[i] != -inf)
res = max(res, dp[i] + query(i + 1, n));
}
if (res < -1e15)
cout << "NO" << '\n';
else {
res = -res;
cout << "YES" << '\n';
for (int i = 1; i <= n; i++) res += cst[i];
cout << res << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int k, b, n, t, res = 1, h = 0;
cin >> k >> b >> n >> t;
while (res <= t) {
res = res * k + b;
n--;
}
cout << max(n + 1, h) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long INF = 1e18 + 5;
const int maxn = 1000 + 5;
string second;
long long a, b, c, na, nb, nc, sa, sb, sc, r;
bool check(long long sum) {
long long cur = r;
if (a < na * sum) {
if (cur < (na * sum - a) * sa)
return 0;
else
cur -= (na * sum - a) * sa;
}
if (b < nb * sum) {
if (cur < (nb * sum - b) * sb)
return 0;
else
cur -= (nb * sum - b) * sb;
}
if (c < nc * sum) {
if (cur < (nc * sum - c) * sc)
return 0;
else
cur -= (nc * sum - c) * sc;
}
return 1;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(NULL);
cin >> second;
cin >> a >> b >> c;
cin >> sa >> sb >> sc;
cin >> r;
for (int i = 0; i < second.size(); i++) {
if (second[i] == 'B')
na++;
else if (second[i] == 'S')
nb++;
else
nc++;
}
long long l = 1, r = 1e13, ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double const PI_mul_2 = 6.283185307179586476925286766559;
int const MAX_SIZE = 262144 + 100;
struct my_complex {
long double re, im;
my_complex() { re = im = 0.0; }
my_complex mul_with(const my_complex& wth) {
my_complex ans;
ans.re = re * wth.re - im * wth.im;
ans.im = re * wth.im + im * wth.re;
return ans;
}
};
int rev[MAX_SIZE];
my_complex roots[MAX_SIZE];
void fft(my_complex const* const as, int n, my_complex* res) {
if (n <= 0) return;
int k = 0;
while ((1L << k) < n) k++;
rev[0] = 0;
int high1 = -1;
for (int i = 1; i < n; i++) {
if ((i & (i - 1)) == 0) high1++;
rev[i] = rev[i ^ (1L << high1)];
rev[i] |= (1L << (k - high1 - 1));
}
for (int i = 0; i < n; i++) res[i] = as[rev[i]];
long double inv_n = ((long double)1.0) / ((long double)n);
roots[0].re = 1.0;
roots[0].im = 0.0;
if (1 < n) {
roots[1].re = cos(PI_mul_2 * inv_n);
roots[1].im = sin(PI_mul_2 * inv_n);
}
for (int i = 2; i < n; i++) roots[i] = roots[i - 1].mul_with(roots[1]);
my_complex val;
for (int len = 1, rstep = n / 2; len < n; len <<= 1L, rstep /= 2)
for (int pdest = 0; pdest < n; pdest += len)
for (int i = 0; i < len; i++, pdest++) {
val = roots[i * rstep].mul_with(res[pdest + len]);
res[pdest + len].re = res[pdest].re - val.re;
res[pdest + len].im = res[pdest].im - val.im;
res[pdest].re += val.re;
res[pdest].im += val.im;
}
}
void fft_rev(my_complex const* const as, int n, my_complex* res) {
if (n <= 0) return;
fft(as, n, res);
long double inv_n = ((long double)1.0) / ((long double)n);
for (int i = 0; i < n; i++) {
res[i].re *= inv_n;
res[i].im *= inv_n;
}
for (int i = 1; i <= n / 2; i++) swap(res[i], res[n - i]);
}
my_complex a[MAX_SIZE], a_vals[MAX_SIZE], b[MAX_SIZE], tot_sum[MAX_SIZE];
int const MAX_CH = 200100;
char tmp[MAX_CH], st[MAX_CH], T[MAX_CH];
int n, m, k;
void solve(char ch, int is_first_run, int is_final_run) {
int loc_cnt = 0, bg = 0 - k, en = -1;
while (en <= k && en < n) {
if (st[en] == ch) loc_cnt++;
en++;
}
en--;
a[0].re = loc_cnt > 0;
a[0].im = 0.0;
int JJ = 0;
while (JJ < n - 1) {
if (en + 1 < n) {
en++;
loc_cnt += st[en] == ch;
}
if (bg >= 0) loc_cnt -= st[bg] == ch;
bg++;
JJ++;
a[JJ].re = loc_cnt > 0;
a[JJ].im = 0.0;
}
for (int i = 0; i < n / 2; i++) swap(a[i], a[n - 1 - i]);
for (int EE = 0; EE < m; EE++) {
if (T[EE] == ch)
b[EE].re = 1.0;
else
b[EE].re = 0.0;
b[EE].im = 0.0;
}
int gg = 1;
while (gg < n) gg <<= 1;
if (is_first_run) {
}
for (int i = 0; i < gg; i++) a[i].im = b[i].re;
for (int i = 0; i < gg; i++) {
a[i].re = (a[i].re + a[i].im) / 2.0;
a[i].im -= a[i].re;
}
int a_vals_len = 0;
fft(a, gg, a_vals);
for (int i = 0; i < gg; i++) {
tot_sum[i].re += a_vals[i].re * a_vals[i].re - a_vals[i].im * a_vals[i].im;
tot_sum[i].im += 2 * a_vals[i].re * a_vals[i].im;
}
if (is_final_run) {
fft_rev(tot_sum, gg, a);
int ans = 0;
for (int i = m - 1; i < n; i++) ans += ((int)(a[i].re + 0.5)) == m;
cout << ans;
}
}
int main() {
gets(tmp);
sscanf(tmp, "%d%d%d", &n, &m, &k);
gets(st);
gets(T);
solve('A', 1, 0);
solve('C', 0, 0);
solve('G', 0, 0);
solve('T', 0, 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, c[110];
long long f[110][110][110], p[110][110];
inline int read() {
int s(0);
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) s = s * 10 + c - '0', c = getchar();
return s;
}
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) c[i] = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) p[i][j] = read();
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int l = 0; l <= k; l++) f[i][j][l] = 1234567890123456789ll;
if (c[1])
f[1][c[1]][1] = 0;
else
for (int i = 1; i <= m; i++) f[1][i][1] = p[1][i];
for (int i = 2; i <= n; i++) {
if (c[i]) {
if (c[i - 1])
for (int j = 1; j <= min(i, k); j++)
f[i][c[i]][j] = c[i] == c[i - 1] ? f[i - 1][c[i - 1]][j]
: f[i - 1][c[i - 1]][j - 1];
else
for (int j = 1; j <= m; j++)
for (int l = 1; l <= min(i, k); l++)
f[i][c[i]][l] = min(
f[i][c[i]][l], j == c[i] ? f[i - 1][j][l] : f[i - 1][j][l - 1]);
} else if (c[i - 1])
for (int j = 1; j <= m; j++)
for (int l = 1; l <= min(i, k); l++) {
if (j == c[i - 1])
f[i][j][l] = f[i - 1][c[i - 1]][l] + p[i][j];
else
f[i][j][l] = f[i - 1][c[i - 1]][l - 1] + p[i][j];
}
else
for (int o = 1; o <= m; o++)
for (int j = 1; j <= m; j++)
for (int l = 1; l <= min(i, k); l++) {
if (j == o)
f[i][j][l] = min(f[i][j][l], f[i - 1][o][l] + p[i][j]);
else
f[i][j][l] = min(f[i][j][l], f[i - 1][o][l - 1] + p[i][j]);
}
}
long long ans = 1234567890123456789ll;
for (int i = 1; i <= m; i++) ans = min(ans, f[n][i][k]);
if (ans == 1234567890123456789ll)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
mt19937 gen(228);
vector<int> pos[26];
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int q;
cin >> q;
for (int i = 0; i < s.size(); i++) {
pos[s[i] - 'a'].push_back(i);
}
while (q--) {
int l, r;
cin >> l >> r;
l--;
if (r - l == 1) {
cout << "Yes\n";
continue;
}
if (s[l] != s[r - 1]) {
cout << "Yes\n";
continue;
}
int cnt = 0;
for (int i = 0; i < 26; i++) {
auto itl = lower_bound((pos[i]).begin(), (pos[i]).end(), l);
if (itl == pos[i].end() || *itl >= r) continue;
cnt++;
}
if (cnt >= 3) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200005], tmp[200005], max_value, n, temp, max_cnt;
bool visited[200005];
int main() {
queue<long long> q;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
tmp[i] = arr[i];
}
sort(tmp + 1, tmp + n + 1);
for (long long i = 1; i <= n; i++) {
temp++;
if (temp > max_cnt) {
max_cnt = temp;
max_value = tmp[i];
}
if (i < n && tmp[i] != tmp[i + 1]) temp = 0;
}
for (int i = 1; i <= n; i++) {
if (arr[i] == max_value) {
q.push(i);
visited[i] = true;
}
}
printf("%lld\n", n - max_cnt);
while (!q.empty()) {
long long go = q.front();
q.pop();
if (1 <= go - 1 && go - 1 <= n && arr[go - 1] != max_value &&
!visited[go - 1]) {
visited[go - 1] = true;
q.push(go - 1);
if (arr[go - 1] > max_value)
printf("2 %lld %lld\n", go - 1, go);
else
printf("1 %lld %lld\n", go - 1, go);
arr[go - 1] = max_value;
}
if (1 <= go + 1 && go + 1 <= n && arr[go + 1] != max_value &&
!visited[go + 1]) {
visited[go + 1] = true;
q.push(go + 1);
if (arr[go + 1] > max_value)
printf("2 %lld %lld\n", go + 1, go);
else
printf("1 %lld %lld\n", go + 1, go);
arr[go + 1] = max_value;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1000 * 100 + 100];
bool vis2[1000 * 100 + 100];
int val[1000 * 100 + 100];
int main() {
int n;
cin >> n;
if (n % 4 > 1) {
cout << -1 << endl;
return 0;
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
int v = 2;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
if (n % 2 == 1 && i == (n + 1) / 2)
val[i] = i;
else {
vis[n - v + 1] = vis[n - i + 1] = vis[v] = vis[i] = true;
val[v] = n - i + 1;
val[n - i + 1] = n - v + 1;
val[i] = v;
val[n - v + 1] = i;
v += 2;
;
}
}
}
for (int i = 1; i <= n; ++i) cout << val[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct frac {
long long int n1, d1, n2, d2;
};
frac t[200005], w[200005];
pair<int, int> v[200005];
bool compare(frac a, frac b) { return a.n2 * b.d2 <= b.n2 * a.d2; }
bool cmp(frac a, frac b) {
if (a.n1 * b.d1 == b.n1 * a.d1) return a.n2 * b.d2 > b.n2 * a.d2;
return a.n1 * b.d1 < b.n1 * a.d1;
}
long long int getinv(int l, int r) {
if (l == r) return 0;
int m = (l + r) / 2, i = l, j = (l + r) / 2 + 1, k = 0;
long long int ans = getinv(l, m);
ans += getinv(m + 1, r);
while (i <= m && j <= r) {
if (compare(t[j], t[i])) {
w[k++] = t[j++];
ans += m - i + 1;
} else if (compare(t[i], t[j])) {
w[k++] = t[i++];
} else {
w[k++] = t[i++];
}
}
while (i <= m) {
w[k++] = t[i++];
}
while (j <= r) {
w[k++] = t[j++];
}
for (i = l; i <= r; i++) t[i] = w[i - l];
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, i, w;
cin >> n >> w;
for (i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
t[i].n1 = abs(v[i].first);
t[i].d1 = abs(v[i].second + w);
t[i].n2 = abs(v[i].first);
t[i].d2 = abs(v[i].second - w);
}
sort(t, t + n, cmp);
cout << getinv(0, n - 1) << '\n';
return 0;
}
| 8 |
#include<iostream>
#include<vector>
#include<cstdio>
#include<map>
using namespace std;
#define ll long long
#define For(i,l,r) for(int i=l;i<=r;i++)
#define Pair pair<ll,ll>
#define F first
#define S second
#define MAXN 400001
int N,M;bool vis[MAXN],in[MAXN];map<Pair,int>id;vector<Pair>E[MAXN],ans;
int get(){int x=0;char c=getchar();while(c<'0'||c>'9')c=getchar();while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();return x;}
ll GCD(ll a,ll b){return b?GCD(b,a%b):a;}Pair turn(Pair x){return {x.F/GCD(x.F,x.S),x.S/GCD(x.F,x.S)};}
int dfs(int u)
{
int now=-1;vis[u]=in[u]=1;
for(auto i:E[u])
{
if(vis[i.F]){if(!in[i.F])now!=-1?ans.push_back({now,i.S}),now=-1:now=i.S;continue;}
int x=dfs(i.F);if(x!=-1)ans.push_back({x,i.S});else now!=-1?ans.push_back({now,i.S}),now=-1:now=i.S;
}
in[u]=0;return now;
}
int main()
{
N=get();For(i,1,N){int a=get(),b=get(),c=get(),d=get();Pair x=turn({1ll*b*c,1ll*(a+b)*d}),y=turn({1ll*b*(c+d),1ll*a*d});if(!id[x])id[x]=++M;if(!id[y])id[y]=++M;E[id[x]].push_back({id[y],i}),E[id[y]].push_back({id[x],i});}
For(i,1,M)if(!vis[i])dfs(i);cout<<ans.size()<<endl;for(auto i:ans)cout<<i.F<<' '<<i.S<<endl;return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
puts("2000");
int n = 1000;
for (int i = 1; i <= n; i++) printf("%d %d %d %d\n", i, 1, i, 2);
for (int i = n; i >= 1; i--) printf("%d %d %d %d\n", i, 1, i, 2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g[2];
vector<int> _was[2];
bool dfsX(int i, const vector<vector<int>> &gg, vector<int> &was) {
if (was[i] == 1) {
return false;
}
if (was[i] == 2) {
return true;
}
was[i] = 1;
for (auto u : gg[i]) {
if (!dfsX(u, gg, was)) {
return false;
}
}
was[i] = 2;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int m;
cin >> m;
for (int k = 0; k < 2; ++k) g[k].resize(n);
for (int k = 0; k < 2; ++k) _was[k].resize(n, 0);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
g[0][x].push_back(y);
g[1][y].push_back(x);
}
string ans(n, 'E');
for (int i = 0; i < n; ++i) {
if (_was[0][i] + _was[1][i] == 0) {
ans[i] = 'A';
}
for (int k = 0; k < 2; ++k) {
if (_was[k][i] > 0) {
continue;
}
if (!dfsX(i, g[k], _was[k])) {
cout << -1 << endl;
return 0;
}
}
}
int nA = 0;
for (int i = 0; i < n; ++i)
if (ans[i] == 'A') nA++;
cout << nA << endl;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int H, W, n;
const int MAX = 105;
bool edge[MAX][MAX][2];
bool bio[MAX][MAX];
bool ok(int x, int y) {
if (x < 0 || x >= H) return false;
if (y < 0 || y >= W) return false;
return true;
}
int flood(int x, int y) {
bio[x][y] = 1;
int ret = 1;
if (ok(x, y + 1) && edge[x][y][0] && !bio[x][y + 1]) ret += flood(x, y + 1);
if (ok(x + 1, y) && edge[x][y][1] && !bio[x + 1][y]) ret += flood(x + 1, y);
return ret;
}
int main() {
cin >> H >> W >> n;
for (int i = 0; i < MAX; i++)
for (int j = 0; j < MAX; j++)
for (int k = 0; k < 2; k++) edge[i][j][k] = true;
for (int i = 0; i < n; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
for (int j = y1; j < y2; j++) {
edge[x1 - 1][j][1] = false;
}
} else {
for (int j = x1; j < x2; j++) {
edge[j][y1 - 1][0] = false;
}
}
}
vector<int> ans;
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++) {
if (!bio[i][j]) {
ans.push_back(flood(i, j));
}
}
sort(ans.begin(), ans.end());
for (int i = 0; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<vector<int> > g(n + 1);
if (n * k > n * (n - 1) / 2) {
cout << -1 << endl;
exit(0);
}
cout << n * k << endl;
stringstream out;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
int k = (i + j) % n;
out << i + 1 << " " << k + 1 << endl;
}
}
cout << out.str();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> QwQ;
int l = 2;
int c[1005];
long long max(long long b, long long c) {
if (b > c) return b;
return c;
}
long long min(long long b, long long c) {
if (b > c) return c;
return b;
}
int main() {
int i, j, k, f = 0, t, p;
long long x1, x2, y1, y2;
double ans;
long long Ans1, Ans2, Ans = 0, m1, m2, sum;
int n;
k = 1;
t = 2;
c[1] = 4, c[2] = 7;
for (i = 2; i <= 9; i++) {
c[++l] = c[k] * 10 + 4;
p = l;
c[++l] = c[k] * 10 + 7;
for (j = k + 1; j <= t; j++) {
c[++l] = c[j] * 10 + 4;
c[++l] = c[j] * 10 + 7;
}
t = l;
k = p;
}
scanf("%I64d%I64d%I64d%I64d", &x1, &y1, &x2, &y2);
scanf("%d", &n);
c[0] = 0;
c[1023] = 2000000009;
for (i = 1; i <= 1022; i++) {
m1 = max(c[i - 1] + 1, x1);
m2 = min(c[i], y1);
Ans1 = m2 - m1 + 1;
if (Ans1 <= 0) continue;
j = i + n - 1;
if (j > 1022) break;
m1 = max(c[j], x2);
m2 = min(c[j + 1] - 1, y2);
Ans2 = m2 - m1 + 1;
if (Ans2 <= 0) continue;
Ans += Ans1 * Ans2;
}
for (i = 1; i <= 1022; i++) {
m1 = max(c[i - 1] + 1, x2);
m2 = min(c[i], y2);
Ans1 = m2 - m1 + 1;
if (Ans1 <= 0) continue;
j = i + n - 1;
if (j > 1022) break;
m1 = max(x1, c[j]);
m2 = min(c[j + 1] - 1, y1);
Ans2 = m2 - m1 + 1;
if (Ans2 <= 0) continue;
Ans += Ans1 * Ans2;
}
if (n == 1) {
for (i = 1; i <= 1022; i++) {
if (x1 <= c[i] && c[i] <= y1 && x2 <= c[i] && c[i] <= y2) Ans--;
}
}
sum = (y1 - x1 + 1) * (y2 - x2 + 1);
ans = (double)(Ans * 1.0) / (double)(sum * 1.0);
printf("%.12f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 * 100 + 7;
int pipe[2][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
string p[2];
cin >> p[0] >> p[1];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n; j++) {
if (p[i][j] == '1' || p[i][j] == '2')
pipe[i][j] = 0;
else
pipe[i][j] = 1;
}
}
int r = 0, c = 0, in = 1;
while (c < n) {
if (r == 1 && c == n - 1) break;
if (r == 0) {
if (in == 1) {
if (pipe[r][c] == 0) {
c++;
continue;
}
if (pipe[r][c] == 1) {
r++;
in = 2;
continue;
}
}
if (in == 4) {
if (pipe[r][c] == 0) {
break;
}
if (pipe[r][c] == 1) {
in = 1;
c++;
continue;
}
}
}
if (r == 1) {
if (in == 1) {
if (pipe[r][c] == 0) {
c++;
continue;
}
if (pipe[r][c] == 1) {
in = 4;
r--;
continue;
}
}
if (in == 2) {
if (pipe[r][c] == 0) {
break;
}
if (pipe[r][c] == 1) {
in = 1;
c++;
continue;
}
}
}
}
if (r == 1 && c == n - 1) {
if (in == 1 && pipe[r][c] == 0)
cout << "YES" << endl;
else if (in == 2 && pipe[r][c] == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
char s[100005], stack[100005], ss;
int main() {
long long n, k, now, i, i2, l, plus = 0, kid, pos;
scanf("%lld %lld", &n, &k);
for (i = 1; i <= k; i++) {
scanf("%lld", &now);
plus = 0;
ss = 0;
kid = n;
while (kid / 2 + plus + 1 != now) {
if (kid / 2 + plus + 1 < now) {
stack[++ss] = 'R';
plus += kid / 2 + 1;
kid /= 2;
} else {
stack[++ss] = 'L';
kid /= 2;
}
}
now = kid;
scanf("%s", s);
l = strlen(s);
for (i2 = 0; i2 < l; i2++) {
if (s[i2] == 'R') {
if (now == 1) continue;
plus += now / 2 + 1;
now /= 2;
stack[++ss] = 'R';
} else if (s[i2] == 'L') {
if (now == 1) continue;
now /= 2;
stack[++ss] = 'L';
} else {
if (now == n) continue;
if (stack[ss] == 'R') plus -= now + 1;
now = now * 2 + 1;
ss--;
}
}
printf("%lld\n", plus + now / 2 + 1);
}
return 0;
}
| 5 |
Subsets and Splits