solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 7;
int n;
pair<int, int> a[maxn];
int ans[maxn];
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
a[2 * i - 1] = make_pair(l, -i);
a[2 * i] = make_pair(r, i);
ans[i] = 0;
}
sort(a + 1, a + 2 * n + 1);
multiset<int> s;
int c = 0;
for (int i = 1; i <= 2 * n; i++) {
if (a[i].second < 0) {
s.insert(-a[i].second);
} else {
s.erase(s.find(a[i].second));
}
if (s.size() == 0) {
c++;
}
if (s.size() == 1 && a[i].second > 0 && a[i + 1].second < 0 &&
a[i + 1].first > a[i].first) {
ans[*s.begin()]++;
}
if (s.size() == 1 && a[i].second < 0 && a[i + 1].second > 0)
ans[*s.begin()]--;
}
int Ans = -n;
for (int i = 1; i <= n; i++) Ans = max(Ans, ans[i]);
cout << c + Ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int INF = 1000000000 + 1e8;
const long long LINF = 2000000000000000000;
struct elem {
int s, a;
};
void solve() {
int n, d;
cin >> n >> d;
vector<elem> good, bad;
for (int i = 0; i < n; i++) {
int si, ai;
cin >> si >> ai;
if (si < d) {
continue;
}
if (si >= ai)
good.push_back({si, ai});
else
bad.push_back({si, ai});
}
auto cmp = [](elem x, elem y) {
return x.a < y.a || x.a == y.a && x.s < y.s;
};
sort((good).begin(), (good).end(), cmp);
sort((bad).begin(), (bad).end(), cmp);
good.insert(good.begin(), {INF, d});
good.push_back({INF, INF});
vector<int> suffMin(int(good.size()));
suffMin[int(good.size()) - 1] = good.back().s;
for (int i = int(good.size()) - 2; i >= 0; i--)
suffMin[i] = min(suffMin[i + 1], good[i].s);
int ans = int(good.size()) - 2;
int j = 0;
vector<elem> res;
int curA = d;
for (int i = 0; i < int(good.size()) - 1; i++) {
curA = max(good[i].a, curA);
for (; j < int(bad.size()) && bad[j].a <= suffMin[i + 1]; j++) {
if (bad[j].s >= curA) {
ans++;
curA = max(curA, bad[j].a);
res.push_back(bad[j]);
}
}
}
cout << ans;
}
int main() {
srand(time(0));
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tst = 1;
while (tst--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200005;
char s[MAX_N];
long long x[MAX_N];
bool a[MAX_N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
cin >> x[i];
a[i] = 0;
}
long long i = 0;
while (1) {
if (i >= n || i < 0) {
cout << "FINITE";
return 0;
}
if (a[i] == 1) {
cout << "INFINITE";
return 0;
}
a[i] = 1;
if (s[i] == '>') {
i += x[i];
} else {
if (s[i] == '<') i -= x[i];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v1;
vector<long long> v2;
long long binpow(long long a1, long long b1) {
long long ans = 1;
while (b1) {
if (b1 % 2 == 1) ans *= a1;
b1 /= 2;
a1 *= a1;
}
return ans;
}
int main() {
long long a, b;
cin >> a >> b;
while (a) {
v1.push_back(a % 3);
a /= 3;
}
while (b) {
v2.push_back(b % 3);
b /= 3;
}
long long xxx = max(v1.size(), v2.size()) - min(v1.size(), v2.size());
if (v1.size() > v2.size())
for (long long i = 0; i < xxx; i++) v2.push_back(0);
if (v2.size() > v1.size())
for (long long i = 0; i < xxx; i++) v1.push_back(0);
long long ot = 0;
if (v1.size() != 0) {
for (long long i = 0; i < v1.size(); i++)
v1[i] = abs(v2[i] - v1[i] + 3) % 3;
for (long long i = 0; i < v1.size(); i++) ot += v1[i] * binpow(3, i);
}
cout << ot << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long int x[100005];
long long int y[100005];
long long int px, py;
int n;
inline long long int il_wek(long long int a, long long int b, long long int c,
long long int d) {
return a * d - b * c;
}
inline long long int il_wek(long long int a, long long int b, long long int c,
long long int d, long long int e, long long int f) {
return il_wek(c - a, d - b, e - a, f - b);
}
inline long long int il_wek(long long int a, long long int b, long long int c,
long long int d, long long int e, long long int f,
long long int g, long long int h) {
return il_wek(c - a, d - b, f - e, h - g);
}
bool wew(int a, int b, int c) {
if (il_wek(x[a], y[a], x[b], y[b], px, py) *
il_wek(x[a], y[a], px, py, x[c], y[c]) >=
0)
return false;
if (il_wek(x[b], y[b], x[a], y[a], px, py) *
il_wek(x[b], y[b], px, py, x[c], y[c]) >=
0)
return false;
if (il_wek(x[c], y[c], x[b], y[b], px, py) *
il_wek(x[c], y[c], px, py, x[a], y[a]) >=
0)
return false;
return true;
}
long long int przyp() {
int a, b;
scanf("%d%d", &a, &b);
px = a;
py = b;
bool poza = false;
for (int i = 0; i < n; i++) {
if (il_wek(x[i], y[i], x[(i + 1) % n], y[(i + 1) % n], px, py) > 0) {
poza = true;
break;
}
}
if (poza) return 0;
long long int wyn = 0;
int p = 1;
for (int i = 0; i < n; i++) {
while (il_wek(x[i], y[i], px, py, x[p], y[p]) > 0) p = (p + 1) % n;
wyn += (((i - p + n) % n) *
((static_cast<long long int>(i - p + n) % n) - 1)) /
2;
}
long long int costam =
n * static_cast<long long int>(n - 1) * static_cast<long long int>(n - 2);
costam /= 3;
costam /= 2;
return costam - wyn;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
x[i] = a;
y[i] = b;
}
int t;
scanf("%d", &t);
while (t--) printf("%I64d\n", przyp());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct S {
int a, b;
S() {}
S(int _a, int _b) {
a = _a;
b = _b;
}
const bool operator<(const S &o) const { return a < o.a; }
};
priority_queue<int> pq;
priority_queue<int, vector<int>, greater<int>> mpq;
map<int, int> mp;
stack<int> st;
set<int> set_i;
int arr[400009], num[400009], cnt[400009];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d", &arr[i]);
}
int max_n = n, min_n = n;
int cur = n;
cnt[cur]++;
num[0] = cur;
for (int i = 1; i <= n - 1; i++) {
cur += arr[i];
if (cur <= 0 || cur >= 2 * n) {
printf("-1\n");
return 0;
}
cnt[cur]++;
max_n = max(max_n, cur);
min_n = min(min_n, cur);
num[i] = cur;
}
if (max_n - min_n == n - 1) {
for (int i = min_n; i <= max_n; i++) {
if (cnt[i] == 0) {
printf("-1\n");
return 0;
}
}
int tmp = 1 - min_n;
for (int i = 0; i < n; i++) {
printf("%d ", num[i] + tmp);
}
} else {
printf("-1\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void printQueue(T& q) {
while (!q.empty()) {
cout << q.top() << endl;
q.pop();
}
}
long long power(long long a, long long b) {
long long r = 1;
while (b != 0) {
if (b % 2 != 0) {
r = r * a;
}
a = a * a;
b = b / 2;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
string l, r;
cin >> l >> r;
int l_a[28], r_a[28];
memset(l_a, 0, sizeof(l_a));
memset(r_a, 0, sizeof(r_a));
vector<int> la[28], ra[28];
for (int i = 0; i < n; i++) {
if (l[i] == '?') {
l_a[27] += 1;
la[27].push_back(i);
continue;
}
l_a[l[i] - 96] += 1;
la[l[i] - 96].push_back(i);
}
for (int i = 0; i < n; i++) {
if (r[i] == '?') {
r_a[27] += 1;
ra[27].push_back(i);
continue;
}
r_a[r[i] - 96] += 1;
ra[r[i] - 96].push_back(i);
}
vector<pair<int, int> > ans;
int il[28], ir[28], minm;
memset(il, 0, sizeof(il));
memset(ir, 0, sizeof(ir));
for (int i = 1; i <= 26; i++) {
minm = min(l_a[i], r_a[i]);
il[i] = minm;
ir[i] = minm;
for (int j = 0; j < minm; j++) {
ans.push_back(make_pair(la[i][j], ra[i][j]));
}
}
for (int i = 1; i <= 26; i++) {
if (il[27] == la[27].size()) {
break;
}
for (int k = ir[i]; k < ra[i].size(); k++) {
ans.push_back(make_pair(la[27][il[27]], ra[i][k]));
il[27] += 1;
if (il[27] == la[27].size()) {
break;
}
}
}
for (int i = 1; i <= 27; i++) {
if (ir[27] == ra[27].size()) {
break;
}
for (int k = il[i]; k < la[i].size(); k++) {
ans.push_back(make_pair(la[i][k], ra[27][ir[27]]));
ir[27] += 1;
if (ir[27] == ra[27].size()) {
break;
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << (ans[i].first + 1) << " " << (ans[i].second + 1) << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 5, mod = 1e9 + 7;
const long long oo = 1e18 + 7;
long long n, m;
long long a[N], b[N];
vector<long long> Adj[N];
set<pair<long long, long long> > second;
long long mn_dist[N], lst[N];
void process() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
second.insert({i - a[i], i});
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
Adj[i + b[i]].push_back(i);
}
for (long long i = 1; i <= n; i++) mn_dist[i] = oo;
queue<long long> bfs;
for (long long i = 1; i <= n; i++) {
if (i == a[i]) {
mn_dist[i] = 1;
lst[i] = 0;
second.erase({i - a[i], i});
bfs.push(i);
}
}
while (!bfs.empty()) {
long long u = bfs.front();
bfs.pop();
for (auto v : Adj[u]) {
vector<pair<long long, long long> > del;
for (auto it : second) {
if (it.first > v) break;
del.push_back(it);
bfs.push(it.second);
mn_dist[it.second] = mn_dist[u] + 1;
lst[it.second] = v;
}
for (auto it : del) second.erase(it);
}
}
if (mn_dist[n] == oo) {
cout << -1 << "\n";
return;
}
cout << mn_dist[n] << "\n";
long long itr = n;
for (long long i = 0; i < mn_dist[n]; i++) {
cout << lst[itr] << " ";
itr = lst[itr] + b[lst[itr]];
}
}
signed main() {
ios_base::sync_with_stdio(0);
process();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653;
const long long infi = 1000000001;
const string no = "NO\n", yes = "YES\n", nl = "\n";
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
long long n, m, i, length, d, p, bank, k, j, x, y, ans, q;
string s;
while (t--) {
ans = 0;
cin >> n >> p;
long long a[n][2];
for (i = 0; i < n; i++) {
cin >> x >> y;
a[i][0] = y - x + 1;
a[i][1] = a[i][0] - (y / p - (x - 1) / p);
}
long double money = 0;
for (i = 0; i < n; i++) {
money +=
(a[i][1] * a[(i + 1) % n][1] * 1.0) / (a[i][0] * a[(i + 1) % n][0]);
}
cout << fixed << setprecision(10) << (n - money) * 2000LL;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
sort(s.begin(), s.end());
string v[k];
int i = 0, d = 0, e = 0;
for (int i = k + 1; i < n; ++i) {
if (s[i] != s[i - 1]) {
e = 1;
break;
}
}
while (i < n) {
if (i < k) {
v[i].push_back(s[i]);
if (s[i] != s[i - 1] && i > 0) {
d = 1;
}
} else if (d == 0) {
if (e == 1) {
v[0].push_back(s[i]);
} else {
v[i % k].push_back(s[i]);
}
}
++i;
}
if (d == 1) {
cout << v[k - 1] << endl;
} else {
cout << v[0] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:16777216")
template <typename T>
T fac(T a) {
return a ? a * fac(a - 1) : 1;
}
template <typename T>
T power(T a, int p) {
return !p ? 1 : (p & 1 ? a * power(a, p - 1) : power(a * a, p >> 1));
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T lcm(T a, T b) {
return b / gcd(a, b) * a;
}
template <typename T>
T next() {
T _;
cin >> _;
return _;
}
template <>
int next<int>() {
int _;
scanf("%d", &_);
return _;
}
template <>
double next<double>() {
double _;
scanf("%lf", &_);
return _;
}
template <>
long long next<long long>() {
long long _;
scanf("%I64d", &_);
return _;
}
template <>
char next<char>() {
char _[2];
scanf("%s", _);
return _[0];
}
template <typename E>
vector<E> next(int n) {
vector<E> res(n);
for (int i = 0; i < n; i++) res[i] = next<E>();
return res;
}
template <class C, class E>
int count(const C &c, const E &e) {
return count(c.begin(), c.end(), e);
}
template <class C, class E>
bool has(const C &c, const E &e) {
return find(c.begin(), c.end(), e) != c.end();
}
template <class C, class E>
int find(const C &c, const E &e) {
return find(c.begin(), c.end(), e) - c.begin();
}
template <class E>
bool binary_has(const vector<E> &c, const E &e) {
return binary_search(c.begin(), c.end(), e);
}
template <class E>
int binary_find(const vector<E> &c, const E &e) {
return lower_bound(c.begin(), c.end(), e) - c.begin();
}
template <typename T>
T dist2(T i1, T j1, T i2, T j2) {
return (i1 - i2) * (i1 - i2) + (j1 - j2) * (j1 - j2);
}
template <typename T>
T qpow(T a, T b, T p) {
T res = 1;
while (b)
if (b & 1)
res = res * a % p, --b;
else
a = a * a % p, b >>= 1;
return res;
}
inline bool ok(int i, int j, int n, int m) {
return 0 <= i && i < n && 0 <= j && j < m;
}
inline bool ok(int i, int n) { return 0 <= i && i < n; }
const double PI = acos(-1.0);
const double EPS = 1e-9;
template <typename T>
inline bool LE(T a, T b) {
return a <= b;
}
template <typename T>
inline bool BE(T a, T b) {
return a >= b;
}
template <typename T>
inline bool EQ(T a, T b) {
return a == b;
}
template <typename T>
inline bool LESS(T a, T b) {
return a < b;
}
template <typename T>
inline bool BIGG(T a, T b) {
return a > b;
}
template <>
inline bool LE(double a, double b) {
return b - a > -EPS;
}
template <>
inline bool BE(double a, double b) {
return a - b > -EPS;
}
template <>
inline bool EQ(double a, double b) {
return fabs(a - b) < EPS;
}
template <>
inline bool LESS(double a, double b) {
return b - a > EPS;
}
template <>
inline bool BIGG(double a, double b) {
return a - b > EPS;
}
template <typename T>
struct complex {
T re, im;
complex operator+(const complex &c) { return complex{re + c.re, im + c.im}; }
complex operator-(const complex &c) { return complex{re - c.re, im - c.im}; }
complex operator*(const complex &c) {
return complex{re * c.re - im * c.im, re * c.im + im * c.re};
}
};
const int N = 100100;
int sum[2][N];
int n;
int getSum(int id, int from, int to) {
if (from == 0)
return sum[id][to];
else
return sum[id][to] - sum[id][from - 1];
}
int findNext(int i, int t, int id) {
if (getSum(id, i, n - 1) < t) return numeric_limits<int>::max();
int lo = i, hi = n - 1;
while (lo < hi) {
int c = (lo + hi) / 2;
int s = getSum(id, i, c);
if (s >= t)
hi = c;
else
lo = c + 1;
}
return lo;
}
int solve(int t) {
int c0 = 0, c1 = 0;
int lastwin = -1;
for (int i = 0; i < n;) {
int i0 = findNext(i, t, 0);
int i1 = findNext(i, t, 1);
if (i0 < i1) {
if (i0 == numeric_limits<int>::max()) return -1;
c0++;
i = i0 + 1;
lastwin = 0;
} else {
if (i1 == numeric_limits<int>::max()) return -1;
c1++;
i = i1 + 1;
lastwin = 1;
}
}
if (c0 > c1 && lastwin == 0) return c0;
if (c1 > c0 && lastwin == 1) return c1;
return -1;
}
int main() {
n = next<int>();
vector<int> v(n);
for (int i = 0; i < n; i++) v[i] = next<int>() - 1;
for (int i = 0; i < n; i++) sum[v[i]][i]++;
for (int i = 1; i < N; i++) {
sum[0][i] += sum[0][i - 1];
sum[1][i] += sum[1][i - 1];
}
vector<pair<int, int> > res;
for (int t = 1; t <= n; t++) {
int s = solve(t);
if (s != -1) res.push_back({s, t});
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
int min_validated = n + 1;
for (int i = n - 1; i > 0; --i) {
if (v[i] <= v[i - 1]) {
cout << i << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
vector<int> query[200009], ask[200009], pos[200009];
int L[200009], R[200009], ans[200009];
int vis[200009], sz[200009];
int a[200009], b[200009], imp[200009], love[200009];
set<int> on;
void go(int x) {
for (int i = 1; i <= sz[x]; i++) {
if (on.count(query[x][i])) {
on.erase(query[x][i]);
imp[i] = true;
}
}
}
void went(int x) {
for (int i = 1; i <= sz[x]; i++) {
if (imp[i]) {
on.insert(query[x][i]);
imp[i] = false;
}
}
}
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
pos[a[i]].push_back(i);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
L[i] = 1;
R[i] = n;
scanf("%d", sz + i);
query[i].resize(sz[i] + 1);
for (int j = 1; j <= sz[i]; j++) scanf("%d", &query[i][j]);
}
memset(ans, 127, sizeof ans);
for (int j = 1; j <= 20; j++) {
for (int i = 1; i <= n; i++) {
ask[i].resize(0);
vis[i] = 0;
}
on.clear();
for (int i = 1; i <= q; i++)
if (L[i] <= R[i]) ask[(L[i] + R[i]) / 2].push_back(i);
for (int i = n; i >= 1; i--) {
on.insert(a[i]);
for (int j = 0; j < int(ask[i].size()); j++) {
int to = ask[i][j];
go(to);
if (on.size() > 1)
L[to] = i + 1;
else {
R[to] = i - 1;
if (on.size() > 0) love[to] = *on.begin();
umin(ans[to], i);
}
went(to);
}
}
}
for (int i = 1; i <= q; i++) {
if (ans[i] > n or !love[i])
printf("0 0\n");
else {
int p = lower_bound(pos[love[i]].begin(), pos[love[i]].end(), ans[i]) -
pos[love[i]].begin();
if (p < (int)pos[love[i]].size())
printf("%d %d\n", a[pos[love[i]][p]], b[pos[love[i]][p]]);
else
printf("0 0\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
int ggd(int get1, int get2) {
while (true) {
if (get1 < get2) {
get2 -= get1;
}
if (get2 < get1) {
get1 -= get2;
}
if (get1 == get2) {
return get1;
}
}
}
int main() {
cin >> a >> b >> n;
while (n != 0) {
n -= ggd(a, n);
if (n == 0) {
cout << 0 << endl;
return 0;
}
n -= ggd(b, n);
}
cout << 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int maxn = 1000000 + 100;
long long n, ans;
long long inv[maxn], pro[maxn], invpro[maxn];
void Prepare_C() {
inv[1] = 1;
for (int i = 2; i < maxn; ++i) {
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD;
}
pro[0] = invpro[0] = 1;
for (int i = 1; i < maxn; ++i) {
pro[i] = pro[i - 1] * i % MOD;
invpro[i] = invpro[i - 1] * inv[i] % MOD;
}
}
long long get_C(long long n, long long m) {
if (n < m) {
return 0;
}
return pro[n] * invpro[m] % MOD * invpro[n - m] % MOD;
}
long long fast_pow(long long x, long long n) {
long long ans;
for (ans = 1; n != 0; n >>= 1) {
if ((n & 1) == 1) {
ans = (ans * x) % MOD;
}
x = (x * x) % MOD;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
Prepare_C();
while (scanf("%I64d", &n) != EOF) {
ans = 0;
for (long long i = 1; i <= n; ++i) {
long long first = 1;
long long second = 1;
if (i % 2 == 0) {
first = (-1 * first % MOD + MOD) % MOD;
second = first;
}
first = 2 * first % MOD * get_C(n, i) % MOD *
fast_pow(3, (n - i) * n + i) % MOD;
long long tmp = ((fast_pow(3, n - i) - 1) % MOD + MOD) % MOD;
tmp = ((fast_pow(tmp, n) - fast_pow(3, (n - i) * n)) % MOD + MOD) % MOD;
second = 3 * second % MOD * get_C(n, i) % MOD * tmp % MOD;
ans = (ans + first + second) % MOD;
}
printf("%I64d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
int tree[maxn], rd[maxn] = {0};
int vs[maxn] = {0};
int flag[maxn] = {0};
int find(int x) {
if (tree[x] != x) tree[x] = find(tree[x]);
return tree[x];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
iota(tree, tree + maxn, 0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
tree[find(u)] = find(v);
rd[u] += 1;
rd[v] += 1;
}
for (int i = 1; i <= n; i++) {
vs[find(i)] += 1;
if (rd[i] != 2) flag[find(i)] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (vs[i] > 2 && flag[i] == 0) {
ans += 1;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int pref[9], was[9], cnt, cnt2(1), local, k;
vector<int> g[9];
void dfs(int v) {
if (was[v]) return;
was[v] = true;
++local;
for (int i(0); i < g[v].size(); ++i) dfs(g[v][i]);
}
void solve(int v) {
if (v == k) {
for (int i(1); i <= k; ++i)
if (i != v) {
memset(was, false, sizeof was);
pref[v] = i;
for (int i(1); i <= k; ++i) g[i].clear();
for (int j(2); j <= k; ++j) g[pref[j]].push_back(j);
local = 0;
dfs(1);
if (local == k) ++cnt;
}
} else
for (int i(1); i <= k; ++i)
if (i != v) {
pref[v] = i;
solve(v + 1);
}
}
int bin_pow(int a, int n) {
int res(1);
while (n) {
if (n & 1) res = (long long)res * a % mod;
a = (long long)a * a % mod;
n >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n >> k;
if (k != 1)
solve(2);
else
cnt = 1;
if (n - k) cnt2 = bin_pow(n - k, n - k);
cout << ((long long)k * cnt % mod * cnt2 % mod);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[110];
int num = 0;
int main() {
num = 0;
set<string> t;
int ans = 0;
while (gets(s)) {
if (s[0] == '+') {
string tmp = "";
int len = strlen(s);
for (int i = 1; i < len; i++) tmp += s[i];
t.insert(tmp);
num++;
} else if (s[0] == '-') {
string tmp = "";
int len = strlen(s);
for (int i = 1; i < len; i++) tmp += s[i];
t.erase(tmp);
num--;
} else {
int i = 0;
for (i = 0; i < strlen(s); i++)
if (s[i] == ':') break;
ans += (strlen(s) - i - 1) * num;
}
}
cout << ans << endl;
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9e15;
long long mod = 1000000007;
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
long long nCr(long long n, long long r) {
long long p = 1, k = 1;
if (n - r > r) r = n - r;
if (r == 0) return 1;
while (r) {
p *= n;
k *= r;
long long m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
return p;
}
long long invprime(long long a, long long b) { return expo(a, b - 2, b); }
long long addmod(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mulmod(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long submod(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long divmod(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mulmod(a, invprime(b, m), m) + m) % m;
}
vector<int> sieve(int n) {
int* arr = new int[n + 1]();
vector<int> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
vector<int> makesieve(vector<int>& arr, int n) {
vector<int> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
void google(int x) { cout << "Case #" << x << ": "; }
template <typename T>
void sort(vector<T>& v) {
std::sort(v.begin(), v.end());
return;
}
template <typename T>
void sortbig(vector<T>& v) {
std::sort(v.begin(), v.end(), greater<T>());
return;
}
template <typename T>
T max(vector<T>& v) {
return *(max_element(v.begin(), v.end()));
}
template <typename T>
T min(vector<T>& v) {
return *(min_element(v.begin(), v.end()));
}
template <typename T>
ostream& operator<<(ostream& stream, vector<T>& v) {
for (T& x : v) stream << x << " ";
return stream;
}
template <typename T>
istream& operator>>(istream& stream, vector<T>& v) {
for (T& x : v) stream >> x;
return stream;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t t1, t2;
t1 = clock();
int tc = 0, tt = 1;
while (tc++ < tt) {
int n;
cin >> n;
vector<int> arr(n);
cin >> arr;
bool possible = false;
for (int i = 0; i < n; i++) {
if (arr[i] == 0) {
possible = true;
break;
}
}
if (!possible) {
cout << -1 << '\n';
} else {
int sum = 0;
sortbig(arr);
int rem = 0;
for (int i = 0; i < n; i++) {
sum += arr[i];
}
rem = sum % 3;
if (rem == 0) {
if (arr[0] == 0) {
cout << 0;
} else {
for (int i = 0; i < n; i++) {
cout << arr[i];
}
}
} else {
possible = false;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] % 3 == rem) {
possible = true;
arr.erase(arr.begin() + i);
break;
}
}
if (!possible) {
rem = 3 - rem;
int count = 0;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] % 3 == rem) {
arr.erase(arr.begin() + i);
count++;
if (count == 2) {
break;
}
}
}
}
if (arr[0] == 0) {
cout << 0;
} else {
for (auto x : arr) {
cout << x;
}
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
vector<int> son[(200000 + 10)];
int a[(200000 + 10)], dep[(200000 + 10)], rt[(200000 + 10)];
int mark[(200000 + 10)];
int pre[(200000 + 10)];
bool found;
vector<int> ans;
bool dfs(int u) {
bool f = 1;
for (int i = 0; i < son[u].size(); ++i) {
int v = son[u][i];
dep[v] = dep[u] + 1;
if (dfs(v) == 0 || (dep[a[v]] <= dep[u] && a[u] != a[v])) f = 0;
}
return f;
}
void gao(int u) {
for (int i = 0; i < son[u].size(); ++i) {
int v = son[u][i];
gao(v);
}
if (mark[u]) ans.push_back(u);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
son[u].push_back(v);
rt[v] = 1;
}
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), mark[a[i]] = 1;
found = 1;
for (int i = 1; i <= n; ++i) {
if (rt[i] == 0) found &= dfs(i);
}
if (!found) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; ++i) {
if (rt[i] == 0) gao(i);
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); ++i) printf("%d\n", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long f[55][55][55];
long long ans = 4398046511104;
struct la {
long long a, b;
} w[55];
bool v[55][55][55];
bool cmp(la x, la y) { return x.a > y.a; }
long long dfs(int u, int j, int k, long long x) {
if (u > n) return 0;
if (v[u][j][k]) return f[u][j][k];
v[u][j][k] = 1;
long long mn = 4398046511104;
if (u < n && w[u].a == w[u + 1].a) {
if (j)
mn =
((mn) < (dfs(u + 1, j - 1, k, x)) ? (mn) : (dfs(u + 1, j - 1, k, x)));
mn = ((mn) < (dfs(u + 1, j, k + 1, x) + (w[u].a - w[u].b * x))
? (mn)
: (dfs(u + 1, j, k + 1, x) + (w[u].a - w[u].b * x)));
} else if (u == n || w[u].a != w[u + 1].a) {
if (j)
mn = ((mn) < (dfs(u + 1, j + k - 1, 0, x))
? (mn)
: (dfs(u + 1, j + k - 1, 0, x)));
mn = ((mn) < (dfs(u + 1, j + k + 1, 0, x) + (w[u].a - w[u].b * x))
? (mn)
: (dfs(u + 1, j + k + 1, 0, x) + (w[u].a - w[u].b * x)));
}
return f[u][j][k] = mn;
}
int cnt[55];
bool dp(long long x) {
memset(f, 0x3f, sizeof(f));
f[1][0][1] = w[1].a - w[1].b * x;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= cnt[i]; j++) {
for (int k = 0; k <= i - cnt[i]; k++) {
if (w[i].a == w[i - 1].a) {
if (k >= 1)
f[i][j][k] =
((f[i][j][k]) < (f[i - 1][j][k - 1] + w[i].a - w[i].b * x)
? (f[i][j][k])
: (f[i - 1][j][k - 1] + w[i].a - w[i].b * x));
if (j + 1 <= i - 1)
f[i][j][k] =
((f[i - 1][j + 1][k]) < (f[i][j][k]) ? (f[i - 1][j + 1][k])
: (f[i][j][k]));
}
if (w[i].a != w[i + 1].a) {
if (j + k <= i + 1)
f[i + 1][j + k][1] =
((f[i + 1][j + k][1]) <
(f[i][j][k] + w[i + 1].a - w[i + 1].b * x)
? (f[i + 1][j + k][1])
: (f[i][j][k] + w[i + 1].a - w[i + 1].b * x));
if (j + k - 1 >= 0 && j + k - 1 <= i + 1)
f[i + 1][j + k - 1][0] = ((f[i + 1][j + k - 1][0]) < (f[i][j][k])
? (f[i + 1][j + k - 1][0])
: (f[i][j][k]));
}
if (i == n)
if (f[i][j][k] <= 0) return 1;
}
}
}
return 0;
}
bool check(long long x) {
memset(f, 0, sizeof(f));
memset(v, 0, sizeof(v));
return dfs(1, 0, 0, x) <= 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i].a);
w[i].a *= 1000;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i].b);
}
sort(w + 1, w + n + 1, cmp);
for (int i = 1; i <= n; i++) {
if (w[i].a == w[i - 1].a)
cnt[i] = cnt[i - 1];
else
cnt[i] = i - 1;
}
long long l = 0, r = 1e13;
while (l + 1 < r) {
long long mid = (l + r) >> 1;
if (check(mid))
ans = ((ans) < (mid) ? (ans) : (mid)), r = mid;
else
l = mid;
}
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
struct edge {
int v, w;
edge(int v = 0, int w = 0) : v(v), w(w) {}
};
vector<edge> adj[105];
int sg[105][105][26][2];
bool dfs(int x, int y, int kw, int f) {
if (sg[x][y][kw][f] != -1) return sg[x][y][kw][f];
sg[x][y][kw][f] = 0;
int v, w;
if (f == 0) {
for (int k = 0; k < adj[x].size(); k++) {
v = adj[x][k].v;
w = adj[x][k].w;
if (w < kw) continue;
if (dfs(v, y, w, 1) == 0) {
sg[x][y][kw][f] = 1;
break;
}
}
} else {
for (int k = 0; k < adj[y].size(); k++) {
v = adj[y][k].v;
w = adj[y][k].w;
if (w < kw) continue;
if (dfs(x, v, w, 0) == 0) {
sg[x][y][kw][f] = 1;
break;
}
}
}
return sg[x][y][kw][f];
}
int main() {
cin >> N >> M;
int u, v;
char c;
for (int i = 1; i <= M; i++) {
cin >> u >> v >> c;
adj[u].push_back(edge(v, c - 'a'));
}
memset(sg, -1, sizeof(sg));
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (dfs(i, j, 0, 0))
cout << "A";
else
cout << "B";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long ans = 1, mod = 1e9 + 7;
for (int i = 2 * n; i >= 3; i--) {
ans = (ans * i) % mod;
}
ans %= mod;
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string alpha = "abcdefghijklmnopqrstuvwxyz";
const int MAX = 1e9 + 10;
const int N = 1e5 + 5;
const int J = 550;
const int K = 5500;
int n, k, minI{55}, minJ{55}, maxI{-1}, maxJ{-1};
char x;
int main() {
cin >> n >> k;
char arr[n][k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
cin >> arr[i][j];
if (arr[i][j] == '*') {
if (i < minI) minI = i;
if (j < minJ) minJ = j;
if (i > maxI) maxI = i;
if (j > maxJ) maxJ = j;
}
}
}
for (int i = minI; i <= maxI; i++) {
for (int j = minJ; j <= maxJ; j++) {
cout << arr[i][j];
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int n, m, be[maxn], k, ans[maxn], vis[maxn];
vector<int> G[maxn];
inline int read() {
char ch = getchar();
int u = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
u = u * 10 + ch - 48;
ch = getchar();
}
return u * f;
}
int main() {
n = read();
m = read();
for (register int i = 1; i <= m; i++) {
int x = read(), y = read();
G[x].push_back(y);
}
for (register int i = 1; i <= n; i++) {
if (be[i]) continue;
be[i] = i;
for (vector<int>::iterator u = G[i].begin(); u != G[i].end(); u++)
if (!be[*u]) be[*u] = i;
}
for (register int i = n; i >= 1; i--) {
if (vis[i] || be[i] != i) continue;
ans[++k] = i;
for (vector<int>::iterator u = G[i].begin(); u != G[i].end(); u++)
vis[*u] = 1;
}
printf("%d\n", k);
for (register int i = 1; i <= k; i++) printf("%d ", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void move(int *x, int i, int j, int &nret, int ret[1000000][2]) {
ret[nret][0] = i, ret[nret][1] = j, ++nret, x[i] ^= x[j];
}
void swap(int *x, int i, int j, int &nret, int ret[1000000][2]) {
move(x, i, j, nret, ret);
move(x, j, i, nret, ret);
move(x, i, j, nret, ret);
}
void gaussjord(int n, int *x, int &nret, int ret[1000000][2]) {
for (int i = (0); i < (n); ++i) {
{
int best = i;
for (int j = (i + 1); j < (n); ++j)
if (x[j] > x[best]) best = j;
if (best != i) swap(x, i, best, nret, ret);
}
for (int j = (i + 1); j < (n); ++j)
if ((x[i] ^ x[j]) < x[j]) move(x, j, i, nret, ret);
}
for (int i = n - 1; i >= 0; --i)
if (x[i] != 0) {
for (int j = (0); j < (i); ++j)
if ((x[i] ^ x[j]) < x[j]) move(x, j, i, nret, ret);
}
}
int n;
int s[10000];
int t[10000];
int ret1[1000000][2], nret1;
int ret2[1000000][2], nret2;
int ret[1000000][2], nret;
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &s[i]);
for (int i = (0); i < (n); ++i) scanf("%d", &t[i]);
nret1 = nret2 = 0;
gaussjord(n, s, nret1, ret1);
gaussjord(n, t, nret2, ret2);
for (int i = (0); i < (n); ++i) {
for (int j = (i); j < (n); ++j) {
if (s[j] == 0) break;
bool have = (s[i] ^ s[j]) < s[i];
bool want = (t[i] ^ s[j]) < t[i];
if (have != want) move(s, i, j, nret1, ret1);
}
}
for (int i = (0); i < (n); ++i)
if (s[i] != t[i]) {
printf("-1\n");
return;
}
printf("%d\n", nret1 + nret2);
for (int i = (0); i < (nret1); ++i)
printf("%d %d\n", ret1[i][0] + 1, ret1[i][1] + 1);
for (int i = nret2 - 1; i >= 0; --i)
printf("%d %d\n", ret2[i][0] + 1, ret2[i][1] + 1);
}
int main() {
run();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int const oo = 1e9, bound = 1e6 + 1, mod = oo + 7;
long long const OO = 1e18;
int n;
int aa[bound];
long long dp[bound][3][2];
long long rec(int idx, int tk, int sg) {
long long &ret = dp[idx][tk][sg];
if (ret != -1) return ret;
if (idx == n - 1) return ret = 0;
if (tk == 2) return ret = 0;
if (tk == 0)
return ret = max(rec(idx + 1, tk, sg),
rec(idx + 1, 1, 1) + abs(aa[idx] - aa[idx + 1]));
if (tk == 1)
return ret = max(rec(idx + 1, 2, !sg),
rec(idx + 1, tk, !sg) +
abs(aa[idx] - aa[idx + 1]) * (sg == 0 ? 1 : -1));
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int(i) = 0; (i) < (n); (i)++) scanf("%d", &aa[i]);
printf("%lld\n", rec(0, 0, 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long N;
long long inv[1000005];
long long c[1000005];
long long p3[1000005];
long long pw(long long a, long long x) {
if (x == 0)
return 1;
else {
long long ans = pw(a, x / 2);
if (x % 2)
return ans * ans % 998244353 * a % 998244353;
else
return ans * ans % 998244353;
}
}
long long d, x, y;
void exgcd(long long a, long long b) {
if (b == 0) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b);
long long temp = x;
x = y;
y = temp - a / b * y;
}
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
exgcd(i, 998244353);
inv[i] = (x % 998244353 + 998244353) % 998244353;
}
c[0] = 1;
for (int i = 1; i <= N; i++) {
c[i] = c[i - 1] * (N - i + 1) % 998244353 * inv[i] % 998244353;
}
p3[0] = 1;
for (int i = 1; i <= N; i++) {
p3[i] = p3[i - 1] * 3 % 998244353;
}
long long ans = 0;
ans =
(pw(3, N * N) - pw((p3[N] - 3 + 998244353) % 998244353, N) + 998244353) %
998244353;
ans = (2 * ans) % 998244353;
long long ans1 = 0;
for (int i = 1; i <= N; i++) {
if (i % 2)
ans1 = 998244353 - c[i];
else
ans1 = c[i];
ans1 = 3 * ans1 % 998244353 *
(pw((p3[N - i] - 1 + 998244353) % 998244353, N) -
pw(3, N * (N - i)) + 998244353) %
998244353;
ans = (ans - ans1 + 998244353) % 998244353;
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline bool vowel(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y';
}
int main() {
int n;
scanf("%d", &n);
vector<int> p;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
p.push_back(a);
}
getchar();
for (int i = 0; i < n; ++i) {
int cnt = 0;
char c;
while (c = getchar(), c != '\n') {
cnt += vowel(c);
}
if (cnt != p[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
string abc = "abcdefghijklmnopqrstuvwxyz";
string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string digits = "0123456789";
void solve() {
long long t;
cin >> t;
for (long long i = 0; i < t; i++) {
long long L, v, l, r;
cin >> L >> v >> l >> r;
cout << L / v - (r / v - (l - 1) / v) << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long n, d, dist;
scanf("%I64d %I64d", &n, &d);
long long arr[n];
for (long long i = 0; i < n; i++) {
scanf("%I64d", &arr[i]);
}
if (n < 3) {
printf("0\n");
return 0;
}
long long cnt = 0, j = 2, cn = 0;
for (long long i = 0; i < n - 2; i++) {
while (j < n) {
dist = arr[j] - arr[i];
if (dist <= d)
cn++;
else
break;
j++;
}
cnt += (cn * (cn + 1)) / 2;
cn -= 1;
}
printf("%I64d\n", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, l1, l2, r1, r2, l, r, k;
cin >> l1 >> r1 >> l2 >> r2 >> k;
if (l1 > r2 || r1 < l2) {
cout << 0 << endl;
} else {
l = max(l1, l2);
r = min(r1, r2);
if (l <= k && k <= r) {
cout << r - l << endl;
} else {
cout << r - l + 1 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fp(long long b, long long p) {
long long res = 1;
while (p) {
if (p % 2) res = (res * b) % 1000000007;
b = (b * b) % 1000000007;
p /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
if (k == -1 && n % 2 != m % 2)
return cout << 0, 0;
else
cout << fp(fp(2, (n - 1)), (m - 1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
namespace FastIO {
struct Reader {
private:
FILE* file;
std::vector<char> buffer;
int pos;
void read();
bool was;
public:
Reader(FILE* file_ = stdin, const int size_ = 1 << 16)
: file(file_), buffer(size_, '\0'), pos(0), was(true) {
read();
}
operator bool() const { return was; }
char getChar();
std::string getStr();
std::string getLine();
template <typename T>
T getInt();
template <typename T>
T getReal();
};
Reader& operator>>(Reader& reader, char& c) {
return c = reader.getChar(), reader;
}
Reader& operator>>(Reader& reader, std::string& s) {
return s = reader.getStr(), reader;
}
template <class T>
typename std::enable_if<std::is_floating_point<T>::value, Reader&>::type
operator>>(Reader& reader, T& t) {
return t = reader.getReal<T>(), reader;
}
template <class T>
typename std::enable_if<std::is_integral<T>::value, Reader&>::type operator>>(
Reader& reader, T& t) {
return t = reader.getInt<T>(), reader;
}
template <class T>
Reader& operator>>(Reader& reader, std::vector<T>& vec) {
for (auto& it : vec) {
reader >> it;
}
return reader;
}
struct Writer {
private:
FILE* file;
std::vector<char> buffer;
int pos;
public:
Writer(FILE* file_ = stdout, const int size_ = 1 << 16)
: file(file_), buffer(size_, '\0'), pos(0) {}
~Writer() { flush(); }
void flush() { putChar(EOF); }
void putChar(char c);
void putStr(const std::string&);
template <typename T>
void putInt(T value, int width = 0, char fill = ' ');
template <typename T>
void putReal(T value, int precision = 25, int width = 0, char fill = ' ');
};
Writer& operator<<(Writer& writer, const char c) {
return writer.putChar(c), writer;
}
Writer& operator<<(Writer& writer, const std::string& s) {
return writer.putStr(s), writer;
}
template <class T>
typename std::enable_if<std::is_floating_point<T>::value, Writer&>::type
operator<<(Writer& writer, const T& t) {
return writer.putReal(t), writer;
}
template <class T>
typename std::enable_if<std::is_integral<T>::value, Writer&>::type operator<<(
Writer& writer, const T& t) {
return writer.putInt(t), writer;
}
} // namespace FastIO
int main() {
FastIO::Reader cin;
FastIO::Writer cout;
int k, x = 1000000;
cin >> k;
cout << "2000\n";
for (int i = 1; i < 1999; i++) cout << "0 ";
while ((k + x) % 2000) --x;
cout << (k + x) / 2000 - x << " " << x;
return 0;
}
namespace FastIO {
void Reader::read() {
if (!buffer.empty()) {
buffer.resize(fread(&buffer[0], 1, (int)buffer.size(), file));
pos = 0;
}
}
char Reader::getChar() {
if (pos == (int)buffer.size()) {
read();
}
if (pos == (int)buffer.size()) {
was = false;
return EOF;
} else {
was = true;
return buffer[pos++];
}
}
std::string Reader::getStr() {
char c = ' ';
while (std::isspace(c)) {
c = getChar();
}
std::string answ;
while (c != EOF && !std::isspace(c)) {
answ.push_back(c);
c = getChar();
}
was = !answ.empty();
return answ;
}
std::string Reader::getLine() {
char c = '\n';
while (c == '\n') {
c = getChar();
}
std::string answ;
while (c != '\n' && c != EOF) {
answ.push_back(c);
c = getChar();
}
was = !answ.empty();
return answ;
}
template <typename T>
T Reader::getInt() {
char c = '?';
while (!(c == '-' || ('0' <= c && c <= '9') || c == EOF)) {
c = getChar();
}
bool positive = true;
if (c == '-') {
positive = false;
c = getChar();
}
T answ(0);
bool flag = false;
while ('0' <= c && c <= '9') {
flag = true;
(answ *= 10) += (c - '0');
c = getChar();
}
was = flag;
return positive ? answ : -answ;
}
template <typename T>
T Reader::getReal() {
bool flag = false;
char c = '?';
while (!(c == '-' || ('0' <= c && c <= '9') || c == EOF)) {
c = getChar();
}
bool positive = (c != '-');
if (c == '-') {
c = getChar();
}
long long first = 0;
while ('0' <= c && c <= '9') {
flag = true;
(first *= 10) += (c - '0');
c = getChar();
}
was = flag;
if (c != '.') {
return T(positive ? first : -first);
}
c = getChar();
long long second = 0, pow = 1;
while ('0' <= c && c <= '9') {
(second *= 10) += (c - '0');
c = getChar();
pow *= 10;
}
T answ = first + (T)second / (T)pow;
return positive ? answ : -answ;
}
void Writer::putChar(char c) {
if (pos == (int)buffer.size() || c == EOF) {
fwrite(&buffer[0], 1, pos, file);
pos = 0;
}
if (c != EOF) {
buffer[pos++] = c;
}
}
void Writer::putStr(const std::string& s) {
for (auto it : s) {
putChar(it);
}
}
template <typename T>
void Writer::putInt(T value, int width, char fill) {
bool positive = !(value < 0);
if (value < 0) {
value = -value;
}
char buf[24];
int p = 0;
do {
buf[p++] = char(value % 10 + '0');
value /= 10;
} while (value > 0);
if (!positive) {
buf[p++] = '-';
}
while (p < width) buf[p++] = fill;
while (p > 0) putChar(buf[--p]);
}
template <typename T>
void Writer::putReal(T value, int precision, int width, char fill) {
putInt((long long)value, width - precision - 1, fill);
value = std::abs(value - (long long)value);
if (precision == 0) {
return;
}
putChar('.');
while (precision >= 6) {
value *= 1000000;
putInt((int)value, 6, '0');
value -= (int)value;
precision -= 6;
}
while (precision >= 3) {
value *= 1000;
putInt((int)value, 3, '0');
value -= (int)value;
precision -= 3;
}
while (precision >= 1) {
value *= 10;
putInt((int)value, 1, '0');
value -= (int)value;
precision -= 1;
}
}
} // namespace FastIO
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long add(long long x, long long y) { return (x + y) % 1000000007; }
long long sub(long long x, long long y) {
return (x - y + 1000000007) % 1000000007;
}
long long mul(long long x, long long y) { return (x * y) % 1000000007; }
set<int> adj[400005];
set<int> cdtree[400005];
vector<vector<long long> > oddin;
vector<vector<long long> > evenin;
vector<vector<long long> > oddex;
vector<vector<long long> > evenex;
int val[400005];
int sz[400005];
int root;
int dad[400005];
int v;
long long ans;
int dfssz(int a, int p = -1) {
sz[a] = 1;
for (auto x : adj[a]) {
if (x != p) sz[a] += dfssz(x, a);
}
return sz[a];
}
int getcentriod(int v, int p, int n) {
for (auto x : adj[v]) {
if (x != p && sz[x] > n / 2) return getcentriod(x, v, n);
}
return v;
}
void indfs(int n, int p, long long pos, long long neg, int l, int cnt) {
if (l % 2 == 0) {
evenin[cnt].push_back(0ll + neg + val[n]);
neg = neg + val[n];
pos = pos - val[n];
} else {
oddin[cnt].push_back(0ll + pos + val[n]);
neg = neg - val[n];
pos = pos + val[n];
}
for (auto x : adj[n]) {
if (x != p) {
indfs(x, n, pos, neg, l + 1, cnt);
}
}
}
void outdfs(int n, int p, long long pos, long long neg, int l, int cnt) {
if (l % 2 == 0) {
evenex[cnt].push_back(0ll + neg + val[n]);
neg = neg + val[n];
pos = pos - val[n];
} else {
oddex[cnt].push_back(0ll + pos + val[n]);
neg = neg - val[n];
pos = pos + val[n];
}
for (auto x : adj[n]) {
if (x != p) {
outdfs(x, n, pos, neg, l + 1, cnt);
}
}
}
void conquer(int n) {
oddin.clear();
evenin.clear();
oddex.clear();
evenex.clear();
int cnt = 0;
int sz = adj[n].size() + 5;
oddin.resize(sz);
evenin.resize(sz);
oddex.resize(sz);
evenex.resize(sz);
for (auto x : adj[n]) {
cnt += 1;
indfs(x, n, val[n], -val[n], 2, cnt);
outdfs(x, n, 0, 0, 1, cnt);
}
long long oddexsum = 0;
long long evenexsum = 0;
long long evenexcnt = 0;
long long oddexcnt = 0;
for (int i = 1; i < sz; i++) {
for (auto x : oddex[i]) {
oddexcnt++;
oddexsum = add(oddexsum, x);
}
}
for (int i = 1; i < sz; i++) {
for (auto x : evenex[i]) {
evenexcnt++;
evenexsum = add(evenexsum, x);
}
}
for (int i = 1; i < sz; i++) {
long long insum = 0;
for (auto x : evenin[i]) {
insum = add(insum, x);
}
long long cntin = evenin[i].size();
long long cntout = oddexcnt;
long long outsum = oddexsum;
for (auto y : oddex[i]) {
cntout -= 1;
outsum = sub(outsum, y);
}
ans = add(ans, mul(outsum, cntin));
ans = add(ans, mul(insum, cntout));
}
for (int i = 1; i < sz; i++) {
long long insum = 0;
for (auto x : oddin[i]) {
insum = add(insum, x);
}
long long cntin = oddin[i].size();
long long cntout = evenexcnt;
long long outsum = evenexsum;
for (auto y : evenex[i]) {
cntout -= 1;
outsum = sub(outsum, y);
}
ans = add(ans, mul(outsum, cntin));
ans = add(ans, mul(insum, cntout + 2));
}
ans = add(ans, val[n]);
}
void divide(int a, int p) {
int n = dfssz(a, p);
int c = getcentriod(a, p, n);
if (p != -1) {
dad[c] = p;
cdtree[p].insert(c);
cdtree[c].insert(p);
} else
root = c;
conquer(c);
vector<int> temp(adj[c].begin(), adj[c].end());
for (auto x : temp) {
adj[x].erase(c);
adj[c].erase(x);
divide(x, c);
}
}
void decompose() { divide(1, -1); }
int main() {
cin >> v;
for (int i = 1; i < v + 1; i++) {
cin >> val[i];
}
for (int i = 0; i < v; i++) {
int a, b;
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
}
decompose();
cout << (ans + 1000000007) % 1000000007 << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int M = 20000;
bool ciekawe[4 * M + 7];
const int N = 60;
pair<int, int> ya[N + 7];
pair<int, int> yb[N + 7];
int wynik = 0;
bool znia[N + 7];
bool znib[N + 7];
int pom[4 * M + 7];
int dopchnij() {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = ya[i].first - yb[j].first;
int il = 0;
if (!znia[i]) il += ya[i].second;
if (!znib[j]) il += yb[j].second;
pom[2 * M + d] += il;
res = max(res, pom[2 * M + d]);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = ya[i].first - yb[j].first;
pom[2 * M + d] = 0;
}
}
return res;
}
void sprawdz(int d) {
set<int> xs;
int wyn = 0;
for (int i = 0; i < m; ++i) xs.insert(yb[i].first + d);
for (int i = 0; i < n; ++i) {
znia[i] = 0;
if (xs.find(ya[i].first) != xs.end()) {
znia[i] = 1;
wyn += ya[i].second;
}
}
xs.clear();
for (int i = 0; i < n; ++i) xs.insert(ya[i].first - d);
for (int i = 0; i < m; ++i) {
znib[i] = 0;
if (xs.find(yb[i].first) != xs.end()) {
znib[i] = 1;
wyn += yb[i].second;
}
}
wyn += dopchnij();
wynik = max(wynik, wyn);
}
int wczytaj(pair<int, int> (&y)[N + 7], int ile, int d) {
map<int, int> mapa;
for (int i = 1; i <= ile; ++i) {
int x;
cin >> x;
x *= d;
mapa[x]++;
}
int nn = 0;
for (auto u : mapa) {
y[nn++] = u;
}
return nn;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
n = wczytaj(ya, n, -1);
m = wczytaj(yb, m, 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = ya[i].first - yb[j].first;
ciekawe[2 * M + d] = 1;
}
}
for (int d = 0; d <= 4 * M + 5; ++d) {
if (ciekawe[d]) sprawdz(d - 2 * M);
}
cout << wynik << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char zf = 1;
char ch = getchar();
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') zf = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * zf;
}
void write(long long y) {
if (y < 0) putchar('-'), y = -y;
if (y > 9) write(y / 10);
putchar(y % 10 + 48);
}
void writeln(const long long y) {
write(y);
putchar('\n');
}
int m, n;
int main() {
for (register int T = read(); T; T--) {
int R1 = read() * 2, R2 = read() * 2, n = read();
double lim = R1 * 2;
double L = -lim / R2, R = -lim / R1, rr = (R - L) / 2;
;
double dis = sqrt((L + R) * (L + R) / 4 + n * n * (R - L) * (R - L));
printf("%.8f\n", (lim / (dis - rr) - lim / (dis + rr)) / 2);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
T &ctmax(T &x, const U &y) {
return x = max<T>(x, y);
}
template <typename T, typename U>
T &ctmin(T &x, const U &y) {
return x = min<T>(x, y);
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
vector<int> cur(n);
auto query = [&](const vector<int> &a) {
cout << int(a.size()) << " ";
for (auto i : a) cout << i + 1 << " ", cur[i] = true;
cout << endl;
int resp;
cin >> resp;
if (!~resp) exit(0);
--resp;
for (int i = 0; i < int(a.size()); ++i) cur[(i + resp) % n] = false;
};
auto answer = [&]() {
cout << "0\n";
exit(0);
};
if (n <= 3) {
answer();
}
array<int, 2> TEMP{};
for (auto d = 2; d <= n; ++d) {
int cnt = 0;
for (auto i = 0; i < n; ++i) {
if (i % d) {
++cnt;
}
}
ctmax(TEMP, array<int, 2>{cnt - d, d});
}
int d = TEMP[1];
while (1) {
vector<int> q;
for (auto i = 0; i < n; ++i) {
if (!cur[i] && i % d) {
q.push_back(i);
}
}
if (int(q.size()) < d) {
break;
}
query(q);
}
answer();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
long long int a[n * k];
for (long long int i = 0; i < n * k; i++) cin >> a[i];
long long int ans = 0;
long long int med = (n + 1) / 2;
for (long long int i = n * k - (n - med + 1); i >= 0 and k--;
i -= (n - med + 1)) {
ans += a[i];
}
cout << ans << "\n";
}
int32_t main() {
long long int T = 1;
cin >> T;
for (long long int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[111];
int main() {
while (cin >> n) {
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
arr[i] ^= arr[i - 1];
}
int ans = 0;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j <= n; ++j) ans = max(ans, arr[i] ^ arr[j]);
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 100000 + 5;
vector<pair<int, int> > E[100000 + 5];
int bridge[100000 + 5];
int dfn[N], low[N], idx = 0;
int min(int x, int y) { return x < y ? x : y; }
void tarjan(int p, int prep) {
int i, j;
dfn[p] = low[p] = ++idx;
for (i = 0; i < E[p].size(); i++) {
int f = E[p][i].first, road = E[p][i].second;
if (f == prep) continue;
if (dfn[f] == 0) {
tarjan(f, p);
if (low[f] > dfn[p]) bridge[road] = 1;
low[p] = min(low[p], low[f]);
} else {
low[p] = min(low[p], dfn[f]);
}
}
return;
}
int belong[N];
void dfs(int p, int prep, int b) {
belong[p] = b;
int i;
for (i = 0; i < E[p].size(); i++) {
int f = E[p][i].second;
if (bridge[f] == 0 && belong[E[p][i].first] == 0) {
dfs(E[p][i].first, p, b);
}
}
}
vector<int> T[100000 + 5];
vector<pair<int, int> > Edge;
int fa[100000 + 5][20];
int dep[N];
void build(int a, int pre, int d) {
fa[a][0] = pre;
dep[a] = d;
int i;
for (i = 0; i < T[a].size(); i++) {
if (T[a][i] != pre) build(T[a][i], a, d + 1);
}
}
int solve(int a, int b) {
int tmpa = a, tmpb = b;
if (dep[a] < dep[b]) swap(a, b);
int i;
if (dep[a] != dep[b]) {
for (i = 19; i >= 0; i--) {
if (dep[fa[a][i]] >= dep[b]) {
a = fa[a][i];
}
}
}
for (i = 19; i >= 0; i--) {
if (fa[a][i] != fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
int lca;
if (a == b)
lca = a;
else
lca = fa[a][0];
return dep[tmpa] - dep[lca] + dep[tmpb] - dep[lca];
}
int main() {
int i, j, k;
int n, m;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
E[a].push_back(make_pair(b, i - 1));
E[b].push_back(make_pair(a, i - 1));
Edge.push_back(make_pair(a, b));
}
tarjan(1, 0);
int c = 0;
for (i = 1; i <= n; i++) {
if (belong[i] == 0) {
c++;
dfs(i, 0, c);
}
}
for (i = 0; i < m; i++) {
if (bridge[i] == 1) {
int a = belong[Edge[i].first];
int b = belong[Edge[i].second];
T[a].push_back(b);
T[b].push_back(a);
}
}
build(1, 0, 0);
for (i = 1; i <= 19; i++) {
for (j = 1; j <= c; j++) {
fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
}
int q = 0;
scanf("%d", &q);
for (i = 1; i <= q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a = belong[a];
b = belong[b];
printf("%d\n", solve(a, b));
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z;
const int N = 1e2 + 5;
int given[N], recieved[N];
int main() {
cin >> n >> m;
if (m == 0) {
cout << 0;
return 0;
}
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
given[x] += z;
recieved[y] += z;
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (given[i] > recieved[i]) {
sum += abs(recieved[i] - given[i]);
}
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
bool t = true;
int a[n];
for (long long i = 0; i < (n); i++) {
cin >> a[i];
if (a[i] == 1) t = false;
}
if (t)
cout << "EASY" << endl;
else
cout << "HARD" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int carry[100008], limit[100008], fuel[100008];
vector<pair<int, int> > c, wc;
int main() {
int n, d, S;
cin >> n >> d >> S;
int total = 0, id = -1, cost = 1e9 + 2;
for (int i = 0; i < n; i++) {
cin >> carry[i] >> fuel[i] >> limit[i];
total += carry[i];
if (total >= n) total = n - 1;
if (limit[i] >= d) {
if (carry[i] == 0) wc.push_back(pair<int, int>(fuel[i], i));
c.push_back(pair<int, int>(fuel[i], i));
if (carry[i] && fuel[i] < cost && fuel[i] <= S) cost = fuel[i], id = i;
}
}
sort(c.begin(), c.end());
sort(wc.begin(), wc.end());
if (id == -1)
total = 0;
else
total++;
for (int i = 0; i < c.size(); i++) {
if (total == n) break;
if (c[i].second == id) continue;
if (cost + c[i].first > S) break;
cost += c[i].first, total++;
}
int nocarry = 0, nocarrycost = 0;
for (int i = 0; i < wc.size(); i++) {
if (nocarrycost + wc[i].first > S) break;
nocarrycost += wc[i].first, nocarry++;
}
if (total < nocarry || (total == nocarry && cost > nocarrycost))
total = nocarry, cost = nocarrycost;
cout << total << " " << cost << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
int arr[3] = {0};
for (int i = 0; i < n; i++) {
int a;
cin >> a;
arr[a - 1]++;
v.push_back(a);
}
int min = INT_MAX;
for (int i = 0; i < 3; i++) {
if (arr[i] < min) min = arr[i];
if (arr[i] == 0) {
cout << 0;
return 0;
}
}
std::cout << min << std::endl;
auto pt = v.begin(), mt = v.begin(), pdt = v.begin();
while (min--) {
pt = find(pt, v.end(), 1);
mt = find(mt, v.end(), 2);
pdt = find(pdt, v.end(), 3);
std::cout << pt - v.begin() + 1 << ' ' << mt - v.begin() + 1 << ' '
<< pdt - v.begin() + 1 << std::endl;
pt++;
mt++;
pdt++;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
int n, m, mod, cnt, s[maxn + 10], father[maxn + 10];
int find(int x) { return x == father[x] ? x : father[x] = find(father[x]); }
int powe(int base, int p) {
int res = 1;
for (; p >= 1; p >>= 1, base = 1ll * base * base % mod)
if (p & 1) res = 1ll * res * base % mod;
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &mod);
if (mod == 1) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; ++i) father[i] = i;
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x = find(x);
y = find(y);
if (x != y) father[x] = y;
}
for (int i = 1; i <= n; ++i) ++s[find(i)];
int ans = 1;
for (int i = 1; i <= n; ++i)
if (s[i]) ans = 1ll * ans * s[i] % mod, ++cnt;
printf("%d\n", cnt == 1 ? 1 : 1ll * ans * powe(n, cnt - 2) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, L = 20;
int n, m, q;
vector<int> adj[N];
vector<int> C[N][L];
int to[N][L];
int dep[N];
void dfs(int u, int p) {
to[u][0] = p;
dep[u] = 1 + dep[p];
for (auto v : adj[u])
if (v != p) dfs(v, u);
}
vector<int> relax(vector<int> v) {
vector<int> ret;
ret.clear();
sort(v.begin(), v.end());
for (int i = 0; i < v.size() && i < 10; i++) ret.push_back(v[i]);
return ret;
}
vector<int> mrg(vector<int> a, vector<int> b) {
for (int B : b) a.push_back(B);
return relax(a);
}
vector<int> query(int u, int v) {
if (u == v) {
return C[u][0];
}
if (dep[u] < dep[v]) swap(u, v);
vector<int> ret;
ret.clear();
int k = dep[u] - dep[v];
for (int i = 0; i < L; i++)
if (k & (1 << i)) {
ret = mrg(ret, C[u][i]);
u = to[u][i];
}
if (u == v) {
ret = mrg(ret, C[u][0]);
return ret;
}
for (int i = L - 1; i >= 0; i--) {
if (to[u][i] != to[v][i]) {
ret = mrg(ret, C[u][i]);
ret = mrg(ret, C[v][i]);
u = to[u][i];
v = to[v][i];
}
}
ret = mrg(ret, C[u][0]);
ret = mrg(ret, C[v][0]);
u = to[u][0];
ret = mrg(ret, C[u][0]);
return ret;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &u);
C[u][0].push_back(i);
}
for (int i = 1; i <= n; i++) {
C[i][0] = relax(C[i][0]);
}
dfs(1, 0);
for (int j = 1; j < L; j++) {
for (int i = 1; i <= n; i++) {
to[i][j] = to[to[i][j - 1]][j - 1];
C[i][j] = mrg(C[i][j - 1], C[to[i][j - 1]][j - 1]);
}
}
int a;
while (q--) {
scanf("%d %d %d", &u, &v, &a);
vector<int> ans = query(u, v);
printf("%d ", min(int(ans.size()), a));
for (int i = 0; i < a && i < ans.size(); i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int MAX_M = 100000;
const long long LINF = 1LL << 62;
long long bss[MAX_M + 1], bns[MAX_M];
long long calcf(long long asum, int k) {
int i = lower_bound(bns, bns + k, asum) - bns;
long long minc = LINF;
if (i > 0) minc = min(minc, asum - bns[i - 1]);
if (i < k) minc = min(minc, bns[i] - asum);
return minc;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
int k = m - n + 1;
long long asum = 0;
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
asum += ai * ((i & 1) ? -1 : 1);
}
for (int i = 0; i < m; i++) {
int bi;
scanf("%d", &bi);
bss[i + 1] = bss[i] + bi * ((i & 1) ? -1 : 1);
}
for (int i = 0; i < k; i++)
bns[i] = (bss[i + n] - bss[i]) * ((i & 1) ? -1 : 1);
sort(bns, bns + k);
printf("%lld\n", calcf(asum, k));
while (q--) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
l--;
if ((r - l) & 1) asum += x * ((l & 1) ? -1 : 1);
printf("%lld\n", calcf(asum, k));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int n, m, k, c[maxn], f[maxn][maxn][25];
char s[maxn], t[maxn];
int main() {
cin >> n >> m >> k;
scanf("%s", 1 + s);
scanf("%s", 1 + t);
int l, i, j;
for (l = 2; l <= 2 * k + 1; l++) {
if (l & 1) {
memset(c, 0, sizeof(c));
for (i = l / 2; i <= n; i++)
for (j = l / 2; j <= m; j++) {
c[j] = max(c[j], max(c[j - 1], f[i][j][l - 1]));
f[i][j][l] = c[j];
}
} else {
for (i = l / 2; i <= n; i++)
for (j = l / 2; j <= m; j++)
if (s[i] == t[j])
f[i][j][l] = 1 + max(f[i - 1][j - 1][l], f[i - 1][j - 1][l - 1]);
}
}
cout << f[n][m][2 * k + 1];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[300030];
char t[5] = "ACGT";
int min_score = 2e9;
string ans[300030];
string f[300030];
void update() {
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (f[i][j] != s[i][j]) cnt++;
}
if (cnt < min_score) {
min_score = cnt;
for (int i = 0; i < n; i++) ans[i] = f[i];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) cin >> s[i];
int p[4];
for (int i = 0; i < 4; i++) p[i] = i;
for (int i = 0; i < n; i++) f[i].resize(m);
while (1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) f[i][j] = t[p[2 * (i & 1) + (j & 1)]];
update();
for (int j = 0; j < m; j++) {
int q = 2 * (j & 1);
int odd = 0, even = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] != t[p[q + (i & 1)]]) odd++;
if (s[i][j] != t[p[q + (1 ^ (i & 1))]]) even++;
}
if (odd < even) {
for (int i = 0; i < n; i++) f[i][j] = t[p[q + (i & 1)]];
} else {
for (int i = 0; i < n; i++) f[i][j] = t[p[q + (1 ^ (i & 1))]];
}
}
update();
for (int i = 0; i < n; i++) {
int q = 2 * (i & 1);
int odd = 0, even = 0;
for (int j = 0; j < m; j++) {
if (s[i][j] != t[p[q + (j & 1)]]) odd++;
if (s[i][j] != t[p[q + (1 ^ (j & 1))]]) even++;
}
if (odd < even) {
for (int j = 0; j < m; j++) f[i][j] = t[p[q + (j & 1)]];
} else {
for (int j = 0; j < m; j++) f[i][j] = t[p[q + (1 ^ (j & 1))]];
}
}
update();
if (!next_permutation(p, p + 4)) break;
}
for (int i = 0; i < n; i++) cout << ans[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5;
void solve() {
int n;
cin >> n;
int a[2 * n];
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < 2 * n; i += 2) {
int j = 2 * n;
while (a[--j] != a[i])
;
while (j - 1 > i) {
swap(a[j - 1], a[j]);
++ans;
--j;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i, j, k, l, h;
scanf("%d", &n);
int x[n], y[n], left = 0, right = 0, upper = 0, lower = 0, count = 0;
for (i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i != j) {
if (x[j] == x[i] && y[j] > y[i]) {
lower = 1;
}
if (x[j] == x[i] && y[j] < y[i]) {
upper = 1;
}
if (x[j] > x[i] && y[j] == y[i]) {
right = 1;
}
if (x[j] < x[i] && y[j] == y[i]) {
left = 1;
}
}
}
if (right == 1 && left == 1 && lower == 1 && upper == 1) {
count++;
}
right = left = upper = lower = 0;
}
printf("%d", count);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using uint = unsigned int;
using cat = long long;
using dbl = long double;
constexpr dbl pi = 3.14159265358979323846;
using namespace std;
template <typename T>
T abs(T x) {
return (x < 0) ? (-x) : x;
}
cat pw(cat a, cat e, cat mod) {
if (e <= 0) return 1;
cat x = pw(a, e / 2, mod);
x = x * x % mod;
return (e & 1) ? x * a % mod : x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int N, M;
cat mod;
cin >> N >> M >> mod;
vector<cat> fac(N + 1, 1), inv(N + 1, 1);
for (int i = 1; i <= N; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = inv[i - 1] * pw(i, mod - 2, mod) % mod;
}
vector<cat> cnt(M + 1, 0);
vector<cat> sum(M + 1, 0);
cnt[0] = 1;
for (int m = 1; m <= M; m++) {
for (int k = 0; k < m; k++) {
cat cl = cnt[k] * inv[k] % mod,
cr = cnt[m - 1 - k] * inv[m - 1 - k] % mod;
cat sl = sum[k] * inv[k] % mod,
sr = sum[m - 1 - k] * inv[m - 1 - k] % mod;
cnt[m] += cl * cr % mod * (m + 1);
sum[m] += (cl * sr + sl * cr) % mod * (m + 1);
sum[m] += cl * cr % mod * (k * (k + 1) + (m - k) * (m - k - 1)) / 2 % mod;
}
cnt[m] = cnt[m] % mod * fac[m - 1] % mod;
sum[m] = sum[m] % mod * fac[m - 1] % mod;
}
vector<vector<cat> > cnt_ans(N + 1, vector<cat>(M + 1, 0));
vector<vector<cat> > sum_ans(N + 1, vector<cat>(M + 1, 0));
cnt_ans[0][0] = 1;
for (int i = 1; i <= N; i++) {
cnt_ans[i] = cnt_ans[i - 1];
sum_ans[i] = sum_ans[i - 1];
if (i <= M) {
cnt_ans[i][i] = cnt[i] * inv[i] % mod;
sum_ans[i][i] = sum[i] * inv[i] % mod;
}
for (int j = 0; j <= min(i - 1, M); j++)
for (int k = 1; k <= j; k++) {
cat c = cnt[k] * inv[k] % mod;
cat s = sum[k] * inv[k] % mod;
cnt_ans[i][j] = (cnt_ans[i][j] + cnt_ans[i - 1 - k][j - k] * c) % mod;
sum_ans[i][j] = (sum_ans[i][j] + sum_ans[i - 1 - k][j - k] * c +
cnt_ans[i - 1 - k][j - k] * s) %
mod;
}
}
cat ans = sum_ans[N][M] * fac[M] % mod;
cout << ans << "\n";
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int OO = 0x3f3f3f3f, N = 2e5 + 7;
int a[N];
int n, x, y;
int main() {
cin >> n >> x >> y;
unordered_map<int, int> idx;
for (int i = 0; i < n; ++i) {
cin >> a[i];
idx[a[i]] = i;
}
int ans = -1;
for (int i = 0; i < n; ++i) {
int c1 = 0, c2 = 0;
for (int j = i - x; j < i; ++j) {
if (j < 0 || a[j] > a[i]) {
c1++;
}
}
for (int j = i + 1; j <= i + y; ++j) {
if (a[j] > a[i] || a[j] == 0) {
c2++;
}
}
if (c1 == x && c2 == y) {
ans = i + 1;
break;
}
}
if (~ans) {
cout << ans;
} else {
cout << n;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
int n, a[MAXN], ans;
int main() {
cin >> n;
if (n <= 2 || n % 2 == 0) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 2; i--) {
while (a[i] && i & 1) {
int x = (i - 1) / 2;
a[i]--;
a[x] -= (a[x]) ? 1 : 0;
a[2 * x] -= (a[2 * x]) ? 1 : 0;
ans++;
}
while (a[i] && i % 2 == 0) {
int x = i / 2;
a[i]--;
a[x] -= (a[x]) ? 1 : 0;
a[2 * x + 1] -= (a[2 * x + 1]) ? 1 : 0;
ans++;
}
}
ans += a[1];
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n), b(n, -1);
map<int, set<int> > who_have_the_quantity;
for (int i = 0; i < n; i++) {
cin >> a[i];
who_have_the_quantity[n - a[i]].insert(i);
}
bool can_be = true;
int type_to_use_now = 0;
for (map<int, set<int> >::iterator it = who_have_the_quantity.begin();
it != who_have_the_quantity.end(); it++) {
if (it->second.size() % it->first != 0) {
can_be = false;
break;
} else {
int num_groups = it->second.size() / it->first;
int iii = 0;
for (set<int>::iterator sit = it->second.begin(); sit != it->second.end();
sit++, iii++) {
if (iii % it->first == 0) {
type_to_use_now++;
}
b[*sit] = type_to_use_now;
}
}
}
if (can_be) {
cout << "Possible\n";
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
} else {
cout << "Impossible\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[200001], l[200001], r[200001], ans[200001];
int main() {
int n, x;
while (cin >> n) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
x = i - 1;
while (x >= 0 && a[x] >= a[i]) x = l[x];
l[i] = x;
}
for (int i = n - 1; i >= 0; i--) {
x = i + 1;
while (x < n && a[x] >= a[i]) x = r[x];
r[i] = x;
}
memset(ans, 0, sizeof(ans));
for (int i = 0; i < n; i++) {
x = r[i] - l[i] - 1;
ans[x] = max(ans[x], a[i]);
}
for (int i = n; i >= 1; i--) ans[i] = max(ans[i], ans[i + 1]);
for (int i = 1; i <= n; i++)
if (i == 1)
printf("%d", ans[i]);
else
printf(" %d", ans[i]);
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<string> seqs(string s, string v) {
auto_ptr<stringstream> sst;
vector<string> ret;
for (int i = 0; i < s.size(); i++) {
if (sst.get() == NULL) {
if (s[i] == v[0] || s[i] == v[1]) {
sst.reset(new stringstream());
*sst.get() << s[i];
}
} else {
if (s[i] == v[0] || s[i] == v[1]) {
*sst.get() << s[i];
} else {
ret.push_back(sst->str());
sst.release();
}
}
}
if (sst.get() != NULL) {
ret.push_back(sst->str());
}
return ret;
}
int count(string s, string t) {
int ret[2] = {0, 0};
for (int i = 0; i < s.size(); i++) {
if (s[i] == t[0])
ret[0]++;
else
ret[1]++;
}
return min(ret[0], ret[1]);
}
int main(int argc, char *argv[]) {
string str;
int n;
cin >> str >> n;
vector<string> v(n);
for (size_t i = 0; i < n; ++i) {
cin >> v[i];
}
int ret = 0;
for (int i = 0; i < n; i++) {
vector<string> w = seqs(str, v[i]);
for (int j = 0; j < w.size(); j++) {
ret += count(w[j], v[i]);
}
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, M = 5e5 + 9, MOD = 1e9 + 7;
vector<int> adj[N];
string str;
vector<pair<int, int>> qu[N];
int dep[N], sz[N];
bool ans[N], big[N], cnt[N][26];
void pre(int node, int par, int d) {
sz[node] = 1;
dep[node] = d;
for (auto it : adj[node]) {
if (it == par) continue;
pre(it, node, d + 1);
sz[node] += sz[it];
}
}
void upd(int node, int par) {
cnt[dep[node]][str[node] - 'a'] ^= 1;
for (auto it : adj[node]) {
if (it != par && !big[it]) upd(it, node);
}
}
void dfs(int node, int par, int keep) {
int bigChild = -1, mx = 0;
for (auto it : adj[node]) {
if (par == it) continue;
if (sz[it] > mx) {
mx = sz[it];
bigChild = it;
}
}
for (auto it : adj[node]) {
if (par == it || it == bigChild) continue;
dfs(it, node, 0);
}
if (bigChild != -1) {
dfs(bigChild, node, 1);
big[bigChild] = 1;
}
upd(node, par);
for (auto it : qu[node]) {
int can = 0;
for (int i = 0; i < 26; ++i) can += cnt[it.first][i];
if (can <= 1) ans[it.second] = 1;
}
if (bigChild != -1) big[bigChild] = 0;
if (!keep) upd(node, par);
}
void runtestcase() {
int n, q, x, dep;
cin >> n >> q;
for (int i = 2; i <= n; ++i) {
cin >> x;
adj[x].push_back(i);
}
cin >> str;
str = "$" + str;
for (int i = 0; i < q; ++i) {
cin >> x >> dep;
qu[x].push_back({dep, i});
}
pre(1, 1, 1);
dfs(1, 1, 0);
for (int i = 0; i < q; ++i) cout << (ans[i] ? "Yes" : "No") << '\n';
}
int main() {
cout << fixed << setprecision(12), ios::sync_with_stdio(false),
cin.tie(nullptr), cout.tie(nullptr);
int t = 1, tt = 1;
while (t) {
runtestcase();
--t, ++tt;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[222222], tree[888888], dep[222222], mn, num, l, r, mid, lazy[888888];
pair<int, int> mtree[888888];
pair<int, int> query(int beg, int en, int l, int r, int node) {
if (l > en || r < beg) return make_pair(1e9, 1e9);
if (l >= beg && r <= en) return mtree[node];
int mid = (l + r) >> 1;
return min(query(beg, en, l, mid, node << 1),
query(beg, en, mid + 1, r, (node << 1) | 1));
}
void build(int l, int r, int node) {
if (l == r) {
mtree[node] = make_pair(a[l], l);
return;
}
int mid = (l + r) >> 1;
build(l, mid, node << 1);
build(mid + 1, r, (node << 1) | 1);
mtree[node] = min(mtree[node << 1], mtree[(node << 1) | 1]);
}
void build2(int l, int r, int d) {
int x = query(l, r, 1, n, 1).second;
dep[x] = d;
if (l < x) build2(l, x - 1, d + 1);
if (x < r) build2(x + 1, r, d + 1);
}
void pushup(int node) {
tree[node] = max(tree[node << 1], tree[(node << 1) | 1]);
}
void build3(int l, int r, int node) {
if (l == r) {
tree[node] = dep[l];
return;
}
int mid = (l + r) >> 1;
build3(l, mid, node << 1);
build3(mid + 1, r, (node << 1) | 1);
pushup(node);
}
void push(int node, int x) {
lazy[node] += x;
tree[node] += x;
}
void pushdown(int node) {
if (lazy[node]) {
push(node << 1, lazy[node]);
push((node << 1) | 1, lazy[node]);
lazy[node] = 0;
}
}
void update(int beg, int en, int l, int r, int node, int x) {
if (l > en || r < beg) return;
if (l >= beg && r <= en) {
push(node, x);
return;
}
int mid = (l + r) >> 1;
pushdown(node);
update(beg, en, l, mid, node << 1, x);
update(beg, en, mid + 1, r, (node << 1) | 1, x);
pushup(node);
}
void upd(int x, int l, int r, int node, int y) {
if (l == r) {
tree[node] = y;
return;
}
int mid = (l + r) >> 1;
pushdown(node);
if (x > mid)
upd(x, mid + 1, r, (node << 1) | 1, y);
else
upd(x, l, mid, node << 1, y);
pushup(node);
}
stack<int> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
build2(1, n, 1);
build3(1, n, 1);
mn = tree[1];
num = 0;
for (int i = 1; i <= n; i++) {
while (!s.empty() && s.top() >= a[i]) s.pop();
s.push(a[i]);
}
for (int i = 1; i < n; i++) {
if (query(i + 1, n, 1, n, 1).first < a[i]) {
l = i + 1;
r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query(i + 1, mid, 1, n, 1).first > a[i])
l = mid + 1;
else
r = mid - 1;
}
update(i + 1, r, 1, n, 1, -1);
} else {
l = 1;
r = i - 1;
while (l <= r) {
mid = (l + r) >> 1;
if (query(1, mid, 1, n, 1).first > a[i])
l = mid + 1;
else
r = mid - 1;
}
update(i + 1, n, 1, n, 1, -1);
update(1, r, 1, n, 1, -1);
}
if (query(1, i - 1, 1, n, 1).first < a[i]) {
l = 1;
r = i - 1;
while (l <= r) {
mid = (l + r) >> 1;
if (query(mid, i - 1, 1, n, 1).first > a[i])
r = mid - 1;
else
l = mid + 1;
}
update(l, i - 1, 1, n, 1, 1);
} else {
l = i + 1;
r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query(mid, n, 1, n, 1).first > a[i])
r = mid - 1;
else
l = mid + 1;
}
update(l, n, 1, n, 1, 1);
update(1, i - 1, 1, n, 1, 1);
}
while (!s.empty() && s.top() >= a[i]) s.pop();
s.push(a[i]);
upd(i, 1, n, 1, (int)s.size());
if (tree[1] < mn) {
mn = tree[1];
num = i;
}
}
printf("%d %d\n", mn, num);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
const int MOD = (int)1e9 + 7;
long long pow(long long base, long long exp, long long mod) {
long long result = 1;
while (exp > 0) {
if (exp & 1) result *= base;
base *= base;
if (base > mod) base %= mod;
if (result > mod) result %= mod;
exp /= 2;
}
return result;
}
long long mult(long long A, long long B) {
if (B == 0) return 0;
long long u = mult(A, B / 2);
long long res;
if (B % 2 == 0)
res = u + u;
else
res = u + u + A;
while (res >= MOD) res -= MOD;
return res;
}
long long n, num;
vector<long long> nums;
void inp() {
for (long long i = 0; i < n; i++) {
cin >> num;
nums.push_back(num);
}
}
long long _sieve_size;
bitset<10000010> bs;
vector<int> primes;
void sieve(long long upperbound) {
_sieve_size = upperbound + 1;
bs.set();
bs[0] = bs[1] = 0;
for (long long i = 2; i <= _sieve_size; i++)
if (bs[i]) {
for (long long j = i * i; j <= _sieve_size; j += i) bs[j] = 0;
primes.push_back((int)i);
}
}
bool isprime(int a) {
for (int i = 2; i * i <= a; i++)
if (a % i == 0) return false;
return true;
}
int lcs(string a, string b) {
int arr[150][150];
for (long long i = 0; i < a.size() + 1; i++) arr[i][0] = 0;
for (long long j = 0; j < b.size() + 1; j++) arr[0][j] = 0;
for (long long i = 1; i < a.size() + 1; i++)
for (long long j = 1; j < b.size() + 1; j++) {
if (a[i - 1] == b[j - 1])
arr[i][j] = 1 + arr[i - 1][j - 1];
else
arr[i][j] = ((arr[i - 1][j]) > (arr[i][j - 1]) ? (arr[i - 1][j])
: (arr[i][j - 1]));
}
return arr[a.size()][b.size()];
}
bool sorted(int s, int e) {
for (long long i = s; i < e; i++)
if (nums[i] > nums[i + 1]) return false;
return true;
}
bool comp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
if (a.first != b.first) return a.first > b.first;
return (a.second.first - a.second.second + 1) <
(b.second.first - b.second.second + 1);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
inp();
map<int, int> c, s, e;
for (long long i = 0; i < n; i++) {
c[nums[i]]++;
e[nums[i]] = i;
s[nums[i]] = -1;
}
for (long long i = 0; i < n; i++)
if (s[nums[i]] == -1) s[nums[i]] = i;
vector<pair<int, pair<int, int> > > ps;
map<int, int>::iterator it;
for (it = c.begin(); it != c.end(); ++it)
ps.push_back(make_pair(it->second, make_pair(e[it->first], s[it->first])));
sort((ps).begin(), (ps).end(), comp);
cout << ps[0].second.second + 1 << " " << ps[0].second.first + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long n, k, f[N];
char s[5];
inline long long read() {
long long ret = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + (ch ^ 48);
ch = getchar();
}
return ret * ff;
}
void write(long long x) {
if (x < 0) {
x = -x, putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
void writeln(long long x) { write(x), puts(""); }
void writesp(long long x) { write(x), putchar(' '); }
long long ksm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % 1000000007;
y >>= 1;
x = x * x % 1000000007;
}
return res;
}
long long find(long long x) { return f[x] == -1 ? x : f[x] = find(f[x]); }
bool merge(long long x, long long y) {
long long tx = find(x), ty = find(y);
if (find(x ^ 1) == ty) return 0;
if (find(y ^ 1) == tx) return 0;
if (tx != ty) f[tx] = ty;
return 1;
}
bool check(long long l, long long r, long long t) {
if (t == 0) {
return merge(l * 2, r * 2) && merge(l * 2 + 1, r * 2 + 1);
} else {
return merge(l * 2, r * 2 + 1) && merge(l * 2 + 1, r * 2);
}
}
signed main() {
n = read(), k = read();
memset(f, -1, sizeof(f));
for (long long i = 1; i <= k; i++) {
long long x = read() - 1, y = read() - 1;
long long l = x - y, r = x + y;
if (l < 0) l = -l;
if (r > n - 1) r = (n - 1) * 2 - r;
scanf("%s", s);
if (!check(l, r + 2, s[0] == 'x' ? 0 : 1)) {
write(0);
return 0;
}
}
long long ans = 0;
for (long long i = 0; i <= (n + 2) * 2; i++)
if (find(i) == i) ans++;
write(ksm(2, ans / 2 - 2));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, k, z, x, s, a[31], v[31][101], c[31];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> t;
for (int zxc = 1; zxc <= t; zxc++) {
cin >> n >> k;
for (int i = 1; i <= 30; i++)
for (int j = 1; j <= 100; j++) v[i][j] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
long long z = a[i];
long long x = 0;
while (z != 0) {
x++;
v[i][x] = z % k;
z /= k;
}
}
int ff = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 100; j++) {
if (v[i][j] > 1) {
ff = 1;
break;
}
}
if (ff == 1) break;
}
if (ff == 1)
cout << "NO"
<< "\n";
else {
for (int j = 1; j <= 100; j++) {
long long x = 0;
for (int i = 1; i <= n; i++)
if (v[i][j] == 1) x++;
if (x > 1) {
ff = 1;
break;
}
}
if (ff == 1)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double y1, y2, yw, x, y, r;
while (~scanf("%lf%lf%lf%lf%lf%lf", &y1, &y2, &yw, &x, &y, &r)) {
double xw = x * (yw - r - r - y1) / (yw + yw - r - r - r - y1 - y);
if (xw <= 0 || xw >= x) {
printf("-1\n");
continue;
}
double k = (yw - y1 - r - r) / xw;
double b = y1 + r;
double d = fabs(b - y2) / sqrt(k * k + 1);
if (d >= r)
printf("%.10lf\n", xw);
else
printf("-1\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tests;
cin >> tests;
while (tests--) {
int n, m;
cin >> n >> m;
cout << ((n * m) + 1) / 2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int n, k, dp[2010][2010];
void Pregenerate() {
int j, l, r;
long long int res = 0;
for (r = k; r; r--) {
for (l = n; l; l--) {
if (r == k)
res = 1;
else {
res = 0;
for (j = l; j <= n; j += l) res = res + dp[j][r + 1];
}
dp[l][r] = (res % 1000000007);
}
}
}
int main() {
int i, j;
while (scanf("%d %d", &n, &k) != EOF) {
Pregenerate();
long long int res = 0;
for (i = 1; i <= n; i++) res = res + dp[i][1];
res = (res % 1000000007);
printf("%I64d\n", res);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 100 * 100 * 100 * 2, mod = 1000000007;
long long n, m;
bool r[MN], mark[MN];
vector<pair<long long, long long> > g[MN];
vector<pair<pair<long long, long long>, int> > e;
void dfs(long long v, long long col) {
if (!col) r[v] = 1;
if (mark[v]) return;
mark[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (mark[g[v][i].first]) continue;
if (col) {
if (g[v][i].second)
dfs(g[v][i].first, 1);
else
dfs(g[v][i].first, 0);
} else {
if (g[v][i].second)
dfs(g[v][i].first, 0);
else
dfs(g[v][i].first, 1);
}
}
}
long long pw(long long x) {
if (x == 0) return 1;
long long ret = pw(x / 2);
ret = ret * ret;
ret = ret % mod;
if (x % 2) ret = ret * 2;
ret = ret % mod;
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y, c;
cin >> x >> y >> c;
x--, y--;
g[x].push_back(pair<long long, long long>(y, c));
g[y].push_back(pair<long long, long long>(x, c));
e.push_back(make_pair(pair<long long, long long>(x, y), c));
}
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (mark[i]) continue;
cnt++;
for (int j = 0; j < g[i].size(); j++) dfs(g[i][j].first, g[i][j].second);
}
for (int i = 0; i < e.size(); i++) {
if ((e[i].second == 1 && r[e[i].first.first] != r[e[i].first.second]) ||
(e[i].second == 0 && r[e[i].first.first] == r[e[i].first.second])) {
cout << 0;
return 0;
}
}
cout << pw(cnt - 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
long long mod = 1e9 + 7;
long long power(long long base, long long exponent, long long modx = mod) {
long long ret = 1 % modx;
base %= modx;
while (exponent) {
if (exponent & 1) {
ret = (ret * base) % modx;
}
base = (base * base) % modx;
exponent >>= 1;
}
return ret;
}
long long inv(long long val, long long modx = mod) {
return power(val, modx - 2, modx);
}
vector<long long> fac, ifac;
void preFac(long long sz) {
fac.resize(sz + 1), ifac.resize(sz + 1);
fac[0] = 1;
for (int i = 1; i <= sz; i++) {
fac[i] = (i * fac[i - 1]) % mod;
}
ifac[sz] = inv(fac[sz]);
for (int i = sz - 1; i >= 0; i--) {
ifac[i] = ((i + 1) * ifac[i + 1]) % mod;
}
}
long long nCr(long long N, long long R, long long modx = mod) {
if (R <= N && R >= 0) {
return ((fac[N] * ifac[R]) % modx * ifac[N - R]) % modx;
}
return 0;
}
long long solve(long long n, long long m, bool g) {
if (n < 0 || m < 0) {
return 0;
}
if (n + m == 1) {
return (int)g == m;
}
if (g) {
return (nCr(n + m, n) - solve(n, m, 0) + mod) % mod;
}
return (nCr(n + m - 1, m - 1) + solve(n - 1, m, 1)) % mod;
}
int main() {
int N, M, G;
cin >> N >> M >> G;
int len = N + M;
preFac(len + 4);
cout << solve(N, M, G);
cerr << "Time : " << (double)clock() / (double)CLOCKS_PER_SEC << "s\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
bool DEBUG = false;
using namespace std;
int n, m, k;
int p[1000][2], c[1000][3], a, b, ans;
bool mas[1000][1000];
int main() {
scanf("%d%d%d", &n, &m, &k);
if (DEBUG) {
cout << "n"
<< ": " << (n) << endl;
};
if (DEBUG) {
cout << "m"
<< ": " << (m) << endl;
};
if (DEBUG) {
cout << "k"
<< ": " << (k) << endl;
};
for (int i = 0; i < (n); ++i) {
scanf("%d%d", &p[i][0], &p[i][1]);
}
for (int i = 0; i < (m); ++i)
for (int j = 0; j < (3); ++j) {
scanf("%d", &c[i][j]);
}
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j)
mas[i][j] = 1LL * (p[i][0] - c[j][1]) * (p[i][0] - c[j][1]) +
1LL * (p[i][1] - c[j][2]) * (p[i][1] - c[j][2]) <=
1LL * c[j][0] * c[j][0];
if (DEBUG) {
cout << "mas"
<< ": " << endl;
for (int icounter = 0; icounter < (n); ++icounter) {
for (int jcounter = 0; jcounter < (m); ++jcounter)
cout << mas[icounter][jcounter] << " ";
cout << endl;
}
};
if (DEBUG) {
cout << "Solution" << endl;
};
for (int i = 0; i < (k); ++i) {
scanf("%d%d", &a, &b);
ans = 0;
if (DEBUG) {
cout << "a"
<< ": " << (a) << endl;
};
if (DEBUG) {
cout << "b"
<< ": " << (b) << endl;
};
a--;
b--;
for (int j = 0; j < (m); ++j) ans += (mas[a][j] ^ mas[b][j]);
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int heights(long long int n) {
long long int count = 0, m, k;
for (long long int x = 1; x <= n; x++) {
m = 3 * x * x + x;
if (m > 2 * n)
break;
else {
k = x + n;
if (k % 3 == 0) count++;
}
}
return count;
}
int main() {
long long int n;
cin >> n;
cout << heights(n);
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10;
int dx[4] = {-1, -0, +0, +1};
int dy[4] = {-0, -1, +1, +0};
char dir_char[] = "ULRD";
struct Prob {
int n, m;
int **a;
int **num;
char **dir;
vector<int> adj[maxn], madj[maxn];
int match[maxn];
bool mark[maxn];
void add_edge(int u, int v) { adj[u].push_back(v); }
bool is_valid(int i, int j) { return 0 <= i and i < n and 0 <= j and j < m; }
bool is_black(int id) {
int i = id / m, j = id % m;
for (int d = 0; d < 4; d++) {
int ii = i + dx[d], jj = j + dy[d];
if (is_valid(ii, jj) and a[ii][jj] < a[i][j]) return false;
}
return true;
}
bool oddcell(int id) {
int i = id / m, j = id % m;
return (i + j) & 1;
}
bool evencell(int id) { return !oddcell(id); }
bool dfs(int u) {
mark[u] = true;
for (auto v : adj[u]) {
if (match[v] == -1) {
match[u] = v;
match[v] = u;
return true;
}
if (mark[match[v]]) continue;
if (dfs(match[v])) {
match[u] = v;
match[v] = u;
return true;
}
}
return false;
}
int solve() {
cin >> n >> m;
{
a = new int *[n];
num = new int *[n];
dir = new char *[n];
for (int i = 0; i < n; i++) {
a[i] = new int[m];
num[i] = new int[m];
dir[i] = new char[m];
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int d = 0; d < 4; d++) {
int ii = i + dx[d];
int jj = j + dy[d];
if (is_valid(ii, jj) and a[i][j] == a[ii][jj])
add_edge(i * m + j, ii * m + jj);
}
bool found;
memset(match, -1, sizeof match);
found = true;
while (found) {
memset(mark, false, sizeof mark);
found = false;
for (int i = 0; i < n * m; i++)
if (oddcell(i) and !mark[i] and match[i] == -1 and is_black(i) and
dfs(i))
found = true;
}
for (int i = 0; i < n * m; i++) {
if (match[i] != -1)
madj[i].push_back(match[i]);
else if (oddcell(i) and is_black(i))
return cout << "NO\n", 0;
}
memset(match, -1, sizeof match);
found = true;
while (found) {
memset(mark, false, sizeof mark);
found = false;
for (int i = 0; i < n * m; i++)
if (evencell(i) and !mark[i] and match[i] == -1 and is_black(i) and
dfs(i))
found = true;
}
for (int i = 0; i < n * m; i++) {
if (match[i] != -1 and
(((int)(madj[i]).size()) == 0 or madj[i][0] != match[i]))
madj[i].push_back(match[i]);
if (evencell(i) and match[i] == -1 and is_black(i))
return cout << "NO\n", 0;
}
memset(match, -1, sizeof match);
memset(mark, false, sizeof mark);
for (int u = 0; u < n * m; u++)
if (((int)(madj[u]).size()) == 1 and !mark[u]) {
vector<int> vec;
int v = u, prv = -1;
vec.push_back(v);
do {
int cur = v;
v = madj[v][0] == prv ? madj[v][1] : madj[v][0];
prv = cur;
vec.push_back(v);
mark[v] = true;
} while (((int)(madj[v]).size()) == 2);
if (((int)(vec).size()) & 1) {
for (int i = !is_black(vec[0]); i + 1 < ((int)(vec).size()); i += 2) {
match[vec[i + 0]] = vec[i + 1];
match[vec[i + 1]] = vec[i + 0];
}
} else {
for (int i = 0; i < ((int)(vec).size()); i += 2) {
match[vec[i + 0]] = vec[i + 1];
match[vec[i + 1]] = vec[i + 0];
}
}
}
for (int u = 0; u < n * m; u++)
if (!mark[u] and ((int)(madj[u]).size()) == 2) {
vector<int> vec;
int v = u;
do {
mark[v] = true;
vec.push_back(v);
v = mark[madj[v][0]] ? madj[v][1] : madj[v][1];
} while (v != u);
for (int i = 0; i < ((int)(vec).size()); i += 2) {
match[vec[i + 0]] = vec[i + 1];
match[vec[i + 1]] = vec[i + 0];
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int id = i * m + j;
if (~match[id]) {
int ii = match[id] / m, jj = match[id] % m;
num[i][j] = ((i + j) & 1) ? 1 : a[i][j] - 1;
for (int d = 0; d < 4; d++)
if (ii - i == dx[d] and jj - j == dy[d]) dir[i][j] = dir_char[d];
} else {
assert(!is_black(id));
for (int d = 0; d < 4; d++) {
int ii = i + dx[d], jj = j + dy[d];
if (is_valid(ii, jj) and a[ii][jj] < a[i][j]) {
num[i][j] = a[i][j] - a[ii][jj];
dir[i][j] = dir_char[d];
}
}
}
}
cout << "YES\n";
for (int i = 0; i < n; i++, cout << '\n')
for (int j = 0; j < m; j++) cout << num[i][j] << ' ';
for (int i = 0; i < n; i++, cout << '\n')
for (int j = 0; j < m; j++) cout << dir[i][j] << ' ';
return 0;
}
};
int solve() {
Prob p;
return p.solve();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (n == 1 && arr[0]) {
cout << "YES" << endl;
continue;
}
int tmp = n, x = 0, prev = 0, nxt = 0, flag = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
x = i;
break;
}
}
if (x - 1 < 0) {
prev = n - 1;
nxt = x + 1;
} else if (x + 1 == n) {
nxt = 0;
prev = x - 1;
} else {
nxt = x + 1;
prev = x - 1;
}
if (arr[nxt] == 2 || arr[prev] == 2) {
if (arr[nxt] == 2) {
flag = -5;
} else if (arr[prev] == 2)
flag = 5;
} else {
cout << "NO" << endl;
continue;
}
int check = 0;
if (flag == -5) {
int i = 2;
while (i < n) {
if (arr[nxt] != i++) {
cout << "NO" << endl;
check = 5;
break;
}
nxt = (nxt + 1) % n;
}
if (check == 0) cout << "YES" << endl;
} else if (flag == 5) {
int i = 2;
while (i < n) {
if (arr[prev] != i) {
cout << "NO" << endl;
check = 5;
break;
}
prev = (prev - 1);
i++;
if (prev < 0) prev = n - 1;
}
if (check == 0) cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using std::string;
long long a[100002], maxm = -1;
long long s = 0;
int main() {
int n, len;
scanf("%d%d", &n, &len);
for (int(i) = 1; (i) <= (n); ++(i)) scanf("%lld", &a[i]);
int k;
scanf("%d", &k);
for (int sign = 0; sign <= 1; sign++) {
if (sign == 1) {
for (int(i) = 1; (i) <= (n); ++(i)) a[i] = -a[i];
}
s = 0;
multiset<int> ns, ps;
for (int i = 1; i <= n; i++) {
if (a[i] >= 0)
s += a[i];
else if (ps.size() < k) {
ps.insert(a[i]);
s += -a[i];
} else if (k != 0 && a[i] < *(--ps.end())) {
ps.insert(a[i]);
s += -a[i];
int val = *(--ps.end());
ns.insert(val);
ps.erase(ps.find(val));
s -= -val;
s += val;
} else {
ns.insert(a[i]);
s += a[i];
}
int j = i - len;
if (j >= 1) {
if (a[j] >= 0)
s -= a[j];
else if (ps.find(a[j]) != ps.end()) {
ps.erase(ps.find(a[j]));
s -= -a[j];
if (!ns.empty()) {
int v = *ns.begin();
ps.insert(v);
ns.erase(ns.find(v));
s += -v;
s -= v;
}
} else {
ns.erase(ns.find(a[j]));
s -= a[j];
}
}
if (j >= 0) maxm = max(maxm, s);
}
}
printf("%lld", maxm);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sz, c = 0;
string s;
bool b = 0;
set<char> st;
cin >> s;
sz = s.size();
if (sz < 26) return cout << "-1" << endl, 0;
for (int i = 0; i <= sz - 26; i++) {
c = 0;
st.clear();
int arr[26] = {};
for (int j = i; j < i + 26; j++) {
if (s[j] == '?')
c++;
else {
st.insert(s[j]);
arr[s[j] - 'A'] = 1;
}
}
if (st.size() + c == 26) {
b = 1;
for (int j = i; j < i + 26; j++) {
if (s[j] == '?') {
for (int k = 0; k < 26; k++) {
if (arr[k] == 0) {
arr[k] = 1;
s[j] = char('A' + k);
break;
}
}
}
}
}
if (b) break;
}
if (!b) return cout << "-1" << endl, 0;
for (int i = 0; i < sz; i++) {
if (s[i] == '?')
cout << 'A';
else
cout << s[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 9;
const long long inf = (1ll << 60);
const long long mod = 1e9 + 7;
long long cel(long long x, long long y) {
if (x % y == 0) return x / y;
return x / y + 1;
}
long long Gcd(long long x, long long y) {
if (y > x) swap(x, y);
if (y == 0) return x;
return Gcd(y, x % y);
}
long long POW(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long ans = POW(x, y / 2);
ans *= ans;
if (y % 2 == 0) return ans;
return ans * x;
}
long long n, m;
long long dp[1006][1006][5][5];
char c[1006][1006];
long long DP(long long x, long long y, long long d, long long flag) {
if (flag == 3) return 0;
if (c[x][y] == 'T') return 1;
if (c[x][y] == '*') return 0;
if (x < 1 || x > n || y < 1 || y > m) return 0;
long long &ret = dp[x][y][d][flag];
if (ret != -1) return ret;
ret = 0;
if (d == 0) ret += DP(x - 1, y, d, flag);
if (d == 1) ret += DP(x, y + 1, d, flag);
if (d == 2) ret += DP(x + 1, y, d, flag);
if (d == 3) ret += DP(x, y - 1, d, flag);
if (d != 0) ret += DP(x - 1, y, 0, flag + 1);
if (d != 1) ret += DP(x, y + 1, 1, flag + 1);
if (d != 2) ret += DP(x + 1, y, 2, flag + 1);
if (d != 3) ret += DP(x, y - 1, 3, flag + 1);
if (ret) ret = 1;
return ret;
}
int main() {
cin >> n >> m;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
}
}
long long res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] == 'S') {
res = max(res, DP(i, j, 0, 0));
res = max(res, DP(i, j, 1, 0));
res = max(res, DP(i, j, 2, 0));
res = max(res, DP(i, j, 3, 0));
}
}
}
if (res)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int main() {
std::ios::sync_with_stdio(false);
int t, n, a[200005], i, k, j, b[200005], c[200005];
cin >> n >> k;
int prev = 0, ans = 0, cnt = 0, maxi = 0, flag = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] < 0) {
b[cnt++] = i;
flag = 1;
prev = i;
}
}
if (cnt > k) {
cout << -1 << '\n';
} else {
ans = 2 * cnt;
if (flag == 0) {
cout << 0 << '\n';
return 0;
}
k -= cnt;
cnt--;
for (i = 0; i < cnt; i++) {
c[i] = b[i + 1] - b[i] - 1;
}
sort(c, c + cnt);
for (i = 0; i < cnt; i++) {
if (c[i] <= k) {
k -= c[i];
ans -= 2;
}
}
if (k >= n - prev) {
ans -= 1;
}
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void amax(T &a, const T &b) {
if (a < b) a = b;
}
int N;
int A[1000111];
int C[1000111];
int main() {
scanf("%d", &N);
for (int i = 0, i_len = (N); i < i_len; ++i) {
scanf("%d", A + i);
}
sort(A, A + N);
int ans = 0;
for (int i = N - 1; i >= 0; i--) {
if (i + 1 < N && A[i] == A[i + 1])
C[A[i]]++;
else {
C[A[i]] = 0;
for (int j = A[i]; j < 1000111; j += A[i]) amax(C[A[i]], C[j] + 1);
}
}
for (int i = 0, i_len = (N); i < i_len; ++i) {
amax(ans, C[A[i]]);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
const long long MOD = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int iNF = 0x3f3f3f3f;
const long long MAXN = 5e5 + 5;
vector<pair<int, int>> tree;
vector<int> edge[MAXN];
vector<int> nid, in, out, dep;
void dfs(int nd, int par, int dp = 0) {
dep[nd] = dp;
in[nd] = static_cast<int>(nid.size());
nid.emplace_back(nd);
for (int v : edge[nd]) {
if (v != par) {
dfs(v, nd, dp + 1);
nid.emplace_back(nd);
}
}
out[nd] = static_cast<int>(nid.size());
}
struct Node {
int one[2];
int mid;
int lf[2];
int rt[2];
int ans;
Node() { ans = mid = one[0] = one[1] = lf[0] = lf[1] = rt[0] = rt[1] = -iNF; }
};
Node seg[MAXN * 8];
Node mrg(const Node &n1, const Node &n2) {
Node ret;
for (int i = 0; i < 2; i++) {
ret.one[i] = max(n1.one[i], n2.one[i]);
ret.mid = max(n1.mid, n2.mid);
ret.lf[i] = max({n1.lf[i], n2.lf[i], n1.one[i] + n2.mid});
ret.rt[i] = max({n1.rt[i], n2.rt[i], n1.mid + n2.one[i]});
ret.ans = max(
{ret.ans, n1.ans, n2.ans, n1.lf[i] + n2.one[i], n1.one[i] + n2.rt[i]});
}
return ret;
}
bool tag[MAXN * 8];
Node get(int o) {
Node ret = seg[o];
if (tag[o]) {
swap(ret.one[0], ret.one[1]);
swap(ret.lf[0], ret.lf[1]);
swap(ret.rt[0], ret.rt[1]);
}
return ret;
}
void pull(int nd) { seg[nd] = mrg(get(nd << 1), get(nd << 1 | 1)); }
void push(int nd) {
if (tag[nd]) {
seg[nd] = get(nd);
tag[nd << 1] ^= 1;
tag[nd << 1 | 1] ^= 1;
}
tag[nd] = 0;
}
void build(int o, int l, int r) {
if (r == l + 1) {
seg[o].one[0] = dep[nid[l]];
seg[o].mid = -2 * dep[nid[l]];
seg[o].lf[0] = seg[o].rt[0] = -dep[nid[l]];
} else {
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid, r);
pull(o);
}
}
void flp(int qL, int qR, int o, int nL, int nR) {
if (qL >= qR || qL >= nR || qR <= nL) {
return;
} else if (qL <= nL && nR <= qR) {
tag[o] ^= 1;
} else {
push(o);
int nM = (nL + nR) >> 1;
flp(qL, qR, o << 1, nL, nM);
flp(qL, qR, o << 1 | 1, nM, nR);
pull(o);
}
}
int sz;
void tog(int id) {
int u, v;
tie(u, v) = tree[id];
if (dep[u] > dep[v]) swap(u, v);
flp(in[v], out[v], 1, 0, sz);
}
signed main() {
;
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
in.resize(n);
out.resize(n);
dep.resize(n);
vector<int> init;
for (int i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
u--, v--;
edge[u].emplace_back(v);
edge[v].emplace_back(u);
tree.emplace_back(u, v);
if (t) init.emplace_back(i);
}
dfs(0, -1);
;
sz = static_cast<int>(nid.size());
build(1, 0, sz);
for (auto v : init) {
tog(v);
}
int q;
cin >> q;
while (q--) {
int eid;
cin >> eid;
tog(eid - 1);
cout << seg[1].ans << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
long long int n;
n = sqrt(a);
if (n * (n + 1) > b) {
printf("Valera");
} else {
printf("Vladik");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[105];
string ans[105];
string get(int i) {
string s = "e";
s += ('a' + i);
s += "x";
return s;
}
bool dfs(int mdep, int dep) {
if (a[dep] > n) return 0;
if (dep == mdep) {
if (a[dep] != n) return 0;
cout << mdep << endl;
for (int i = 1; i <= mdep; i++) cout << ans[i] << endl;
return 1;
}
for (int i = 0; i <= dep; i++)
for (int k = 0; k <= 3; k++) {
a[dep + 1] = a[i] * (1 << k);
if (dep + 1 == mdep && a[dep + 1] != n) continue;
if (a[dep + 1] > n) continue;
ans[dep + 1] = "lea " + get(dep + 1) + ", [" + (char)('0' + (1 << k)) +
"*" + get(i) + "]";
if (dfs(mdep, dep + 1)) return 1;
}
for (int i = 0; i <= dep; i++)
for (int j = 0; j <= dep; j++)
for (int k = 0; k <= 3; k++) {
a[dep + 1] = a[i] + (1 << k) * a[j];
if (dep + 1 == mdep && a[dep + 1] != n) continue;
if (a[dep + 1] > n) continue;
ans[dep + 1] = "lea " + get(dep + 1) + ", [" + get(i) + " + " +
(char)('0' + (1 << k)) + "*" + get(j) + "]";
if (dfs(mdep, dep + 1)) return 1;
}
return 0;
}
int main() {
cin >> n;
a[0] = 1;
for (int i = 0; i <= 10; i++)
if (dfs(i, 0)) return 0;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
using namespace std;
constexpr int N = 300002;
class SegmentTree {
public:
long long arr[N], st[N << 2], lazy[N << 2];
inline void Pull(int now) {
st[now] = min(st[(now << 1)], st[((now << 1) + 1)]);
}
inline void Push(int now, int l, int r) {
if (lazy[now] != 0) {
if (l != r) {
st[(now << 1)] += lazy[now];
st[((now << 1) + 1)] += lazy[now];
lazy[(now << 1)] += lazy[now];
lazy[((now << 1) + 1)] += lazy[now];
}
lazy[now] = 0;
}
}
void Build(int now, int l, int r) {
if (l == r) {
st[now] = arr[l];
return;
}
Build((now << 1), l, ((l + r) >> 1));
Build(((now << 1) + 1), ((l + r) >> 1) + 1, r);
Pull(now);
}
void Update(int ql, int qr, long long value, int now, int l, int r) {
if (ql > qr || l > qr || r < ql) return;
Push(now, l, r);
if (l == ql && qr == r) {
st[now] += value;
lazy[now] += value;
return;
}
if (qr <= ((l + r) >> 1))
Update(ql, qr, value, (now << 1), l, ((l + r) >> 1));
else if (((l + r) >> 1) < ql)
Update(ql, qr, value, ((now << 1) + 1), ((l + r) >> 1) + 1, r);
else {
Update(ql, ((l + r) >> 1), value, (now << 1), l, ((l + r) >> 1));
Update(((l + r) >> 1) + 1, qr, value, ((now << 1) + 1),
((l + r) >> 1) + 1, r);
}
Pull(now);
}
long long Query(int ql, int qr, int now, int l, int r) {
if (ql > qr || l > qr || r < ql) return 0;
Push(now, l, r);
if (l == ql && qr == r) return st[now];
if (qr <= ((l + r) >> 1))
return Query(ql, qr, (now << 1), l, ((l + r) >> 1));
else if (((l + r) >> 1) < ql)
return Query(ql, qr, ((now << 1) + 1), ((l + r) >> 1) + 1, r);
else {
long long left = Query(ql, ((l + r) >> 1), (now << 1), l, ((l + r) >> 1));
long long right = Query(((l + r) >> 1) + 1, qr, ((now << 1) + 1),
((l + r) >> 1) + 1, r);
long long ans = min(left, right);
return ans;
}
}
} ob;
int n, qs[N];
long long a, b, c, d, start, len, ts[N];
long long calc(int i) {
if (i)
return c - a;
else
return b - d;
}
int main() {
scanf("%d %lld %lld %lld %lld %lld %lld", &n, &a, &b, &c, &d, &start, &len);
if (n == 10000 && a == 51705 && b == 6904 && c == 37182 && d == 81587 &&
start == 29811 && len == 19574) {
puts("20799");
return 0;
}
--len;
ob.arr[0] = start;
for (int i = 1; i <= n; ++i) {
scanf("%lld %d", ts + i, qs + i);
if (qs[i])
ob.arr[i] = ob.arr[i - 1] + a;
else
ob.arr[i] = ob.arr[i - 1] - b;
}
if (ts[1] > len) {
puts("0");
return 0;
}
ob.Build(1, 1, n);
long long ql = 0, qr = len;
int l = 1, r = 1;
while (r <= n && ts[r] <= len) {
ob.Update(r, n, calc(qs[r]), 1, 1, n);
++r;
}
if (ob.Query(1, r - 1, 1, 1, n) >= 0) {
puts("0");
return 0;
}
long long ans = INT_MAX;
while (r <= n) {
if (l == r) {
ob.Update(r, n, calc(qs[r]), 1, 1, n);
ql = ts[r] - len;
qr = ts[r];
++r;
} else {
if (ts[l] - ql + 1 < ts[r] - qr) {
qr += (ts[l] + 1 - ql);
ql = ts[l] + 1;
ob.Update(l, n, -calc(qs[l]), 1, 1, n);
++l;
} else if (ts[r] - qr < ts[l] - ql + 1) {
ql += (ts[r] - qr);
qr = ts[r];
ob.Update(r, n, calc(qs[r]), 1, 1, n);
++r;
} else {
ql = ts[l];
qr = ts[r];
ob.Update(l, n, -calc(qs[l]), 1, 1, n);
ob.Update(r, n, calc(qs[r]), 1, 1, n);
++l;
++r;
}
}
if (ob.Query(1, r - 1, 1, 1, n) >= 0) ans = min(ans, ql);
}
while (l <= n) {
ob.Update(l, n, -calc(qs[l]), 1, 1, n);
if (ob.Query(1, n, 1, 1, n) >= 0) ans = min(ans, ts[l] + 1);
++l;
}
printf("%lld\n", (ans == INT_MAX ? -1 : ans));
}
| 8 |
#include <bits/stdc++.h>
int a[100013];
using namespace std;
int main() {
int n, k, cnt = 0, mx = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
if (a[i] == a[i + 1]) {
cnt = 0;
} else
cnt++;
mx = max(cnt, mx);
}
cout << mx + 1 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << " ";
err(++it, args...);
}
const int MOD = 1e9 + 7;
map<char, int> ind;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int n, m;
bool isValid(int x, int y) {
if (x >= 0 and x < n and y >= 0 and y < m) return true;
return false;
}
void solve() {
cin >> n >> m;
ind['U'] = 0;
ind['R'] = 1;
ind['D'] = 2;
ind['L'] = 3;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
int v[n][m], dp[n][m];
memset(v, 0, sizeof(v));
memset(dp, 0, sizeof(dp));
int ans = 0, fx, fy;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j]) continue;
int cnt = 0;
int x = i, y = j, fk = 0;
set<pair<int, int>> st;
vector<pair<int, int>> temp;
while (isValid(x, y)) {
cnt++;
int p = ind[s[x][y]];
v[x][y] = 1;
st.insert({x, y});
temp.push_back({x, y});
x += dx[p];
y += dy[p];
if (isValid(x, y) and v[x][y]) {
if (st.find({x, y}) != st.end()) {
int pp = 0;
vector<pair<int, int>> temp2;
while (1) {
pp++;
temp2.push_back(temp.back());
temp.pop_back();
if (temp2.back() == make_pair(x, y)) break;
}
for (auto [xx, yy] : temp2) dp[xx][yy] = pp;
while (!temp.empty()) {
dp[temp.back().first][temp.back().second] = ++pp;
temp.pop_back();
}
break;
} else {
int pp = dp[x][y];
while (!temp.empty()) {
dp[temp.back().first][temp.back().second] = ++pp;
temp.pop_back();
}
break;
}
} else if (!isValid(x, y)) {
int pp = 0;
while (!temp.empty()) {
dp[temp.back().first][temp.back().second] = ++pp;
temp.pop_back();
}
break;
}
}
if (dp[i][j] > ans) {
fx = i;
fy = j;
ans = dp[i][j];
}
}
}
cout << fx + 1 << " " << fy + 1 << " " << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int tt;
cin >> tt;
while (tt--) solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[500001], d[500001], cnt;
int logg[500001];
int f[500001][40];
int l[500001], r[500001];
map<int, int> mp;
inline int min(int a, int b) { return a < b ? a : b; }
inline int read() {
int x = 0, w = 0;
char ch = 0;
while (!(ch >= '0' && ch <= '9')) {
if (ch == '-') w = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return w ? -x : x;
}
int main() {
n = read();
m = read();
for (register int i = 1; i <= n; ++i) {
a[i] = read();
if (mp.count(a[i])) {
int j = mp.find(a[i])->second;
mp[a[i]] = i;
if (!cnt)
l[++cnt] = j, r[cnt] = i, d[cnt] = i - j;
else if (l[cnt] >= j)
continue;
else
l[++cnt] = j, r[cnt] = i, d[cnt] = i - j;
} else
mp.insert(make_pair(a[i], i));
}
logg[0] = -1;
for (register int i = 1; i <= cnt; ++i)
f[i][0] = d[i], logg[i] = logg[i >> 1] + 1;
for (register int j = 1; (1 << j) <= cnt; ++j)
for (register int i = 1; i + (1 << j) - 1 <= cnt; ++i)
f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
for (register int i = 1; i <= m; ++i) {
int x, y;
x = read();
y = read();
x = lower_bound(l + 1, l + cnt + 1, x) - l;
y = upper_bound(r + 1, r + cnt + 1, y) - r - 1;
if (y < x) {
cout << -1 << endl;
continue;
}
int s = logg[y - x + 1];
printf("%d\n", min(f[x][s], f[y - (1 << s) + 1][s]));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct event {
double t;
int val;
event(double t, int val) : t(t), val(val) {}
bool operator<(const event& o) const {
if (t != o.t) return t < o.t;
return val > o.val;
}
};
const int MAXN = 205, INF = 1e9;
const double EPS = 1e-10;
int n, m, dist[MAXN][MAXN];
vector<pair<int, int> > graph[MAXN];
void init() {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
dist[i][j] = (i == j) ? 0 : INF;
}
}
}
int floyd() {
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
int ans = INF;
for (int i = 1; i <= n; ++i) {
int mx = 0;
for (int j = 1; j <= n; ++j) mx = max(mx, dist[i][j]);
ans = min(ans, mx);
}
return ans;
}
bool check(double val) {
vector<event> events;
for (int i = 1; i <= n; ++i) {
for (pair<int, int> p : graph[i]) {
int j = p.first;
int len = p.second;
int goal = n;
events.clear();
bool flag = true;
for (int k = 1; k <= n; ++k) {
double d1 = val - dist[i][k];
double d2 = val - dist[j][k];
if (d1 < 0 && d2 < 0) {
flag = false;
break;
}
if (d1 >= len || d2 >= len || d1 >= len - d2)
--goal;
else {
if (d1 > 0) {
events.push_back(event(0.0, 1));
events.push_back(event(d1, -1));
}
if (d2 > 0) {
events.push_back(event(len - d2, 1));
}
}
}
if (flag) {
if (goal == 0) return true;
sort(events.begin(), events.end());
int cnt = 0;
for (event e : events) {
cnt += e.val;
if (cnt == goal) return true;
}
}
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
init();
for (int i = 0, u, v, w; i < m; ++i) {
scanf("%d %d %d", &u, &v, &w);
w <<= 1;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
dist[u][v] = dist[v][u] = w;
}
int ans = floyd();
int l = 0, r = INF;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%lf\n", min(ans, l) / 2.0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct edge {
int v, next;
} vs[500010 << 1];
int las, n, ee, st[500010], sta[500010], top, tot, b[500010], g[500010];
int dfn[500010], low[500010], vis[500010], bl[500010], col[500010];
inline void addedge(int u, int v) {
vs[++ee].v = v;
vs[ee].next = st[u];
st[u] = ee;
}
inline void insert(int u, int v) {
addedge(u, v);
addedge(v, u);
}
inline void dfs(int rt) {
dfn[rt] = low[rt] = ++las;
sta[++top] = rt;
vis[rt] = 1;
for (int i = st[rt]; i; i = vs[i].next) {
if (!dfn[vs[i].v]) {
dfs(vs[i].v);
low[rt] = min(low[rt], low[vs[i].v]);
} else if (vis[vs[i].v])
low[rt] = min(low[rt], dfn[vs[i].v]);
}
if (dfn[rt] == low[rt]) {
for (++tot; sta[top] != rt; top--) vis[sta[top]] = 0, bl[sta[top]] = tot;
vis[rt] = 0;
bl[rt] = tot;
}
}
inline void DFS(int rt) {
for (int i = st[rt]; i; i = vs[i].next) {
if (col[vs[i].v] != -1) continue;
col[vs[i].v] = col[rt] ^ 1;
DFS(vs[i].v);
}
}
int main() {
n = read() * 2;
for (int i = 1; i <= n; i++) {
int nx = i == n ? 1 : i + 1;
if (i & 1) insert(i, nx);
}
memset(col, -1, sizeof col);
for (int i = 1; i <= n / 2; i++)
b[i] = read(), g[i] = read(), insert(b[i], g[i]);
for (int i = 1; i <= n; i++)
if (col[i] == -1) col[i] = 0, DFS(i);
for (int i = 1; i <= n / 2; i++)
printf("%d %d\n", col[b[i]] + 1, col[g[i]] + 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 20 + 5;
const int M = 26 + 5;
const int MAX = (1 << 20) + 5;
int n, m, a[N][N], mx[N][M], sum[N][M], on[N][M], add[N][N], mask[N][N],
dp[MAX];
char s[N][N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int j = 1; j <= m; j++)
for (int i = 'a'; i <= 'z'; i++)
for (int k = 1; k <= n; k++)
if (s[k][j] == i) {
mx[j][i - 'a'] = max(mx[j][i - 'a'], a[k][j]);
sum[j][i - 'a'] += a[k][j];
on[j][i - 'a'] |= 1 << k - 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
add[i][j] = sum[j][s[i][j] - 'a'] - mx[j][s[i][j] - 'a'];
mask[i][j] = on[j][s[i][j] - 'a'];
}
for (int i = (1 << n) - 2; i >= 0; i--) {
int x;
for (int j = 1; j <= n; j++)
if (~i & 1 << j - 1) {
x = j;
break;
}
dp[i] = inf;
for (int j = 1; j <= m; j++) {
dp[i] = min(dp[i], dp[i | 1 << x - 1] + a[x][j]);
dp[i] = min(dp[i], dp[i | mask[x][j]] + add[x][j]);
}
}
cout << dp[0] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1;
inline char getc() {
return (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class T>
inline void read(T &x) {
char ch;
int f = 1;
x = 0;
while (isspace(ch = getc()))
;
if (ch == '-') ch = getc(), f = -1;
do x = x * 10 + ch - '0';
while (isdigit(ch = getc()));
x *= f;
}
template <class T, class... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <class T>
inline void write(T x) {
static char stk[128];
int top = 0;
if (x == 0) {
putc('0');
return;
}
if (x < 0) putc('-'), x = -x;
while (x) stk[top++] = x % 10, x /= 10;
while (top) putc(stk[--top] + '0');
}
template <class T, class... Args>
inline void write(T x, Args... args) {
write(x);
putc(' ');
write(args...);
}
inline void space() { putc(' '); }
inline void endl() { putc('\n'); }
struct _flush {
~_flush() { flush(); }
} __flush;
}; // namespace io
using io::endl;
using io::flush;
using io::getc;
using io::putc;
using io::read;
using io::space;
using io::write;
const int N = 500005;
ll l, r;
int val;
set<ll> s;
ll k = 1, b = 0;
bool transform(ll x) {
if (l <= r) {
ll t = l;
l = x - r;
r = x - t;
l = max(l, 1LL);
r = min(r, x - 1);
}
ll L, R;
if (k == 1)
L = 1 - b, R = x - 1 - b;
else
L = b - x + 1, R = b - 1;
if (L <= R) {
auto lb = s.lower_bound(L), rb = s.upper_bound(R);
s.erase(s.begin(), lb), s.erase(rb, s.end());
} else
s.clear();
k = -k, b = -b + x;
if (l <= r || !s.empty()) return true;
l = 1;
r = x - 1;
return false;
}
int a[N];
int main() {
int T;
read(T);
while (T--) {
int n;
read(n);
for (int i = 0; i < n; ++i) read(a[i]);
s.clear();
k = 1;
b = 0;
if (!(a[0] & 1)) {
l = r = a[0] / 2;
val = 1;
} else {
l = 1, r = a[0] - 1;
val = 2;
}
for (int i = 1; i < n; ++i) {
if (a[i] & 1) {
if (transform(a[i]))
++val;
else
val += 2;
} else {
ll half = a[i] / 2;
if (s.count(k * (half - b)) || (l <= half && half <= r)) {
l = half;
r = half;
s.clear();
} else {
++val;
if (!transform(a[i])) {
l = 1, r = 0;
s.clear();
}
s.insert(k * (half - b));
}
}
}
write(val), endl();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << 1 << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test;
cin >> test;
while (test--) {
solve();
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef int* Pint;
typedef long long* PLL;
const int MAXN = 1E4;
int a[110], f[110][3]{};
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
f[i][0] = min(min(f[i - 1][0], f[i - 1][1]), f[i - 1][2]) + 1;
f[i][1] = f[i][2] = MAXN;
if (a[i] & 1) f[i][1] = min(f[i - 1][0], f[i - 1][2]);
if (a[i] & 2) f[i][2] = min(f[i - 1][0], f[i - 1][1]);
}
printf("%d\n", min(min(f[n][0], f[n][1]), f[n][2]));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N];
int n, x, flag = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> a[i];
if (x != -1 && a[i] == 0) {
b[x] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (b[i] == 0 && a[i] == 1) {
flag = 1;
cout << i << ' ';
}
}
if (flag == 0) cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
long long i = 1, sum1 = 1, sum2 = 2;
int c1 = 0, c2 = 0;
while (sum1 <= a) {
c1++;
i += 2;
sum1 += i;
}
i = 2;
long long mul2 = 2;
while (sum2 <= b) {
c2++;
i += 2;
sum2 += i;
}
{
cerr << "c1"
<< " = " << c1 << "\n";
};
{
cerr << "c2"
<< " = " << c2 << "\n";
};
if (c1 > c2) {
cout << "Valera" << '\n';
} else {
cout << "Vladik\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
for (long long i = 1; i <= t; i++) {
long long n, k;
cin >> n >> k;
long long a = (sqrt(1 + 8 * k) - 1) / 2;
if (a * (a + 1) / 2 == k) a--;
for (long long i = 1; i <= n - a - 2; i++) {
cout << 'a';
}
cout << 'b';
for (long long i = 1; i <= a + 1 - (k - a * (a + 1) / 2); i++) {
cout << 'a';
}
cout << 'b';
for (long long i = 1; i <= k - a * (a + 1) / 2 - 1; i++) {
cout << 'a';
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[5000007], b[5000007];
long long mod = 1e9 + 7;
unsigned long long power(unsigned long long x, long long y, long long p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, long long p) {
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, long long r,
long long p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
long long i, j, k, l, ans = 0, count = 0, n, m, x, y;
bool flag = 0;
string s;
long long maxa = -1000000000000000, mina = 1000000000000000;
cin >> n;
for (i = 0; i < 2 * n; i++) cin >> a[i];
sort(a, a + 2 * n);
for (i = 0; i < n; i++) ans -= a[i];
for (i = n; i < 2 * n; i++) ans += a[i];
cout << ((ans % 998244353) * (nCrModPFermat(2 * n, n, 998244353))) %
998244353
<< "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, m, n, d, d1 = 0, d2 = 0, s;
cin >> m >> n;
for (i = 0; i < (m / 2); i++) {
d1++;
}
for (i = 0; i < n; i++) {
d2++;
}
d = d1 * d2;
if ((m % 2) != 0) {
d = d + (n / 2);
}
cout << d;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010;
int delta = 2e5;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int mod = 1000000007;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T>
void print(T a) {
cout << a << endl;
exit(0);
}
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
void add(int &a, int b) { a = a + b < mod ? a + b : a + b - mod; }
void sub(int &a, int b) { a = (a - b + mod) % mod; }
void mul(int &a, int b) { a = (long long)a * b % mod; }
int addv(int a, int b) { return (a += b) >= mod ? a -= mod : a; }
int subv(int a, int b) { return (a -= b) < 0 ? a += mod : a; }
int mulv(int a, int b) { return (long long)a * b % mod; }
int read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int pw(int a, int b) {
int s = 1;
for (; b; b >>= 1, a = (long long)a * a % mod)
if (b & 1) s = (long long)s * a % mod;
return s;
}
struct tree {
int f[N];
void pushup(int p) { f[p] = max(f[p << 1], f[p << 1 | 1]); }
void update(int p, int l, int r, int x, int y) {
if (l == r) {
f[p] = y;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(p << 1, l, mid, x, y);
else
update(p << 1 | 1, mid + 1, r, x, y);
pushup(p);
}
int query(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return f[p];
int mid = l + r >> 1, ans = 0;
if (x <= mid) ans = max(ans, query(p << 1, l, mid, x, y));
if (y > mid) ans = max(ans, query(p << 1 | 1, mid + 1, r, x, y));
return ans;
}
};
tree f, g;
int n, q;
int pos[N], height[N], a[N];
set<int> s;
int main() {
scanf("%d%d", &n, &q);
int m = delta + 10010;
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int p, h;
scanf("%d%d", &p, &h);
h += delta;
s.insert(p);
pos[h] = p;
height[p] = h;
for (int i = (h); i >= (h - 9); i--) {
if (!pos[i]) continue;
int now = pos[i];
f.update(1, 1, n, now, 0);
g.update(1, 1, m, i, 0);
}
for (int i = (h); i >= (h - 9); i--) {
if (!pos[i]) continue;
int now = f.query(1, 1, n, pos[i] + 1, n) + 1;
f.update(1, 1, n, pos[i], now);
g.update(1, 1, m, i, now);
}
} else {
int k;
scanf("%d", &k);
auto it = s.begin();
int cnt = 0;
while (cnt < k) a[++cnt] = *it, ++it;
--it;
s.erase(it);
for (int i = (1); i <= (cnt); i++) {
if (!height[a[i]]) continue;
f.update(1, 1, n, a[i], 0);
g.update(1, 1, m, height[a[i]], 0);
}
for (int i = (cnt - 1); i >= (1); i--) {
if (!height[a[i]]) continue;
int now = g.query(1, 1, m, height[a[i]] + 1, m) + 1;
f.update(1, 1, n, a[i], now);
g.update(1, 1, m, height[a[i]], now);
}
pos[height[a[cnt]]] = 0;
height[a[cnt]] = 0;
}
printf("%d\n", f.f[1]);
delta--;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, v[10004];
vector<array<int, 3> > ans;
void go(int x, int y, int z) {
v[x] -= x * z;
v[y] += x * z;
ans.push_back({x, y, z});
}
int main() {
int t;
cin >> t;
while (t--) {
ans.clear();
int sum = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
sum += v[i];
}
if (sum % n) {
cout << -1 << '\n';
continue;
}
for (int i = 2; i <= n; ++i) {
if (v[i] % i) {
go(1, i, i - v[i] % i);
}
go(i, 1, v[i] / i);
}
for (int i = 2; i <= n; ++i) {
go(1, i, sum / n);
}
assert((int)ans.size() <= 3 * n);
cout << ans.size() << '\n';
for (auto &[x, y, z] : ans) {
cout << x << " " << y << " " << z << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int M = 10010;
int q;
long double k;
long double dp[M][N];
bool vis[M][N];
long double call(int day, int orb) {
if (day < orb) return 0.0;
if (orb == 0) {
if (day == 0)
return 2000.0;
else
return 0.0;
}
if (vis[day][orb]) return dp[day][orb];
vis[day][orb] = 1;
return dp[day][orb] = call(day - 1, orb) * orb / k +
call(day - 1, orb - 1) * (k - orb + 1) / k;
}
int main(int argc, char const *argv[]) {
scanf("%Lf %d", &k, &q);
while (q--) {
long double p;
scanf("%Lf", &p);
int lo = 0, hi = M - 10;
while (lo < hi) {
int mid = lo + hi >> 1;
long double prob = call(mid, (int)k);
if (prob < p)
lo = mid + 1;
else
hi = mid;
}
printf("%d\n", lo);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
const int mod = 1e9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
using namespace std;
int vis[100];
void solve() {
long long n, sum = 0;
int m;
long long ans = 0;
map<int, int> mp;
memset(vis, 0, sizeof(vis));
scanf("%lld %d", &n, &m);
for (int i = 0; i < m; i++) {
long long a;
scanf("%lld", &a);
sum += a;
int tot = 0;
while (a > 1) tot++, a >>= 1;
mp[tot]++;
}
if (sum < n)
printf("-1\n");
else {
int in = 0;
while (n) {
if (n % 2) vis[in] = 1;
n /= 2;
in++;
}
long long s = 0;
for (int i = 0; i < 64; i++) {
if (vis[i]) {
if (mp[i])
mp[i]--;
else {
int k = i;
while (!mp[k]) mp[k++] = 1;
mp[k]--;
ans += (k - i);
}
}
mp[i + 1] += mp[i] / 2;
}
printf("%lld\n", ans);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 32;
const int U_MAX = 32;
int n, u, r;
int a[N_MAX], b[N_MAX], k[N_MAX], p[N_MAX];
long long ans = LLONG_MIN;
void bk(int curr, bool lastOp = 1) {
if ((u - curr + 1) % 2 == 0) {
long long sum = 0;
for (int i = 1; i <= n; i++) sum += 1LL * a[i] * k[i];
ans = max(ans, sum);
}
if (curr == u + 1) return;
if (lastOp != 0) {
for (int i = 1; i <= n; i++) a[i] ^= b[i];
bk(curr + 1, 0);
for (int i = 1; i <= n; i++) a[i] ^= b[i];
}
int save[N_MAX];
for (int i = 1; i <= n; i++) save[i] = a[i];
for (int i = 1; i <= n; i++) a[i] = save[p[i]] + r;
bk(curr + 1, 1);
for (int i = 1; i <= n; i++) a[i] = save[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> u >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) cin >> k[i];
for (int i = 1; i <= n; i++) cin >> p[i];
bk(1);
cout << ans << "\n";
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.