solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long int i = 0; i < n; i++) {
if (arr[i] % 2 == 0) {
cout << arr[i] - 1 << " ";
} else {
cout << arr[i] << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int t, n, m, a, b, p;
while (~(scanf("%d", &n))) {
p = 0;
if (n >= 0)
printf("%d\n", n);
else {
n = -n;
m = n;
a = n % 10;
b = n / 10 % 10;
while (m != 0) {
m /= 10;
p++;
}
if (p == 2) {
if (a == 0) {
printf("0\n");
continue;
} else {
if (a >= b) {
printf("-%d\n", b);
continue;
}
if (a < b) {
printf("-%d\n", a);
continue;
}
}
} else {
if (b == 0) {
printf("-%d\n", n / 10);
continue;
} else if (a == 0) {
printf("-%d%d\n", n / 100, a);
continue;
} else {
if (a >= b) {
printf("-%d%d\n", n / 100, b);
continue;
}
if (a < b) {
printf("-%d%d\n", n / 100, a);
continue;
}
}
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int a[127543];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int s = 1;
int max = 0;
for (int i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
s++;
} else
s = 1;
if (s > max) max = s;
}
if (n == 1)
cout << 1 << endl;
else
cout << max << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1) cout << endl;
};
return os;
}
template <typename T>
void Out(T x) {
cout << x << endl;
}
template <typename T1, typename T2>
void Ans(bool first, T1 y, T2 n) {
if (first)
Out(y);
else
Out(n);
}
using vec = vector<long long>;
using mat = vector<vec>;
using Pii = pair<long long, long long>;
using PiP = pair<long long, Pii>;
using PPi = pair<Pii, long long>;
using bools = vector<bool>;
using pairs = vector<Pii>;
const long long mod = 1000000007;
struct LazySegmentTree {
using T_A = long long;
using T_B = long long;
T_A id_A = -1000000000000000000;
T_B id_B = 0;
long long N;
vector<T_A> dat;
vector<T_B> ope;
inline T_A F_AA(T_A &u, T_A &v) { return max(u, v); }
inline T_A F_AB(T_A &u, T_B &v, long long sz) { return u + v; }
inline T_B F_BB(T_B &u, T_B &v) { return u + v; }
LazySegmentTree(long long n) {
N = 1;
while (n > N) N = N << 1;
dat = vector<T_A>(2 * N - 1, id_A);
ope = vector<T_B>(2 * N - 1, id_B);
}
LazySegmentTree(long long n, vector<T_A> &v) {
N = 1;
while (n > N) N = N << 1;
dat = vector<T_A>(2 * N - 1, id_A);
ope = vector<T_B>(2 * N - 1, id_B);
for (long long i = (0); i < (n); i++) dat[i + N - 1] = v[i];
for (long long i = (N - 1) - 1; i >= (0); i--)
dat[i] = F_AA(dat[i * 2 + 1], dat[i * 2 + 2]);
}
void eval(long long k, long long l, long long r) {
if (ope[k] != id_B) {
dat[k] = F_AB(dat[k], ope[k], r - l);
if (r - l > 1) {
ope[k * 2 + 1] = F_BB(ope[k * 2 + 1], ope[k]);
ope[k * 2 + 2] = F_BB(ope[k * 2 + 2], ope[k]);
}
ope[k] = id_B;
}
}
void update(long long a, long long b, T_B x, long long k, long long l,
long long r) {
eval(k, l, r);
if (b <= l || r <= a) return;
if (a <= l && r <= b) {
ope[k] = F_BB(ope[k], x);
eval(k, l, r);
} else {
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
dat[k] = F_AA(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
T_A get(long long a, long long b, long long k, long long l, long long r) {
if (r <= a || b <= l) return id_A;
eval(k, l, r);
if (a <= l && r <= b)
return dat[k];
else {
T_A vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
T_A vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
return F_AA(vl, vr);
}
}
void update(long long a, long long b, T_B x) { update(a, b, x, 0, 0, N); }
T_A get(long long a, long long b) { return get(a, b, 0, 0, N); }
T_A val(long long k) { return get(k, k + 1); }
long long dfs(long long l = -1, long long r = -1, long long k = -1) {
if (l == -1) l = 0, r = N, k = 0;
eval(k, l, r);
if (dat[k] <= 0) return -1;
if (r - l == 1) return l;
long long c = (l + r) / 2;
long long i1 = dfs(c, r, k * 2 + 2);
if (i1 >= 0) return i1;
long long i2 = dfs(l, c, k * 2 + 1);
return i2;
}
};
signed main() {
long long n, m;
cin >> n >> m;
vec a(n);
cin >> a;
vec b(m);
cin >> b;
long long q;
cin >> q;
vec ans(q);
const long long N = 1000000;
vec ini(N + 1, 0);
for (long long i = (0); i < (n); i++) ini[a[i]]++;
for (long long i = (0); i < (m); i++) ini[b[i]]--;
for (long long i = (N)-1; i >= (0); i--) ini[i] += ini[i + 1];
LazySegmentTree ST(N + 1, ini);
long long t, i0, x;
for (long long i = (0); i < (q); i++) {
cin >> t >> i0 >> x;
i0--;
if (t == 1) {
ST.update(0, a[i0] + 1, -1);
a[i0] = x;
ST.update(0, a[i0] + 1, 1);
} else {
ST.update(0, b[i0] + 1, 1);
b[i0] = x;
ST.update(0, b[i0] + 1, -1);
}
ans[i] = ST.dfs();
}
for (long long i = (0); i < (q); i++) cout << ans[i] << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[1001], b[1001];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int ans = 0;
for (int i = 0; i < n; i++) {
int x, y;
x = y = 0;
for (int j = i; j < n; j++) {
x = x | a[j];
y = y | b[j];
ans = max(ans, x + y);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, a[maxn], b[maxn], sgmnt[maxn * 10], A[maxn], B[maxn];
void Build(int v = 1, int l = 0, int r = n - 1) {
sgmnt[v] = r - l + 1;
int mid = l + r >> 1;
if (l < r) {
Build(v * 2, l, mid);
Build(v * 2 + 1, mid + 1, r);
}
}
void Delete(int id, int v = 1, int l = 0, int r = n - 1) {
sgmnt[v]--;
if (l < r) {
int mid = l + r >> 1;
if (id <= mid)
Delete(id, v * 2, l, mid);
else
Delete(id, v * 2 + 1, mid + 1, r);
}
}
int Sum(int L, int R, int v = 1, int l = 0, int r = n - 1) {
if (L > R) return 0;
if (l == L && r == R) return sgmnt[v];
int mid = l + r >> 1, tmp = 0;
if (l <= mid) tmp += Sum(L, min(mid, R), v * 2, l, mid);
if (mid + 1 <= r) tmp += Sum(max(mid + 1, L), R, 2 * v + 1, mid + 1, r);
return tmp;
}
int Val(int id, int v = 1, int l = 0, int r = n - 1) {
if (l == r) return l;
int mid = l + r >> 1;
if (id < sgmnt[v * 2])
return Val(id, v * 2, l, mid);
else
return Val(id - sgmnt[v * 2], v * 2 + 1, mid + 1, r);
}
void Create(int a[], int arr[]) {
Build();
for (int i = n - 1; i >= 0; i--) {
arr[i] = Sum(0, a[i] - 1);
Delete(a[i]);
}
}
int32_t main() {
cin >> n;
for (int i = n - 1; i >= 0; i--) cin >> a[i];
for (int i = n - 1; i >= 0; i--) cin >> b[i];
Create(a, A);
Create(b, B);
for (int i = 0; i < n; i++)
A[i] += B[i], A[i + 1] += A[i] / (i + 1), A[i] %= i + 1;
Build();
for (int i = n - 1; i >= 0; i--) {
int tmp = Val(A[i]);
cout << tmp << " ";
Delete(tmp);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int32_t tests;
cin >> tests;
for (int32_t test = 0; test < tests; test++) {
int64_t a, b;
cin >> a >> b;
if (a < b) {
swap(a, b);
}
if ((a + b) % 3 == 0 && 2 * a >= b && 2 * b >= a) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define maxn 200005
int fa[maxn];
int n, m;
ll k;
struct node {
int a, b, c;
node(int a = 0, int b = 0, ll c = 0)
:a(a), b(b), c(c) {}
bool operator<(const node& a)const {
return c < a.c;
}
};
int find(int i) {
while (i != fa[i])i = fa[i] = fa[fa[i]];
return i;
}
int un(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
fa[a] = b;
return 1;
}
return 0;
}
vector<node> vec1, vec2;
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i <= n; i++)fa[i] = i;
vec1.clear(); vec2.clear();
ll a, b, c;
ll ans = 2e12;
for (int i = 0; i < m; i++) {
scanf("%lld%lld%lld", &a, &b, &c);
if (c <= k) vec1.push_back(node(a, b, c));
else vec2.push_back(node(a, b, c));
ans = min(abs(c - k), ans);
}
int num = 0;
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
for (int i = 0; i < vec1.size(); i++) {
if (un(vec1[i].a, vec1[i].b))num++;
}
ll ans2 = 0;
int num2 = 0;
for (int i = 0; i < vec2.size(); i++) {
if (un(vec2[i].a, vec2[i].b))num2++, ans2 += vec2[i].c - k;
}
if (ans2)
printf("%lld\n", ans2);
else printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
double r, h;
int ans, x;
int main() {
cin >> r >> h;
x = (h + r * (1 - sqrt(3) / 2)) / r;
ans = (1 + 2 * x);
if (2 * h >= r) {
x = (2 * h - r) / (2 * r);
ans = max(ans, 2 + 2 * x);
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, d, mod, inv[N], f[N][11][N];
int main() {
scanf("%d%d%d", &n, &d, &mod), inv[0] = inv[1] = 1;
if (n <= 2) return puts("1"), 0;
for (int i = 2; i < n; ++i)
inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
f[1][0][0] = f[1][d - 1][0] = 1;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= d; ++j)
for (int k = 1; k < i; ++k) {
f[i][j][k] = f[i][j][k - 1];
for (int t = 1, res = 1, p = f[k][d - 1][k - 1] - 1;
t * k < i && t <= j; ++t)
res = 1LL * res * (++p) % mod * inv[t] % mod,
(f[i][j][k] += 1LL * f[i - t * k][j - t][min(k - 1, i - t * k - 1)] *
res % mod) %= mod;
}
printf("%lld\n", (f[n][d][(n + 1) / 2 - 1] +
1LL * (1 - n % 2) * f[n / 2][d - 1][n / 2 - 1] *
(f[n / 2][d - 1][n / 2 - 1] + 1) / 2 % mod) %
mod);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int n, m, r, c;
double a[N][N], b[N], tmp[N][N];
double f[N];
void init() {
int i, j;
tmp[1][1] = tmp[1][2] = tmp[m][m - 1] = tmp[m][m] = 1.0 / 3;
for (i = 2; i <= m - 1; ++i)
for (j = i - 1; j <= i + 1; ++j) tmp[i][j] = 0.25;
for (i = 1; i <= m; ++i) tmp[i][i] -= 1;
}
void cp() {
int i, j;
for (i = 1; i <= m; ++i)
for (j = i - 1; j <= i + 1; ++j) a[i][j] = tmp[i][j];
b[1] = -1 - f[1] / 3, b[m] = -1 - f[m] / 3;
for (i = 2; i <= m - 1; ++i) b[i] = -1 - f[i] / 4;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int i, j, k;
scanf("%d%d%d%d", &n, &m, &r, &c);
if (m == 1) {
printf("%d.0000\n", (n - r) * 2);
return 0;
}
init();
for (i = n - 1; i >= r; --i) {
cp();
for (k = 1; k <= m - 1; ++k) {
double c = a[k + 1][k] / a[k][k];
a[k + 1][k + 1] -= c * a[k][k + 1];
b[k + 1] -= c * b[k];
}
f[m] = b[m] / a[m][m];
for (k = m - 1; k >= 1; --k)
f[k] = (b[k] - a[k][k + 1] * f[k + 1]) / a[k][k];
}
printf("%.4lf\n", f[c]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << ((n % 2) ? n / 2 : n / 2 - 1) << endl;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
int a[14] = {0};
int b[14] = {0};
long long max = 0;
long long temp = 0;
long long cur;
int i, j, k, fp;
for (i = 0; i < 14; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < 14; i++) {
if (a[i] == 0)
continue;
else {
memcpy(b, a, sizeof(a));
j = i;
cur = b[j];
b[j] = 0;
if (cur > 14) {
fp = cur / 14;
cur = cur % 14;
for (k = 0; k < 14; k++) b[k] += fp;
}
do {
if (j >= 13) j -= 14;
b[j + 1] += 1;
j++;
cur--;
} while (cur > 0);
for (k = 0; k < 14; k++) {
if (b[k] % 2 == 0) temp += b[k];
}
if (temp > max) max = temp;
temp = 0;
}
}
printf("%lld\n", max);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a[10];
a[1] = "1";
a[2] = "2";
a[3] = "3";
a[4] = "322";
a[5] = "5";
a[6] = "35";
a[7] = "7";
a[8] = "7222";
a[9] = "7332";
long long int n;
scanf("%I64d", &n);
getchar();
string s;
cin >> s;
vector<string> v;
for (long long int i = 0; i < n; i++) {
if (s[i] > '1' && s[i] <= '9') {
long long int temp = s[i] - '0';
v.push_back(a[temp]);
}
}
string q;
vector<string>::iterator itr;
for (itr = v.begin(); itr != v.end(); itr++) {
q += *itr;
}
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
cout << q << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
vector<long long> v;
cout << 0 << " ";
long long sum = arr[0];
v.push_back(arr[0]);
vector<long long> a;
long long c = 0;
for (long long i = 1; i < n; i++) {
sum = sum + arr[i];
if (sum <= m) {
cout << c << " ";
v.push_back(arr[i]);
push_heap(v.begin(), v.end());
} else {
while (sum > m) {
sum = sum - v[0];
pop_heap(v.begin(), v.end());
long long k = v.back();
v.pop_back();
a.push_back(k);
push_heap(a.begin(), a.end(), greater<int>());
c++;
}
cout << c << " ";
if (!a.empty()) {
if (arr[i] < a[0]) {
v.push_back(arr[i]);
push_heap(v.begin(), v.end());
} else {
sum = sum - arr[i];
while (!a.empty()) {
sum = sum + a[0];
if (sum > m) {
sum = sum - a[0];
break;
}
pop_heap(a.begin(), a.end(), greater<int>());
long long k = a.back();
a.pop_back();
v.push_back(k);
push_heap(v.begin(), v.end());
c--;
}
a.push_back(arr[i]);
push_heap(a.begin(), a.end(), greater<int>());
c++;
}
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
if (n == 0) {
return 0;
} else {
cin >> s;
if (!(n % 2)) {
for (int i = 0; i < n; i++) {
cout << s[i];
if (i == n - 1) break;
if (i & 1) cout << '-';
}
} else {
for (int i = 0; i < n - 3; i++) {
cout << s[i];
if (i & 1) cout << '-';
}
for (int i = n - 3; i <= n - 1; i++) cout << s[i];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void OPEN(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
vector<pair<pair<int, int>, int> > p;
char cc[405][405];
int main() {
p.clear();
for (int i = 0; i < (3); ++i) {
int l, w;
cin >> l >> w;
p.push_back(make_pair(make_pair(l, w), i));
}
sort(p.begin(), p.end());
for (int i = 0; i < (401); ++i)
for (int j = 0; j < (401); ++j) cc[i][j] = '.';
do {
for (int i = 0; i < (2); ++i) {
for (int j = 0; j < (2); ++j) {
for (int k = 0; k < (2); ++k) {
int w1, h1, w2, h2;
w1 = p[0].first.first + p[1].first.first;
h1 = p[0].first.second + p[2].first.second;
w2 = p[2].first.first + p[1].first.first;
h2 = p[1].first.second;
if (w1 == h1 && w1 == w2 && h1 == h2) {
for (int it = 0; it < (p[0].first.first); ++it) {
for (int jt = 0; jt < (p[0].first.second); ++jt) {
cc[it][jt] = (char)(p[0].second + 'A');
}
}
for (int it = (p[0].first.first);
it <= (p[0].first.first + p[1].first.first - 1); ++it) {
for (int jt = 0; jt < (p[1].first.second); ++jt) {
cc[it][jt] = (char)(p[1].second + 'A');
}
}
for (int it = 0; it < (p[2].first.first); ++it) {
for (int jt = (p[0].first.second);
jt <= (p[0].first.second + p[2].first.second - 1); ++jt) {
cc[it][jt] = (char)(p[2].second + 'A');
}
}
cout << w1 << endl;
for (int it = 0; it < (w1); ++it) {
for (int jt = 0; jt < (w1); ++jt) {
cout << cc[it][jt];
}
cout << endl;
}
return 0;
}
w1 = p[0].first.first + p[1].first.first + p[2].first.first;
if (w1 == p[0].first.second && w1 == p[1].first.second &&
w1 == p[2].first.second) {
for (int it = 0; it < (p[0].first.first); ++it) {
for (int jt = 0; jt < (p[0].first.second); ++jt) {
cc[it][jt] = (char)(p[0].second + 'A');
}
}
for (int it = (p[0].first.first);
it <= (p[0].first.first + p[1].first.first - 1); ++it) {
for (int jt = 0; jt < (p[1].first.second); ++jt) {
cc[it][jt] = (char)(p[1].second + 'A');
}
}
for (int it = (p[0].first.first + p[1].first.first);
it <=
(p[0].first.first + p[1].first.first + p[2].first.first - 1);
++it) {
for (int jt = 0; jt < (p[2].first.second); ++jt) {
cc[it][jt] = (char)(p[2].second + 'A');
}
}
cout << w1 << endl;
for (int it = 0; it < (w1); ++it) {
for (int jt = 0; jt < (w1); ++jt) {
cout << cc[it][jt];
}
cout << endl;
}
return 0;
}
swap(p[2].first.first, p[2].first.second);
}
swap(p[1].first.first, p[1].first.second);
}
swap(p[0].first.first, p[0].first.second);
}
} while (next_permutation(p.begin(), p.end()));
cout << -1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100005];
long long n;
bool check() {
for (long long j = 0; j < (n - 1); j++) {
if (abs(arr[j] - arr[j + 1]) != 1) return false;
}
return true;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long a, b, c, d, i;
cin >> a >> b >> c >> d;
n = a + b + c + d;
long long even[100005];
long long odd[100005];
;
for (i = 0; i < 1e5; i++) arr[i] = -2, odd[i] = -2, even[i] = -2;
for (i = 0; i < a + c; i++) {
if (i < a)
even[i] = 0;
else
even[i] = 2;
}
for (i = 0; i < b + d; i++) {
if (i < b)
odd[i] = 1;
else
odd[i] = 3;
}
if (n == 1) {
cout << "YES\n";
if (a == 1)
cout << "0";
else if (b == 1)
cout << "1";
else if (c == 1)
cout << "2";
else
cout << "3";
return 0;
}
for (i = 0; i < n; i += 2) {
arr[i] = even[(i / 2)];
arr[i + 1] = odd[i / 2];
}
if (check()) {
cout << "YES\n";
for (i = 0; i < n; i++) cout << arr[i] << " ";
} else {
for (i = 0; i < n; i += 2) {
arr[i] = odd[(i / 2)];
arr[i + 1] = even[i / 2];
}
if (check()) {
cout << "YES\n";
for (i = 0; i < n; i++) cout << arr[i] << " ";
} else
cout << "NO";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int oo = int(2e9) + 9;
const double eps = 1e-9;
const double pi = 3.14159265358979323846264338327950;
vector<vector<pair<int, int> > > AdjList(100005);
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > dist(100005);
map<pair<int, int>, int> is;
int y = 0;
for (int i = 0; i <= 100004; i++) dist[i] = make_pair(oo, oo);
for (int i = 1; i <= m; i++) {
int u, v, f;
cin >> u >> v >> f;
AdjList[u].push_back(make_pair(v, f));
AdjList[v].push_back(make_pair(u, f));
y += (f == 1);
}
vector<pair<int, int> > parent(100005);
parent[1] = make_pair(0, -1);
priority_queue<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int> >,
greater<pair<pair<int, int>, int> > >
pq;
pq.push(make_pair(make_pair(0, 0), 1));
dist[1] = make_pair(0, 0);
while (!pq.empty()) {
int d1 = pq.top().first.first;
int d2 = pq.top().first.second;
int u = pq.top().second;
pq.pop();
if (d1 != dist[u].first) continue;
for (vector<pair<int, int> >::iterator v = (AdjList[u]).begin();
v != (AdjList[u]).end(); v++) {
if (dist[v->first].first > d1 + 1) {
dist[v->first].first = d1 + 1;
dist[v->first].second = d2 + v->second;
pq.push(make_pair(dist[v->first], v->first));
parent[v->first] = make_pair(u, 1 - v->second);
continue;
}
if (dist[v->first].first == d1 + 1)
if (dist[v->first].second < d2 + v->second) {
dist[v->first].second = d2 + v->second;
pq.push(make_pair(dist[v->first], v->first));
parent[v->first] = make_pair(u, 1 - v->second);
}
}
}
cout << dist[n].first + y - 2 * dist[n].second << endl;
int t = n;
int color[100005];
memset(color, 00, sizeof(color));
color[t] = 1;
while (t != 0) {
if (parent[t].second == 1)
cout << parent[t].first << " " << t << " " << parent[t].second << endl;
t = parent[t].first;
color[t] = 1;
}
for (int u = 1; u <= n; u++)
for (vector<pair<int, int> >::iterator v = (AdjList[u]).begin();
v != (AdjList[u]).end(); v++)
if (!is[make_pair(u, v->first)])
if (!(color[v->first] == 1 && color[u] == 1))
if (v->second == 1) {
cout << u << " " << v->first << " "
<< "0\n";
is[make_pair(u, v->first)] = true;
is[make_pair(v->first, u)] = true;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
struct node {
int val[4][4], Add;
node() {
memset(val, 0, sizeof val);
Add = 0;
}
};
node seg[maxn * 4];
int n;
const int zarib[] = {1, -2, 1};
int Z[4][4];
node merge(node a, node b) {
node c = a;
c.Add = 0;
for (int l = 0; l < 3; l++)
for (int r = l + 1; r < 4; r++)
for (int k = l; k < r; k++)
c.val[l][r] = max(c.val[l][r], a.val[l][k] + b.val[k][r]);
return c;
}
void put(int v, int val) {
seg[v].Add += val;
for (int l = 0; l < 3; l++)
for (int r = l + 1; r < 4; r++) seg[v].val[l][r] += Z[l][r] * val;
}
void shift(int s, int e, int v) {
if (e - s >= 2 && seg[v].Add) {
put(2 * v, seg[v].Add);
put(2 * v + 1, seg[v].Add);
}
seg[v].Add = 0;
}
void add(int l, int r, int val, int s = 0, int e = n, int v = 1) {
if (l <= s && e <= r) {
put(v, val);
return;
}
if (r <= s || e <= l) return;
shift(s, e, v);
int m = (s + e) / 2;
add(l, r, val, s, m, 2 * v);
add(l, r, val, m, e, 2 * v + 1);
seg[v] = merge(seg[2 * v], seg[2 * v + 1]);
}
string s;
void handle(int i, int val) {
if (s[i] == '(')
add(i + 1, n, val);
else
add(i + 1, n, -val);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int l = 0; l < 3; l++)
for (int r = l + 1; r < 4; r++) Z[l][r] = Z[l][r - 1] + zarib[r - 1];
int q;
cin >> n >> q >> s;
n = 2 * (n - 1) + 1;
for (int i = 0; i < n - 1; i++) handle(i, 1);
cout << seg[1].val[0][3] << endl;
while (q--) {
int x, y;
cin >> x >> y;
x--, y--;
handle(x, -1), handle(y, -1);
swap(s[x], s[y]);
handle(x, 1), handle(y, 1);
cout << seg[1].val[0][3] << endl;
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void Read(T &n) {
char c;
n = 0;
while (!isdigit(c = getchar()))
;
do {
n = n * 10 + c - '0';
} while (isdigit(c = getchar()));
}
const int N = 1E6 + 2;
const int B = 62;
int n;
long long k, a[N];
int ver1[N], ver2[N];
int Tsize, cnt[N], child[N][2];
void Read_Input() {
Read(n);
Read(k);
for (int i = 2; i <= n; i++) {
int u;
long long w;
Read(u);
Read(w);
a[i] = a[u] ^ w;
}
}
long long Cal(int pos) {
Tsize = 0;
memset(cnt, 0, sizeof(cnt));
memset(child, -1, sizeof(child));
for (int i = 1; i <= n; i++) {
int c = a[i] >> pos & 1;
if (ver1[i] == -1) continue;
if (child[ver1[i]][c] == -1) child[ver1[i]][c] = ++Tsize;
ver1[i] = child[ver1[i]][c];
cnt[ver1[i]]++;
}
long long ret = 0;
for (int i = 1; i <= n; i++) {
int c = a[i] >> pos & 1;
if (ver2[i] == -1) continue;
ret += cnt[child[ver2[i]][c]];
}
return ret;
}
void Solve() {
long long ans = 0;
for (int pos = 61; pos >= 0; pos--) {
long long x = Cal(pos);
if (x < k) {
k -= x;
ans |= 1ll << pos;
for (int i = 1; i <= n; i++) {
int c = a[i] >> pos & 1;
if (ver2[i] == -1) continue;
ver2[i] = child[ver2[i]][c ^ 1];
}
} else {
for (int i = 1; i <= n; i++) {
int c = a[i] >> pos & 1;
if (ver2[i] == -1) continue;
ver2[i] = child[ver2[i]][c];
}
}
}
printf("%I64d", ans);
}
int main() {
Read_Input();
Solve();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
long long ans;
int cnt;
int main() {
int n, m;
cin >> n >> m;
if (m == 0 && n != 1 || n * 9 < m) {
cout << "-1"
<< " "
<< "-1";
return 0;
}
if (m == 0 && n == 1) {
cout << 0 << " " << 0;
return 0;
}
while (ans + 9 < m) {
s += '9';
ans += 9;
}
ans = m - ans;
for (int i = 1; n >= i; i++) {
for (int j = 0; 9 >= j; j++) {
if ((m - j - cnt) <= (n - i) * 9) {
if (i == 1 && j == 0) continue;
cnt += j;
cout << j;
break;
}
}
}
cout << " ";
for (int i = 0; n > i; i++) {
if (s.size() < i)
cout << 0;
else if (s.size() == i)
cout << ans;
else
cout << s[i];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n, m, h, s, sh;
long double prob(int j) {
long double ret = 1;
for (int t = s - sh; t >= s - sh - n + j + 1; t--) ret *= t;
for (int t = s; t >= s - n + 1; t--) ret /= t;
for (int t = n; t >= n - j + 1; t--) ret *= t;
for (int t = j; t >= 1; t--) ret /= t;
for (int t = sh; t >= sh - j + 1; t--) ret *= t;
return ret;
}
int main() {
read_file();
while (cin >> n >> m >> h) {
s = -1;
n--;
h--;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (i == h) sh = x - 1;
s += x;
}
if (s < n) {
cout << -1 << '\n';
continue;
}
double ans = 0;
for (int j = 1; j <= sh; j++) {
if (0 <= n - j && n - j <= s - sh) ans += prob(j);
}
printf("%.25lf\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int A;
int GCD(int a, int b) {
if (b == 0) return a;
return GCD(b, a % b);
}
int solve(int b) {
int n = A, sum = 0;
while (n != 0) {
sum += n % b;
n /= b;
}
return sum;
}
int main() {
int sum = 0;
cin >> A;
for (int b = 2; b <= A - 1; b++) {
sum += solve(b);
}
int gcd = GCD(sum, A - 2);
cout << sum / gcd << "/" << (A - 2) / gcd;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int inf = 0x3f3f3f3f;
int t;
long long n, m, a, b;
long long ans;
int main() {
cin >> t;
while (t--) {
scanf("%lld%lld%lld%lld", &a, &b, &n, &m);
if (a + b < n + m) {
puts("No");
continue;
}
if (a > b) {
if (b >= m) {
long long c = b - m;
if (c + a < n)
puts("No");
else
puts("Yes");
} else {
long long c = a - b;
n -= c;
a = b;
if (a >= m && a - m + b >= n)
puts("Yes");
else
puts("No");
}
} else {
if (a >= m) {
long long c = a - m;
if (c + b < n)
puts("No");
else
puts("Yes");
} else {
long long c = b - a;
n -= c;
b = a;
if (a >= m && a - m + b >= n)
puts("Yes");
else
puts("No");
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long perso[100010], bike[100010], n, m, a;
pair<int, int> check2(long long k, long long s) {
long long count = 0, sum = 0;
for (int i = n - k, j = 0; j < k and i < n; j++, i++) {
if (perso[i] >= bike[j]) {
count++;
sum += bike[j];
} else {
if (s + perso[i] >= bike[j]) {
s -= bike[j] - perso[i];
sum += perso[i];
count++;
} else
break;
}
}
sum -= s;
if (sum < 0) sum = 0;
pair<int, int> p = pair<int, int>(count, sum);
return p;
}
int main() {
while (cin >> n >> m >> a) {
for (int i = 0; i < n; i++) scanf("%d", &perso[i]);
for (int i = 0; i < m; i++) scanf("%d", &bike[i]);
sort(perso, perso + n);
sort(bike, bike + m);
long long low = 0, high = min(n, m), mid, ans = 0, sum = 0, x, y;
pair<int, int> c;
while (low <= high) {
mid = (low + high) / 2;
c = check2(mid, a);
x = c.first;
y = c.second;
if (x == mid) {
low = mid + 1;
ans = mid;
sum = y;
} else
high = mid - 1;
}
printf("%lld %lld\n", ans, sum);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010 + 1;
int n, m, ans[MAXN];
pair<pair<int, int>, int> box[MAXN];
bool tag[MAXN];
int main() {
int task;
scanf("%d", &task);
for (int oo = 0; oo < task; oo++) {
scanf("%d", &n);
m = (n << 1) - 1;
for (int i = 0; i < m; i++) {
scanf("%d%d", &box[i].first.first, &box[i].first.second);
box[i].second = i + 1;
}
sort(box, box + m);
for (int i = 0; i < m - 1; i += 2) {
ans[i >> 1] =
box[box[i].first.second > box[i + 1].first.second ? i : i + 1].second;
}
ans[n - 1] = box[m - 1].second;
sort(ans, ans + n);
puts("YES");
for (int i = 0; i < n; i++) {
printf("%d%c", ans[i], i != n - 1 ? ' ' : '\n');
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int t[2 * 400];
int main() {
int n;
while (cin >> n) {
vector<pair<int, pair<int, int> > > a;
int j = 1, k = 0;
for (int i = 0; i < (2 * n - 1) * n; ++i) {
int x;
cin >> x;
a.push_back(pair<int, pair<int, int> >(x, pair<int, int>(j, k)));
k++;
if (j == k) {
j++;
k = 0;
}
}
sort(a.begin(), a.end());
memset(t, 0, sizeof(t));
for (int i = a.size() - 1; i >= 0; --i) {
int x = a[i].second.first;
int y = a[i].second.second;
if (t[x] || t[y]) continue;
t[x] = y + 1, t[y] = x + 1;
}
cout << t[0];
for (int i = 1; i < 2 * n; ++i) {
cout << ' ' << t[i];
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MAXN = 1000006;
pair<int, int> P[4];
int best, x1, x2, d;
pair<int, int> ANS[4];
bool swapped;
int per[4];
int test(int y1, int y2) {
assert(x2 - x1 == y2 - y1);
pair<int, int> S[] = {pair<int, int>(x1, y1), pair<int, int>(x1, y2),
pair<int, int>(x2, y1), pair<int, int>(x2, y2)};
for (int i = 0; i < (4); ++i) per[i] = i;
int ret = 1 << 30;
do {
bool ok = 1;
int c = 0;
for (int i = 0; i < (4); ++i) {
pair<int, int> w = P[per[i]];
if (w.first != S[i].first && w.second != S[i].second) {
ok = 0;
continue;
}
c = max(c, abs(w.first - S[i].first) + abs(w.second - S[i].second));
}
if (ok && c < best) {
best = c;
for (int i = 0; i < (4); ++i) ANS[per[i]] = S[i];
if (swapped)
for (int i = 0; i < (4); ++i) swap(ANS[i].first, ANS[i].second);
}
if (ok) ret = min(ret, c);
} while (next_permutation(per, per + 4));
return ret;
}
int probuj(int second) {
return min(test(second - d, second), test(second, second + d));
}
void go() {
vector<int> first;
for (int i = 0; i < (4); ++i) first.push_back(P[i].first);
sort((first).begin(), (first).end());
first.resize(unique((first).begin(), (first).end()) - first.begin());
for (int i = 0; i < (first.size()); ++i)
for (int j = 0; j < (i); ++j) {
x1 = first[j], x2 = first[i];
d = x2 - x1;
for (int k = 0; k < (4); ++k) probuj(P[k].second);
int zbior = 0;
for (int k = 0; k < (4); ++k)
if (P[k].first == x1)
zbior += 1;
else if (P[k].first == x2)
zbior += 100;
if (zbior != 202) continue;
int kon = 200 * 1000 * 1000, pocz = -kon;
while (pocz + 3 <= kon) {
int w = (kon - pocz) / 3;
int t1 = probuj(pocz + w), t2 = probuj(pocz + 2 * w);
if (t1 >= t2)
pocz = pocz + w;
else
kon = pocz + 2 * w;
}
int tutaj = 1 << 30;
while (pocz <= kon) {
tutaj = min(tutaj, probuj(pocz));
++pocz;
}
}
}
void solve() {
for (int i = 0; i < (4); ++i) scanf("%d%d", &P[i].first, &P[i].second);
best = 1 << 30;
swapped = 0;
go();
swapped = 1;
for (int i = 0; i < (4); ++i) swap(P[i].first, P[i].second);
go();
if (best == (1 << 30))
puts("-1");
else {
printf("%d\n", best);
for (int i = 0; i < (4); ++i)
printf("%d %d\n", ANS[i].first, ANS[i].second);
}
}
int main() {
int te;
scanf("%d", &te);
while (te--) solve();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int a[1005], p[1005], z[1005], d[1005];
inline void dfs(int k, int n) {
d[k] = 1;
if (!n) return;
for (int i = 0; i <= z[n]; ++i) dfs(k + i * n, n - 1);
}
int main() {
int n, x, k = 0, m = 0;
scanf("%d%d", &n, &x), memset(d, 0, sizeof d), memset(p, 0, sizeof p),
memset(z, 0, sizeof z);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), p[a[i]] = i;
for (int i = x; i; i = a[i], ++k)
;
for (int i = 1, l = 0; i <= n; ++i, l = 0)
if (i != x && !a[i]) {
for (int y = i; y; y = p[y], ++l)
if (y == x) {
l = 0;
break;
}
z[l]++, m = max(m, l);
}
dfs(k, m);
for (int i = 1; i <= n; ++i)
if (d[i]) printf("%d\n", i);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int col[510][510], num[250010], tg[250010], i, j, n, k, x, y, ans, tot, cnt = 0;
int fx[4] = {1, 0, -1, 0}, fy[4] = {0, 1, 0, -1};
char c[510][510];
void dfs(int x, int y, int color) {
if (x < 1 || y < 1 || x > n || y > n || col[x][y] || c[x][y] != '.') return;
++num[col[x][y] = color];
for (int i = 0; i < 4; ++i) dfs(x + fx[i], y + fy[i], color);
}
void work(int x, int y, int z) {
if (tg[col[x][y]] == z) return;
tg[col[x][y]] = z;
tot += num[col[x][y]];
}
int main() {
scanf("%d%d\n", &n, &k);
for (i = 1; i <= n; ++i, scanf("\n"))
for (j = 1; j <= n; ++j) scanf("%c", &c[i][j]);
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (c[i][j] == '.' && !col[i][j]) dfs(i, j, ++cnt);
for (i = 0; i + k <= n; ++i) {
for (x = 1; x <= k; ++x)
for (y = 1; y <= k; ++y)
if (col[i + x][y]) --num[col[i + x][y]];
for (j = 1; j <= cnt; ++j) tg[j] = -1;
for (j = 0; j + k <= n; ++j) {
tot = k * k;
for (x = 1; x <= k; ++x) {
work(i, j + x, j);
work(i + k + 1, j + x, j);
work(i + x, j, j);
work(i + x, j + k + 1, j);
}
ans = max(ans, tot);
for (x = 1; x <= k; ++x) {
if (col[i + x][j + 1]) ++num[col[i + x][j + 1]];
if (col[i + x][j + k + 1]) --num[col[i + x][j + k + 1]];
}
}
for (x = 1; x <= k; ++x)
for (y = n - k + 2; y <= n; ++y)
if (col[i + x][y]) ++num[col[i + x][y]];
}
printf("%d\n", ans);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long size = 1e8;
long long MUL(long long a, long long b) {
return ((a % MOD) * (b % MOD)) % MOD;
}
long long ADD(long long &a, long long &b) {
return ((a % MOD) + (b % MOD)) % MOD;
}
long long SUB(long long a, long long b) {
return ((a % MOD) - (b % MOD) + MOD) % MOD;
}
struct data_type {
long long starting, ending, id;
};
bool comp(data_type &a, data_type &b) { return a.ending < b.ending; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int t;
t = 1;
while (t--) {
long long n, a, b;
cin >> n;
vector<data_type> arr(n);
for (long long i = 0; i < n; i++) {
cin >> a >> b;
arr[i].starting = a;
arr[i].ending = b;
arr[i].id = i;
}
sort(arr.begin(), arr.end(), comp);
int ans[n];
vector<bool> days(1e8, true);
for (long long i = 0; i < n; i++) {
long long start = arr[i].starting;
while (start <= arr[i].ending && !days[start]) {
start++;
}
ans[arr[i].id] = start;
days[start] = false;
}
for (auto x : ans) cout << x << " ";
}
return EXIT_SUCCESS;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long p, q, n, x, i;
cin >> p >> q >> n;
for (i = 0; i < n; i++) {
cin >> x;
if (q == 0) {
cout << "NO";
return 0;
}
if (x > p / q) {
cout << "NO";
return 0;
} else {
p -= q * x;
x = p;
p = q;
q = x;
}
}
if (q == 0)
cout << "YES";
else
cout << "NO";
}
| 9 |
#define fast ios::sync_with_stdio(false); cin.tie(0)
#define foru(i, k, n) for (int i = k; i < n; i++)
#define ford(i, k, n) for (int i = k; i >= n; i--)
#define pb push_back
#define ff first
#define ss second
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <bitset>
#include <map>
#include <set>
#include <queue>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int sz = 1e6;
int n, k;
int a[sz], b[sz], p[sz], mxp[sz];
bool ok(int x) {
b[0] = 0;
foru(i, 0, n)b[i+1] = (a[i] >= x ? 1 : -1);
p[0] = 0;
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] + b[i];
mxp[i] = min(mxp[i - 1], p[i]);
}
for (int i = k; i <= n; i++) {
if (p[i] - mxp[i - k] > 0)return 1;
}
return 0;
}
int main() {
fast;
cin >> n >> k;
foru(i, 0, n)cin >> a[i];
int l = 1, r = 1e9, mid, bst = -1;
while (l <= r) {
mid = (l + r + 1) / 2;
if (ok(mid)) {
bst = mid;
l = mid + 1;
}
else r = mid - 1;
}
cout << bst << '\n';
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, i, a = 0, b = 0, l;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> l;
if (l == 1)
a++;
else
b++;
}
if (b <= 1) {
while (b--) {
cout << 2 << " ";
}
while (a--) {
cout << 1 << " ";
}
return;
}
if (a == 0) {
while (b--) {
cout << 2 << " ";
}
return;
}
cout << 2 << " " << 1 << " " << 2 << " ";
b -= 2;
a -= 1;
while (b--) {
cout << 2 << " ";
}
while (a--) {
cout << 1 << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 2;
int group[N], n, m, en[N];
vector<int> adj[N];
set<pair<int, int> > s;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--, u--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) {
en[i] = adj[i].size();
s.insert(pair<int, int>(en[i], i));
}
while (1) {
set<pair<int, int> >::iterator it = s.end();
it--;
int v = it->second;
if (en[v] <= 1) break;
s.erase(pair<int, int>(en[v], v));
en[v] = adj[v].size() - en[v];
group[v] = 1 - group[v];
s.insert(pair<int, int>(en[v], v));
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
s.erase(pair<int, int>(en[u], u));
if (group[v] == group[u])
en[u]++;
else
en[u]--;
s.insert(pair<int, int>(en[u], u));
}
}
for (int i = 0; i < n; i++) cout << group[i];
cout << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e+18;
const double EPS = 1e-9;
const int MOD = 1000000007;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
signed main() {
int n, m, sx, sy, gx, gy;
bool ok[1000][1000] = {};
char field[1000][1000];
cin >> n >> m;
getchar();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
field[i][j] = getchar();
if (field[i][j] == 'S') {
sx = i;
sy = j;
} else if (field[i][j] == 'T') {
gx = i;
gy = j;
}
}
getchar();
}
queue<pair<int, int> > tate, yoko;
tate.push(pair<int, int>(sx, sy));
yoko.push(pair<int, int>(sx, sy));
for (int i = 0; i < 3; i++) {
int tsiz = tate.size(), ysiz = yoko.size();
for (int j = 0; j < tsiz; j++) {
int x = tate.front().first, y = tate.front().second, nx = x;
tate.pop();
while (nx >= 0 && field[nx][y] != '*') {
if (i != 2 && !ok[nx][y]) yoko.push(pair<int, int>(nx, y));
ok[nx][y] = true;
nx--;
}
nx = x;
while (nx < n && field[nx][y] != '*') {
if (i != 2 && !ok[nx][y]) yoko.push(pair<int, int>(nx, y));
ok[nx][y] = true;
nx++;
}
}
for (int j = 0; j < ysiz; j++) {
int x = yoko.front().first, y = yoko.front().second, ny = y;
yoko.pop();
while (ny >= 0 && field[x][ny] != '*') {
if (i != 2 && !ok[x][ny]) tate.push(pair<int, int>(x, ny));
ok[x][ny] = true;
ny--;
}
ny = y;
while (ny < m && field[x][ny] != '*') {
if (i != 2 && !ok[x][ny]) tate.push(pair<int, int>(x, ny));
ok[x][ny] = true;
ny++;
}
}
}
if (ok[gx][gy])
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long base = 233;
const long long ff = 1e6 + 1;
const long long mod = 1e9 + 7;
const long long inf = 1e17 + 1;
inline long long read() {
long long x;
scanf("%lld", &x);
return x;
}
long long n, x[ff], y[ff];
double K(long long xx, long long xt, long long yy, long long yt) {
double kx = (double)(xx) - (double)(yy);
double yx = (double)(xt) - (double)(yt);
return yx / kx;
}
double D(long long xx, long long xt, long long yy, long long yt) {
double kx = (double)(xx) - (double)(yy);
double yx = (double)(xt) - (double)(yt);
return sqrt(kx * kx + yx * yx);
}
bool judge(long long e1, long long e2) {
double K1 = K(x[e1 + 1], y[e1 + 1], x[e1], y[e1]),
K2 = K(x[e2 + 1], y[e2 + 1], x[e2], y[e2]);
double D1 = D(x[e1 + 1], y[e1 + 1], x[e1], y[e1]),
D2 = D(x[e2 + 1], y[e2 + 1], x[e2], y[e2]);
return (K1 == K2 && D1 == D2);
}
void init() {
srand(time(0));
cin >> n;
if (n & 1) puts("nO"), exit(0);
for (long long i = 1; i <= n; ++i) scanf("%lld %lld", &x[i], &y[i]);
for (long long i = 1; i <= n / 2 - 1; ++i)
if (!judge(i, i + n / 2)) puts("nO"), exit(0);
puts("YES");
}
signed main() {
long long T = 1;
while (T--) init();
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
using namespace std;
long long n, m, cycle[200005], present[200005], val[200005], par[200005],
cnt = 1, visited1[200005], visited2[200005], visited3[200005];
vector<long long> adj[200005], radj[200005];
long long p[200005][20], depth[200005];
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) res = (res * x) % 1000000007;
x = (x * x) % 1000000007;
y = y >> 1;
}
return res;
}
void dfs(long long u) {
visited1[u] = 1;
long long i;
for (i = 0; i < adj[u].size(); i++) {
long long x = adj[u][i];
if (!visited1[x]) {
par[x] = u;
dfs(x);
} else if (x != par[u]) {
long long y = u;
long long flag = 0;
while (x != y && cycle[y] == 0) {
flag = 1;
cycle[y] = cnt;
y = par[y];
}
if (flag) {
present[cnt] = 1;
cycle[x] = cnt;
cnt++;
}
}
}
}
void construct_tree(long long u) {
visited2[u] = 1;
long long i;
for (i = 0; i < adj[u].size(); i++) {
long long x = adj[u][i];
if (cycle[x] != cycle[u]) {
radj[cycle[x]].push_back(cycle[u]);
radj[cycle[u]].push_back(cycle[x]);
}
if (!visited2[x]) construct_tree(x);
}
}
void dfs1(long long u, long long par) {
visited3[u] = 1;
depth[u] = depth[par] + 1;
p[u][0] = par;
long long i;
if (present[u]) val[u] += 1;
for (i = 0; i < radj[u].size(); i++) {
long long x = radj[u][i];
if (!visited3[x]) {
val[x] += val[u];
dfs1(x, u);
}
}
}
void compute() {
long long i, j;
for (i = 1; i < 20; i++)
for (j = 1; j <= n; j++) {
if (p[j][i - 1] != -1) p[j][i] = p[p[j][i - 1]][i - 1];
}
}
long long lca(long long u, long long v) {
if (depth[v] < depth[u]) swap(u, v);
long long diff = depth[v] - depth[u];
long long i;
for (i = 0; i < 20; i++)
if ((diff >> i) & 1) v = p[v][i];
if (u == v) return u;
for (i = 20 - 1; i >= 0; i--)
if (p[u][i] != p[v][i]) {
u = p[u][i];
v = p[v][i];
}
return p[u][0];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
memset(p, -1, sizeof(p));
long long i, j, u, v;
for (i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
for (i = 1; i <= n; i++)
if (cycle[i] == 0) {
cycle[i] = cnt;
cnt++;
}
construct_tree(1);
depth[0] = 0;
dfs1(1, 0);
compute();
long long q;
cin >> q;
while (q--) {
long long u, v;
cin >> u >> v;
if (cycle[u] == cycle[v] && cycle[u])
cout << "2\n";
else {
long long x = val[cycle[u]];
long long y = val[cycle[v]];
long long l = lca(cycle[u], cycle[v]);
long long z = val[l];
long long ans = x + y - (2 * z);
if (present[l]) ans++;
ans = power(2, ans) % 1000000007;
cout << ans << "\n";
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
bool neg = false;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') neg = true, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (neg) x = -x;
return x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int maxn = 2e5;
int n, m, q, A[maxn + 2];
struct Tnode {
int G[2][6], lazy;
void init(int ok) {
lazy = 0;
for (int _b = m - 1, i = 0; i <= _b; ++i) G[0][i] = G[1][i] = i + 1;
if (!ok)
G[0][m] = m, G[1][m] = 0;
else
G[0][m] = 0, G[1][m] = m;
}
void flip() {
for (int _b = m, i = 0; i <= _b; ++i) swap(G[0][i], G[1][i]);
}
} Tree[maxn << 2];
Tnode operator+(const Tnode &a, const Tnode &b) {
Tnode c;
c.lazy = 0;
for (int _b = 1, i = 0; i <= _b; ++i)
for (int _b = m, j = 0; j <= _b; ++j) c.G[i][j] = a.G[i][b.G[i][j]];
return c;
}
void build(int id, int l, int r) {
if (l == r) {
Tree[id].init(A[l]);
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
Tree[id] = Tree[id << 1] + Tree[id << 1 | 1];
}
void down(int id, int lc, int rc) {
if (Tree[id].lazy) {
Tree[id].lazy = 0;
Tree[lc].flip();
Tree[lc].lazy ^= 1;
Tree[rc].flip();
Tree[rc].lazy ^= 1;
}
}
void update(int id, int l, int r, int u, int v) {
if (l > v || r < u) return;
if (l >= u && r <= v) {
Tree[id].flip();
Tree[id].lazy ^= 1;
return;
}
down(id, id << 1, id << 1 | 1);
int mid = (l + r) >> 1;
update(id << 1, l, mid, u, v);
update(id << 1 | 1, mid + 1, r, u, v);
Tree[id] = Tree[id << 1] + Tree[id << 1 | 1];
}
Tnode query(int id, int l, int r, int u, int v) {
if (l >= u && r <= v) return Tree[id];
down(id, id << 1, id << 1 | 1);
Tnode res;
int mid = (l + r) >> 1;
if (v <= mid)
res = query(id << 1, l, mid, u, v);
else if (mid < u)
res = query(id << 1 | 1, mid + 1, r, u, v);
else
res = query(id << 1, l, mid, u, v) + query(id << 1 | 1, mid + 1, r, u, v);
return res;
}
void input() {
n = rd();
m = rd();
q = rd();
for (int _b = n, i = 1; i <= _b; ++i) A[i] = rd() & 1;
}
void solve() {
build(1, 1, n);
while (q--) {
int ty, l, r;
ty = rd();
l = rd();
r = rd();
if (ty == 1) {
if (rd() & 1) update(1, 1, n, l, r);
} else {
write(query(1, 1, n, l, r).G[0][m] ? 1 : 2);
putchar('\n');
}
}
}
int main() {
input();
solve();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[4], c = 0;
for (int i = 0; i < 4; i++) {
cin >> arr[i];
}
sort(arr, arr + 4);
for (int i = 0; i < 4; i++) {
if (arr[i] == arr[i + 1])
c++;
else
continue;
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll mod = 998244353;
const double eps = DBL_EPSILON;
long long fast_pow(long long a, long long n, long long m) {
long long ans = 1;
while (n > 0) {
if ((n & 1) != 0) ans = (ans % m * a % m) % m;
a = (a % m * a % m) % m;
n >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
ll first = (n - 2);
for (int i = 1; i < n - 2; i++) first = (first * 2) % mod;
ll cmb = 1;
ll l = 0;
for (int i = n; i <= m; i++) {
l++;
cmb = ((cmb * i) % mod) * fast_pow(l, mod - 2, mod);
cmb %= mod;
}
cout << (first * cmb) % mod << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 5050;
const int MVAL = 2000000000;
struct data {
int t, l, r, d;
};
int a[MN];
int b[MN];
vector<data> query;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int i;
for ((i) = 0; (i) < (int)(n); ++(i)) a[i] = MVAL;
for ((i) = 0; (i) < (int)(m); ++(i)) {
int t, l, r, d;
scanf("%d %d %d %d", &t, &l, &r, &d);
--l, --r;
query.push_back({t, l, r, d});
if (t == 1) {
for (int j = l; j <= r; ++j) b[j] += d;
} else {
for (int j = l; j <= r; ++j) a[j] = min(a[j], d - b[j]);
}
}
memcpy(b, a, sizeof a);
for ((i) = 0; (i) < (int)(m); ++(i)) {
if (query[i].t == 1) {
for (int j = query[i].l; j <= query[i].r; ++j) a[j] += query[i].d;
} else {
int maxi = -MVAL;
for (int j = query[i].l; j <= query[i].r; ++j) maxi = max(maxi, a[j]);
if (maxi != query[i].d) {
puts("NO");
return 0;
}
}
}
puts("YES");
for ((i) = 0; (i) < (int)(n); ++(i)) {
if (i) printf(" ");
if (b[i] == MVAL) {
printf("101");
continue;
}
printf("%d", b[i]);
}
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, rem[111] = {0}, d = 0;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> x;
if (rem[(k - x % k) % k])
d += 2, --rem[(k - x % k) % k];
else
++rem[x % k];
}
cout << d;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string S;
cin >> S;
int pos = S.find('0');
if (pos == -1) {
cout << S.substr(1);
} else {
cout << S.substr(0, pos);
cout << S.substr(pos + 1);
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,fma")
const int N = 4e4 + 15;
int n, k, a[N], t[N << 3], add[N << 3];
void push(int v) {
add[v << 1] += add[v];
add[v << 1 | 1] += add[v];
t[v << 1] += add[v];
t[v << 1 | 1] += add[v];
add[v] = 0;
}
void mult(int v, int tl, int tr, int l, int r, int val) {
if (tl > r || tr < l || l > r) return;
push(v);
if (tl >= l && tr <= r) {
t[v] += val;
add[v] += val;
return;
}
int mid = tl + tr >> 1;
mult(v << 1, tl, mid, l, r, val);
mult(v << 1 | 1, mid + 1, tr, l, r, val);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
int get(int v, int tl, int tr, int l, int r) {
if (tl > r || tr < l || l > r) return 0;
push(v);
if (tl >= l && tr <= r) return t[v];
int mid = tl + tr >> 1;
return max(get(v << 1, tl, mid, l, r), get(v << 1 | 1, mid + 1, tr, l, r));
}
int dp[2][N], ind[N], lpos[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
lpos[i] = ind[a[i]];
ind[a[i]] = i;
}
for (int g = 1; g <= k; ++g) {
memset(t, 0, sizeof(t));
memset(add, 0, sizeof(add));
for (int i = 1; i <= n; ++i) mult(1, 0, n, i, i, dp[(g & 1) ^ 1][i]);
for (int i = 1; i <= n; ++i) {
mult(1, 0, n, lpos[i], i - 1, 1);
if (i == 1)
dp[g & 1][i] = get(1, 0, n, g - 1, i - 1);
else
dp[g & 1][i] = get(1, 1, n, g - 1, i - 1);
}
}
printf("%d", dp[k & 1][n]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
string s;
int f[2001][2001];
int g[2001][2001];
const int base = 1000000007;
void add(int &x, int y) {
x += y;
if (x >= base) x -= base;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
n -= m;
cin >> s;
int low = 0;
int sum = 0;
for (auto &c : s)
if (c == '(') {
sum++;
} else {
sum--;
low = min(low, sum);
}
low = -low;
if (low > n) {
cout << 0;
return 0;
}
f[n][0] = 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j <= n; j++)
if (f[i][j]) {
if (i && (j < n)) add(f[i - 1][j + 1], f[i][j]);
if (i && (j)) add(f[i - 1][j - 1], f[i][j]);
if ((j >= low) && (j + sum <= n)) add(g[i][j + sum], f[i][j]);
}
}
for (int i = n; i >= 0; i--) {
for (int j = 0; j <= n; j++)
if (g[i][j]) {
if (i && (j < n)) add(g[i - 1][j + 1], g[i][j]);
if (i && (j)) add(g[i - 1][j - 1], g[i][j]);
}
}
cout << g[0][0] << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ih, num, test, x, c;
cin >> test;
while (test--) {
c = 0;
cin >> num;
cin >> x;
long a[num], b[num];
for (ih = 0; ih < num; ih++) cin >> a[ih];
for (ih = 0; ih < num; ih++) cin >> b[ih];
sort(a, a + num);
sort(b, b + num);
reverse(b + 0, b + num);
for (ih = 0; ih < num; ih++)
if (a[ih] + b[ih] > x) {
cout << "NO\n";
c++;
break;
}
if (c == 0) cout << "YES\n";
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, x, i, j, cnt = 0;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
if (a[i] != a[i + 1]) cnt++;
}
printf("%d", cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n), ans(m, 0);
vector<pair<long long, int>> q(m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
scanf("%lld", &q[i].first);
q[i].second = i;
}
sort(q.begin(), q.end());
for (int cnt = 0, ptr = m - 1; ptr >= 0 && cnt <= n; cnt++) {
int idx = 0;
vector<long long> p(n + 1, 0), w(n + 1, 0);
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] + a[i - 1];
w[i] = min(w[i - 1], p[i]);
if (p[idx] > p[i]) idx = i;
}
for (; ptr >= 0 && q[ptr].first >= -p[idx]; ptr--) ans[q[ptr].second] = cnt;
long long wst = 0, lvl = -INF;
for (int i = n - 1; i >= 0; i--) {
wst = min(wst, p[i + 1]);
if (lvl <= min(w[i], wst - a[i])) {
lvl = min(w[i], wst - a[i]);
idx = i;
}
}
a[idx] = 0;
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, m;
bitset<35> s[10];
int c[10];
set<int> correct_bits;
int ans = 0;
bool consistent(bitset<35>& code) {
bool ans = true;
for (int i = 1; i < m; i++) {
ans &= __builtin_popcountll((code ^ s[i]).to_ullong()) + c[i] == n;
}
return ans;
}
void rb(int pos) {
if (correct_bits.size() == c[0]) {
bitset<35> code;
for (int i = 0; i < n; i++) {
if (correct_bits.count(i)) {
code[i] = s[0][i];
} else {
code[i] = not s[0][i];
}
}
if (consistent(code)) {
ans++;
}
} else {
for (int i = pos; i < n; i++) {
correct_bits.insert(i);
rb(i + 1);
correct_bits.erase(i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
string bit_string;
cin >> bit_string;
s[i] = bitset<35>(bit_string);
cin >> c[i];
}
rb(0);
cout << ans << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
vector<vector<int>> edges;
struct QE {
QE(int n, int d) : node(n), dist(d) {}
int node;
int dist;
};
void Load() {
scanf("%d %d %d %d", &n, &m, &s, &t);
edges = vector<vector<int>>(n + 1, vector<int>());
int a, b;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &a, &b);
edges[a].push_back(b);
edges[b].push_back(a);
}
}
void BFS(int s, vector<int>* sdist) {
queue<QE> q;
vector<int> processed(n + 1, false);
q.push({s, 0});
processed[s] = true;
while (!q.empty()) {
QE next = q.front();
(*sdist)[next.node] = next.dist;
q.pop();
for (int i : edges[next.node]) {
if (!processed[i]) {
q.push({i, next.dist + 1});
processed[i] = true;
}
}
}
}
void Solve() {
vector<int> sdist(n + 1, 1050), tdist(n + 1, 1050);
BFS(s, &sdist);
BFS(t, &tdist);
int stdist = sdist[t];
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j) {
if (sdist[i] + tdist[j] + 1 >= stdist &&
sdist[j] + tdist[i] + 1 >= stdist) {
ans++;
}
}
}
printf("%d\n", ans - m);
}
int main() {
Load();
Solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int k;
scanf("%d", &k);
int x = pow(2, 17);
printf("%d %d\n", 2, 3);
printf("%d %d %d\n", x ^ k, x, 0);
printf("%d %d %d\n", k, x ^ k, k);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
long long k;
vector<long long> a;
long long int sum = 0;
for (i = 0; i < n; i++) {
cin >> k;
a.push_back(k);
}
for (i = 0; i < n; i++) {
sum = sum + a[i] + i * (a[i] - 1);
}
if (count(a.begin(), a.end(), 1) == n) {
cout << sum;
} else {
cout << sum;
}
}
| 3 |
//xhxh
//LYC_music yyds!
#include<bits/stdc++.h>
using namespace std;
int read()
{
int pos=1,num=0;
char ch=getchar();
while (!isdigit(ch))
{
if (ch=='-') pos=-1;
ch=getchar();
}
while (isdigit(ch))
{
num=num*10+(int)(ch-'0');
ch=getchar();
}
return pos*num;
}
void write(int x)
{
if (x<0)
{
putchar('-');
write(-x);
return;
}
if (x>=10) write(x/10);
putchar(x%10+'0');
}
void writesp(int x)
{
write(x);
putchar(' ');
}
void writeln(int x)
{
write(x);
putchar('\n');
}
int T,n,a[100001];
int main()
{
T=read();
while (T--)
{
n=read();
for (int i=1;i<=n;i++)
a[i]=read();
for (int i=1;i<=n;i++)
if (a[i]%2==1) writesp(a[i]);
for (int i=1;i<=n;i++)
if (a[i]%2==0) writesp(a[i]);
putchar('\n');
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
vector<pair<int, int>> fin;
int idx = 0;
while (idx < n) {
int curr = v[idx].first;
int temp_max = v[idx].second;
while (curr == v[idx].first && idx < n) {
temp_max = max(temp_max, v[idx].second);
idx++;
}
fin.push_back({curr, temp_max});
}
if ((int)fin.size() == 1) {
cout << "Poor Alex\n";
return;
}
int curr_max = 0;
for (int i = 0; i < (int)fin.size(); i++) {
if (fin[i].second < curr_max) {
cout << "Happy Alex\n";
return;
}
curr_max = max(curr_max, fin[i].second);
}
cout << "Poor Alex\n";
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a;
cin >> a;
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 'U') y++;
if (a[i] == 'D') y--;
if (a[i] == 'L') x--;
if (a[i] == 'R') x++;
}
int sum = n - (abs(x) + abs(y));
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1003];
char res[1003];
int n;
int coun[33];
int coun3[33];
int main() {
scanf("%s", s);
scanf("%d", &n);
int i, j;
for (i = 0; s[i]; i++) coun[s[i] - 'a']++;
int coun2 = 0;
for (i = 0; i < 30; i++)
if (coun[i] > 0) coun2++;
if (coun2 > n) {
printf("-1\n");
return 0;
}
int l, r, re;
l = 0;
r = 1003;
int sum = 0;
while (r - l > 1) {
sum = 0;
re = ((l + r) >> 1);
for (j = 0; j < 30; j++) {
sum += coun[j] / re;
if (coun[j] % re != 0) sum++;
}
if (sum > n)
l = re;
else
r = re;
}
for (j = 0; j < 30; j++) {
coun3[j] = coun[j] / r;
if (coun[j] % r != 0) coun3[j]++;
}
i = 0;
for (j = 0; j < 30; j++) {
while (coun3[j] > 0) {
res[i++] = j + 'a';
coun3[j]--;
}
}
printf("%d\n", r);
while (i < n) res[i++] = 'a';
printf("%s\n", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ar1[200010], ar2[200010];
map<long long, long long> M;
map<long long, long long>::iterator it;
int main() {
long long n, m, i, j, two, ans;
while (scanf("%I64d", &n) == 1) {
M.clear();
two = 0;
for (i = 1; i <= n; i++) {
scanf("%I64d", &ar1[i]);
M[ar1[i]]++;
}
for (i = 1; i <= n; i++) {
scanf("%I64d", &ar2[i]);
M[ar2[i]]++;
}
for (int i = 1; i <= n; i++)
if (ar1[i] == ar2[i]) two++;
scanf("%I64d", &m);
ans = 1;
for (it = M.begin(); it != M.end(); it++) {
for (i = 1; i <= it->second; i++) {
j = i;
while (two && j % 2 == 0) j /= 2, two--;
ans = (ans * j) % m;
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 62);
const int inf = (1 << 30);
const int nmax = 1e5 + 50;
const int mod = 1e9 + 7;
using namespace std;
int n, i, j;
long long tot, a[nmax], b[nmax];
pair<long long, int> mn;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
mn = make_pair(llinf, 0);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) b[j] = a[j];
tot = 0;
for (j = i - 1; j >= 1; j--) {
if (b[j] > b[j + 1]) {
tot += b[j] - b[j + 1];
b[j] = b[j + 1];
}
}
for (j = i + 1; j <= n; j++) {
if (b[j] > b[j - 1]) {
tot += b[j] - b[j - 1];
b[j] = b[j - 1];
}
}
mn = min(mn, make_pair(tot, i));
}
for (j = 1; j <= n; j++) b[j] = a[j];
i = mn.second;
for (j = i - 1; j >= 1; j--) {
if (b[j] > b[j + 1]) {
tot += b[j] - b[j + 1];
b[j] = b[j + 1];
}
}
for (j = i + 1; j <= n; j++) {
if (b[j] > b[j - 1]) {
tot += b[j] - b[j - 1];
b[j] = b[j - 1];
}
}
for (i = 1; i <= n; i++) cout << b[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int c[200];
int main() {
long long int t;
cin >> t;
long long int a[t], b[t];
vector<pair<long long int, long long int> > vp;
for (long long int i = 0; i < t; i++) cin >> a[i];
for (long long int i = 0; i < t; i++) {
cin >> b[i];
vp.push_back(make_pair(b[i], i));
}
sort(a, a + t, greater<long long int>());
sort(vp.begin(), vp.end());
for (long long int i = 0; i < t; i++) b[vp.at(i).second] = a[i];
for (long long int i = 0; i < t; i++) cout << b[i] << ' ';
return 0;
}
| 5 |
#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;
}
inline void getint(int &first) {
char c;
while (c = getchar(), c > '9' || c < '0')
;
for (first = 0; c >= '0' && c <= '9'; c = getchar())
first = (first << 1) + (first << 3) + c - '0';
}
inline void print(int first) {
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
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[111];
int main() {
long long k;
int n;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) k += a[i], a[i]--;
sort(a, a + n);
long long ans = 0;
for (long long l = 1, r; l <= a[n - 1]; l = r + 1) {
r = a[n - 1];
for (int i = 0; i < n; i++)
if (a[i] / l) smin(r, a[i] / (a[i] / l));
long long mid = 0;
for (int i = 0; i < n; i++) mid += a[i] / l;
mid = k / (mid + n);
if (mid >= l) smax(ans, min(mid, r));
}
if (k / n >= a[n - 1] + 1) smax(ans, k / n);
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int ans;
int main() {
scanf("%d%d", &a, &b);
if (a == b)
puts("infinity");
else {
int x = a - b;
int i = 1;
for (; i * i < x; i++)
if (x % i == 0) {
if (i > b) ans++;
if (x / i > b) ans++;
}
if (i * i == x && i > b) ans++;
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, vx, vy;
bool flagx = false, flagy = false;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) return x = 1, y = 0, void();
exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - a / b * y;
}
signed main() {
cin >> n >> m >> x >> y >> vx >> vy;
if (vy == 0) {
if (y == 0 || y == m)
printf("%lld %lld\n", vx > 0 ? n : 0, y);
else
printf("-1\n");
return 0;
}
if (vx == 0) {
if (x == 0 || x == n)
printf("%lld %lld\n", x, vy > 0 ? m : 0);
else
printf("-1\n");
return 0;
}
if (vx < 0) vx = -vx, x = n - x, flagx = true;
if (vy < 0) vy = -vy, y = m - y, flagy = true;
long long A, B, C = gcd(n, m);
if ((x - y) % C) return printf("-1"), 0;
long long dA = -m / C, dB = n / C;
exgcd(n, m, A, B), B = -B;
if (dA < 0) dA = -dA, dB = -dB;
A *= (x - y) / C, A = (A % dA + dA) % dA;
if (!A) A = dA;
B = (A * n - (x - y)) / m;
printf("%lld %lld\n", ((A & 1) ^ flagx) ? n : 0, ((B & 1) ^ flagy) ? m : 0);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
int main() {
long long a, b, x, y;
cin >> a >> b >> x >> y;
long long g = gcd(x, y);
x /= g;
y /= g;
long long c1 = a / x;
long long c2 = b / y;
long long ans = min(c1, c2);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long P = 239017, MaxN = 2100000, INF = 1000000000;
int a, arr[1000000], sum[1000000], have[1000000];
char s[1000000];
int main() {
scanf("%d%s", &a, s);
int len = strlen(s);
for (int i = 0; i < len; ++i) arr[i] = s[i] - '0';
sum[0] = 0;
for (int i = 1; i <= len; ++i) sum[i] = sum[i - 1] + arr[i - 1];
int S = 0;
for (int i = 1; i <= len; ++i)
for (int j = 1; j <= i; ++j) ++have[sum[i] - sum[j - 1]], ++S;
long long ans = 0;
for (int i = 1; i <= len; ++i)
for (int j = 1; j <= i; ++j) {
if ((sum[i] - sum[j - 1]) && a % (sum[i] - sum[j - 1]) == 0) {
if ((a / (sum[i] - sum[j - 1])) < 1000000)
ans += have[a / (sum[i] - sum[j - 1])];
}
if (a == 0 && (sum[i] - sum[j - 1]) == 0) ans += S;
}
printf("%I64d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long a[30 + 10];
int b[30 + 10];
int k[30 + 10];
int p[30 + 10];
long long deal[30 + 10][30 + 10];
long long ans;
int n, u, r;
void Xor(long long array[]) {
for (int i = 1; i <= n; i++) array[i] = array[i] ^ b[i];
}
void Add(long long array[]) {
long long tmp[30 + 10];
for (int i = 1; i <= n; i++) tmp[i] = array[i];
for (int i = 1; i <= n; i++) array[i] = tmp[p[i]] + r;
}
void dfs(int p, int pre) {
if ((u - p) % 2 == 0) {
long long tmp = 0;
for (int i = 1; i <= n; i++) tmp = tmp + deal[p][i] * k[i];
if (tmp > ans) ans = tmp;
}
if (p >= u)
return;
else {
for (int i = 1; i <= n; i++) deal[p + 1][i] = deal[p][i];
Add(deal[p + 1]);
dfs(p + 1, 0);
if (pre != 1) {
for (int i = 1; i <= n; i++) deal[p + 1][i] = deal[p][i];
Xor(deal[p + 1]);
dfs(p + 1, 1);
}
}
}
int main() {
while (scanf("%d%d%d", &n, &u, &r) != EOF) {
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &k[i]);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
ans = -1000000000000ll;
for (int i = 1; i <= n; i++) deal[0][i] = a[i];
dfs(0, 0);
printf("%I64d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 5;
const int mod = 1e9 + 9;
const int N = 1e5 + 5;
int a[N], b[N], d[N], locB[N], locA[N];
int main() {
ios_base::sync_with_stdio(false);
int n;
set<pair<int, int> > pos, neg;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
locA[a[i]] = i;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
locB[b[i]] = i;
}
for (int i = 0; i < n; i++) {
d[a[i]] = locB[a[i]] - i;
if (d[a[i]] >= 0) {
pos.insert({d[a[i]], a[i]});
} else {
neg.insert({d[a[i]] * -1, a[i]});
}
}
for (int i = 0; i < n; i++) {
int ans = 1e6;
if (!pos.empty()) ans = min(ans, (pos.begin()->first) - i);
if (!neg.empty()) ans = min(ans, (neg.begin()->first) + i);
cout << ans << endl;
if (i == n - 1) break;
while (!pos.empty() && (pos.begin()->first) == i) {
auto it = pos.begin();
neg.insert({-i, it->second});
pos.erase(it);
}
neg.erase(neg.find({d[b[i]] * -1, b[i]}));
int idx = locA[b[i]];
pos.insert({n - idx + i, b[i]});
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long get_arith(long long a, long long b, long long c, long long N) {
long long res = (a / c) * N * (N - 1) / 2 + (b / c) * N;
a %= c;
b %= c;
if (a) res += get_arith(c, (a * N + b) % c, a, (a * N + b) / c);
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
pair<long long, long long> Exgcd(long long a, long long b) {
if (a == 0) return {0, 1};
if (b == 0) return {1, 0};
long long q = a / b;
pair<long long, long long> t = Exgcd(b, a % b);
return pair<long long, long long>(t.second, t.first - t.second * q);
}
long long Get2(long long p, long long q, long long pv) {
while (pv < 0) pv += q;
long long g = gcd(p, q);
p /= g, q /= g, pv /= g;
pair<long long, long long> tp = Exgcd(p, q);
long long inv = (tp.first % q + q) % q;
return inv * pv % q;
}
long long Min(long long be, long long p, long long q, long long c) {
be += q;
p %= q;
if (p == 0) return 0;
long long M = get_arith(p, be, q, c);
long long bb = 0, ee = q, mid, res = q + 1, pv = 1e18;
long long pv1, pv2, res1, res2;
while (bb <= ee) {
mid = (bb + ee) >> 1;
long long z = get_arith(p, be + mid, q, c);
if (z == M)
bb = mid + 1;
else {
res = min(res, mid);
pv = -be - mid;
ee = mid - 1;
}
}
pv1 = pv;
res1 = res;
bb = 0, ee = q;
res = q + 1;
while (bb <= ee) {
mid = (bb + ee) >> 1;
long long z = get_arith(p, be - mid, q, c);
if (z == M)
bb = mid + 1;
else {
if (res > mid - 1) {
res = mid - 1;
pv = mid - 1 - be;
}
ee = mid - 1;
}
}
res2 = res;
pv2 = pv;
if (pv > 7e17) return 0;
if (res1 == res2) {
long long t1 = Get2(p, q, pv1);
long long t2 = Get2(p, q, pv2);
return min(t1, t2);
} else if (res1 < res2) {
return Get2(p, q, pv1);
} else {
return Get2(p, q, pv2);
}
}
int main() {
long long a, b, p, q, TC;
scanf("%lld", &TC);
while (TC--) {
scanf("%lld%lld%lld%lld", &a, &b, &p, &q);
long long be = (a * (2 * p) + q) % (2 * q);
long long res = a + Min(be, 2 * p, 2 * q, b - a + 1);
printf("%lld\n", res);
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100010;
const ll INF = 1e9 + 69;
int n, a[N];
string good;
bitset <N> mul;
void fuck (int ss, int ee) {
int st = ss, en = ee;
while (st <= ee and a[st] == 1) ++st;
while (en >= ss and a[en] == 1) --en;
ll prod = 1;
for (int i = ss; i <= ee; ++i) prod = min(INF, prod * a[i]);
if (prod > en - st + 69) {
for (int i = st + 1; i <= en; ++i) mul[i] = 1;
return;
}
vector <ll> vec;
vector <pair <int, int>> range;
for (int i = st; i <= en;) {
int j = i;
ll cur = 1, cnt = 0;
while (j <= en and a[j] != 1) {
if (j > i) mul[j] = 1;
cur = min(INF, cur * a[j++]);
}
vec.emplace_back(cur);
if (j > en) break;
int from = j;
while (j <= en and a[j] == 1) ++cnt, ++j;
range.emplace_back(from, j - 1);
vec.emplace_back(cnt); i = j;
}
if (vec.size() > 1) {
assert(vec.size() & 1);
int sz = (vec.size() - 1) / 2;
ll opt = 0; int opt_mask = -1;
for (int mask = 0; mask < 1 << sz; ++mask) {
ll cur = vec[0], tot = 0;
for (int i = 1, j = 0; i + 1 < vec.size(); i += 2, ++j) {
ll cnt = vec[i], val = vec[i + 1];
if (mask & 1 << j) tot += cur + cnt, cur = val;
else cur *= val;
}
tot += cur;
if (tot > opt) opt = tot, opt_mask = mask;
}
for (int i = 1, j = 0; i + 1 < vec.size(); i += 2, ++j) {
ll cnt = vec[i], val = vec[i + 1];
if (~opt_mask & 1 << j) {
auto [l, r] = range[j];
for (int p = l; p <= r + 1; ++p) mul[p] = 1;
}
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
cin >> good;
sort(good.begin(), good.end());
if (good.size() == 1 or good == "+-") {
for (int i = 1; i <= n; ++i) {
if (i > 1) putchar(good[0]);
printf("%d", a[i]);
}
cout << '\n';
return 0;
}
if (good == "*-") {
int firstZero = 1;
while (firstZero <= n and a[firstZero]) ++firstZero;
for (int i = 1; i <= n; ++i) {
if (i > 1) putchar(i == firstZero ? '-' : '*');
printf("%d", a[i]);
}
cout << '\n';
return 0;
}
for (int i = 1; i <= n; ++i) {
if (a[i] == 0) continue;
int j = i;
while (j <= n and a[j]) ++j;
fuck(i, j - 1);
i = j - 1;
}
for (int i = 1; i <= n; ++i) {
if (i > 1) putchar(mul[i] ? '*' : '+');
printf("%d", a[i]);
}
cout << '\n';
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, i, j, p;
cin >> t;
while (t--) {
cin >> n;
long long s = 0;
p = n / 2;
for (i = 1;; i = i + 2) {
s = s + (n - i) * p;
p = p - 1;
if (n == i) {
break;
}
}
cout << 4 * s << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
for (int i = 0; i < a; ++i) {
int b, c;
cin >> b >> c;
int d[b];
int u[b];
int e[c];
for (int j = 0; j < b; ++j) {
cin >> d[j];
u[j] = d[j];
}
for (int k = 0; k < c; ++k) cin >> e[k];
int jk = 0;
for (int hh = 0; hh < b; ++hh) {
int gf = 0;
for (int hj = 0; hj < b - 1; ++hj) {
if (d[hj] > d[hj + 1]) {
int hhg = 0;
for (int kk = 0; kk < c; ++kk) {
if (e[kk] == hj + 1) hhg = 1;
}
if (hhg == 1)
swap(d[hj], d[hj + 1]);
else {
gf = 1;
break;
}
}
}
if (gf == 1) {
jk = 1;
cout << "NO"
<< "\n";
break;
}
}
if (jk == 0)
cout << "YES"
<< "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Input() {
char c = getchar();
int x = 0, z = 1;
for (; c < '0' || c > '9'; c = getchar()) z = c == '-' ? -1 : 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
return x * z;
}
const int mod(1e9 + 7);
const int maxn(1005);
int n, m, f[maxn][maxn], g[maxn], c[maxn][maxn], fac[maxn];
void Upd(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
n = Input(), m = Input(), fac[0] = f[0][0] = c[0][0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1LL * fac[i - 1] * i % mod;
for (int i = 1, j; i <= n; ++i)
for (c[i][0] = j = 1; j <= i; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i; ++j) {
f[i][j] = f[i - 1][j];
if (j) Upd(f[i][j], f[max(0, i - 2)][j - 1]);
}
int num = n - 1;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= i; ++j)
Upd(g[i], 1LL * f[num][j] * f[num][i - j] % mod);
g[i] = 1LL * g[i] * fac[n - i] % mod;
}
for (int i = n - 1; ~i; --i)
for (int j = i + 1; j <= n; ++j)
Upd(g[i], mod - 1LL * g[j] * c[j][i] % mod);
printf("%d\n", g[m]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
int main() {
int l, a, p, c, i, j, k;
scanf("%d%d%d", &l, &a, &p);
i = l * 4;
j = a * 2;
if (i <= j && i <= p)
c = l * 7;
else if (j <= i && j <= p && a >= 2) {
if (j % 2 == 0)
j = a / 2;
else
j = (a - 1) / 2;
c = j * 7;
} else if (p <= i && p <= j && p >= 4) {
k = p / 4;
c = k * 7;
} else
c = 0;
printf("%d", c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long i = 1;
while (true) {
cout << "? " << i << " " << 2 * i << endl;
string ans;
cin >> ans;
if (ans == "x") {
break;
}
i *= 2;
}
long long l = i;
long long r = 2 * i;
while (l + 1 < r) {
long long s = (l + r) / 2;
cout << "? " << l << " " << s << endl;
string ans;
cin >> ans;
if (ans == "x") {
r = s;
} else {
l = s;
}
}
if (r == 2) {
cout << "? " << 0 << " " << 1 << endl;
string ans;
cin >> ans;
if (ans == "x") {
r = 1;
} else {
l = 2;
}
}
cout << "! " << r << endl;
}
int main(int argc, const char* argv[]) {
while (true) {
string s;
cin >> s;
if (s != "start") {
return 0;
}
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e9 + 7;
int main() {
double a, x1, y1, b, c, d, x, y, f;
int i;
cin >> a >> b >> c >> d;
x = a / b;
y = c / d;
x1 = x;
y1 = (1 - x) * (1 - y);
f = x1;
for (i = 0; i < 10000; i++) {
f = x1 + y1 * f;
}
cout << fixed << setprecision(12) << f;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long bit[100010], arr[100010], dp[100010][12];
void update(long long val, int idx, int n) {
for (; idx <= n; idx += idx & -idx) bit[idx] += val;
}
long long query(int idx) {
long long sum = 0;
for (; idx > 0; idx -= idx & -idx) sum += bit[idx];
return sum;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
dp[i][1] = 1;
}
if (k == 0) return cout << n << "\n", 0;
for (int j = 2; j <= k + 1; j++) {
for (int i = 0; i < n; i++) bit[i + 1] = 0;
for (int i = 1; i < n; i++) {
update(dp[i - 1][j - 1], arr[i - 1] + 1, n);
dp[i][j] = query(arr[i]);
}
}
long long ans = 0;
for (int i = 0; i < n; i++) ans += dp[i][k + 1];
cout << ans << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bitset<2002> affect[2000 + 1];
pair<int, int> snake[2000 + 1];
int C[2000 + 1][2000 + 1];
int bonus[2000 + 1];
int range[2000 + 1];
int N, M, R;
void Precalc() {
for (int i = 0; i <= 2000; i++) C[i][0] = 1;
for (int i = 1; i <= 2000; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
}
int main() {
int i, j, coef, both, res = 0;
scanf("%d %d %d", &N, &M, &R);
for (i = 1; i <= N; i++)
scanf("%d %d %d", &snake[i].first, &snake[i].second, &bonus[i]);
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++)
if (max(abs(snake[i].first - snake[j].first),
abs(snake[i].second - snake[j].second)) <= R) {
affect[i][j] = 1;
++range[j];
}
Precalc();
for (i = 1; i <= N; i++) {
coef = (C[N][M] - C[N - range[i]][M] + 1000000007) % 1000000007;
res = (res + (1LL * bonus[i] * coef) % 1000000007 * bonus[i]) % 1000000007;
}
for (i = 1; i <= N; i++)
for (j = i + 1; j <= N; j++) {
both = (affect[i] | affect[j]).count();
coef =
(C[N][M] - C[N - range[i]][M] - C[N - range[j]][M] + C[N - both][M]) %
1000000007;
if (coef < 0) coef += 1000000007;
res =
(res + (2LL * bonus[i] * coef) % 1000000007 * bonus[j]) % 1000000007;
}
printf("%d\n", res);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
void speed_up() {
ios::sync_with_stdio(0);
cin.tie(0);
}
void Inp_Out() {}
void leftrotate(string &s, int d) {
reverse(s.begin(), s.begin() + d);
reverse(s.begin() + d, s.end());
reverse(s.begin(), s.end());
}
void rightrotate(string &s, int d) { leftrotate(s, s.length() - d); }
int binary(long long arr[], long long lo, long long hi, long long p) {
long long m = (hi - lo + 1) / 2;
cout << m << "\n";
if (lo == hi)
return lo;
else if (arr[m - 1] < p) {
return binary(arr, m + 1, hi, p);
} else
return binary(arr, lo, m - 1, p);
}
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i < n; i++)
if (n % i == 0) return false;
return true;
}
int main() {
speed_up();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
;
long long num = 4 * n - n;
string s((num / 4), '9');
string s2(n - (num / 4), '8');
cout << s + s2 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int an;
map<string, int> H;
bool is_alpha(char c) { return c >= 'A' && c <= 'Z'; }
void f(char s[], int &offset) {
if (s[offset] == 0) return;
int i;
char name[16];
for (i = offset; is_alpha(s[i]); i++)
;
strncpy(name, s + offset, i - offset);
name[i - offset] = 0;
if (H.count(name) == 0) {
H[name] = 1;
} else
H[name]++;
an += H[name] - 1;
offset = i;
if (s[offset] == ':') {
do {
offset++;
f(s, offset);
} while (s[offset] == ',');
}
offset++;
H[name]--;
}
int main() {
char s[1024];
gets(s);
int tmp = 0;
f(s, tmp);
printf("%d\n", an);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e3 + 5;
int root[MAX_N];
int sz[MAX_N];
int find(int u) {
if (root[u] != u) {
root[u] = find(root[u]);
}
return root[u];
}
void merge(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
sz[u] += sz[v];
root[v] = u;
}
int pairc(int n) { return (n * (n - 1)) / 2; }
int main() {
for (int i = 0; i < MAX_N; i++) {
root[i] = i;
sz[i] = 1;
}
int n, m, k;
cin >> n >> m >> k;
vector<int> gov(k);
for (int i = 0; i < k; i++) {
cin >> gov[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
merge(u, v);
}
pair<int, int> bigc = make_pair(-1, -1);
set<int> govrs;
for (int c : gov) {
int r = find(c);
bigc = max(bigc, make_pair(sz[r], r));
govrs.insert(r);
}
for (int u = 1; u <= n; u++) {
int r = find(u);
if (!govrs.count(r)) {
merge(u, bigc.second);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (find(i) == i) {
ans += pairc(sz[i]);
}
}
ans -= m;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-12;
const int inf = 2000000000;
const long long int infLL = (long long int)2e18;
long long int MOD = 998244353;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
bool comp(const pair<long long int, pair<long long int, long long int> > &p1,
const pair<long long int, pair<long long int, long long int> > &p2) {
return p1.first > p2.first;
}
bool comp1(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) {
if (p1.first == p2.first) {
return p1.second > p2.second;
}
return p1.first < p2.first;
}
long long int converter(string a) {
long long int i, mul = 1, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
int msb(unsigned x) {
union {
double a;
int b[2];
};
a = x;
return (b[1] >> 20) - 1023;
}
const int MAX = 100005;
double a[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.unsetf(ios::floatfield);
cout.precision(14);
cout.setf(ios::fixed, ios::floatfield);
;
int n, i;
cin >> n;
double allsum = 0.0, res = 0.0;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 1; i <= n; ++i) {
res += a[i];
allsum = (allsum + a[i - 1]) * a[i];
res += (allsum * 2.0);
}
cout << res << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
struct Node {
int val, d, id;
Node() {}
Node(int a, int b, int c) : val(a), d(b), id(c) {}
bool operator<(const Node &n) const {
if (val != n.val) return val > n.val;
return id < n.id;
}
};
int n;
Node arr[MAXN];
bool vis[MAXN];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i].val >> arr[i].d;
arr[i].id = i;
}
sort(arr + 1, arr + n + 1);
int ans = 0;
for (int i = n; i >= 1; i--) {
if (vis[arr[i].id]) continue;
if (arr[i].d < 0) continue;
vis[arr[i].id] = 1;
arr[i].val += arr[i].d;
for (int j = i - 1; j >= 1; j--) {
if (arr[j + 1] < arr[j]) {
ans++;
swap(arr[j], arr[j + 1]);
} else
break;
}
i++;
}
for (int i = 1; i <= n; i++) {
if (vis[arr[i].id]) continue;
vis[arr[i].id] = 1;
arr[i].val += arr[i].d;
for (int j = i + 1; j <= n; j++) {
if (arr[j] < arr[j - 1]) {
ans++;
swap(arr[j], arr[j - 1]);
} else
break;
}
i--;
}
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5000;
int mod, fact[N], c[N], phi, prc[N], pwra[N];
int rev(int x) {
int pwr[40];
pwr[0] = x;
for (int i = 1; i < 35; i++) {
pwr[i] = (pwr[i - 1] * 1ll * pwr[i - 1]) % mod;
}
int res = 1, v = phi - 1;
for (int j = 30; j >= 0; j--) {
int bit = (v >> j) & 1;
if (bit) {
res = (res * 1ll * pwr[j]) % mod;
}
}
return res;
}
int getC(int n, int k) {
int res = (fact[n] * 1ll * rev(fact[k])) % mod;
res = (res * 1ll * rev(fact[n - k])) % mod;
return res;
}
int main() {
int n, m, a, q;
scanf("%d %d %d %d", &n, &m, &a, &q);
int rem = 1;
pwra[0] = 1;
for (int i = 1; i <= 1e6 + 500; i++) {
rem = (rem * 1ll * a) % q;
pwra[i] = rem;
if (rem == 1) {
mod = i;
break;
}
}
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * 1ll * i) % mod;
}
phi = mod - 1;
c[0] = 1;
prc[0] = 1;
for (int i = 1; i <= m; i++) {
c[i] = getC(m, i);
prc[i] = (prc[i - 1] + c[i]) % mod;
}
for (int i = 1; i <= n; i++) {
if (i + m <= n) {
printf("%d ", pwra[prc[m]]);
} else {
printf("%d ", pwra[prc[n - i]]);
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
int read() {
register int x = 0;
register char f = 1, ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f ^= 1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0');
return f ? x : -x;
}
int n, m, cnt, tot;
struct node {
int u, v, t, k;
bool operator<(const node &rhs) const {
return u < rhs.u || (u == rhs.u && v < rhs.v) ||
(u == rhs.u && v == rhs.v && t < rhs.t);
}
} a[200005 << 1];
struct edge {
int u, v;
} q[200005], e[200005 << 1];
bool vis[200005 << 1];
int E[200005][2];
struct DSU {
int fa[200005], dep[200005], tp, sta[200005], stad[200005];
void init(int n) {
for (register int i = 1; i <= n; ++i) fa[i] = i, dep[i] = 1;
tp = 0;
}
int find(int x) { return fa[x] == x ? x : find(fa[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
if (dep[x] < dep[y]) std ::swap(x, y);
if (x == y) return;
sta[++tp] = y;
if (dep[y] == dep[x])
stad[tp] = 1, ++dep[x];
else
stad[tp] = 0;
fa[y] = x;
}
bool same(int x, int y) { return find(x) == find(y); }
void undo() {
int y = sta[tp], x = fa[y], d = stad[tp];
--tp, dep[x] -= d, fa[y] = y;
}
} D;
struct Segment_Tree {
std ::vector<int> a[200005 << 2];
void modify(int u, int l, int r, int L, int R, int x) {
if (L <= l && r <= R) return a[u].push_back(x), void(0);
int md = (l + r) >> 1;
if (L <= md) modify(u << 1, l, md, L, R, x);
if (R > md) modify(u << 1 | 1, md + 1, r, L, R, x);
}
void solve(int u, int l, int r) {
static int lastans = 0;
int now = D.tp;
for (int i : a[u])
if (vis[i]) D.merge(e[i].u, e[i].v);
if (l == r) {
if (q[l].u) {
int x = (q[l].u + lastans - 1) % n + 1,
y = (q[l].v + lastans - 1) % n + 1;
putchar((lastans = D.same(x, y)) ^ '0');
} else
vis[E[l][lastans]] ^= 1;
} else {
int md = (l + r) >> 1;
solve(u << 1, l, md), solve(u << 1 | 1, md + 1, r);
}
while (D.tp > now) D.undo();
}
} T;
int main() {
n = read(), m = read();
for (register int i = 1; i <= m; ++i) {
int opt = read(), x = read(), y = read();
if (opt == 2)
q[i] = (edge){x, y};
else {
x > y ? std ::swap(x, y), 0 : 0, a[++cnt] = (node){x, y, i, 0};
x %= n, y %= n, ++x, ++y;
x > y ? std ::swap(x, y), 0 : 0, a[++cnt] = (node){x, y, i, 1};
}
}
std ::sort(a + 1, a + 1 + cnt);
for (register int i = 1; i <= cnt; ++i) {
if (a[i].u == a[i - 1].u && a[i].v == a[i - 1].v)
T.modify(1, 1, m + 1, a[i - 1].t + 1, a[i].t, tot);
else
T.modify(1, 1, m + 1, a[i - 1].t + 1, m + 1, tot),
e[++tot] = (edge){a[i].u, a[i].v};
E[a[i].t][a[i].k] = tot;
}
T.modify(1, 1, m + 1, a[cnt].t + 1, m + 1, tot);
D.init(n);
T.solve(1, 1, m + 1);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> h(10);
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'L') {
for (int i = 0; i < 10; i++) {
if (h[i] == 0) {
h[i] = 1;
break;
}
}
} else if (s[i] == 'R') {
for (int i = 9; i > -1; i--) {
if (h[i] == 0) {
h[i] = 1;
break;
}
}
} else {
h[s[i] - '0'] = 0;
}
}
for (int i = 0; i < 10; i++) {
cout << h[i];
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e18 + 10;
long long MOD = 1000000009;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a, b;
cin >> a >> b;
int n = a.length();
int pref[n];
memset(pref, 0, sizeof pref);
for (long long i = 0; i < n; i++)
if (a[i] == '1') pref[i]++;
for (long long i = 1; i < n; i++) pref[i] += pref[i - 1];
int c = 0, bl = b.length();
for (long long i = 0; i < bl; i++)
if (b[i] == '1') c++;
int ans = 0;
for (long long i = bl - 1; i < n; i++) {
if (i == bl - 1) {
if (pref[i] % 2 == c % 2) ans++;
} else if ((pref[i] - pref[i - bl]) % 2 == c % 2)
ans++;
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int fun(int num, int b) {
if (num == 0) return 0;
return 1 + fun(num / b, b);
}
int main() {
int n1, n2, num, b;
string str, str2;
cin >> n1 >> n2;
num = n1 + n2;
stringstream ss, ss1, ss2;
ss << n1 << n2;
str = ss.str();
vector<int> vec;
for (int i = 0; i < str.size(); i++) {
vec.push_back(int(str[i] - '0'));
}
b = *max_element(vec.begin(), vec.end()) + 1;
ss1 << n1;
str = ss1.str();
ss2 << n2;
str2 = ss2.str();
reverse(str.begin(), str.end());
reverse(str2.begin(), str2.end());
n1 = n2 = 0;
for (int i = 0; i < str.size(); i++) {
n1 += pow(b, i) * int(str[i] - '0');
}
for (int i = 0; i < str2.size(); i++) {
n2 += pow(b, i) * int(str2[i] - '0');
}
cout << fun(n1 + n2, b) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
inline void cmin(int &x, int y) {
if (y < x) x = y;
}
inline void cmax(int &x, int y) {
if (y > x) x = y;
}
using namespace std;
const int N = 2010;
bool vis[N][10][10000];
int a[N], b[N], n;
struct State {
int i, j, st, d;
State(int _i, int _j, int _st, int _d) : i(_i), j(_j), st(_st), d(_d) {}
};
queue<State> q;
void pushstate(int p, int j, int st, int d) {
int x[4] = {0}, c = 0;
for (int i = 0; i <= 3; i++) {
x[c++] = st % 10, st /= 10;
if (x[c - 1] == j || !x[c - 1]) x[--c] = 0;
}
while (c < 4 && p < n && a[p + 1] == j) ++p, x[c++] = b[p];
sort(x, x + 4);
st = 0;
for (int i = 3; i >= 0; i--) st = st * 10 + x[i];
if (!vis[p][j][st]) vis[p][j][st] = true, q.emplace(p, j, st, d);
}
void BFS() {
pushstate(0, 1, 0, 2 * n);
while (!q.empty()) {
State o = q.front();
q.pop();
if (o.i == n && !o.st) {
printf("%d\n", o.d);
return;
}
for (int j : {o.j - 1, o.j + 1}) {
if (j < 1 || j > 9) continue;
pushstate(o.i, j, o.st, o.d + 1);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
BFS();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
double x, y;
cin >> x >> y;
x = y * log(x) - x * log(y);
cout << (x > 0 ? ">" : x != 0 ? "<" : "=");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v[108];
int n, i, j;
for (i = 0; i < 108; i++) v[i].resize(108);
vector<int> in(108);
scanf("%d", &(n));
;
for (i = 0; i < n; i++) scanf("%d", &(in[i]));
;
for (i = 0; i < n; i++)
for (j = 0; j < in[i]; j++) scanf("%d", &(v[i][j]));
;
int ans = 1000000, ians;
for (i = 0; i < n; i++) {
ians = 0;
for (j = 0; j < in[i]; j++) ians += 5 * v[i][j] + 15;
ans = min(ans, ians);
}
printf("%d\n", (ans));
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void faster() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
if (0) {
freopen(
"input"
".in",
"r", stdin);
freopen(
"input"
".out",
"w", stdout);
}
}
int n, a[1001], s = 0, cnt = 0;
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 1) cnt++;
}
cout << cnt << "\n";
for (int i = 1; i < n; ++i) {
if (a[i] == 1) cout << a[i - 1] << " ";
}
cout << a[n - 1];
}
int main() {
faster();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void c_inp() {}
int32_t main() {
c_inp();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
}
long long arr1[n], arr2[n];
arr1[0] = arr[0];
arr2[n - 1] = arr[n - 1];
for (long long i = 1; i < n; ++i) {
arr1[i] = min(arr1[i - 1], arr[i]);
}
for (long long i = n - 2; i >= 0; --i) {
arr2[i] = min(arr2[i + 1], arr[i]);
}
bool flag = true;
for (long long i = 1; i < n - 1; ++i) {
if (arr[i] > arr1[i - 1] && arr[i] > arr2[i + 1]) {
flag = false;
cout << "YES\n";
for (long long j = 0; j < n; ++j) {
if (arr1[j] == arr1[i - 1]) {
cout << j + 1 << " " << i + 1 << " ";
break;
}
}
for (long long j = n - 1; j >= 0; --j) {
if (arr2[j] == arr2[i + 1]) {
cout << j + 1 << "\n";
break;
}
}
break;
}
}
if (flag) cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 218;
const int MAXM = 3200;
const long long MOD = 1000000007LL;
int a[MAXN], b[MAXN];
long long dp[MAXM][MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
++dp[a[i]][i];
if (a[i] != b[i]) {
a[n + i] = b[i];
b[n + i] = a[i];
++dp[a[n + i]][n + i];
}
}
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < n + n; ++j) {
if (dp[i][j] == 0) {
continue;
}
dp[i][j] %= MOD;
for (int k = 0; k < n + n; ++k) {
if (j % n != k % n && a[k] == b[j]) {
dp[i + a[k]][k] += dp[i][j];
}
}
}
}
printf("%d\n", (int)(accumulate(dp[m], dp[m] + n + n, 0LL) % MOD));
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << "\n";
err(++it, args...);
}
const long long N = 2e5 + 5, M = 26, inf = 1e18;
bool ok(vector<int> &a, int m) {
int cnt = 0;
for (int i = 0; i < ((int)(a).size()); i++) {
cnt += a[i] == 0;
if (a[i] or i + 1 == ((int)(a).size())) {
if (cnt >= m) return 0;
cnt = 0;
}
}
return 1;
}
void put(string &s, vector<int> &a, int m, int j, string &ans) {
vector<int> st;
int last = -1;
for (int i = 0; i < ((int)(s).size()); i++) {
if (s[i] - 'a' == j) {
st.push_back(i);
}
if (a[i]) {
last = i;
st.clear();
}
if (((int)(st).size()) and i >= last + m) {
int pos = st.back();
a[pos] = 1;
ans += s[pos];
last = pos;
st.clear();
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int m;
string s, ans;
cin >> m >> s;
vector<int> a(((int)(s).size()));
for (int i = 0; i < M; i++) {
put(s, a, m, i, ans);
if (ok(a, m)) {
return cout << ans, 0;
}
char c = 'a' + i;
ans += string(
count(s.begin(), s.end(), c) - count(ans.begin(), ans.end(), c), c);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010, MOD = 1e9 + 7;
long long c[MAXN][MAXN];
int main() {
for (int i = 0; i <= 1005; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = ((c[i - 1][j] % MOD) + (c[i - 1][j - 1] % MOD)) % MOD;
}
}
int n, m, k;
cin >> n >> m >> k;
if (2 * k > n - 1 || 2 * k > m - 1) {
cout << 0 << endl;
return 0;
}
cout << ((c[n - 1][2 * k] % MOD) * (c[m - 1][2 * k] % MOD)) % MOD << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n,cnt;
long long ans,c[400010];
struct tree
{
int l,r;
long long mx1,mx2;
}tr[2000010];
struct node
{
long long a,b;
}a[200010];
inline void build(int rt,int l,int r)
{
tr[rt].l=l;
tr[rt].r=r;
tr[rt].mx1=0;
tr[rt].mx2=0;
if(l==r)
return;
int mid=(l+r)>>1;
build(rt<<1,l,mid);
build(rt<<1|1,mid+1,r);
}
inline int cmp(node x,node y)
{
if(x.a!=y.a)
return x.a<y.a;
else
return x.b>y.b;
}
inline void update1(int rt,int id,long long x)
{
int l=tr[rt].l,r=tr[rt].r;
if(l==r)
{
tr[rt].mx1=max(tr[rt].mx1,x);
return;
}
int mid=(l+r)>>1;
if(id<=mid)
update1(rt<<1,id,x);
else
update1(rt<<1|1,id,x);
tr[rt].mx1=max(tr[rt<<1].mx1,tr[rt<<1|1].mx1);
}
inline void update2(int rt,int id,long long x)
{
int l=tr[rt].l,r=tr[rt].r;
if(l==r)
{
tr[rt].mx2=max(tr[rt].mx2,x);
return;
}
int mid=(l+r)>>1;
if(id<=mid)
update2(rt<<1,id,x);
else
update2(rt<<1|1,id,x);
tr[rt].mx2=max(tr[rt<<1].mx2,tr[rt<<1|1].mx2);
}
inline long long query1(int rt,int le,int ri)
{
int l=tr[rt].l,r=tr[rt].r;
if(le<=l&&r<=ri)
return tr[rt].mx1;
int mid=(l+r)>>1;
long long res=0;
if(le<=mid)
res=query1(rt<<1,le,ri);
if(mid+1<=ri)
res=max(res,query1(rt<<1|1,le,ri));
return res;
}
inline long long query2(int rt,int le,int ri)
{
int l=tr[rt].l,r=tr[rt].r;
if(le<=l&&r<=ri)
return tr[rt].mx2;
int mid=(l+r)>>1;
long long res=0;
if(le<=mid)
res=query2(rt<<1,le,ri);
if(mid+1<=ri)
res=max(res,query2(rt<<1|1,le,ri));
return res;
}
inline int cmp2(node x,node y)
{
if(min(x.a,x.b)!=min(y.a,y.b))
return min(x.a,x.b)>min(y.a,y.b);
else
return (x.b-x.a)>(y.b-y.a);
}
inline int cmp3(node x,node y)
{
if(x.b!=y.b)
return x.b<y.b;
else
return x.a>y.a;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;++i)
{
scanf("%lld",&a[i].a);
c[i]=a[i].a;
}
for(int i=1;i<=n;++i)
{
scanf("%lld",&a[i].b);
c[i+n]=a[i].b;
ans+=abs(a[i].a-a[i].b);
}
sort(c+1,c+2*n+1);
cnt=unique(c+1,c+2*n+1)-c-1;
build(1,1,cnt);
sort(a+1,a+n+1,cmp);
long long res=ans;
for(int i=1;i<=n;++i)
{
if(a[i].a>=a[i].b)
{
int x=lower_bound(c+1,c+cnt+1,a[i].b)-c;
long long y;
y=query1(1,1,x);
// if(a[i].a==2062)
// cout<<y<<endl;
if(y>a[i].b&&y<a[i].a)
res=min(res,ans-2ll*(y-a[i].b));
if(y>=a[i].a)
res=min(res,ans-2ll*(a[i].a-a[i].b));
x=lower_bound(c+1,c+cnt+1,a[i].a)-c;
y=query2(1,x,cnt);
if(y>=a[i].b)
res=min(res,ans-2ll*(a[i].a-y));
}
else
{
int x=lower_bound(c+1,c+cnt+1,a[i].a)-c;
update1(1,x,a[i].b);
x=lower_bound(c+1,c+cnt+1,a[i].b)-c;
update2(1,x,a[i].a);
}
}
build(1,1,cnt);
sort(a+1,a+n+1,cmp3);
for(int i=1;i<=n;++i)
{
if(a[i].a<=a[i].b)
{
int x=lower_bound(c+1,c+cnt+1,a[i].a)-c;
long long y;
y=query1(1,1,x);
// if(a[i].a==2062)
// cout<<y<<endl;
if(y>a[i].a&&y<a[i].b)
res=min(res,ans-2ll*(y-a[i].a));
if(y>=a[i].b)
res=min(res,ans-2ll*(a[i].b-a[i].a));
x=lower_bound(c+1,c+cnt+1,a[i].b)-c;
y=query2(1,x,cnt);
if(y>=a[i].a)
res=min(res,ans-2ll*(a[i].b-y));
}
else
{
int x=lower_bound(c+1,c+cnt+1,a[i].b)-c;
update1(1,x,a[i].a);
x=lower_bound(c+1,c+cnt+1,a[i].a)-c;
update2(1,x,a[i].b);
}
}
sort(a+1,a+n+1,cmp2);
build(1,1,cnt);
for(int i=1;i<=n;++i)
{
if(a[i].a>=a[i].b)
{
int x=lower_bound(c+1,c+cnt+1,a[i].a)-c;
long long y=query1(1,1,x);
res=min(res,ans-2*y);
}
else
{
int x=lower_bound(c+1,c+cnt+1,a[i].b)-c;
update1(1,x,a[i].b-a[i].a);
}
}
printf("%lld\n",res);
return 0;
} | 17 |
#include <bits/stdc++.h>
using namespace std;
int x, t, a, b, da, db, q[100009], w[100009], l, k;
int main() {
cin >> x >> t >> a >> b >> da >> db;
if (x == 0) {
cout << "YES";
return 0;
}
for (int i = 0; i < t; i++) {
q[i] = a;
w[i] = b;
a -= da;
b -= db;
if (q[i] == x || w[i] == x) {
cout << "YES";
return 0;
}
}
for (int i = 0; i < t; i++)
for (int j = 0; j < t; j++) {
if (q[i] + w[j] == x) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char str[51234];
int L[51234][123];
int P[51234][27];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> str;
n = strlen(str);
for (int i = 0; i < 26; ++i) {
int w = n;
P[n][i] = 0x3f3f3f3f;
for (int j = n - 1; j >= 0; --j) {
if (str[j] - 'a' == i) w = j;
P[j][i] = w;
}
}
for (int i = 0; i <= n; ++i) {
L[i][0] = i - 1;
L[i][1] = i;
}
memset(L, 0x3f, sizeof(L));
for (int i = 0; i < n; ++i) {
L[i][0] = i - 1;
L[i][1] = i;
}
int mx = 1;
for (int k = 2; k < 102; ++k) {
for (int i = n - 1; i >= 0; --i) {
if (i < n) {
int t = L[i + 1][k - 2] + 1;
if (t < n) {
L[i][k] = min(L[i + 1][k], P[t][str[i] - 'a']);
} else {
L[i][k] = L[i + 1][k];
}
}
}
if (L[0][k] < n) mx = k;
}
int l, r;
bool flag = 0;
for (int i = 0; i < n; ++i) {
for (int k = 100; k >= 1; --k) {
if (L[i][k] < n) {
l = i, r = L[i][k];
n = k;
flag = 1;
}
if (flag) break;
}
if (flag) break;
}
string s1;
for (int i = l; i <= r; ++i) {
s1 += str[i];
}
string prefix, surfix;
for (int i = 0; i < s1.length(); ++i) {
if (L[i + 1 + l][n] < l + s1.length()) {
s1 = s1.substr(0, L[i + 1 + l][n] - l + 1);
continue;
} else if (L[i + l][n] == l + s1.length() - 1) {
prefix = prefix + s1[i];
n--;
if (i != s1.length() - 1) surfix = s1[s1.length() - 1] + surfix, n--;
s1 = s1.substr(0, s1.length() - 1);
} else {
s1 = s1.substr(0, s1.length() - 1);
i--;
}
if (n <= 0) break;
}
cout << prefix << surfix << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
bool p = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') p = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
if (p) x = -x;
}
int n;
const int N = 5005;
const long long MOD = 998244353;
long long Hina[N][N], a[N], b[N];
long long F[N], G[N], H[N], fac[N], inv[N], Aya[N << 1], ans[3 * N];
int nxt[N], pre[N];
int vis[N];
long long va = 0, vb = 0, vc = 0, vd = 0;
long long ksm(long long basic, long long mi) {
long long tmp = 1;
while (mi) {
if (mi & 1) tmp = tmp * basic % MOD;
mi >>= 1;
basic = basic * basic % MOD;
}
return tmp;
}
long long C(int n, int m) {
if (n < m || m < 0) return 0;
if (n == m || !m) return 1;
return fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
long long Ans[3 * N];
int las[N], fir[N];
int main() {
read(n);
for (int i = 1; i <= n; ++i) read(a[i]);
for (int i = 1; i <= n; ++i) read(b[i]);
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = 1ll * i * fac[i - 1] % MOD;
}
inv[n] = ksm(fac[n], MOD - 2);
for (int i = n - 1; i; --i) {
inv[i] = 1ll * (i + 1) * inv[i + 1] % MOD;
}
for (int i = 1; i <= n; ++i) {
if (a[i] && b[i]) {
nxt[a[i]] = b[i];
pre[b[i]] = a[i];
} else if (a[i]) {
las[a[i]] = 1;
} else if (b[i]) {
fir[b[i]] = 1;
} else {
++va;
}
}
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
vis[i] = 1;
int head = i, tail = i;
while (pre[head] && !vis[pre[head]]) {
head = pre[head];
vis[head] = 1;
}
while (nxt[tail] && !vis[nxt[tail]]) {
tail = nxt[tail];
vis[tail] = 1;
}
if (pre[head] == tail && nxt[tail] == head) ++vd;
if (las[tail] && fir[head]) ++va;
if (las[tail] && !fir[head]) ++vb;
if (!las[tail] && fir[head]) ++vc;
}
Hina[0][0] = 1;
for (int i = 1; i <= n; ++i) {
Hina[i][0] = 0;
for (int j = 1; j <= i; ++j) {
Hina[i][j] =
(Hina[i - 1][j - 1] + 1ll * (i - 1) * Hina[i - 1][j] % MOD) % MOD;
}
}
for (int i = 0; i <= vb; ++i) {
for (int j = i; j <= vb; ++j) {
long long tmp;
if (j == vb)
tmp = 1;
else
tmp = C(va - 1 + vb - j, va - 1);
G[i] =
(G[i] + Hina[j][i] * C(vb, j) % MOD * tmp % MOD * fac[vb - j] % MOD) %
MOD;
}
}
for (int i = 0; i <= vc; ++i) {
for (int j = i; j <= vc; ++j) {
long long tmp;
if (j == vc)
tmp = 1;
else
tmp = C(va - 1 + vc - j, va - 1);
H[i] =
(H[i] + Hina[j][i] * C(vc, j) % MOD * tmp % MOD * fac[vc - j] % MOD) %
MOD;
}
}
for (int i = 0; i <= va; ++i) {
F[i] = Hina[va][i] * fac[va] % MOD;
}
for (int i = 0; i <= vb; ++i) {
for (int j = 0; j <= vc; ++j) {
Aya[i + j] = (Aya[i + j] + G[i] * H[j] % MOD) % MOD;
}
}
for (int i = 0; i <= vb + vc; ++i) {
for (int j = 0; j <= va; ++j) {
ans[i + j] = (ans[i + j] + Aya[i] * F[j] % MOD) % MOD;
}
}
for (int i = 0; i <= va + vb + vc; ++i) {
Ans[n - i - vd] = ans[i];
}
for (int i = 0; i < n; ++i) printf("%lld ", Ans[i]);
return 0;
}
| 26 |
Subsets and Splits