solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
long long p = n;
long long ans = 0;
while ((2 * k) != p && p > 0 && k > 0) {
ans = max(ans, v[p - 1]);
--k;
--p;
}
long long l = 0;
long long r = p - 1;
while (l <= r) {
ans = max(ans, v[l] + v[r]);
++l;
--r;
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
double sq(double x) { return x * x; }
int dbg = 1;
using namespace std;
pair<int, int> arr[100005];
double shortest(int x, int y, int a, int b) {
double x1 = x, y1 = y, x2 = a, y2 = b;
if (x1 == x2)
if (y1 * y2 <= 0)
return sq(x1);
else
return sq(min(y1, y2)) + sq(x1);
double m = (y2 - y1) / (x2 - x1);
double c = y1 - m * x1;
if ((m * y1 + x1) * (m * y2 + x2) < 0) {
double x, y;
x = -1 * (m * c) / (1 + sq(m));
y = c / (1 + sq(m));
return sq(x) + sq(y);
}
return min(sq(x1) + sq(y1), sq(x2) + sq(y2));
}
int main() {
int n, x, y;
double mini = 1e15, maxi = 0, pi = 3.1415926535897932;
cin >> n >> x >> y;
for (int i = 0; i < n; i++) {
scanf("%d %d", &arr[i].first, &arr[i].second);
;
arr[i].first -= x;
arr[i].second -= y;
}
for (int i = 0; i < n - 1; i++) {
mini = min(mini, shortest(arr[i].first, arr[i].second, arr[i + 1].first,
arr[i + 1].second));
maxi = max(maxi, sq(arr[i].first) + sq(arr[i].second));
}
maxi = max(maxi, sq(arr[n - 1].first) + sq(arr[n - 1].second));
mini = min(mini, shortest(arr[0].first, arr[0].second, arr[n - 1].first,
arr[n - 1].second));
printf("%.9lf\n", pi * (maxi - mini));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 222;
set<int> ori[maxn];
vector<int> ids[maxn];
int top, bot;
int dest[maxn];
int have[maxn];
int occ[maxn];
int ans[maxn][3];
int arr = 0;
int flag[maxn];
vector<pair<int, int> > pp;
void solve() {
int n, m;
scanf("%d %d", &n, &m);
int tot = 0;
for (int i = 1; i <= n; i++) {
int s;
scanf("%d", &s);
tot += s;
int a;
for (int j = 1; j <= s; j++) {
scanf("%d", &a);
ori[i].insert(a);
}
pp.push_back(make_pair(s, i));
}
sort(pp.begin(), pp.end());
reverse(pp.begin(), pp.end());
bot = tot / n;
top = bot;
if (tot % n) top++;
int topcnt = tot % n;
for (int i = 0; i < pp.size(); i++) {
if (i < topcnt)
dest[pp[i].second] = top;
else
dest[pp[i].second] = bot;
}
for (int i = 1; i <= n; i++) {
if (ori[i].size() < dest[i]) flag[i] = 1;
}
set<int> se;
for (int i = 1; i <= n; i++) {
if (ori[i].size() > dest[i]) {
for (int a : ori[i]) {
occ[a]++;
se.insert(a);
ids[a].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
if (flag[i]) {
int needcnt = dest[i] - ori[i].size();
for (int a : ori[i]) have[a] = 1;
vector<int> needdel;
for (int id : se) {
if (!have[id] && occ[id] > 0) {
while (ori[ids[id].back()].size() == dest[ids[id].back()]) {
ids[id].pop_back();
}
int fid = ids[id].back();
ids[id].pop_back();
arr++;
ans[arr][0] = fid;
ans[arr][1] = i;
ans[arr][2] = id;
ori[fid].erase(id);
occ[id]--;
if (occ[id] == 0) needdel.push_back(id);
if (ori[fid].size() == dest[fid]) {
for (int a : ori[fid]) {
occ[a]--;
if (occ[a] == 0) needdel.push_back(a);
}
}
needcnt--;
}
if (needcnt == 0) break;
}
for (int a : ori[i]) have[a] = 0;
for (int a : needdel) se.erase(a);
}
}
cout << arr << endl;
for (int i = 1; i <= arr; i++) {
printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}
}
signed main() { solve(); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, tot, x, l, r;
int A[16];
bool ok(int mask) {
int taken = 0;
int mn = INT_MAX, mx = INT_MIN;
long long sum = 0;
for (int i = 0; i < n; i++) {
if ((mask >> i) & 1) {
taken++;
sum += A[i];
mn = min(mn, A[i]);
mx = max(mx, A[i]);
}
}
return (taken > 1 && sum >= l && sum <= r && (mx - mn) >= x);
}
int main() {
scanf("%d%d%d%d", &n, &l, &r, &x);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
tot = (1 << n);
int cnt = 0;
for (int i = 0; i < tot; i++) {
if (ok(i)) ++cnt;
}
printf("%d\n", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sc1() {
int x;
scanf("%d", &x);
return x;
}
long long sc2() {
long long x;
scanf("%lld", &x);
return x;
}
const int mod = 1e9 + 7;
inline int add(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b) { return (long long)a * b % mod; }
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
const int inf = (int)2e9 + 5;
const long long Inf = (long long)1e18 + 5;
const int N = 5e6 + 5;
int solve() {
int n = sc1(), k = sc1();
if (n % 2 == 0) {
if (k % 2 == 0) {
if (n < k)
puts("NO");
else {
puts("YES");
for (int i = 1; i < k; i++) cout << 1 << " ";
cout << n - (k - 1) << endl;
}
} else {
if (n < (k * 2)) {
puts("NO");
return 0;
} else {
puts("YES");
for (int i = 1; i < k; i++) {
cout << 2 << " ";
}
cout << (n - ((k - 1) * 2)) << endl;
}
}
} else {
if (k % 2 == 0) {
puts("NO");
return 0;
}
if (n < k)
puts("NO");
else {
puts("YES");
for (int i = 1; i < k; i++) {
cout << 1 << " ";
}
cout << (n - (k - 1)) << endl;
}
}
return 0;
}
int main() {
int test = 1, tc = 0;
scanf("%d", &test);
while (test--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
struct rng {
struct A {
int n;
const bool operator!=(A r) { return n != r.n; }
A& operator++() {
n++;
return *this;
}
int operator*() { return n; }
};
int l, r;
rng(int r) : l(0), r(max(0, r)) {}
rng(int l, int r) : l(l), r(max(l, r)) {}
A begin() { return A{l}; }
A end() { return A{r}; }
};
struct UnionFind {
vector<int> p, r;
int gn;
UnionFind(int N) {
p.resize(N);
r.resize(N);
fill(begin(p), end(p), -1);
fill(begin(r), end(r), 1);
gn = N;
}
void merge(int a, int b) {
int x = group(a), y = group(b);
if (x == y) return;
gn--;
if (r[x] < r[y])
p[x] = y;
else if (r[x] > r[y])
p[y] = x;
else {
p[x] = y;
r[x]++;
}
}
int group(int a) {
if (p[a] == -1) return a;
return p[a] = group(p[a]);
}
bool same(int a, int b) { return group(a) == group(b); }
void clear(int i) {
p[i] = -1;
r[i] = 1;
}
};
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<int> U(m), V(m), W(m);
for (int i : rng(m)) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
u--;
v--;
U[i] = u;
V[i] = v;
W[i] = w;
}
vector<int> idx(m);
iota(begin(idx), end(idx), 0);
sort(begin(idx), end(idx), [&](int a, int b) { return W[a] < W[b]; });
vector<bool> ok(m);
vector<int> nxU(m), nxV(m);
ll ans = 0;
UnionFind uf(n);
int l = 0;
while (l < m) {
int r = l;
while (r < m && W[idx[l]] == W[idx[r]]) r++;
for (int i : rng(l, r)) {
int u = U[idx[i]], v = V[idx[i]];
ok[idx[i]] = (uf.same(u, v) == false);
nxU[idx[i]] = uf.group(u);
nxV[idx[i]] = uf.group(v);
}
for (int i : rng(l, r)) {
int u = U[idx[i]], v = V[idx[i]];
uf.merge(u, v);
}
l = r;
}
for (int i : idx) {
uf.clear(U[i]);
uf.clear(V[i]);
}
int q;
scanf("%d", &q);
for (int ph : rng(q)) {
int k;
scanf("%d", &k);
bool res = true;
vector<int> idx(k);
for (int i : rng(k)) {
int x;
scanf("%d", &x);
x--;
idx[i] = x;
if (!ok[x]) res = false;
}
sort(begin(idx), end(idx), [&](int a, int b) { return W[a] < W[b]; });
int l = 0;
while (l < k) {
int r = l;
while (r < k && W[idx[r]] == W[idx[l]]) r++;
for (int i : rng(l, r)) {
int u = nxU[idx[i]], v = nxV[idx[i]];
if (uf.same(u, v)) {
res = false;
break;
}
uf.merge(u, v);
}
for (int i : rng(l, r)) {
uf.clear(nxU[idx[i]]);
uf.clear(nxV[idx[i]]);
}
l = r;
}
if (res) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int l = 1, r = 1;
for (int i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) {
int j = i;
while (n - 1 > j && arr[j] > arr[j + 1]) ++j;
reverse(arr + i, arr + j + 1);
l = i + 1;
r = j + 1;
break;
}
}
for (int i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) {
cout << "no";
return 0;
}
}
printf("yes\n%d %d", l, r);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
struct query {
int t;
lint l, r;
};
query qs[111111];
struct SegmentTree {
int* a;
int* st;
bool* ni;
int n;
SegmentTree(int n) : n(n) {
a = new int[4 * n];
st = new int[4 * n];
ni = new bool[4 * n];
fill(a, a + 4 * n, 0);
fill(st, st + 4 * n, -1);
fill(ni, ni + 4 * n, false);
}
void push(int i, int l, int r) {
if (st[i] != -1) {
a[i] = (r - l) * st[i];
if (l + 1 != r) {
st[i * 2 + 1] = st[i];
ni[i * 2 + 1] = false;
st[i * 2 + 2] = st[i];
ni[i * 2 + 2] = false;
}
st[i] = -1;
}
if (ni[i]) {
a[i] = r - l - a[i];
if (l + 1 != r) {
ni[i * 2 + 1] ^= true;
ni[i * 2 + 2] ^= true;
}
ni[i] = false;
}
}
void set(int i, int l, int r, int ql, int qr, int x, bool inv) {
push(i, l, r);
if (r <= ql || qr <= l) {
return;
}
if (ql <= l && r <= qr) {
st[i] = x;
ni[i] = inv;
push(i, l, r);
return;
}
int m = (l + r) >> 1;
set(i * 2 + 1, l, m, ql, qr, x, inv);
set(i * 2 + 2, m, r, ql, qr, x, inv);
a[i] = a[i * 2 + 1] + a[i * 2 + 2];
}
int lz(int i, int l, int r) {
push(i, l, r);
if (a[i] == r - l) {
return -1;
}
if (a[i] == 0) {
return l;
}
int m = (l + r) >> 1;
int res = lz(i * 2 + 1, l, m);
if (res == -1) {
res = lz(i * 2 + 2, m, r);
}
return res;
}
};
void solve(istream& cin, ostream& cout) {
int n;
cin >> n;
vector<lint> xs;
for (int i = (0); i < int(n); ++i) {
cin >> qs[i].t >> qs[i].l >> qs[i].r;
xs.push_back(qs[i].l - 1);
xs.push_back(qs[i].r);
}
xs.push_back(0);
sort(xs.begin(), xs.end());
xs.resize(unique(xs.begin(), xs.end()) - xs.begin());
SegmentTree st(xs.size() + 3);
for (int i = (0); i < int(n); ++i) {
query q = qs[i];
q.l = lower_bound(xs.begin(), xs.end(), q.l - 1) - xs.begin();
q.r = lower_bound(xs.begin(), xs.end(), q.r) - xs.begin();
if (q.t == 1) {
st.set(0, 0, st.n, q.l, q.r, 1, false);
} else if (q.t == 2) {
st.set(0, 0, st.n, q.l, q.r, 0, false);
} else {
st.set(0, 0, st.n, q.l, q.r, -1, true);
}
cout << xs[st.lz(0, 0, st.n)] + 1 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(cin, cout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 123;
int ka;
long long ff[N], f[N], ans[N];
void go(int v, int z) {
if (z == 0) {
if (ka == 1) {
ans[ka++] = 0;
}
cout << ka << '\n';
for (int i = 0; i <= ka - 1; i++) {
if (i > 0) cout << ' ';
cout << ans[i];
}
cout << '\n';
exit(0);
}
if (v == 0) {
return;
}
if (ff[v - 1] >= z) {
go(v - 1, z);
}
if (f[v] <= z) {
ans[ka++] = f[v];
go(v - 1, z - f[v]);
ka--;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int s, k;
cin >> s >> k;
f[0] = 1;
int i;
for (i = 1; i <= 50; i++) {
for (int j = i - 1; j >= max(i - k, 0); j--) {
f[i] += f[j];
}
if (f[i] > s) {
break;
}
}
ff[0] = 0;
for (int j = 1; j < i; j++) {
ff[j] = ff[j - 1] + f[j];
}
ka = 0;
go(i - 1, s);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
bool used[500][500], mark[500];
vector<pair<int, int> > ans;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int cnt = 0;
cin >> s;
int dx = 0, dy = 0;
for (int i = 0; i < n; i++) {
if (dx == 0 && dy == 0) {
if (s[i] == 'R') dx = 1;
if (s[i] == 'L') dx = -1;
if (s[i] == 'U') dy = 1;
if (s[i] == 'D') dy = -1;
cnt++;
continue;
}
if (s[i] == 'R' && dx != 1) {
if (dx == -1) {
cnt++;
dy = 0;
}
dx = 1;
continue;
}
if (s[i] == 'L' && dx != -1) {
if (dx == 1) {
cnt++;
dy = 0;
}
dx = -1;
continue;
}
if (s[i] == 'U' && dy != 1) {
if (dy == -1) {
cnt++;
dx = 0;
}
dy = 1;
continue;
}
if (s[i] == 'D' && dy != -1) {
if (dy == 1) {
cnt++;
dx = 0;
}
dy = -1;
continue;
}
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
set<pair<int, int>> edge;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(time(nullptr));
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
edge.insert(minmax(a, b));
}
vector<int> vec;
for (int i = 1; i <= n; ++i) vec.push_back(i);
while (1.0 * clock() / CLOCKS_PER_SEC <= 1.5) {
random_shuffle(vec.begin(), vec.end());
int cnt = 0;
for (int i = 0; i < vec.size() - 1; ++i) {
if (edge.count(minmax(vec[i], vec[i + 1])) == 0) ++cnt;
}
if (edge.count(minmax(vec[vec.size() - 1], vec[0])) == 0) ++cnt;
if (cnt >= m) {
for (int i = 0; i < vec.size() - 1 && m; ++i) {
if (edge.count(minmax(vec[i], vec[i + 1])) == 0) {
cout << vec[i] << ' ' << vec[i + 1] << endl;
--m;
}
}
if (m == 0) return 0;
cout << vec[vec.size() - 1] << ' ' << vec[0] << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q, t, p, q1, x, mn = LONG_LONG_MAX, mxx = -1;
cin >> n;
long long a[n], ans[n];
vector<pair<long long, long long> > pr(n, make_pair(-1, -1));
for (int i = 0; i < n; i++) {
cin >> a[i];
ans[i] = a[i];
mn = min(mn, a[i]);
}
cin >> q;
q1 = q;
vector<long long> t2(q + 1, -1);
long long c = 0;
while (q1--) {
c++;
cin >> t;
if (t == 1) {
cin >> p >> x;
pr[p - 1] = make_pair(x, c);
} else {
cin >> x;
t2[c] = x;
mxx = max(mxx, x);
}
}
long long arr[q + 2], mx = -1;
for (int i = 1; i <= 1 + q; i++) arr[i] = -1;
for (int i = q; i >= 1; i--) arr[i] = max(t2[i], arr[i + 1]);
for (int i = 0; i < n; i++) {
if (pr[i].first == -1) {
if (a[i] < mxx) ans[i] = mxx;
} else {
ans[i] = pr[i].first;
if (arr[pr[i].second] != -1 && ans[i] < arr[pr[i].second])
ans[i] = arr[pr[i].second];
}
cout << ans[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int xs, ys, xt, yt;
int v, t;
int vx, vy;
int wx, wy;
double calc(double vx, double vy, double th, double len) {
double vxl = vx * cos(th);
double vxt = vx * sin(th);
double vyl = vy * sin(th);
double vyt = vy * cos(th);
double vl = sqrt(((v) * (v)) - ((vyt - vxt) * (vyt - vxt)));
;
;
;
return len / (vl + vxl + vyl);
}
double calcv(double t2) {
double xtt = (double)xt - t * vx;
double ytt = (double)yt - t * vy;
xtt -= t2 * wx;
ytt -= t2 * wy;
double ll = sqrt(((xtt - xs) * (xtt - xs)) + ((ytt - ys) * (ytt - ys)));
return ll / (t2 + t);
}
int main() {
scanf("%d%d%d%d", &xs, &ys, &xt, &yt);
scanf("%d%d", &v, &t);
scanf("%d%d", &vx, &vy);
scanf("%d%d", &wx, &wy);
double th = atan2(yt - ys, xt - xs);
double len = sqrt(((xs - xt) * (xs - xt)) + ((ys - yt) * (ys - yt)));
double t1 = calc(vx, vy, th, len);
;
if (t1 <= t + eps) {
printf("%.8f\n", t1);
} else {
double s = len * (t1 - t) / t1;
double t2 = calc(wx, wy, th, s);
double l = 0, r = t2;
for (int i = 0; i < 50; ++i) {
double mid = (l + r) / 2;
if (calcv(mid) > v) {
l = mid;
} else {
r = mid;
}
}
printf("%.8f\n", t + l);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, 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 year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline bool isIntege(double num) { return (num == (int)num); }
inline bool collinear(int x1, int y1, int x2, int y2, int x3, int y3) {
return (y1 - y2) * (x1 - x3) == (y1 - y3) * (x1 - x2);
}
inline double coDist(double x1, double y1, double x2, double y2) {
return sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
struct edge {
int u, v, w;
};
bool cmp(const edge &a, const edge &b) { return a.w < b.w; }
string to_s(int t) {
stringstream ss;
ss << t;
return ss.str();
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
clock_t tStart = clock();
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
long long a;
cin >> a;
ans += ((i - 1) * (a - 1) + a);
}
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 3e5 + 5;
int n, m, l, r, x, mp[sz], ans[sz];
set<int> st;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) st.insert(i);
memset(ans, 0, sizeof ans);
while (m--) {
cin >> l >> r >> x;
auto it = st.lower_bound(l);
v.clear();
while (it != st.end() && *it <= r) {
if (*it != x) {
ans[*it] = x;
v.push_back(*it);
}
it++;
}
for (auto i : v) st.erase(i);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.);
const double eps = 1e-15;
const int MOD = 1e9 + 7;
long long power(long long x, long long y) {
if (y == 0) return 1;
long long s = power(x, y / 2);
s *= s;
s %= MOD;
if (y & 1) s *= x;
s %= MOD;
return s;
}
long long Ceil(long long x, long long y) { return (x + y - 1) / y; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long C(long long n, long long k) {
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res %= MOD;
res *= power(i + 1, MOD - 2);
res %= MOD;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long res = power(3, n * 3);
res -= power(7, n);
res += MOD;
res %= MOD;
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 128, maxm = 3100, mod = 12345;
long long n, m, a[maxn][maxm], t, b[maxm], d[maxm], sum;
pair<char, long long> p[maxm];
char c;
bool mark[30], l, mark2[30];
struct matric {
long long a[maxn][maxn];
matric() { memset(a, 0, sizeof a); }
void print() {
cout << endl;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) cout << a[i][j];
cout << endl;
}
matric operator*(const matric b) {
matric c;
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++)
for (int k = 0; k < maxn; k++) {
c.a[i][j] += a[i][k] * b.a[k][j];
c.a[i][j] %= mod;
}
return c;
}
};
matric v, ans, f;
matric pow(matric a, long long n) {
if (n == 1) return v;
f = pow(a, n / 2);
f = f * f;
if (n % 2) f = f * v;
return f;
}
void H(long long x, long long b[]) {
if (x == m) {
for (int i = 0; i < m; i++) a[t][i] = b[i];
t++;
return;
}
for (int i = 0; i < p[x].second; i++) {
b[x] = i;
H(x + 1, b);
b[x] = 0;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long x;
cin >> c >> x;
p[i] = make_pair(c, x);
mark[c - 'A'] = true;
}
if (!n) {
cout << 1 << endl;
return 0;
}
if (!m) {
cout << 0 << endl;
return 0;
}
sort(p, p + m);
for (int i = 0; i < m; i++) d[i] = p[i].first - 'A';
H(0, b);
memset(b, 0, sizeof b);
for (int i = 0; i < t; i++) {
for (int j = 0; j < 26; j++) {
if (!mark[j]) continue;
for (int k = 0; k < m; k++) b[k] = a[i][k];
for (int k = 0; k < m; k++)
if (d[k] == j) b[k] = (b[k] + 1) % p[k].second;
for (int k = 0; k < t; k++) {
l = 1;
for (int u = 0; u < m; u++)
if (a[k][u] != b[u]) l = 0;
if (l) v.a[i][k]++;
}
}
}
ans = pow(v, n);
for (int j = 0; j < t; j++) {
memset(mark2, 0, sizeof mark2);
l = 1;
for (int i = 0; i < m; i++)
if (a[j][i] == 0) mark2[d[i]] = true;
for (int i = 0; i < 26; i++)
if (mark[i] && !mark2[i]) l = 0;
if (l) {
sum += ans.a[0][j];
sum %= mod;
}
}
cout << sum << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("2")
#pragma GCC optimize("inline")
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0, ch = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
const long long N = 500005;
map<long long, long long> mp;
long long a[N], b[N], A[N], B[N], n, m, Y1, Y2, ans = 0;
signed main() {
read(n), read(Y1);
for (long long i = 1; i <= n; i++) read(a[i]), mp[a[i]]++;
read(m), read(Y2);
for (long long i = 1; i <= m; i++) read(b[i]), mp[b[i]]++;
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
for (long long k = 1; k <= (long long)(1e9); k <<= 1) {
for (long long i = 1; i <= n; i++) A[i] = a[i] % (2ll * k);
for (long long i = 1; i <= m; i++) B[i] = b[i] % (2ll * k);
sort(A + 1, A + n + 1);
sort(B + 1, B + m + 1);
long long lst = 0;
for (long long i = 1; i <= n; i = lst + 1) {
lst = i;
while (A[lst] == A[lst + 1] && lst < n) lst++;
long long v = (A[i] + k) % (k << 1ll);
ans = max(ans, lst - i + 1 +
(long long)(upper_bound(B + 1, B + m + 1, v) -
lower_bound(B + 1, B + m + 1, v)));
}
for (long long i = 1; i <= m; i = lst + 1) {
lst = i;
while (B[lst] == B[lst + 1] && lst < m) lst++;
ans = max(ans, lst - i + 1);
}
}
static map<long long, long long>::iterator it;
for (it = mp.begin(); it != mp.end(); it++) ans = max(ans, it->second);
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
std::size_t n, k;
std::cin >> n >> k;
unsigned constexpr MAX = 2e5 + 5;
std::vector<std::vector<unsigned>> times(MAX);
while (n--) {
unsigned x;
std::cin >> x;
unsigned cur = 0;
while (true) {
times[x].push_back(cur);
if (!x) {
break;
}
x /= 2;
++cur;
}
}
unsigned result = std::numeric_limits<unsigned>::max();
for (auto& v : times) {
if (v.size() < k) {
continue;
}
std::nth_element(v.begin(), v.begin() + k, v.end());
result = std::min(result, std::accumulate(v.begin(), v.begin() + k, 0u));
}
std::cout << result << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v1;
vector<int> v2;
int n, m;
cin >> n >> m;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
v1.push_back(x);
}
for (int i = 0; i < m; i++) {
cin >> x;
v2.push_back(x);
}
int i = 0;
int dem = 0;
for (int j = 0; j < m; j++) {
for (; i < n; i++) {
if (v2[j] >= v1[i]) {
dem++;
i++;
break;
} else
break;
}
}
cout << n - dem;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long INF64 = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL;
int a, b;
void Load() { cin >> a >> b; }
long long f(long long y) {
int z = y;
vector<int> dg;
while (z > 0) {
dg.push_back(z % 10);
z /= 10;
}
long long x = 0;
for (int i = (int)dg.size() - 1; i >= 0; i--) x = x * 10 + 9 - dg[i];
return y * x;
}
void Solve() {
long long mx = 0;
if (b < 5) {
for (int i = a; i <= b; i++) {
mx = max(mx, f(i));
}
cout << mx;
return;
}
long long x = 5;
long long t = 1;
for (int i = 1; x * 10 <= b; i++) {
x *= 10;
t *= 10;
}
if (t * 10 <= b) {
cout << f(b);
return;
}
if (a >= x)
cout << f(a);
else
cout << f(x);
}
int main() {
Load();
Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int max_r = 0;
int f = 1;
int count_added = 0;
long long int sum = 0;
int count = 1;
int *r = new int[n];
int *mas = new int[n];
mas[0] = 0;
int *val = new int[n];
int t;
int a;
int k;
for (int i = 0; i < n; i++) {
cin >> t;
if (t == 1) {
cin >> a >> k;
r[count_added] = a - 1;
if (a - 1 > max_r) {
max_r = a - 1;
}
val[count_added] = k;
sum += a * k;
count_added++;
} else if (t == 2) {
cin >> k;
sum += k;
mas[count] = k;
count++;
} else if (t == 3) {
if (max_r == count - 1) {
for (int j = 0; j < count_added; j++) {
if (r[j] == max_r) {
mas[count - 1] += val[j];
r[j]--;
}
}
max_r--;
sum -= mas[count - 1];
count--;
} else {
sum -= mas[count - 1];
count--;
}
}
printf("%.6f\n", (double)sum / (double)count);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10000 + 77, NN = 77;
bitset<N> T[NN], Y, EMP;
int q, n;
int main() {
scanf("%d %d", &q, &n);
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d", &x);
Y = EMP;
while (x--) scanf("%d", &y), Y[y] = 1;
T[i] = Y;
}
for (int i = 1; i <= q; ++i)
for (int j = i + 1; j <= q; ++j)
if ((T[i] & T[j]) == EMP) return !printf("impossible\n");
printf("possible\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '7') n += pow(2, s.length() - i - 1);
}
cout << n + pow(2, s.length()) - 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define int long long
#define endl '\n'
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int a, b, k; cin >> a >> b >> k;
if (!k) {
cout << "Yes" << endl;
for (int i = 0; i < b; i++) cout << 1;
for (int i = 0; i < a; i++) cout << 0; cout << endl;
for (int i = 0; i < b; i++) cout << 1;
for (int i = 0; i < a; i++) cout << 0; cout << endl;
return 0;
}
if (a && b > 1 && k < a + b - 1) {
cout << "Yes" << endl;
vector<int> vec;
for (int i = 0; i < a - 1; i++) vec.push_back(0);
for (int i = 0; i < b - 2; i++) vec.push_back(1);
cout << 1 << 1;
for (int i = 0; i < k - 1; i++) cout << vec[i];
cout << 0;
for (int i = k - 1; i < vec.size(); i++) cout << vec[i]; cout << endl;
cout << 1 << 0;
for (int i = 0; i < k - 1; i++) cout << vec[i];
cout << 1;
for (int i = k - 1; i < vec.size(); i++) cout << vec[i]; cout << endl;
return 0;
}
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int curId;
int totalAddedCount[103][103], isHbox[103], isVbox[103], vis[103][103],
graph[103][103], graphCnt[103], sortedList[103], sortedListInd;
struct trie {
int widgetId, endMark;
trie *next[26];
trie() {
widgetId = 0;
endMark = 0;
for (int i = 0; i < 26; i++) {
next[i] = nullptr;
}
}
};
void trieInsert(trie *cur, char str[23], int currentId) {
for (int i = 0; str[i] != '\0'; i++) {
int now = str[i] - 'a';
if (cur->next[now] == nullptr) {
cur->next[now] = new trie();
}
cur = cur->next[now];
}
cur->endMark = 1;
cur->widgetId = currentId;
}
int trieSearch(trie *cur, char str[23], int type) {
for (int i = 0; str[i] != '\0'; i++) {
int now = str[i] - 'a';
if (cur->next[now] != nullptr) {
cur = cur->next[now];
} else {
return 0;
}
}
return cur->widgetId;
}
void sortNameId(trie *cur) {
if (cur == nullptr) return;
if (cur->endMark == 1) {
sortedList[sortedListInd++] = cur->widgetId;
}
for (int i = 0; i < 26; i++) {
if (cur->next[i] != nullptr) {
sortNameId(cur->next[i]);
}
}
}
struct Widget {
char name[53], type[23];
int id;
long long int border, spacing, x, y, tot;
Widget() {
name[0] = '\0';
type[0] = '\0';
id = 0;
border = 0;
spacing = 0;
x = 0;
y = 0;
tot = 0;
}
};
Widget widget[103];
long long int convertToInt(char str[23]) {
long long int num = 0;
for (int i = 0; str[i] != '\0'; i++) {
num = (num * 10) + (long long int)(str[i] - '0');
}
return num;
}
void setWidget(char name[53], int wid, int wx, int wy, char wtype[23]) {
for (int i = 0; name[i] != '\0'; i++) widget[wid].name[i] = name[i];
widget[wid].id = wid;
widget[wid].spacing = 0;
widget[wid].border = 0;
widget[wid].x = wx;
widget[wid].y = wy;
widget[wid].tot = 0;
for (int i = 0; wtype[i] != '\0'; i++) widget[wid].type[i] = wtype[i];
}
void updateBorder(int wid, long long int wborder) {
widget[wid].border = wborder;
}
void updateSpacing(int wid, long long int wspacing) {
widget[wid].spacing = wspacing;
}
void clearAll() {
for (int i = 0; i < 103; i++) {
isHbox[i] = 0;
isVbox[i] = 0;
for (int j = 0; j < 103; j++) {
totalAddedCount[i][j] = 0;
}
}
}
long long int getMaximum(long long int fs, long long int sn) {
if (fs >= sn) {
return fs;
}
return sn;
}
void dfs(int cur, int pre) {
vis[pre][cur] = 1;
for (int i = 0; i < graphCnt[cur]; i++) {
int now = graph[cur][i];
if (!vis[cur][now]) {
dfs(now, cur);
}
}
if (pre != 0) {
widget[pre].tot += totalAddedCount[pre][cur];
if (graphCnt[cur] == 0) {
if (isHbox[cur] || isVbox[cur]) {
updateBorder(cur, 0);
updateSpacing(cur, 0);
widget[cur].x = 0;
widget[cur].y = 0;
}
} else {
if (isHbox[cur]) {
if (widget[cur].tot > 0)
widget[cur].x += (widget[cur].tot - 1) * widget[cur].spacing;
widget[cur].tot = 0;
} else if (isVbox[cur]) {
if (widget[cur].tot > 0)
widget[cur].y += (widget[cur].tot - 1) * widget[cur].spacing;
widget[cur].tot = 0;
}
widget[cur].x += widget[cur].border * 2;
widget[cur].y += widget[cur].border * 2;
widget[cur].border = 0;
}
if (isHbox[pre]) {
widget[pre].x += (widget[cur].x * totalAddedCount[pre][cur]);
widget[pre].y = getMaximum(widget[pre].y, widget[cur].y);
} else if (isVbox[pre]) {
widget[pre].x = getMaximum(widget[pre].x, widget[cur].x);
widget[pre].y += (widget[cur].y * totalAddedCount[pre][cur]);
}
} else {
if (graphCnt[cur] == 0) {
if (isHbox[cur] || isVbox[cur]) {
updateBorder(cur, 0);
updateSpacing(cur, 0);
widget[cur].x = 0;
widget[cur].y = 0;
}
} else {
if (isHbox[cur]) {
if (widget[cur].tot > 0)
widget[cur].x += (widget[cur].tot - 1) * widget[cur].spacing;
widget[cur].tot = 0;
} else if (isVbox[cur]) {
if (widget[cur].tot > 0)
widget[cur].y += (widget[cur].tot - 1) * widget[cur].spacing;
widget[cur].tot = 0;
}
widget[cur].x += widget[cur].border * 2;
widget[cur].y += widget[cur].border * 2;
widget[cur].border = 0;
}
}
}
int main() {
int n;
char inp[53];
scanf("%d", &n);
curId = 0;
clearAll();
trie *trieRoot = new trie();
getchar();
for (int i = 0; i < n; i++) {
gets(inp);
if (inp[0] == 'W') {
int j = 7;
char name[53], curx[23], cury[23];
int nameId = 0, curxId = 0, curyId = 0;
while (inp[j] != '(') {
name[nameId] = inp[j];
name[nameId + 1] = '\0';
nameId++;
j++;
}
j++;
while (inp[j] != ',') {
curx[curxId] = inp[j];
curx[curxId + 1] = '\0';
curxId++;
j++;
}
j++;
while (inp[j] != ')') {
cury[curyId] = inp[j];
cury[curyId + 1] = '\0';
curyId++;
j++;
}
long long int curxx = convertToInt(curx);
long long int curyy = convertToInt(cury);
if (trieSearch(trieRoot, name, 0) == 0) {
trieInsert(trieRoot, name, ++curId);
}
setWidget(name, trieSearch(trieRoot, name, 0), curxx, curyy, "none");
} else if (inp[0] == 'H') {
int j = 5;
char name[53];
int nameInd = 0;
while (inp[j] != '\0') {
name[nameInd] = inp[j];
name[nameInd + 1] = '\0';
nameInd++;
j++;
}
if (trieSearch(trieRoot, name, 0) == 0) {
trieInsert(trieRoot, name, ++curId);
}
int getId = trieSearch(trieRoot, name, 0);
isHbox[getId] = 1;
char curType[23];
curType[0] = 'h', curType[1] = 'b', curType[2] = '0', curType[3] = 'x';
setWidget(name, getId, 0, 0, curType);
} else if (inp[0] == 'V') {
int j = 5;
char name[53];
int nameId = 0;
while (inp[j] != '\0') {
name[nameId] = inp[j];
name[nameId + 1] = '\0';
nameId++;
j++;
}
if (trieSearch(trieRoot, name, 0) == 0) {
trieInsert(trieRoot, name, ++curId);
}
int getId = trieSearch(trieRoot, name, 0);
isVbox[getId] = 1;
char curType[23];
curType[0] = 'v', curType[1] = 'b', curType[2] = '0', curType[3] = 'x';
setWidget(name, getId, 0, 0, curType);
} else {
int j = 0;
while (inp[j] != '.') j++;
if (inp[j + 1] == 'p') {
int j = 0;
char fname[23], sname[23];
int fnameInd = 0, snameInd = 0;
while (inp[j] != '.') {
fname[fnameInd] = inp[j];
fname[fnameInd + 1] = '\0';
fnameInd++;
j++;
}
while (inp[j] != '(') j++;
j++;
while (inp[j] != ')') {
sname[snameInd] = inp[j];
sname[snameInd + 1] = '\0';
snameInd++;
j++;
}
int fId = trieSearch(trieRoot, fname, 0);
int sId = trieSearch(trieRoot, sname, 0);
if (totalAddedCount[fId][sId] == 0) {
graph[fId][graphCnt[fId]++] = sId;
}
totalAddedCount[fId][sId]++;
} else {
while (inp[j] != '_') j++;
if (inp[j + 1] == 'b') {
char name[53], borderStr[23];
int nameInd = 0, borderStrInd = 0;
int j = 0;
while (inp[j] != '.')
name[nameInd] = inp[j], name[nameInd + 1] = '\0', nameInd++, j++;
j++;
while (inp[j] != '(') j++;
j++;
while (inp[j] != ')') {
borderStr[borderStrInd] = inp[j];
borderStr[borderStrInd + 1] = '\0';
borderStrInd++;
j++;
}
long long int borderInt = convertToInt(borderStr);
updateBorder(trieSearch(trieRoot, name, 0), borderInt);
} else if (inp[j + 1] == 's') {
char name[53], spaceStr[23];
int j = 0, nameInd = 0, spaceStrInd = 0;
while (inp[j] != '.')
name[nameInd] = inp[j], name[nameInd + 1] = '\0', nameInd++, j++;
j++;
while (inp[j] != '(') j++;
j++;
while (inp[j] != ')') {
spaceStr[spaceStrInd] = inp[j];
spaceStr[spaceStrInd + 1] = '\0';
spaceStrInd++;
j++;
}
long long int spaceInt = convertToInt(spaceStr);
updateSpacing(trieSearch(trieRoot, name, 0), spaceInt);
}
}
}
}
for (int i = 1; i <= curId; i++) {
if (isHbox[i] || isVbox[i]) {
dfs(i, 0);
}
}
sortNameId(trieRoot);
for (int i = 0; i < sortedListInd; i++) {
int nowId = sortedList[i];
printf("%s %lld %lld\n", widget[nowId].name, widget[nowId].x,
widget[nowId].y);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void napravi(long long rod[], long long len[], long long a) {
for (long long i = 1; i <= a; i++) {
rod[i] = i;
len[i] = 1;
}
}
long long nadji(long long rod[], long long x) {
if (x == rod[x]) return x;
rod[x] = nadji(rod, rod[x]);
return rod[x];
}
void unija(long long rod[], long long len[], long long x, long long y) {
long long a, b;
a = nadji(rod, x);
b = nadji(rod, y);
if (a == b) return;
if (len[a] > len[b]) {
rod[b] = a;
len[a] += len[b];
} else if (len[a] < len[b]) {
rod[a] = b;
len[b] += len[a];
} else {
rod[a] = b;
len[b] += len[a];
}
}
bool proveri_n(int n) { return n > 0; }
const int N = 500005;
long long v[N], rod[N], len[N];
int main() {
long long n, m, edge, a, b;
scanf("%lld%lld", &n, &m);
for (int i = 0; i < n; i++) v[i] = 0;
napravi(rod, len, n);
for (long long i = 0; i < m; i++) {
scanf("%lld", &edge);
if (edge) scanf("%lld", &a);
for (long long j = 1; j < edge; j++) {
scanf("%lld", &b);
unija(rod, len, a, b);
}
}
for (long long i = 1; i <= n; i++) {
if (proveri_n(n)) {
a = nadji(rod, i);
printf("%lld ", len[a]);
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
const int M = 1e5 + 5;
struct road {
int u, v, d;
} r[M];
int mind = 1e9 + 7, maxd = 0;
struct edge {
int v, nxt, cap;
} e[M << 2];
int head[N * 3], cur[N * 3], cnt = 0, s, t;
int dep[N * 3];
inline void add(int u, int v, int cap) {
e[cnt].v = v;
e[cnt].cap = cap;
e[cnt].nxt = head[u];
head[u] = cnt++;
}
inline void dou_add(int u, int v, int cap) {
add(u, v, cap);
add(v, u, 0);
}
bool bfs() {
for (int i = 0; i < N * 3; ++i) {
cur[i] = head[i];
dep[i] = 0;
}
queue<int> q;
dep[s] = 1;
q.push(s);
while (q.size() > 0) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].v, cap = e[i].cap;
if (!dep[v] && cap) {
dep[v] = dep[u] + 1;
q.push(v);
}
}
}
return dep[t] != 0;
}
int dfs(int u, int flow) {
if (u == t) {
return flow;
}
int delta = flow;
for (int &i = cur[u]; i != -1; i = e[i].nxt) {
int v = e[i].v, cap = e[i].cap;
if (dep[v] == dep[u] + 1 && cap) {
int d = dfs(v, min(cap, delta));
delta -= d;
e[i].cap -= d;
e[i ^ 1].cap += d;
if (delta == 0) {
break;
}
}
}
return flow - delta;
}
int dinic() {
int res = 0, flow;
while (bfs()) {
while (flow = dfs(s, 2147483647)) {
res += flow;
}
}
return res;
}
int n, m;
bool check(int f) {
for (int i = 0; i < N * 3; ++i) {
head[i] = -1;
}
cnt = 0;
for (int i = 1; i <= n; ++i) {
dou_add(s, i, 1);
dou_add(i + n, t, 1);
}
for (int i = 1; i <= m; ++i) {
if (r[i].d <= f) {
dou_add(r[i].u, r[i].v + n, 1);
}
}
return dinic() == n;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> r[i].u >> r[i].v >> r[i].d;
mind = min(mind, r[i].d);
maxd = max(maxd, r[i].d);
}
s = 0, t = 2 * n + 1;
int l = mind, r = maxd;
int res = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
res = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void Weapons19() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
Weapons19();
long long int n, m;
cin >> n >> m;
vector<string> v;
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
vector<vector<long long int>> z(m);
for (long long int i = 0; i < n; i++) {
long long int t = 0;
for (long long int j = m - 1; j >= 0; j--) {
if (v[i][j] == '1')
t++;
else
t = 0;
z[j].push_back(t);
}
}
long long int ans = 0;
for (auto a : z) {
vector<long long int> p = a;
sort(p.begin(), p.end());
long long int x = p.size();
for (long long int i = 0; i < x; i++) ans = max(ans, p[i] * (x - i));
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 31) - 1;
const long long int LINF = (1LL << 63) - 1;
const int NMAX = 100000 + 5;
const int MMAX = 100000 + 5;
const int KMAX = 100000 + 5;
const int PMAX = 100000 + 5;
const int LMAX = 100000 + 5;
const int VMAX = 100000 + 5;
int N, M, X, Y, Z, P;
void Rotate_90_Clockwise(int &N, int &M, int &x0, int &y0) {
int x, y;
x = y0;
y = N - x0 + 1;
x0 = x;
y0 = y;
swap(N, M);
}
void Horizontal_Mirroring(int &N, int &M, int &x0, int &y0) { y0 = M - y0 + 1; }
int main() {
int i, j, x, y, n, m;
scanf("%d%d%d%d%d%d", &N, &M, &X, &Y, &Z, &P);
X %= 4;
Y %= 2;
Z %= 4;
for (i = 1; i <= P; i++) {
n = N;
m = M;
scanf("%d%d", &x, &y);
for (j = 1; j <= X; j++) Rotate_90_Clockwise(n, m, x, y);
for (j = 1; j <= Y; j++) Horizontal_Mirroring(n, m, x, y);
for (j = 1; j <= Z; j++) {
Rotate_90_Clockwise(n, m, x, y);
Rotate_90_Clockwise(n, m, x, y);
Rotate_90_Clockwise(n, m, x, y);
}
printf("%d %d\n", x, y);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 35;
const int INF = 1029384756;
int N, X;
int arr[MAXN][MAXN];
int sq1[MAXN][MAXN], sq2[MAXN][MAXN];
int cu1[MAXN], cu2[MAXN];
bool state[MAXN];
int curval;
void flip(int v, int m) {
for (int i = 0; i < X - 1; i++) {
cu1[i] -= abs(sq1[v][i]);
cu2[i] -= abs(sq2[v][i]);
sq1[v][i] =
arr[v][i] + arr[X + v][i] + m * (arr[v][X + i] + arr[X + v][X + i]);
sq2[v][i] =
arr[v][i] - arr[X + v][i] + m * (arr[v][X + i] - arr[X + v][X + i]);
cu1[i] += abs(sq1[v][i]);
cu2[i] += abs(sq2[v][i]);
}
}
int calc() {
int ans = -INF;
for (int i = 0; i < X - 1; i++) {
for (int j = 0; j < X - 1; j++) {
sq1[i][j] = arr[i][j] + arr[i][X + j] + arr[X + i][j] + arr[X + i][X + j];
sq2[i][j] = arr[i][j] + arr[i][X + j] - arr[X + i][j] - arr[X + i][X + j];
}
}
for (int i = 0; i < X - 1; i++) {
cu1[i] = arr[X - 1][i] + arr[X - 1][X + i];
cu2[i] = -cu1[i];
for (int j = 0; j < X - 1; j++) {
cu1[i] += abs(sq1[j][i]);
cu2[i] += abs(sq2[j][i]);
}
}
for (int i = 0; i < X - 1; i++) state[i] = 0;
for (int k = 0; k < (1 << (X - 1)); k++) {
int val = arr[X - 1][X - 1];
for (int i = 0; i < X - 1; i++) {
bool ns = (k & (1 << i));
if (ns != state[i]) {
flip(i, ns ? -1 : 1);
state[i] = ns;
}
if (ns)
val -= arr[i][X - 1] + arr[X + i][X - 1];
else
val += arr[i][X - 1] + arr[X + i][X - 1];
}
for (int i = 0; i < X - 1; i++) {
val += max(cu1[i], cu2[i]);
}
ans = max(ans, val);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) cin >> arr[i][j];
X = (N + 1) / 2;
int ans = calc();
for (int i = X - 1; i < N; i++)
for (int j = X - 1; j < N; j++) arr[i][j] = -arr[i][j];
ans = max(ans, calc());
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int N = 2e6 + 10;
const long long mod = 1e9 + 7;
int n;
int a[N];
int T;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
int s = 0, mx = 0;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), mx = max(mx, a[i]), s += a[i];
if (mx > s / 2)
puts("T");
else if (s & 1)
puts("T");
else
puts("HL");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
char s[maxn];
int nex[maxn];
void getnext(char* s, int len) {
int i = 0, j = -1;
nex[0] = -1;
while (i < len) {
if (j == -1 || s[i] == s[j]) {
i++;
j++;
nex[i] = j;
} else
j = nex[j];
}
}
void solve() {
int n, k, len;
scanf("%d", &n);
scanf("%d", &k);
scanf("%s", s);
getnext(s, n);
for (int i = 1; i < n + 1; ++i)
if (i % (i - nex[i]) == 0) {
if ((i / (i - nex[i])) % k <= i / (i - nex[i]) / k)
printf("1");
else
printf("0");
} else {
if ((i / (i - nex[i])) % k < i / (i - nex[i]) / k)
printf("1");
else
printf("0");
}
}
int main() { solve(); }
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
if (n < m) {
cout << n + 1 << "\n";
for (i = 0; i <= n; i++) {
cout << i << " " << n - i << "\n";
}
} else {
cout << m + 1 << "\n";
for (i = 0; i <= m; i++) {
cout << i << " " << m - i << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long int a[28];
long long int m;
long long int r;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
m = max(a[i], m);
}
sort(a + 1, a + n + 1);
r = 0;
for (int i = n; i > 0; i--) {
m = min(m, a[i]);
r += m;
m--;
if (m < 0) break;
}
cout << r << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a;
cin >> n;
cout << ((n - 1) * 2) + 1 << " " << 2 << endl;
cout << "1 2" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void print_vec(vector<long long unsigned int> a) {
for (std::vector<long long unsigned int>::iterator i = a.begin();
i != a.end(); ++i) {
cout << *i << " ";
}
cout << endl;
}
long long unsigned int shift_modulo(int i, long long unsigned int cons) {
long long unsigned int sum = 0;
while (i >= 32) {
sum = (sum + (1ULL << 32)) % cons;
i = i - 32;
}
sum = (sum + (1ULL << i)) % cons;
return sum;
}
int main(int argc, char const *argv[]) {
long long unsigned int cons = 998244353;
long long unsigned int n, m;
cin >> n >> m;
vector<int> a(n);
vector<int> b(m);
char temp;
for (int i = n - 1; i >= 0; i--) {
cin >> temp;
a[i] = temp - '0';
}
for (int i = 0; i < m; ++i) {
cin >> temp;
b[i] = temp - '0';
}
vector<long long unsigned int> pra(m);
long long unsigned int sum = 0;
long long unsigned int pow = 1;
for (int i = 0; i < m; i++) {
if (i < n and a[i] == 1) sum = (sum + pow) % cons;
pra[i] = sum;
pow = (pow * 2) % cons;
}
reverse(pra.begin(), pra.end());
long long unsigned int ans = 0;
for (int i = 0; i < m; ++i) {
if (b[i] == 1) {
ans = (ans + pra[i]) % cons;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, t, i, j = 0, s1[101], s2[101];
;
scanf("%d", &n);
s1[n + 1] = '\0';
s2[n] = '\0';
for (i = 1; i <= n; i++) {
scanf("%d", &t);
s1[t] = i;
}
for (i = 1; i < n; i++) {
printf("%d ", s1[i]);
}
printf("%d\n", s1[n]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int mod = 1e9 + 7;
int a[maxn], vis[maxn], num[maxn];
map<int, int> mp;
int cmp(int x, int y) { return x > y; }
int main() {
int T;
scanf("%d", &T);
while (T--) {
mp.clear();
int n;
scanf("%d", &n);
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
vis[i] = 0;
num[i] = 0;
if (!mp[a[i]]) mp[a[i]] = ++cnt;
a[i] = mp[a[i]];
}
for (int i = 1; i <= n; i++) vis[a[i]]++;
sort(vis + 1, vis + 1 + cnt, cmp);
int len = vis[1];
if (cnt == 1) {
printf("0\n");
continue;
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == len) vis[i]--;
}
len--;
int now = 1;
for (int i = 1; i <= cnt; i++) {
int tmp = vis[i];
while (tmp) {
tmp--;
num[now]++;
now = now + 1;
if (now == len + 1) now = 1;
}
}
printf("%d\n", num[len] - 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const long long INF64 = (long long)1e18;
const double INFD = 1e30;
const double EPS = 1e-9;
const double PI = std::acos(-1);
const int MOD = 1e9 + 7;
template <typename T>
inline T read() {
T X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
const int MAXN = 1000005;
const int MAXV = 1000000;
int n, m, k;
int dr[4] = {0, 1, 0, -1};
int dc[4] = {-1, 0, 1, 0};
int dr2[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int dc2[8] = {1, 0, -1, 1, 0, -1, 1, -1};
int CASE = 1;
char S[MAXN];
int A[MAXN];
template <typename T, int N>
struct FenwickTree {
FenwickTree() {}
inline void increase(int t, T x) {
for (int i = t; i <= N; i += lowbit(i)) _arr[i] += x;
}
inline T getSum(int t) {
T s = 0;
for (int i = t; i; i -= lowbit(i)) s += _arr[i];
return s;
}
T _arr[N + 5];
inline int lowbit(int x) { return x & (-x); }
};
FenwickTree<int, 1000000> tree[5];
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
A[i] = read<int>();
sum += A[i];
}
std::sort(A + 1, A + n + 1);
std::reverse(A + 1, A + n + 1);
for (int i = 1; i <= n; i++) {
tree[A[i]].increase(i, 1);
}
int x, y;
int ans = INF2;
bool can = false;
for (int i = 0; i <= sum / 3; i++) {
if ((sum - (i * 3)) % 4 == 0) {
x = i, y = (sum - (i * 3)) / 4;
int sum2 = 0;
for (int j = 0; j <= 4; j++) {
sum2 += tree[j].getSum(y) * std::abs(j - 4);
}
for (int j = 0; j <= 4; j++) {
int c = tree[j].getSum(x + y) - tree[j].getSum(y);
sum2 += c * std::abs(j - 3);
}
for (int j = 1; j <= 4; j++) {
sum2 += (tree[j].getSum(n) - tree[j].getSum(x + y)) * j;
}
ans = std::min(ans, sum2);
can = true;
}
}
if (!can) {
printf("-1");
} else {
printf("%d\n", ans / 2);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int sz = 2502, huge = 15000;
int node[sz], next[sz * 4], to[sz * 4], e;
void ins(int x, int y) {
e++;
next[e] = node[x];
node[x] = e;
to[e] = y;
}
int n, m, I;
int dfn[sz], fa[sz], mo[sz];
void dfs(int x) {
int y, j, p;
dfn[x] = ++I;
for (j = node[x]; j; j = next[j])
if (j != fa[x])
if (dfn[to[j]] == 0)
fa[to[j]] = ((j)&1 ? (j) + 1 : (j)-1), dfs(to[j]);
else if (dfn[to[j]] < dfn[x])
for (y = x, p = ((j)&1 ? (j) + 1 : (j)-1); y != to[j];
y = to[p = fa[y]])
mo[y] = ((p)&1 ? (p) + 1 : (p)-1);
}
void tens(short &x, short y) {
if (x < y) x = y;
}
int vis[sz], tmp[sz];
short ft[sz][3];
short f[sz][sz][3], g[sz][sz][3][3];
int siz[sz];
int ttt = 4;
void dp(int x) {
int y, j, p, a, b, c, d, e, i, s, i2, tag = ++ttt;
siz[x] = 1;
f[x][0][2] = 1;
f[x][0][1] = f[x][0][0] = -huge;
f[x][1][2] = f[x][1][1] = -huge;
f[x][1][0] = 0;
for (j = node[x]; j; j = next[j])
if (j != fa[x] && j != mo[x])
if (to[mo[to[j]]] == x)
for (y = to[j], p = 0; y != x; y = to[fa[y]]) dp(y);
for (j = node[x]; j; j = next[j])
if (j != fa[x] && j != mo[x])
if (to[mo[to[j]]] == x)
for (y = to[j], p = 0; y != x; y = to[fa[y]]) vis[y] = tag;
for (j = node[x]; j; j = next[j])
if (j != fa[x] && j != mo[x])
if (vis[to[j]] != tag) dp(to[j]);
for (j = node[x]; j; j = next[j])
if (j != fa[x] && j != mo[x])
if (to[mo[to[j]]] == x) {
for (y = to[j], p = 0; y != x; y = to[fa[y]]) vis[tmp[++p] = y] = tag;
for (y = 0; y <= siz[tmp[1]]; y++)
for (c = 0; c < 3; c++)
for (d = 0; d < 3; d++)
g[1][y][c][d] = (c == d ? f[tmp[1]][y][c] : -huge);
s = siz[tmp[1]];
for (y = 2; y <= p; y++) {
for (b = 0; b <= s + siz[tmp[y]]; b++)
for (c = 0; c < 3; c++)
for (d = 0; d < 3; d++) g[y][b][c][d] = -huge;
for (a = 0; a <= s; a++)
for (b = 0; b <= siz[tmp[y]]; b++)
for (c = 0; c < 3; c++)
for (d = 0; d < 3; d++)
for (e = 0; e < 3; e++) {
int ff = g[y - 1][a][c][d] + f[tmp[y]][b][e];
if (!(((d) != 2 || (e) != 0) && ((d) != 0 || (e) != 2))) {
if (e == 2)
i = 1;
else
i = e;
ff--;
} else
i = e;
i2 = c;
if (y == 2 && d == 2 && e == 0) i2 = 1;
tens(g[y][a + b][i2][i], ff);
}
s += siz[tmp[y]];
}
for (a = 0; a <= siz[x] + s; a++)
for (c = 0; c < 3; c++) ft[a][c] = -huge;
for (a = 0; a <= s; a++)
for (b = 0; b <= siz[x]; b++)
for (c = 0; c < 3; c++)
for (d = 0; d < 3; d++)
for (e = 0; e < 3; e++) {
int ff = g[p][a][c][e] + f[x][b][d];
if (!(((c) != 2 || (d) != 0) && ((c) != 0 || (d) != 2)) ||
!(((e) != 2 || (d) != 0) && ((e) != 0 || (d) != 2))) {
if (d == 2)
i = 1;
else
i = d;
ff--;
} else
i = d;
if (c == 2 && e == 2 && d == 0) ff--;
if (ff == -1) ff = 0;
tens(ft[a + b][i], ff);
}
siz[x] += s;
for (a = 0; a <= siz[x]; a++)
for (c = 0; c < 3; c++) f[x][a][c] = ft[a][c];
}
for (j = node[x]; j; j = next[j])
if (j != fa[x] && j != mo[x])
if (vis[to[j]] != tag) {
for (a = 0; a <= siz[x] + siz[to[j]]; a++)
for (c = 0; c < 3; c++) ft[a][c] = -huge;
for (a = 0; a <= siz[x]; a++)
for (b = 0; b <= siz[to[j]]; b++)
for (c = 0; c < 3; c++)
for (d = 0; d < 3; d++) {
int ff = f[x][a][c] + f[to[j]][b][d];
if (!(((c) != 2 || (d) != 0) && ((c) != 0 || (d) != 2))) {
if (c == 2)
e = 1;
else
e = c;
ff--;
} else
e = c;
tens(ft[a + b][e], ff);
}
siz[x] += siz[to[j]];
for (a = 0; a <= siz[x]; a++)
for (c = 0; c < 3; c++) f[x][a][c] = ft[a][c];
}
}
int main() {
scanf("%d %d\n", &n, &m);
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
ins(x, y);
ins(y, x);
}
dfs(1);
dp(1);
for (int i = 0; i <= n; i++) {
tens(f[1][i][0], f[1][i][1]);
tens(f[1][i][0], f[1][i][2]);
printf("%d ", f[1][i][0]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long MAXN = 2e5 + 10;
const long long INF = 1e18;
long long n, m, v, u;
vector<long long> g[MAXN];
set<pair<long long, long long> > h[MAXN];
set<long long> back_edge[MAXN];
long long Max = 0;
bool mark[MAXN];
vector<pair<pair<long long, long long>, long long> > ans;
long long par[MAXN];
vector<long long> com;
vector<long long> child[MAXN];
void DFS(long long v, long long p = -1, long long hei = 0) {
mark[v] = 1;
par[v] = p;
long long Cnt = 0;
com.push_back(v);
Max = max(Max, hei);
for (auto u : g[v]) {
if (mark[u] && u != p) {
back_edge[v].insert(u);
Cnt++;
}
}
for (auto u : g[v]) {
if (!mark[u]) {
DFS(u, v, hei + 1);
}
}
h[hei].insert({(Cnt + 1) % 2, v});
}
long long ans1 = 0;
void Episode(long long v) {
Max = 0;
DFS(v);
for (auto u : com) {
while (back_edge[u].size() >= 2) {
v = *(back_edge[u].begin());
back_edge[u].erase(v);
long long uu = *(back_edge[u].begin());
back_edge[u].erase(uu);
ans.push_back({{v, u}, uu});
}
}
long long Cnt = 0;
for (auto u : com) {
Cnt += g[u].size();
}
ans1 += (Cnt / 2) / 2;
for (int i = Max; i >= 1; i--) {
set<long long> pa;
for (auto u : h[i]) {
if (u.first == 0) {
ans.push_back(
{{par[u.second], u.second}, *(back_edge[u.second].begin())});
} else {
pa.insert(par[u.second]);
child[par[u.second]].push_back(u.second);
}
}
for (auto u : pa) {
for (int j = 0; j < child[u].size(); j += 2) {
if (j != child[u].size() - 1) {
ans.push_back({{child[u][j], u}, child[u][j + 1]});
}
}
if (child[u].size() % 2 == 1 && i != 1) {
v = child[u][child[u].size() - 1];
if (back_edge[u].size()) {
ans.push_back({{*(back_edge[u].begin()), u}, v});
h[i - 1].erase({0, u});
h[i - 1].insert({1, u});
} else {
ans.push_back({{par[u], u}, v});
h[i - 1].erase({1, u});
}
}
}
}
for (auto u : com) {
back_edge[u].clear();
child[u].clear();
}
for (int i = 0; i <= Max; i++) h[i].clear();
com.clear();
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> v >> u;
g[v].push_back(u), g[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
Episode(i);
}
}
cout << ans1 << '\n';
for (auto u : ans) {
cout << u.first.first << ' ' << u.first.second << ' ' << u.second << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N], vis[N];
vector<vector<int>> adj(N);
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i + 1];
int x, y;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
adj[x].push_back(y), adj[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
vis[i] = 1;
queue<int> q;
q.push(i);
vector<int> pos, val;
pos.push_back(i), val.push_back(a[i]);
while (!q.empty()) {
int p = q.front();
q.pop();
for (int tt : adj[p])
if (!vis[tt]) {
vis[tt] = 1;
q.push(tt);
pos.push_back(tt), val.push_back(a[tt]);
}
}
sort(pos.begin(), pos.end()), sort(val.rbegin(), val.rend());
for (int j = 0; j < (int)pos.size(); ++j) a[pos[j]] = val[j];
}
for (int i = 0; i < n; ++i) cout << a[i + 1] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int mat[150][150];
int aux[150][150];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &mat[i][j]);
aux[i][j] = 0;
}
unsigned long long int sum = 0;
for (int i = 0; i < n; i++) {
if (!aux[i][i]) {
sum += mat[i][i];
aux[i][i] = 1;
}
if (!aux[i][n - 1 - i]) {
sum += mat[i][n - 1 - i];
aux[i][n - 1 - i] = 1;
}
if (!aux[(n - 1) / 2][i]) {
sum += mat[(n - 1) / 2][i];
aux[(n - 1) / 2][i] = 1;
}
if (!aux[i][(n - 1) / 2]) {
sum += mat[i][(n - 1) / 2];
aux[i][(n - 1) / 2] = 1;
}
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double cov(int x1, int y1, int x2, int y2) {
return sqrt(pow(abs(x2 - x1), 2) + pow(abs(y2 - y1), 2));
}
bool is_odd(int x) { return x % 2 == 1 || x % 2 == -1; }
bool is_even(int x) { return x % 2 == 0; }
int fast_powermod10(int n, long long p) {
if (p == 0) return 1;
int sq = fast_powermod10(n, p / 2);
sq *= sq;
sq %= 10;
return p % 2 == 0 ? sq : (sq * n) % 10;
}
char arr[4][4];
bool test_sub(int i, int j) {
if (i + 1 == 3 || j + 1 == 3) return false;
return arr[i][j] == arr[i][j + 1] && arr[i][j] == arr[i + 1][j] &&
arr[i][j] == arr[i + 1][j + 1];
}
bool test_all_array() {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (test_sub(i, j) == true)
;
return true;
}
return false;
}
}
long long factor(int n) {
if (n == 0 || n == 1)
return 1;
else
return n * factor(n - 1);
}
int main() {
long long m;
string str[] = {
"O-|-OOOO", "O-|O-OOO", "O-|OO-OO", "O-|OOO-O", "O-|OOOO-",
"-O|-OOOO", "-O|O-OOO", "-O|OO-OO", "-O|OOO-O", "-O|OOOO-",
};
cin >> m;
while (m >= 10) {
cout << str[m % 10] << endl;
m /= 10;
}
cout << str[m] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct sa {
int x, id;
friend bool operator<(sa a, sa b) { return a.x < b.x; }
};
int f[200000][22];
bool v[4000000];
int a[200000];
sa b[30];
int n, ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
v[a[i]] = true;
}
for (int k = 0; k <= 20; k++)
for (int i = n; i >= 1; i--) {
f[i][k] = f[i + 1][k];
if (a[i] & (1 << k)) f[i][k] = i;
}
int j, now;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= 20; k++) {
b[k].x = f[i][k];
b[k].id = k;
}
sort(b, b + 21);
now = 0;
for (int k = 0; k <= 20; k = j) {
for (j = k; j <= 20 && b[j].x == b[k].x; j++) {
if (b[k].x != 0) now = now | (1 << b[j].id);
}
if (b[k].x != 0) v[now] = true;
}
}
for (int i = 0; i <= (1 << 21); i++)
if (v[i]) ans++;
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > g[100001];
vector<int> tin(100001, -1), low(100001, -1),
comp(100001, 0), child[100001], G[100001], P(100001), deph(100001);
vector<bool> IsBridge(100001, false), used(100001, false);
int cnt = 0;
int A[100001][22];
void DFS(int v, int e = -1) {
P[v] = e;
for (int u : G[v])
if (u != e) {
deph[u] = deph[v] + 1;
DFS(u, v);
}
}
void preper(int n, int root) {
deph[root] = 0;
DFS(root);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 20; j++)
if (j == 0)
A[i][j] = P[i];
else
A[i][j] = -1;
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++)
if (A[i][j - 1] != -1) A[i][j] = A[A[i][j - 1]][j - 1];
}
int LCA(int v, int u) {
if (deph[u] < deph[v]) swap(u, v);
int k = deph[u] - deph[v];
while (k > 0) {
int t = log2(k);
u = A[u][t];
k -= (1 << t);
}
if (u == v) return u;
for (int j = 20; j >= 0; j--) {
if (A[v][j] != A[u][j]) {
v = A[v][j];
u = A[u][j];
}
}
return P[v];
}
void Tarjan(int v, int e = -1) {
used[v] = true;
tin[v] = low[v] = cnt;
cnt++;
for (pair<int, int> x : g[v]) {
int u = x.first;
if (e == u) continue;
if (used[u]) {
low[v] = min(low[v], tin[u]);
} else {
Tarjan(u, v);
low[v] = min(low[v], low[u]);
if (low[u] > tin[v]) {
IsBridge[x.second] = true;
}
}
}
}
void dfs(int v) {
comp[v] = cnt;
child[cnt].push_back(v);
for (pair<int, int> x : g[v]) {
if (IsBridge[x.second]) continue;
int u = x.first;
if (comp[u] == 0) dfs(u);
}
}
map<pair<int, int>, int> mp;
void CondesGraph(int n, int m) {
Tarjan(1);
cnt = 0;
for (int i = 1; i <= n; i++) {
if (comp[i] == 0) {
cnt++;
dfs(i);
}
}
for (int v = 1; v <= n; v++)
for (pair<int, int> second : g[v]) {
int u = second.first;
int x = comp[u], y = comp[v];
if (x > y) swap(x, y);
if (x != y && mp.count({x, y}) == 0) {
G[x].push_back(y);
G[y].push_back(x);
mp[{x, y}] = 1;
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int v, u;
cin >> v >> u;
g[v].push_back({u, i});
g[u].push_back({v, i});
}
CondesGraph(n, m);
preper(n, 1);
int Q;
cin >> Q;
while (Q--) {
int v, u;
cin >> v >> u;
v = comp[v];
u = comp[u];
if (v == u) {
cout << "0"
<< "\n";
continue;
}
int lca = LCA(v, u);
cout << deph[v] + deph[u] - 2 * deph[lca] << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return abs(a);
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const long long T = 1 << 20;
const long double inf = 1e18;
struct kubek {
vector<int> wierzcholki;
int kolor;
kubek *przodek;
vector<kubek *> potomkowie;
kubek(int v, int k, kubek *p = nullptr)
: wierzcholki({v}), kolor(k), przodek(p), potomkowie() {}
void add(int val) { wierzcholki.push_back(val); }
};
bool operator<(const kubek a, const kubek b) {
if (a.kolor != b.kolor) return a.kolor < b.kolor;
if (a.kolor == 0) {
if ((int)(a.potomkowie).size() == (int)(b.potomkowie).size())
return a.wierzcholki[0] < b.wierzcholki[0];
return (int)(a.potomkowie).size() > (int)(b.potomkowie).size();
}
if ((int)(a.potomkowie).size() == (int)(b.potomkowie).size())
return a.wierzcholki[0] < b.wierzcholki[0];
return (int)(a.potomkowie).size() < (int)(b.potomkowie).size();
}
struct set_cmp {
bool operator()(const kubek *a, const kubek *b) const { return *a < *b; }
};
void wywal(kubek *k) {
if ((int)(k->potomkowie).size() == 0) {
delete k;
return;
}
for (auto &u : k->potomkowie) wywal(u);
delete k;
}
void usun(set<kubek *, set_cmp> &korzenie, vector<vector<int> > &ans,
set<kubek *, set_cmp>::iterator it, int kol) {
assert((*it)->kolor == kol);
ans.push_back((*it)->wierzcholki);
for (auto &u : (*it)->potomkowie) korzenie.insert(u);
korzenie.erase(it);
}
void solve() {
int n;
cin >> n;
vector<int> kolor(6 * n + 1);
vector<int> tab(n * 3);
cin >> tab;
for (auto &u : tab) kolor[u] = 1;
vector<kubek *> stos;
set<kubek *, set_cmp> korzenie;
vector<kubek *> vec_korzenie;
for (int i = 1; i <= n * 6; i++) {
if ((int)(stos).size() == 0) {
kubek *nowy = new kubek(i, kolor[i], nullptr);
vec_korzenie.push_back(nowy);
stos.push_back(nowy);
} else if (stos.back()->kolor == kolor[i]) {
stos.back()->add(i);
if ((int)(stos.back()->wierzcholki).size() == 3) stos.pop_back();
} else {
kubek *nowy = new kubek(i, kolor[i], stos.back());
stos.back()->potomkowie.push_back(nowy);
stos.push_back(nowy);
}
}
for (auto &u : vec_korzenie) korzenie.insert(u);
vector<vector<int> > ans;
for (int i = 0; i < n; i++) {
usun(korzenie, ans, korzenie.begin(), 0);
usun(korzenie, ans, prev(korzenie.end()), 1);
}
reverse((ans).begin(), (ans).end());
for (auto &u : ans) cout << u << '\n';
for (auto &u : vec_korzenie) wywal(u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) solve();
}
| 12 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::sort;
using std::stack;
using std::string;
using std::vector;
template <typename integer>
integer gcd(integer a, integer b) {
if (a < b) std::swap(a, b);
while (b > 0) {
integer t = b;
b = a % b;
a = t;
}
return a;
}
template <typename integer>
integer lcm(integer a, integer b) {
return (a / gcd(a, b)) * b;
}
template <typename integer>
void ex_gcd(integer a, integer b, integer& x, integer& y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
ex_gcd(b, a % b, x, y);
integer x1 = y;
integer y1 = x - a / b * y;
x = x1;
y = y1;
}
template <typename integer>
integer inv(integer k, integer mod) {
integer x, y;
ex_gcd(k, mod, x, y);
x = (x + mod) % mod;
return x;
}
template <typename integer>
integer qpowm(integer n, integer x, integer mod) {
integer a = n;
integer ans = 1;
while (x > 0) {
if (x & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
x = x >> 1;
}
return ans % mod;
}
vector<long long> factor(long long x) {
vector<long long> f;
long long lim = sqrt(x) + 1;
for (int i = 2; i <= lim; i++) {
if (x % i == 0) {
f.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x != 1) f.push_back(x);
return f;
}
int main(int argc, char** argv) {
if (argc == 2 && strcmp(argv[1], "-debug") == 0) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
long long a, b;
cin >> a >> b;
long long c = gcd(a, b);
a = a / c;
b = b / c;
vector<long long> factor_a = factor(a);
factor_a.push_back(a);
long long ans = 0;
long long d;
while (b > 0 && a != 1) {
d = b;
for (auto i : factor_a) {
if (a % i == 0) d = std::min(d, b % i);
}
if (d == 0) d = 1;
ans = ans + d;
b = b - d;
c = gcd(a, b);
a = a / c;
b = b / c;
}
if (a == 1) ans += b;
b = 0;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class A {
public:
int cost;
int pre;
int post;
int index;
};
class B {
public:
int one = 0;
int zero = 0;
};
const int maxi = 200005;
int one_need = 0, zero_need = 0;
int one, zero;
A cc[maxi], org[maxi];
B added[maxi];
vector<int> g[maxi];
bool ck[maxi], taken[maxi];
int par[maxi];
vector<int> child[maxi];
bool cmp(A a, A b) {
if (a.cost < b.cost)
return 1;
else
return 0;
}
void getcost(int n) {
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
int y, z;
cin >> y >> z;
if (y != z) {
y == 0 ? one_need++ : zero_need++;
}
cc[i].cost = x;
cc[i].index = i;
cc[i].pre = y;
cc[i].post = z;
org[i] = cc[i];
}
}
void getgraph(int n) {
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
}
void exclude(int node) {
for (auto v : g[node]) {
if (!ck[v]) {
ck[v] = 1;
par[v] = node;
child[node].push_back(v);
exclude(v);
}
}
}
void sortall(int n) { sort(cc + 1, cc + 1 + n, cmp); }
long long ans = 0;
vector<int> vec;
void allchild(int node) {
for (auto c : child[node]) {
if (!taken[c]) {
taken[c] = 1;
if (org[c].pre != org[c].post) {
vec.push_back(c);
if (org[c].pre == 1)
one++;
else
zero++;
}
one += added[c].one;
zero += added[c].zero;
added[c].one = added[c].zero = 0;
allchild(c);
}
}
}
void getans(int n) {
for (int i = 1; i <= n; i++) {
int cost, pre, post, index;
cost = cc[i].cost;
pre = cc[i].pre;
post = cc[i].post;
index = cc[i].index;
one = zero = 0;
if (!taken[index]) {
taken[index] = 1;
vec.clear();
if (pre != post) {
vec.push_back(index);
org[index].pre == 1 ? one++ : zero++;
}
one += added[index].one;
zero += added[index].zero;
added[index].one = added[index].zero = 0;
allchild(index);
if (one == zero) {
ans += (long long)cost * (long long)one * (long long)2;
} else {
int mini = min(one, zero);
one -= mini;
zero -= mini;
ans += (long long)mini * (long long)2 * (long long)cost;
added[par[index]].one += one;
added[par[index]].zero += zero;
}
}
}
cout << ans << '\n';
}
void solve() {
int n;
cin >> n;
getcost(n);
getgraph(n);
if (one_need != zero_need) {
cout << -1 << '\n';
return;
}
par[1] = 1;
ck[1] = 1;
exclude(1);
sortall(n);
getans(n);
}
int main() {
int test;
test = 1;
while (test--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool adj[220][220] = {};
int n, t = 0, mx = 0, ans, mx1 = 0, t1 = 0, i1, i2;
void dfs(int v, int par) {
for (int i = 1; i <= n; i++) {
if (adj[v][i] && i != par) {
t++;
if (t >= mx) {
mx = t;
ans = i;
}
dfs(i, v);
t--;
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> i1 >> i2;
adj[i1][i2] = adj[i2][i1] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (!adj[i][j]) continue;
adj[i][j] = adj[j][i] = 0;
mx = ans = 0;
dfs(i, 0);
mx = 0;
dfs(ans, 0);
t1 = mx;
mx = ans = 0;
dfs(j, 0);
mx = 0;
dfs(ans, 0);
mx1 = max(mx1, t1 * mx);
adj[i][j] = adj[j][i] = 1;
}
}
cout << mx1;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
int64_t bin_pow(int64_t a, int64_t n) {
int64_t res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= MOD;
}
a *= a;
a %= MOD;
n >>= 1;
n %= MOD;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t n, k;
cin >> n >> k;
if (k > n) {
cout << 0;
return 0;
}
if (k == 1) {
cout << n << endl;
return 0;
}
vector<int64_t> fact(n + 1, 1);
for (int64_t i = 2; i <= n; ++i) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
int64_t ans = 0;
for (int64_t i = 1; i <= n; ++i) {
if (n / i - 1 < k - 1) break;
ans += ((fact[n / i - 1] * bin_pow(fact[n / i - k], MOD - 2)) % MOD *
bin_pow(fact[k - 1], MOD - 2)) %
MOD;
ans %= MOD;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
map<long long, long long> ans;
long long ret = 0;
map<long long, long long> idx;
for (int i = 0; i < n; i++) {
ans[ar[i]] = ans[ar[i] - 1] + 1;
ret = max(ret, ans[ar[i]]);
if (idx.find(ar[i]) == idx.end()) {
idx[ar[i]] = i;
}
}
long long x;
for (auto u : ans) {
if (u.second == ret) {
x = u.first;
break;
}
}
cout << ret << '\n';
long long st = x - ret + 1;
vector<long long> vr;
for (int i = 0; i < n; i++) {
if (st > x) break;
if (ar[i] == st) {
st++;
vr.push_back(i + 1);
}
}
for (auto u : vr) {
cout << u << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, top[2];
char s[maxn];
vector<int> V[2][maxn];
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == '0') {
if (top[1]) {
V[1][top[1]].push_back(i);
swap(V[0][++top[0]], V[1][top[1]--]);
} else {
V[0][++top[0]].push_back(i);
}
} else {
if (!top[0]) {
printf("-1\n"), exit(0);
} else {
V[0][top[0]].push_back(i);
swap(V[1][++top[1]], V[0][top[0]--]);
}
}
}
if (top[1]) {
printf("-1\n"), exit(0);
}
printf("%d\n", top[0]);
for (int i = 1; i <= top[0]; i++) {
auto v = V[0][i];
printf("%d ", v.size());
for (int x : v) printf("%d ", x);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int sz = 1e6 + 9;
int sieve[sz];
int ans = sz;
int main() {
scanf("%d", &n);
for (int u = 2; u <= n; u++) {
if (sieve[u]) continue;
for (int x = 2 * u; x <= n; x += u) sieve[x] = u;
}
int mx = n;
int mn = n - sieve[n] + 1;
for (int i = mn; i <= mx; i++) {
ans = min(ans, i - sieve[i] + 1);
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
shared_ptr<node> L, R;
long long val;
long long lazy;
node(long long val, long long lazy) : val(val), lazy(lazy) {}
};
struct segTree {
long long def;
long long (*op)(long long, long long);
void (*lazyFunc2)(shared_ptr<node> const&, long long, long long, long long,
long long (*op)(long long, long long));
long long maxN;
shared_ptr<node> root;
segTree(long long (*op)(long long, long long),
void (*lazyFunc2)(shared_ptr<node> const&, long long, long long,
long long, long long (*op)(long long, long long)),
long long defaultVal, long long maxVal = 1e15)
: def(defaultVal), op(op), lazyFunc2(lazyFunc2), maxN(maxVal) {
root = make_shared<node>(defaultVal, defaultVal);
}
void lazyFunc(const shared_ptr<node>& u, long long currLo, long long currHi) {
if (!(u->L)) {
u->L = make_shared<node>(def, def);
}
if (!(u->R)) {
u->R = make_shared<node>(def, def);
}
if (u->lazy == def) return;
lazyFunc2(u, currLo, currHi, def, op);
}
void upd(long long lo, long long hi, long long num) {
_upd(lo, hi, num, root, 0, maxN);
}
void _upd(long long lo, long long hi, long long num,
const shared_ptr<node>& u, long long currLo, long long currHi) {
lazyFunc(u, currLo, currHi);
if (currLo > hi || currHi < lo) return;
if (currLo >= lo && currHi <= hi) {
u->lazy = op(u->lazy, num);
lazyFunc(u, currLo, currHi);
return;
}
long long mid = (currLo + currHi) / 2;
_upd(lo, hi, num, u->L, currLo, mid);
_upd(lo, hi, num, u->R, mid + 1, currHi);
u->val = op(u->L->val, u->R->val);
}
long long query(long long lo, long long hi) {
return _query(lo, hi, root, 0, maxN);
}
long long _query(long long lo, long long hi, const shared_ptr<node>& u,
long long currLo, long long currHi) {
if (currLo > hi || currHi < lo) return def;
lazyFunc(u, currLo, currHi);
if (currLo >= lo && currHi <= hi) {
return u->val;
}
long long mid = (currLo + currHi) / 2;
long long l1 = def, l2 = def;
if (u->L) l1 = _query(lo, hi, u->L, currLo, mid);
if (u->R) l2 = _query(lo, hi, u->R, mid + 1, currHi);
return op(l1, l2);
}
};
long long sum1(long long i, long long j) { return i + j; }
void sum_lazy(const shared_ptr<node>& u, long long currLo, long long currHi,
long long def, long long (*op)(long long, long long)) {
u->L->lazy = op(u->L->lazy, u->lazy);
u->R->lazy = op(u->R->lazy, u->lazy);
u->val += (currHi - currLo + 1) * (u->lazy);
u->lazy = def;
}
int main() {
int n, q;
cin >> n >> q;
int lo = 0, hi = n - 1;
bool flip = 0;
segTree s(sum1, sum_lazy, 0, 1e5 + 5);
s.upd(0, n - 1, 1);
for (int x = 0; x < q; x++) {
int t;
cin >> t;
if (t == 1) {
int p;
cin >> p;
if (flip) p = hi - lo + 1 - p;
if (p <= (hi - lo + 1) / 2) {
for (int x = 1; p - x >= 0; x++) {
s.upd(lo + p + x - 1, lo + p + x - 1,
s.query(lo + p - x, lo + p - x));
s.upd(lo + p - x, lo + p - x, 0);
}
lo += p;
flip = 0;
} else {
for (int x = 1; p + lo + x - 1 <= hi; x++) {
s.upd(p + lo - x, p + lo - x,
s.query(p + lo + x - 1, p + lo + x - 1));
s.upd(p + lo + x - 1, p + lo + x - 1, 0);
}
hi = lo + p - 1;
flip = 1;
}
} else {
int a, b;
cin >> a >> b;
b--;
if (flip) {
int tmpA = a;
a = hi - b;
b = hi - tmpA;
} else {
a += lo;
b += lo;
}
cout << s.query(a, b) << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void setIO(const string &name) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin.exceptions(istream::failbit);
}
const int inf = 0x3f3f3f3f, mod = 1e9 + 7, maxn = 2e5 + 5;
pair<long long, long long> down[maxn], up[maxn];
int a[maxn];
vector<int> adj[maxn];
void dfs1(int c, int p) {
for (auto &i : adj[c]) {
if (i != p) {
dfs1(i, c);
down[c].first += down[i].first + down[i].second;
down[c].second += down[i].second;
}
}
down[c].second += a[c];
}
void dfs2(int c, int p) {
if (p != -1) {
up[c].first += up[p].first + down[p].first - down[c].first - down[c].second;
up[c].first += up[p].second + down[p].second - down[c].second;
up[c].second += up[p].second + down[p].second - down[c].second;
}
for (auto &i : adj[c]) {
if (i != p) {
dfs2(i, c);
}
}
}
int main() {
setIO("1");
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
int b, c;
cin >> b >> c;
--b, --c;
adj[b].push_back(c);
adj[c].push_back(b);
}
dfs1(0, -1);
dfs2(0, -1);
long long sol = 0;
for (int i = 0; i < n; ++i) {
sol = max(sol, down[i].first + up[i].first);
}
cout << sol << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, c, temp = 0, t[100000] = {0}, count = 0;
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> t[i];
if (t[i] - temp <= c) {
count = count + 1;
} else {
count = 0;
count++;
}
temp = t[i];
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100000;
struct Node {
int w, s, u, v;
};
int n, m;
Node node[maxN];
int p[maxN];
bool Cmp(const int& a, const int& b) {
if (node[a].w != node[b].w) {
return node[a].w < node[b].w;
}
return node[a].s > node[b].s;
}
bool Calc() {
long tot = 0, num = 1;
int u = 2, v = 3;
for (int j = 0; j < m; j++) {
if (!node[p[j]].s && tot - j <= 0) {
return false;
}
if (node[p[j]].s) {
num++;
tot = num * (num - 1) / 2;
node[p[j]].u = 1;
node[p[j]].v = num;
} else {
node[p[j]].u = u;
node[p[j]].v = v;
u++;
if (u == v) {
v++;
u = 2;
}
}
}
return true;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int j = 0; j < m; j++) {
scanf("%d%d", &node[j].w, &node[j].s);
p[j] = j;
}
sort(p, p + m, Cmp);
if (Calc()) {
for (int j = 0; j < m; j++) {
printf("%d %d\n", node[j].u, node[j].v);
}
} else {
puts("-1");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
int tmp;
for (int c1 = 0; c1 < n; c1++) {
cin >> tmp;
v.push_back(tmp);
}
sort(v.begin(), v.end());
int arr[150002] = {0}, cnt = 0;
for (int c1 = 0; c1 < n; c1++) {
if (v[c1] != 1 && arr[v[c1] - 1] != 1) {
arr[v[c1] - 1] = 1;
cnt++;
} else if (arr[v[c1]] != 1) {
arr[v[c1]] = 1;
cnt++;
} else if (arr[v[c1] + 1] != 1) {
arr[v[c1] + 1] = 1;
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using db = double;
const int N = 11;
struct ball {
db x, v, m;
int id;
bool operator<(ball b) const { return x < b.x; }
} b[N];
db ans[N];
int main() {
ios ::sync_with_stdio(0);
int n;
db t;
cin >> n >> t;
for (int i = 1; i <= n; i++) {
cin >> b[i].x >> b[i].v >> b[i].m;
b[i].id = i;
}
sort(b + 1, b + n + 1);
while (1) {
db nxt = 25252;
int j = 0;
for (int i = 1; i < n; i++)
if (b[i].v > b[i + 1].v) {
db t = (b[i + 1].x - b[i].x) / (b[i].v - b[i + 1].v);
if (t < nxt) {
nxt = t;
j = i;
}
}
if (nxt > t) break;
for (int i = 1; i <= n; i++) b[i].x += b[i].v * nxt;
db nv1 = ((b[j].m - b[j + 1].m) * b[j].v + 2 * b[j + 1].m * b[j + 1].v) /
(b[j].m + b[j + 1].m);
db nv2 = -(b[j + 1].v - b[j].v) + nv1;
b[j].v = nv1;
b[j + 1].v = nv2;
t -= nxt;
}
for (int i = 1; i <= n; i++) b[i].x += b[i].v * t;
for (int i = 1; i <= n; i++) ans[b[i].id] = b[i].x;
cout << fixed << setprecision(9);
for (int i = 1; i <= n; i++) cout << ans[i] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, l, r;
cin >> n >> q;
long long int a[n + 1], b[n + 2];
memset(b, 0, sizeof b);
memset(a, 0, sizeof a);
for (int t = 1; t <= n; t++) {
cin >> a[t];
}
for (int i = 0; i < q; i++) {
cin >> l >> r;
b[l]++;
b[r + 1]--;
}
for (int i = 2; i <= n + 1; i++) {
b[i] += b[i - 1];
}
sort(b, b + n + 2, greater<int>());
sort(a, a + n + 1, greater<int>());
long long int sum = 0, k = 0;
for (int i = 0; i < n; i++) {
k = a[i] * b[i];
sum += k;
}
cout << sum;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 123, mod = (int)1e9 + 7;
int n, k, a[N], b[N], upd[N];
vector<pair<long long, long long> > v[N];
void precalc() {
set<pair<pair<long long, long long>, long long> > st;
for (int i = 1; i <= n; i++) {
long long l = a[i], r = b[i];
if (l == r) continue;
while (st.lower_bound({{l + 1, -1}, -1}) != st.end() &&
st.lower_bound({{l + 1, -1}, -1})->first.second < r) {
pair<pair<long long, long long>, long long> it =
*st.lower_bound({{l + 1, -1}, -1});
st.erase(it);
long long id = it.second;
long long len = min(r, it.first.first) - max(l, it.first.second);
if (it.first.second <= l) st.insert({{l, it.first.second}, id});
if (it.first.first >= r) st.insert({{it.first.first, r}, id});
v[i].push_back({id, -len});
}
st.insert({{r, l}, i});
v[i].push_back({i, r - l});
}
}
pair<long long, long long> calc(int k) {
long long cnt = 0, sum = 0;
long long cur_sum = 0, tmp_sum = 0;
for (int i = 0; i < N; i++) upd[i] = 0;
for (int i = 1, j = 1; i <= n; i++) {
for (auto it : v[i]) {
long long id = it.first;
long long len = it.second;
if (id < j) {
cur_sum += id * len;
} else {
cur_sum += (j - 1) * len;
tmp_sum += len;
upd[id] += len;
}
}
while (tmp_sum > k && j <= i) {
cur_sum += tmp_sum;
tmp_sum -= upd[j];
j++;
}
cnt += j - 1;
sum += cur_sum;
}
return {cnt, sum};
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
precalc();
int l = 0, r = 1e9;
while (l <= r) {
int m = (l + r) / 2;
if (calc(m).first >= k)
l = m + 1;
else
r = m - 1;
}
long long ans = l * (k - calc(l - 1).first) + calc(l - 1).second;
printf("%lld", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
int i, j, k, l, m, n, a[1000000];
int main() {
int top;
scanf("%d", &n);
a[0] = -1;
top = 0;
for (i = 0; i < n; i++) {
scanf("%d", &m);
if (m > a[top])
a[++top] = m;
else {
int high = top, low = 1, mid;
while (low <= high) {
mid = (high + low) / 2;
if (m > a[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
a[low] = m;
}
}
printf("%d\n", top);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[4005] = {
0, 1, 9, 245, 126565, 54326037, 321837880,
323252721, 754868154, 328083248, 838314395, 220816781, 893672292, 166441208,
251255697, 114256285, 118775501, 482714697, 11784725, 460862131, 550384565,
106742050, 425241115, 626692854, 674266678, 320014275, 345949512, 527320049,
897822749, 137190263, 491039182, 810384961, 482023334, 658099864, 886790989,
845381174, 371433224, 278969124, 420088324, 696766322, 388302635, 141033366,
46387851, 932125021, 278342766, 371131134, 922501918, 110778457, 506223573,
806353719, 391845991, 923507761, 780307355, 109951115, 830090230, 605558495,
344686604, 988110893, 944684429, 715019947, 799898820, 384672708, 907325090,
758952329, 550672104, 368337206, 394915145, 401744167, 923781939, 831857516,
407845661, 329267374, 927004007, 891609656, 897919613, 481297880, 737337940,
651873737, 287246681, 973133651, 679864988, 784719328, 820504764, 875613823,
806512665, 164851642, 500228957, 951814419, 447763649, 273141670, 979349615,
964027956, 809510400, 276634497, 116631976, 426739449, 175282420, 885948162,
62270880, 974395255, 675165056, 759589968, 837957573, 931897605, 152352780,
585420109, 1772087, 333401718, 898833639, 745874265, 786209423, 691982338,
498790927, 473374639, 274302623, 971280670, 241671319, 13070005, 302088807,
550276351, 436592588, 631667314, 548656698, 730626984, 146295220, 674398632,
400383348, 454138904, 786220712, 118620797, 233440672, 217349271, 274853536,
310607544, 105221205, 769566615, 853585061, 800665807, 695377419, 924327065,
388199705, 551624811, 721435546, 501720515, 308465454, 825369234, 396065729,
451899519, 295058424, 142088952, 473485086, 378771634, 734511215, 462404399,
959198328, 337668263, 794122911, 38911400, 951992982, 472696081, 373904752,
105884826, 630251717, 28980684, 845136347, 353665773, 691661192, 19922354,
231463797, 757917231, 242739918, 979036950, 713722080, 234689388, 2243164,
209872853, 240808787, 539523346, 425797848, 913772061, 224613100, 421742777,
222232478, 92712941, 215137570, 949901408, 274827432, 15162482, 593145989,
274574232, 239282092, 762720192, 804146934, 500629424, 565985054, 81127381,
671811155, 655565571, 890331075, 237994348, 743647404, 667160634, 713914299,
668506729, 741341289, 277636808, 762781382, 14272789, 902864131, 567443405,
149113383, 648844381, 825489976, 933016723, 192288078, 734493315, 240985733,
861817693, 762711459, 525904609, 532463481, 377133989, 620711079, 772561562,
980733194, 227599811, 162774370, 209512798, 787116594, 3509258, 748795368,
378035466, 612938915, 802091952, 857679599, 481748937, 493370392, 358420805,
48301629, 412001241, 463126722, 509578422, 967799131, 994766554, 687287243,
863623583, 771554899, 690911527, 855314994, 923686429, 246862514, 192479791,
133487041, 703444043, 295281758, 801816257, 920762934, 749306433, 973004841,
848644684, 560026478, 952127278, 616654635, 839390326, 975154012, 409583672,
635350249, 343228425, 335331602, 223826406, 952341037, 589677800, 249747234,
555694261, 137143500, 628190328, 461598392, 431912756, 29349807, 759199489,
783281228, 781971312, 915823407, 388508707, 718062705, 27424111, 309999451,
963383322, 831185229, 132910888, 347028136, 850484840, 223055285, 142335980,
144754000, 772005560, 81796039, 167696020, 79454283, 172772542, 201056991,
484957644, 716630285, 763194701, 211505841, 903448791, 926964672, 257752668,
482951716, 411539070, 620249847, 592476107, 170473128, 814662613, 898000271,
57354872, 361106091, 488697643, 889007954, 138725767, 684860983, 36248116,
304610143, 137633385, 413715776, 99010024, 779653665, 100387568, 286328069,
564731826, 621740468, 943513219, 506666491, 249987886, 553719884, 769853086,
337485319, 702455584, 809637762, 755400257, 892290368, 502180086, 364275817,
118162370, 873374339, 261271695, 970132574, 744105500, 434447173, 117975095,
383088393, 625447969, 180281249, 545367713, 133236931, 360175662, 148087453,
806871297, 498529036, 886076476, 65645000, 465138299, 967109895, 331362616,
472283705, 796894900, 199697765, 503759892, 472807906, 187586706, 941198065,
782234442, 57693411, 18678611, 82626204, 395317191, 570588915, 152519440,
449852456, 63696518, 763741345, 878748386, 494317541, 444782633, 93316211,
929164666, 529288371, 165769871, 730546850, 955877127, 994202767, 492009567,
275683011, 415902127, 95725776, 718047399, 786963365, 73091278, 986172399,
174591541, 913259286};
int main() {
cin >> ans[0];
cout << ans[ans[0]];
return 0;
}
| 10 |
#include <bits/stdc++.h>
//#define int long long
#define pii pair<short, int>
#define x1 x1228
#define y1 y1228
#define left left228
#define right right228
#define data data228
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define debug(x) cout << #x << ": " << x << endl;
#define TIME (ld)clock()/CLOCKS_PER_SEC
using namespace std;
/** Fast input-output */
template <class T = int> inline T readInt();
inline double readDouble();
inline int readUInt();
inline int readChar(); // first non-blank character
inline void readWord( char *s );
inline bool readLine( char *s ); // do not save '\n'
inline bool isEof();
inline int getChar();
inline int peekChar();
inline bool seekEof();
inline void skipBlanks();
template <class T> inline void writeInt( T x, char end = 0, int len = -1 );
inline void writeChar( int x );
inline void writeWord( const char *s );
inline void writeDouble( double x, int len = 0 );
inline void flush();
static struct buffer_flusher_t {
~buffer_flusher_t() {
flush();
}
} buffer_flusher;
/** Read */
static const int buf_size = 4096;
static unsigned char buf[buf_size];
static int buf_len = 0, buf_pos = 0;
inline bool isEof() {
if (buf_pos == buf_len) {
buf_pos = 0, buf_len = fread(buf, 1, buf_size, stdin);
if (buf_pos == buf_len)
return 1;
}
return 0;
}
inline int getChar() {
return isEof() ? -1 : buf[buf_pos++];
}
inline int peekChar() {
return isEof() ? -1 : buf[buf_pos];
}
inline bool seekEof() {
int c;
while ((c = peekChar()) != -1 && c <= 32)
buf_pos++;
return c == -1;
}
inline void skipBlanks() {
while (!isEof() && buf[buf_pos] <= 32U)
buf_pos++;
}
inline int readChar() {
int c = getChar();
while (c != -1 && c <= 32)
c = getChar();
return c;
}
inline int readUInt() {
int c = readChar(), x = 0;
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getChar();
return x;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-')
s = -1, c = getChar();
else if (c == '+')
c = getChar();
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
inline double readDouble() {
int s = 1, c = readChar();
double x = 0;
if (c == '-')
s = -1, c = getChar();
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getChar();
if (c == '.') {
c = getChar();
double coef = 1;
while ('0' <= c && c <= '9')
x += (c - '0') * (coef *= 1e-1), c = getChar();
}
return s == 1 ? x : -x;
}
inline void readWord( char *s ) {
int c = readChar();
while (c > 32)
*s++ = c, c = getChar();
*s = 0;
}
inline bool readLine( char *s ) {
int c = getChar();
while (c != '\n' && c != -1)
*s++ = c, c = getChar();
*s = 0;
return c != -1;
}
/** Write */
static int write_buf_pos = 0;
static char write_buf[buf_size];
inline void writeChar( int x ) {
if (write_buf_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_buf_pos = 0;
write_buf[write_buf_pos++] = x;
}
inline void flush() {
if (write_buf_pos)
fwrite(write_buf, 1, write_buf_pos, stdout), write_buf_pos = 0;
}
template <class T>
inline void writeInt( T x, char end, int output_len ) {
if (x < 0)
writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n)
s[n++] = '0' + x % 10, x /= 10;
while (n < output_len)
s[n++] = '0';
while (n--)
writeChar(s[n]);
if (end)
writeChar(end);
}
inline void writeWord( const char *s ) {
while (*s)
writeChar(*s++);
}
inline void writeDouble( double x, int output_len ) {
if (x < 0)
writeChar('-'), x = -x;
int t = (int)x;
writeInt(t), x -= t;
writeChar('.');
for (int i = output_len - 1; i > 0; i--) {
x *= 10;
t = std::min(9, (int)x);
writeChar('0' + t), x -= t;
}
x *= 10;
t = std::min(9, (int)(x + 0.5));
writeChar('0' + t);
}
typedef long long ll;
typedef long double ld;
const int maxn = 1500 + 7, mod = 1e9 + 7, MAXN = 2e6 + 7;
const double eps = 1e-9;
const ll INF = 1e18, inf = 1e15;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int n, q;
int cl[maxn][maxn];
vector<pii> ladder1[2][maxn], ladder2[2][maxn];
vector<pii> merge(vector<pii> p1, vector<pii> p2) {
vector<pii> res;
res.reserve((int)p1.size() + (int)p2.size());
int pt1 = 0;
int pt2 = 0;
while (pt1 < (int)p1.size() && pt2 < (int)p2.size()) {
if (p1[pt1].ff <= p2[pt2].ff) {
res.pb(p1[pt1++]);
} else {
res.pb(p2[pt2++]);
}
}
while (pt1 < (int)p1.size()) {
res.pb(p1[pt1++]);
}
while (pt2 < (int)p2.size()) {
res.pb(p2[pt2++]);
}
return res;
}
int used[maxn * maxn];
void compress(vector<pii> &res) {
for (auto x : res) {
used[x.ss] = 0;
}
vector<pii> nw;
for (auto x : res) {
if (!used[x.ss]) {
nw.pb(x);
used[x.ss] = 1;
}
}
while ((int)nw.size() > q + 1) {
nw.pop_back();
}
res = nw;
}
void add(int i, int j, vector<pii> &cur, vector<int> &point) {
short sz = min(i + 1, n - j);
if ((int)cur.size() <= q) {
point[0]++;
point[sz]--;
} else {
point[0]++;
point[min(sz, cur.back().ff)]--;
}
}
void solve() {
n = readInt();
q = readInt();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cl[i][j] = readInt();
}
}
vector<int> point(n + 1);
int pt = 0;
for (int i = 0; i < n; ++i) {
pt ^= 1;
for (int j = n - 1; j >= 0; --j) {
vector<pii> res = ladder1[pt][j + 1];
if (i) {
res = merge(res, ladder1[pt ^ 1][j + 1]);
}
for (auto &x : res) {
x.ff++;
}
res = merge(res, {{0, cl[i][j]}});
compress(res);
ladder1[pt][j] = res;
res.clear();
if (i) {
res = merge(ladder2[pt ^ 1][j], ladder2[pt ^ 1][j + 1]);
for (auto &x : res) {
x.ff++;
}
}
res = merge(res, {{0, cl[i][j]}});
compress(res);
ladder2[pt][j] = res;
res = merge(res, ladder1[pt][j]);
compress(res);
add(i, j, res, point);
}
for (int j = 0; j < n; ++j) {
ladder1[pt ^ 1][j].clear();
ladder2[pt ^ 1][j].clear();
}
}
// cout << TIME;
// return;
int res = 0;
for (int i = 0; i < n; ++i) {
res += point[i];
cout << res << '\n';
}
}
signed main() {
#ifdef LOCAL
freopen("TASK.in", "r", stdin);
freopen("TASK.out", "w", stdout);
#endif // LOCAL
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
cout << fixed;
int t = 1;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt_rnd_64(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long l, long long r) {
return (mt_rnd_64() % (r - l + 1)) + l;
}
const int N = 2 * 1e3 + 5;
int n, k, ans, mx;
char a[N][N];
int r[N][N];
int c[N][N];
pair<int, int> gr[N];
pair<int, int> gc[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++) {
int start = -1;
int stop = -1;
for (int j = 1; j <= n; j++)
if (a[i][j] == 'B') {
if (start == -1) {
start = j;
}
stop = j;
}
if (start == -1) ans++;
gr[i].first = start;
gr[i].second = stop;
}
for (int i = 1; i <= n; i++) {
int start = -1;
int stop = -1;
for (int j = 1; j <= n; j++)
if (a[j][i] == 'B') {
if (start == -1) {
start = j;
}
stop = j;
}
if (start == -1) ans++;
gc[i].first = start;
gc[i].second = stop;
}
for (int C = 1; C <= n - k + 1; C++) {
for (int i = 1; i <= k; i++)
if ((gr[i].first >= C) && (gr[i].second <= C + k - 1)) r[1][C]++;
for (int i = 2; i <= n - k + 1; i++) {
r[i][C] = r[i - 1][C];
if ((gr[i - 1].first >= C) && (gr[i - 1].second <= C + k - 1)) r[i][C]--;
if ((gr[i + k - 1].first >= C) && (gr[i + k - 1].second <= C + k - 1))
r[i][C]++;
}
}
for (int C = 1; C <= n; C++) {
for (int i = 1; i <= k; i++) {
if ((gc[i].first >= C) && (gc[i].second <= C + k - 1)) c[C][1]++;
}
for (int i = 2; i <= n - k + 1; i++) {
c[C][i] = c[C][i - 1];
if ((gc[i - 1].first >= C) && (gc[i - 1].second <= C + k - 1)) c[C][i]--;
if ((gc[i + k - 1].first >= C) && (gc[i + k - 1].second <= C + k - 1))
c[C][i]++;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) mx = max(mx, c[i][j] + r[i][j]);
cout << ans + mx;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 1e5 + 10;
int a[maxn];
int x, y;
string s;
int main() {
int T;
cin >> T;
while (T--) {
cin >> x >> y;
cin >> s;
s += 'X';
int cnt = 0, l = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.') cnt++;
if (s[i] == 'X') {
if (cnt != 0) a[++l] = cnt;
cnt = 0;
}
}
bool flag = false;
int nu = 0, o = 0;
int k = 0;
for (int i = 1; i <= l; i++) {
if (a[i] < y) continue;
if (a[i] >= y && a[i] < x) {
flag = true;
break;
}
if (a[i] >= 2 * y) nu++, o = a[i];
if (nu >= 2) {
flag = true;
break;
}
if (a[i] >= x && a[i] < 2 * y) k++;
}
if (!flag) {
if (nu == 1) {
if (2 * y > x) {
if (o - x > 4 * y - 2) {
flag = true;
}
if (k % 2 == 0) {
if (!((o - x <= 2 * y - 2) ||
(o - x >= 2 * x && o - x <= 4 * y - 2)))
flag = true;
} else {
if (o - x > 3 * y - 2 || o - x < x) flag = true;
}
} else {
if (o < x) flag = true;
if (o - x > 2 * (y - 1)) flag = true;
}
}
if (nu == 0) {
if (k % 2 == 0) flag = true;
}
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, int> mp;
int x[34000], sx;
int y[34000], sy;
int z[34000], sz;
bool ok(int m) {
int ret = 0;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it) {
ret += min(m, it->second);
}
return (ret >= 3 * m);
}
int main() {
scanf("%d", &n);
for (int a, i = 0; i < n; ++i) {
scanf("%d", &a);
++mp[a];
}
int l = 0, r = n, m;
while (l < r - 1) {
m = (l + r) >> 1;
if (ok(m)) {
l = m;
} else {
r = m;
}
}
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it) {
it->second = min(l, it->second);
while (sx < l && it->second > 0) {
x[sx++] = it->first;
--it->second;
}
if (x[sy] < it->first) {
while (sy < l && it->second > 0) {
y[sy++] = it->first;
--it->second;
}
}
if (y[sz] < it->first) {
while (sz < l && it->second > 0) {
z[sz++] = it->first;
--it->second;
}
}
}
printf("%d\n", l);
for (int i = 0; i < l; ++i) {
printf("%d %d %d\n", z[i], y[i], x[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
pair<long long int, long long int> p, arr[100005], temp;
double rmin, rmax;
double dist(pair<long long int, long long int> a) {
double ret;
ret = (a.first * a.first) + (a.second * a.second);
return sqrt(ret);
}
pair<long long int, double> intersect(pair<long long int, long long int> a1,
pair<long long int, long long int> a2) {
long long int v0v2 = ((-1) * a1.first * (a2.first - a1.first)) +
((-1) * a1.second * (a2.second - a1.second));
long long int v2v2 = ((a2.first - a1.first) * (a2.first - a1.first)) +
((a2.second - a1.second) * (a2.second - a1.second));
if (v0v2 > 0 && v0v2 < v2v2) {
double temp = (double)v0v2 / (double)v2v2;
double retx, rety;
retx = a1.first + (temp * (a2.first - a1.first));
rety = a1.second + (temp * (a2.second - a1.second));
return make_pair(1, (double)(sqrt((retx * retx) + (rety * rety))));
} else
return make_pair(0, 0.0);
}
void solve(pair<long long int, long long int> a1,
pair<long long int, long long int> a2) {
double darr[5];
darr[0] = dist(a1);
darr[1] = dist(a2);
pair<long long int, double> val = intersect(a1, a2);
if (val.first == 1) {
darr[2] = val.second;
sort(darr, darr + 3);
rmin = min(rmin, darr[0]);
rmax = max(rmax, darr[2]);
} else {
sort(darr, darr + 2);
rmin = min(rmin, darr[0]);
rmax = max(rmax, darr[1]);
}
return;
}
int main() {
rmin = 10000000000, rmax = -1;
cin >> n >> p.first >> p.second;
for (long long int i = 0; i < n; i++) {
;
scanf("%lld", &temp.first);
;
;
scanf("%lld", &temp.second);
;
temp.first -= p.first;
temp.second -= p.second;
arr[i] = temp;
}
solve(arr[0], arr[n - 1]);
for (long long int i = 1; i < n; i++) {
solve(arr[i], arr[i - 1]);
}
double ans = (M_PI * (rmax - rmin) * (rmax + rmin));
cout << setprecision(30) << (M_PI * (rmax - rmin) * (rmax + rmin)) << endl;
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fact[5000001];
long long power(long long x, long long y) {
if (y == 0) return 1;
long long p = power(x, y / 2) % 998244353;
p = (p * p) % 998244353;
return (y % 2 == 0) ? p : (x * p) % 998244353;
}
long long modInverse(long long a) { return power(a, 998244353 - 2); }
void factorial() {
fact[0] = 1;
for (long long i = 1; i < 5000001; i++)
fact[i] = (i * fact[i - 1]) % 998244353;
}
long long ncr(long long n, long long c) {
return (fact[n] *
((modInverse(fact[n - c]) * modInverse(fact[c])) % 998244353)) %
998244353;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
factorial();
long long n, k;
cin >> n >> k;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long a = n / i - 1;
if (a < k - 1) break;
ans = (ans + ncr(a, k - 1)) % 998244353;
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int n;
n = str.size();
int arr[27][n + 1];
for (int i = 0; i < 27; i++) {
arr[i][0] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 27; j++) {
arr[j][i] = arr[j][i - 1];
}
int pos = str[i - 1] - 'a' + 1;
arr[pos][i]++;
}
int q;
cin >> q;
while (q) {
int l, r;
cin >> l >> r;
if (l == r) {
cout << "Yes\n";
} else {
int cnt = 0;
for (int i = 0; i < 27; i++) {
int num = arr[i][r] - arr[i][l - 1];
if (num >= 1) {
cnt++;
}
}
if (str[l - 1] != str[r - 1] || cnt >= 3) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
q--;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
scanf(" %d %d", &n, &d);
int k;
scanf(" %d", &k);
while (k--) {
int x, y;
scanf(" %d %d", &x, &y);
int calc = x - y;
int calc2 = x + y;
if (-d <= calc && calc <= d && d <= calc2 && calc2 <= 2 * n - d) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
vector<int> a;
int m = 0, f = 0;
bool ok = true;
while (cin >> s) {
if (s.rfind("lios") != -1 && s.rfind("lios") == s.size() - 4) {
a.push_back(0);
m++;
} else if (s.rfind("liala") != -1 && s.rfind("liala") == s.size() - 5) {
a.push_back(0);
f++;
} else if (s.rfind("etr") != -1 && s.rfind("etr") == s.size() - 3) {
a.push_back(1);
m++;
} else if (s.rfind("etra") != -1 && s.rfind("etra") == s.size() - 4) {
a.push_back(1);
f++;
} else if (s.rfind("initis") != -1 && s.rfind("initis") == s.size() - 6) {
a.push_back(2);
m++;
} else if (s.rfind("inites") != -1 && s.rfind("inites") == s.size() - 6) {
a.push_back(2);
f++;
} else {
ok = false;
}
}
int n = a.size();
if (ok && n > 1) {
if (m > 0 && f > 0) {
ok = false;
} else {
int i = 0;
while (i < n && a[i] != 1) ++i;
if (i < n) {
int j = i + 1;
while (j < n) {
if (a[j] != 2) {
ok = false;
break;
} else {
++j;
}
}
j = i - 1;
while (j > -1) {
if (a[j] != 0) {
ok = false;
break;
} else {
--j;
}
}
} else {
ok = false;
}
}
}
if (ok)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int N;
int cc = 0;
vector<int> neg;
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
int v;
scanf("%d", &v);
if (v < 0) neg.push_back(v);
if (v > 0) {
if (cc) putchar(' ');
printf("%d", v);
++cc;
}
}
if (N == 1) {
if (N == neg.size())
printf("%d\n", neg[0]);
else if (cc == 0) {
printf("0\n");
} else
putchar('\n');
return 0;
}
sort(neg.begin(), neg.end());
if (neg.size() & 1) neg.pop_back();
for (int i = 0; i < neg.size(); ++i) {
if (cc) putchar(' ');
++cc;
printf("%d", neg[i]);
}
if (!cc) {
printf("0\n");
return 0;
}
putchar('\n');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > v(200001, vector<long long>(2, 0));
int main() {
string a, b;
cin >> a >> b;
v[0][0] = int(b[0] == '0');
v[0][1] = int(b[0] == '1');
for (int i = 1; i < b.length(); i++) {
v[i][0] += v[i - 1][0] + int(b[i] == '0');
v[i][1] += v[i - 1][1] + int(b[i] == '1');
}
int l = b.length() - a.length();
long long ans = 0;
for (int i = l; i < b.length(); i++) {
if (a[i - l] == '0') {
ans += v[i][1];
if (i - l - 1 >= 0) ans -= v[i - l - 1][1];
} else {
ans += v[i][0];
if (i - l - 1 >= 0) ans -= v[i - l - 1][0];
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[27], num[27], n, kq = 26;
string s;
long long tpm(int x) {
memset(num, 0, sizeof(num));
long long ans = 0, sum = 0;
for (int l = 1, r = 1; r <= n; r++) {
int c = s[r] - 'a';
if (num[c] == 0) sum++;
num[c]++;
while (sum > x) {
int t = s[l] - 'a';
num[t]--;
if (num[t] == 0) sum--;
l++;
}
ans += 1ll * (r - l + 1);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
s = ' ' + s;
for (int i = 1; i <= 26; i++) dp[i] = tpm(i);
for (int i = 2; i <= 26; i++)
if (dp[i] == dp[i - 1]) {
kq = i - 1;
break;
}
cout << kq << '\n';
for (int i = 1; i <= kq; i++) cout << dp[i] - dp[i - 1] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 6250005;
int n, m, k;
int sum[2505][2505];
int getnum(int a, int b, int c, int d) {
int ans = sum[c][d] - sum[c][b - 1] - sum[a - 1][d] + sum[a - 1][b - 1];
return ans;
}
long long int go(int s1, int h1, int s2, int h2) {
if (s1 == s2 && h1 == h2) {
return getnum(s1, h1, s2, h2) == k;
}
if (s2 - s1 > h2 - h1) {
int mid = (s2 + s1) >> 1;
int up[k + 1];
int dw[k + 1];
long long int cnt = 0;
for (int i = h1; i <= h2; i++) {
for (int r = 0; r <= k; r++) {
up[r] = mid - s1 + 1;
dw[r] = s2 - mid;
}
for (int j = i; j <= h2; j++) {
for (int x = 0; x <= k; x++) {
while (up[x] && getnum(mid - up[x] + 1, i, mid, j) > x) --up[x];
while (dw[x] && getnum(mid + 1, i, mid + dw[x], j) > x) --dw[x];
}
for (int r = 0; r <= k; r++) {
cnt += (long long int)(up[r] - (r ? up[r - 1] : 0)) *
(dw[k - r] - ((k - r) ? dw[k - r - 1] : 0));
}
}
}
return cnt + go(s1, h1, mid, h2) + go(mid + 1, h1, s2, h2);
} else {
int mid = (h2 + h1) >> 1;
int up[k + 1];
int dw[k + 1];
long long int cnt = 0;
for (int i = s1; i <= s2; i++) {
for (int r = 0; r <= k; r++) {
up[r] = mid - h1 + 1;
dw[r] = h2 - mid;
}
for (int j = i; j <= s2; j++) {
for (int r = 0; r <= k; r++) {
while (up[r] && getnum(i, mid - up[r] + 1, j, mid) > r) up[r]--;
while (dw[r] && getnum(i, mid + 1, j, mid + dw[r]) > r) dw[r]--;
}
for (int r = 0; r <= k; r++) {
cnt += (long long int)(up[r] - (r ? up[r - 1] : 0)) *
(dw[k - r] - ((k - r) ? dw[k - r - 1] : 0));
}
}
}
return cnt + go(s1, h1, s2, mid) + go(s1, mid + 1, s2, h2);
}
}
char s[2550];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
cin >> s;
for (int j = 1; j <= m; j++) {
sum[i][j] = s[j - 1] - '0';
if (i == 1 && j == 1) continue;
if (i == 1 && j >= 2) {
sum[i][j] += sum[i][j - 1];
continue;
}
if (i >= 2 && j == 1) {
sum[i][j] += sum[i - 1][j];
continue;
}
if (i >= 2 && j >= 2) {
sum[i][j] += (sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1]);
continue;
}
}
}
printf("%lld\n", go(1, 1, n, m));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
const unsigned int MOD = 1000000007;
template <class T>
T power(T a, long long int n) {
T res = 1;
while (n > 0) {
if (n % 2) res = (res * a) % MOD;
a = (a * a) % MOD, n = n / 2;
}
return res % MOD;
}
unsigned int factorial(unsigned int n) {
if (n == 0) return 1;
return n * factorial(n - 1);
}
bool isprime(int n) {
if (n <= 1) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
inline long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
inline long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int getsum(long long int n) {
int sum;
for (sum = 0; n > 0; sum += n % 10, n /= 10)
;
return sum;
}
void tobin(int n) {
int binaryNum[32];
int i = 0;
while (n > 0) {
binaryNum[i] = n % 2;
n = n / 2;
i++;
}
for (int j = i - 1; j >= 0; j--) cout << binaryNum[j];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, a;
cin >> n;
vector<long long int> sum(n + 1, 0);
;
for (int i = 1; i <= n; i++) {
cin >> a;
sum[i] = sum[i - 1] + a;
}
long long int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
long long int intsum = sum[j] - sum[i - 1];
long long int intv = j - i + 1;
if (intsum > 100 * intv) ans = max(ans, intv);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int a, ta;
cin >> a >> ta;
int b, tb;
cin >> b >> tb;
string time;
cin >> time;
int hours = (time[0] - '0') * 10;
hours += (time[1] - '0');
int minutes = (time[3] - '0') * 10 + (time[4] - '0');
int start = (hours - 5) * 60 + minutes;
int End = start + ta;
int before = (start / b) + 1;
int cnt = 0;
for (int i = 0; i < before; i++) {
int leave = i * b;
if (leave + tb > start) cnt++;
}
for (int i = start + 1; i < End; i++) {
if (i % b == 0 && i < 19 * 60) cnt++;
}
cout << cnt << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
void input(std::vector<int> &h, int &n) {
std::cin >> n;
h.resize(n);
for (int i = 0; i < n; ++i) {
std::cin >> h.at(i);
}
}
void buildMarkedArrays(const std::vector<int> &h, std::vector<int> &max_before,
std::vector<int> &min_after, int n) {
max_before.resize(n + 1);
min_after.resize(n + 1);
max_before.at(0) = h.at(0);
min_after.at(n - 1) = INT_MAX;
for (int i = 1; i < n; ++i) {
max_before.at(i) = std::max(max_before.at(i - 1), h.at(i));
}
for (int i = n - 2; i >= 0; --i) {
min_after.at(i) = std::min(min_after.at(i + 1), h.at(i + 1));
}
}
int main() {
std::ios::sync_with_stdio(false);
int n;
std::vector<int> h;
input(h, n);
std::vector<int> max_before, min_after;
buildMarkedArrays(h, max_before, min_after, n);
int sum = 0;
for (int i = 0; i < n; ++i) {
if (max_before.at(i) <= min_after.at(i)) {
sum++;
}
}
std::cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[3][10];
int dig(int x) {
int d = 0;
while (x) {
x /= 10;
d++;
}
return d;
}
bool check(int x) {
int digit = dig(x);
if (digit == 1) {
if (a[0][x] || a[1][x] || a[2][x]) return 1;
} else if (digit == 2) {
int p = x / 10, q = x % 10;
bool ret1 =
(a[0][p] && a[1][q]) || (a[1][p] && a[2][q]) || (a[2][p] && a[0][q]);
int temp = p;
p = q;
q = temp;
bool ret2 =
(a[0][p] && a[1][q]) || (a[1][p] && a[2][q]) || (a[2][p] && a[0][q]);
return (ret1 || ret2);
} else if (digit == 3) {
int r = x % 10;
x /= 10;
int q = x % 10;
x /= 10;
int p = x % 10;
bool ret1 = (a[0][p] && a[1][q] && a[2][r]) ||
(a[1][p] && a[2][q] && a[0][r]) ||
(a[2][p] && a[0][q] && a[1][r]);
int temp = q;
q = r;
r = temp;
bool ret2 = (a[0][p] && a[1][q] && a[2][r]) ||
(a[1][p] && a[2][q] && a[0][r]) ||
(a[2][p] && a[0][q] && a[1][r]);
return (ret1 || ret2);
}
return 0;
}
int main() {
memset(a, 0, 3 * 10 * sizeof(int));
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
int x;
cin >> x;
a[i][x] = 1;
}
}
int ans = 0;
while (1) {
if (check(ans + 1)) {
ans++;
} else {
break;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10;
const double PI = acos(-1.0);
int n, m, l, X;
int cnt[N], r[N], G[N];
complex<double> A[N], B[N];
void FFT(complex<double> C[], int t) {
for (int i = 0; i < n; i++)
if (i < r[i]) swap(C[i], C[r[i]]);
for (int i = 1; i < n; i <<= 1) {
complex<double> x(cos(PI / i), t * sin(PI / i));
for (int j = 0; j < n; j += (i << 1)) {
complex<double> y(1, 0);
for (int k = 0; k < i; k++, y *= x) {
complex<double> p = C[j + k], q = y * C[i + j + k];
C[j + k] = p + q;
C[i + j + k] = p - q;
}
}
}
}
int main() {
scanf("%d%d", &n, &X);
int v, sum = 0, tmp = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &v);
v = v < X;
sum += v;
G[i] = v;
cnt[sum]++;
}
cnt[0]++;
for (int i = 0; i <= n; i++) A[i] = cnt[i], B[i] = cnt[n - i];
m = n + n;
for (n = 1; n <= m; n <<= 1) l++;
l--;
for (int i = 0; i < n; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << l);
FFT(B, 1);
FFT(A, 1);
for (int i = 0; i <= n; i++) A[i] *= B[i];
FFT(A, -1);
long long ANS = 0, t;
G[0] = G[tmp + 1] = 1;
for (int i = 1; i <= tmp + 1; i++) {
if (G[i - 1] && !G[i])
t = 1;
else if (!G[i - 1] && !G[i])
t++;
else if (!G[i - 1] && G[i])
ANS += 1ll * (1 + t) * t / 2;
}
printf("%lld ", ANS);
for (int i = tmp + 1; i <= tmp << 1; i++)
printf("%lld ", (long long)(A[i].real() / n + 0.5));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 20, M = (1 << 18) + 5;
long long n, x, cnt;
double a[N][N], dp[M];
signed main() {
scanf("%lld", &n), dp[(1 << n) - 1] = 1;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) scanf("%lf", &a[i][j]);
for (long long S = (1 << n) - 1; S >= 1; S--) {
cnt = 0, x = S;
while (x) cnt += x & 1, x >>= 1;
for (long long i = 0; i < n; i++)
if (S & (1 << i))
for (long long j = i + 1; j < n; j++)
if (S & (1 << j)) {
dp[S - (1 << j)] += dp[S] * a[i][j] / (1.0 * cnt * (cnt - 1) / 2);
dp[S - (1 << i)] += dp[S] * a[j][i] / (1.0 * cnt * (cnt - 1) / 2);
}
}
for (long long i = 0; i < n; i++)
printf("%.6lf%c", dp[1 << i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[200];
long long b[200];
long long c[200];
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
}
long long cnt = 0;
long long e = 0;
for (long long i = 1; i <= 100; i++) {
if (b[i] == 1) cnt++;
if (b[i] > 2) e = 1;
}
if (cnt % 2 == 0) {
long long r = cnt / 2;
cout << "YES" << endl;
for (long long i = 1; i <= n; i++) {
if (b[a[i]] != 1 || r == 0)
cout << "A";
else {
cout << "B";
r--;
}
}
} else {
if (!e)
cout << "NO" << endl;
else {
long long r = cnt / 2;
long long rr = 1;
cout << "YES" << endl;
for (long long i = 1; i <= n; i++) {
if (b[a[i]] == 1 && r) {
cout << "A";
r--;
} else {
if (b[a[i]] >= 3 && rr) {
cout << "A";
rr--;
} else
cout << "B";
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
bool vis[MAXN][MAXN];
double f[MAXN][MAXN];
double dfs(int n, int m) {
if (!n) return 1.0 / (m + 1.0);
if (!m) return 1.0;
if (vis[n][m]) return f[n][m];
vis[n][m] = true;
double A = m / (m + 1.0) * (1.0 - dfs(m - 1, n));
double B = 1.0, C = 1.0 / (m + 1.0) + A, D = 1.0 - dfs(m, n - 1);
double p = (D - B) / (A + D - B - C);
return f[n][m] = p * A + (1.0 - p) * B;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
double ans = dfs(n, m);
printf("%.10lf %.10lf\n", ans, 1.0 - ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, m, l;
cin >> n >> m >> k >> l;
long long max = n / m;
long long kol = n - k;
if (kol < l) {
cout << -1;
return 0;
}
if (max == 0) {
cout << -1;
return 0;
}
long long minkonf = k + l;
if (minkonf > n) {
cout << -1;
return 0;
}
long long ans = minkonf / m;
if (minkonf % m != 0) ans++;
if (ans * m > n) {
cout << -1;
return 0;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
long long a[maxn];
long long n, m, k;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
for (int i = 0; i < m; i++) {
long long tot = 0, tk = 0;
for (int j = i; j < n; j++) {
if (j % m == i) {
tk = min(tk, tot);
tot -= k;
}
tot += a[j];
ans = max(ans, tot - tk);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e4 + 10;
long long n, x, y;
pair<long long, long long> point[MAXN];
set<pair<long long, long long> > ans;
void solve(long long l, long long r) {
if (r - l <= 1) return;
long long mid = (l + r) / 2;
for (long long i = l; i < r; i++)
ans.insert(make_pair(point[mid].first, point[i].second));
solve(l, mid), solve(mid, r);
return;
}
int32_t main() {
cin >> n;
for (long long i = 0; i < n; i++)
cin >> x >> y, point[i] = make_pair(x, y), ans.insert(make_pair(x, y));
sort(point, point + n), solve(0, n), cout << (long long)ans.size() << endl;
for (auto it : ans) cout << it.first << " " << it.second << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
int _;
using namespace std;
string s, t;
int pos;
int N, M;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
while (cin >> N >> M) {
cin >> s >> t;
pos = s.length();
for (int i = 0; i < s.length(); ++i)
if (s[i] == '*') {
pos = i;
break;
}
int flag = 1;
if (pos == s.length() && s.length() != t.length())
flag = 0;
else
for (int i = 0; i < pos; ++i) {
if (s[i] != t[i]) {
flag = 0;
break;
}
}
if (flag) {
int cur = 1;
for (int i = s.length() - 1; i > pos; --i, ++cur) {
if (t.length() - cur < pos || s[i] != t[t.length() - cur]) {
flag = 0;
break;
}
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000, C = 19;
int n, a[N + 9];
void into() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i + n] = a[i + 2 * n] = a[i];
}
}
int lg[N + 9];
int l[N + 9][C], r[N + 9][C];
int pl[N + 9][C], pr[N + 9][C];
void Get_plr() {
if (n == 1) return;
for (int i = 2; i <= n * 3; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n * 3; ++i) {
l[i][0] = max(i - a[i], 1);
r[i][0] = min(i + a[i], n * 3);
pl[i][0] = pr[i][0] = i;
}
for (int i = 1; i < C; ++i)
for (int j = 1; j + (1 << i) - 1 <= n * 3; ++j) {
int x = pl[j][i - 1], y = pl[j + (1 << i - 1)][i - 1];
pl[j][i] = l[x][0] < l[y][0] ? x : y;
x = pr[j][i - 1];
y = pr[j + (1 << i - 1)][i - 1];
pr[j][i] = r[x][0] > r[y][0] ? x : y;
}
}
int Query_pl(int u, int v) {
int t = lg[v - u + 1], x = pl[u][t], y = pl[v - (1 << t) + 1][t];
return l[x][0] < l[y][0] ? x : y;
}
int Query_pr(int u, int v) {
int t = lg[v - u + 1], x = pr[u][t], y = pr[v - (1 << t) + 1][t];
return r[x][0] > r[y][0] ? x : y;
}
void Get_lr() {
if (n == 1) return;
for (int i = 1; i < C; ++i)
for (int j = 1; j <= n * 3; ++j) {
int x = Query_pl(l[j][i - 1], r[j][i - 1]),
y = Query_pr(l[j][i - 1], r[j][i - 1]);
l[j][i] = min(l[x][i - 1], l[y][i - 1]);
r[j][i] = max(r[x][i - 1], r[y][i - 1]);
}
}
int ans[N + 9];
void Get_ans() {
if (n == 1) return;
for (int i = n + 1; i <= n << 1; ++i) {
int x = i, y = i;
ans[i - n] = 0;
for (int j = C - 1; j >= 0; --j) {
int le = min(l[x][j], l[y][j]), ri = max(r[x][j], r[y][j]);
if (ri - le + 1 >= n) continue;
x = Query_pl(le, ri);
y = Query_pr(le, ri);
ans[i - n] += 1 << j;
}
++ans[i - n];
}
}
void work() {
Get_plr();
Get_lr();
Get_ans();
}
void outo() {
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
}
int main() {
int T = 1;
for (; T--;) {
into();
work();
outo();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e3 + 7;
const int maxm = 1e6 + 7;
const int mod = 1e9 + 7;
int n;
long long ar[maxn];
long long dp[maxn][maxn];
int st[maxn];
int tot;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> ar[i];
ar[0] = -inf;
long long maxx = -inf;
int pos;
for (int i = 1; i <= n; i++) {
long long tmp = ar[i];
dp[i][i] = ar[i];
for (int j = i - 1; j >= 1; j--) {
if (ar[j] <= dp[i][j + 1]) {
tmp += ar[j];
dp[i][j] = ar[j];
} else {
tmp += dp[i][j + 1];
dp[i][j] = dp[i][j + 1];
}
}
for (int k = i + 1; k <= n; k++) {
if (ar[k] <= dp[i][k - 1]) {
tmp += ar[k];
dp[i][k] = ar[k];
} else {
tmp += dp[i][k - 1];
dp[i][k] = dp[i][k - 1];
}
}
if (tmp > maxx) {
maxx = tmp;
pos = i;
}
}
for (int i = 1; i <= n; i++) {
printf("%lld%c", dp[pos][i], i == n ? '\n' : ' ');
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1e9 + 5;
long long int mod = 998244353;
long long int nax = 2e5;
vector<vector<long long int>> days(nax + 1);
vector<vector<pair<long long int, long long int>>> g(nax + 1);
void dfs(long long int node, long long int pa, long long int k,
long long int no) {
long long int x = 1;
for (auto ele : g[node]) {
long long int child = ele.first, index = ele.second;
if (x == no) {
x++;
}
if (child != pa) {
days[x].push_back(index);
dfs(child, node, k, x);
x++;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
long long int u, v;
cin >> u >> v;
g[u].push_back({v, i + 1});
g[v].push_back({u, i + 1});
}
long long int k = 0;
for (long long int node = 1; node <= n; ++node) {
k = max(k, (long long int)g[node].size());
}
dfs(1, 0, k, 0);
cout << k << "\n";
for (long long int i = 1; i <= k; i++) {
cout << days[i].size() << " ";
for (auto ele : days[i]) {
cout << ele << " ";
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
int a[1100];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int cost = INF;
int t = -1;
for (int index = 1; index <= 100; index++) {
int tmp = 0;
for (int j = 1; j <= n; j++) {
if (a[j] >= index - 1 && a[j] <= index + 1)
continue;
else if (a[j] < index - 1)
tmp += (index - 1 - a[j]);
else if (a[j] > index + 1)
tmp += (a[j] - index - 1);
}
if (tmp < cost) {
cost = tmp;
t = index;
}
}
printf("%d %d\n", t, cost);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 6e6;
bool used[2 * nmax];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long maxb, maxc;
cin >> maxb >> maxc;
long long ans = 0;
for (long long b = 1; b * b <= maxc && b <= maxb; ++b) {
used[-b + nmax] = true;
++ans;
}
for (long long b = 2; b <= maxb; ++b) {
long long rg = min(maxc, b * b - 1);
ans += rg * 2;
}
for (long long b = 2; b <= maxb; ++b) {
for (long long a = b - 1; a >= 1 && b * b - a * a <= maxc; --a) {
long long r = -b - a;
if (used[r + nmax]) {
--ans;
} else {
used[r + nmax] = true;
}
r = -b + a;
if (used[r + nmax]) {
--ans;
} else {
used[r + nmax] = true;
}
}
}
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 100000;
int ans = 0, i, j, k = 0, tmp;
int64_t n, s[17] = {0};
int solve(int64_t x) {
int tmp, i = k;
if (x <= 11) return min(x, 11 - x + 2);
while (s[i - 1] >= x) i--;
tmp = ((x / s[i - 1]) * (i - 1) + solve(x % s[i - 1]));
if (2 * x < s[i]) return tmp;
return min(tmp, i + solve(s[i] - x));
}
int main() {
scanf("%I64d", &n);
do {
k++;
s[k] = 10 * s[k - 1] + 1;
} while (s[k] < n);
ans = solve(n);
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)(5e5) + 322;
const long long INF = (long long)(1e9);
const long long mod = (long long)(1e9) + 7;
const double eps = 1e-9;
int s, x1, x2, t1, t2, mn = INF, p, d, ans;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cin >> s >> x1 >> x2 >> t1 >> t2 >> p >> d;
mn = abs(x1 - x2) * t2;
while (p != x1) {
p += d;
ans += t1;
if (p == s) d = -1;
if (p == 0) d = 1;
}
while (p != x2) {
p += d;
ans += t1;
if (p == s) d = -1;
if (p == 0) d = 1;
}
cout << min(mn, ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class help {
public:
int x;
int y;
};
bool opt(help &a, help &b) {
if (a.x != b.x) {
if (a.x > b.x)
return true;
else
return false;
} else {
if (a.y < b.y)
return true;
else
return false;
}
return false;
}
void solve() {
long long n, k;
cin >> n;
cin >> k;
vector<help> vec(n);
for (int i = 0; i < n; i++) cin >> vec[i].x >> vec[i].y;
sort(vec.begin(), vec.end(), opt);
int l = vec[k - 1].x;
int m = vec[k - 1].y;
int ans = 1;
for (int j = k - 2; j >= 0; j--) {
if (vec[j].x == l && vec[j].y == m)
ans++;
else
break;
}
for (int j = k; j < n; j++) {
if (vec[j].x == l && vec[j].y == m)
ans++;
else
break;
}
cout << ans << "\n";
}
int main() {
long long t = 1;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, i, j, x, y, ans, k;
int ar[100];
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
ans = 99999999;
for (i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
}
sort(ar + 1, ar + n + 1);
for (i = 1; i < n; i++) {
ans = min(ans, ar[i + 1] - ar[i]);
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int suma[5001], n, sumb[5001];
int main() {
string a;
int len;
cin >> a;
len = a.size();
a = " " + a;
for (int i = 1; i <= len; i++)
if (a[i] == 'a') {
suma[i] = suma[i - 1] + 1;
} else {
suma[i] = suma[i - 1];
}
for (int i = 1; i <= len; i++) {
if (a[i] == 'b') {
sumb[i] = sumb[i - 1] + 1;
} else {
sumb[i] = sumb[i - 1];
}
}
for (int i = 0; i <= len; i++) {
for (int j = i; j <= len; j++) {
n = max(n, (suma[i]) + (sumb[j] - sumb[i]) + (suma[len] - suma[j]));
}
}
cout << n;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.