solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<int, int> a;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[x]++;
}
int ans = 0;
for (map<int, int>::iterator i = a.begin(); i != a.end(); i++)
ans = max(ans, i->second);
if (n & 1)
puts(ans <= n / 2 + 1 ? "YES" : "NO");
else
puts(ans <= n / 2 ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int infint = (int)1e9;
const long long inf = (long long)1e18;
const int MAXN = 2e5 + 7;
const long long MOD = (long long)1e9 + 7;
long long a[MAXN], b[MAXN], n, pwr[32], q, fen[MAXN];
void insert(vector<long long> &cur, long long x) {
for (auto u : cur)
if (u & -u & x) x ^= u;
if (!x) return;
for (long long j = 0; j < cur.size(); j++)
if (x & -x & cur[j]) cur[j] ^= x;
cur.push_back(x);
}
vector<long long> merge(vector<long long> a, vector<long long> b) {
vector<long long> ans = a;
for (auto u : b) insert(ans, u);
return ans;
}
struct value {
long long val;
vector<long long> v;
};
value seg[4 * MAXN];
void build(long long node, long long st, long long en) {
if (en - st < 2) {
insert(seg[node].v, b[st]);
seg[node].val = b[st];
return;
}
long long mid = (st + en) >> 1;
build(node << 1, st, mid);
build(node << 1 | 1, mid, en);
seg[node].v = merge(seg[node << 1].v, seg[node << 1 | 1].v);
seg[node].val = seg[node << 1].val ^ seg[node << 1 | 1].val;
}
value get(long long node, long long st, long long en, long long l,
long long r) {
if (l <= st && en <= r) return seg[node];
if (l >= en || st >= r) {
value empt;
empt.val = 0;
return empt;
}
long long mid = (st + en) >> 1;
value a1 = get(node << 1, st, mid, l, r);
value a2 = get(node << 1 | 1, mid, en, l, r);
value ans;
ans.val = a1.val ^ a2.val;
ans.v = merge(a1.v, a2.v);
return ans;
}
void modify(long long node, long long st, long long en, long long l,
long long k) {
if (en - st < 2) {
long long p = seg[node].val ^ k;
seg[node].v.clear();
insert(seg[node].v, p);
seg[node].val = p;
return;
}
long long mid = (st + en) >> 1;
if (l < mid)
modify(node << 1, st, mid, l, k);
else
modify(node << 1 | 1, mid, en, l, k);
seg[node].v = merge(seg[node << 1].v, seg[node << 1 | 1].v);
seg[node].val = seg[node << 1].val ^ seg[node << 1 | 1].val;
}
void upd_fen(long long v, long long k) {
v++;
for (; v <= n; v += v & -v) fen[v] ^= k;
}
long long get_fen(long long v) {
v++;
long long ans = 0;
for (; v; v -= v & -v) ans ^= fen[v];
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (long long i = 0; i < n; i++) cin >> a[i];
b[0] = a[0];
for (long long i = 1; i < n; i++) b[i] = (a[i - 1] ^ a[i]);
for (long long i = 0; i < n; i++) upd_fen(i, b[i]);
pwr[0] = 1;
for (long long i = 1; i < 32; i++) pwr[i] = pwr[i - 1] * 2;
build(1, 0, n);
for (long long i = 0; i < q; i++) {
long long type;
cin >> type;
if (type == 1) {
long long l, r, k;
cin >> l >> r >> k;
l--;
modify(1, 0, n, l, k);
if (r != n) modify(1, 0, n, r, k);
upd_fen(l, k);
if (r != n) upd_fen(r, k);
} else {
long long l, r;
cin >> l >> r;
l--;
value tmp = get(1, 0, n, l + 1, r);
long long p = get_fen(l);
insert(tmp.v, p);
cout << pwr[tmp.v.size()] << "\n";
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const int N = (int)5e4 + 7;
const int Q = (int)5e3 + 7;
const int L = (int)1e6 + 7;
int n, q, a[N], tab[N];
int pre[L];
int sol[Q];
vector<pair<int, int>> question[N];
int eval(int x, int y) {
if (x <= y) return pre[y] ^ pre[x - 1];
return pre[x] ^ pre[y - 1];
}
signed realMain() {
for (int i = 1; i < L; i++) {
pre[i] = pre[i - 1] ^ i;
}
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= q; i++) {
int l, r;
cin >> l >> r;
question[r].push_back({l, i});
}
for (int r = 1; r <= n; r++) {
for (int i = r; i >= 1; i--) {
tab[i] = max(tab[i], eval(a[i], a[r]));
tab[i] = max(tab[i], tab[i + 1]);
}
for (auto &it : question[r]) {
sol[it.second] = tab[it.first];
}
}
for (int i = 1; i <= q; i++) {
cout << sol[i] << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> v(n);
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
v[i] = (a[i] - b[i]);
}
sort(v.begin(), v.end(), greater<long long int>());
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
ans += i * v[i];
ans += (n - 1) * b[i];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x;
cin >> x;
for (int i = 1; i <= 10; i++)
for (int h = 1; h <= 10; h++)
if (fabs(i * h / sqrt(i * i + 4 * h * h) - x) <= 1e-5) {
cout << i << " " << h << endl;
return 0;
}
}
| 5 |
#include <iostream>
using namespace std;
typedef long long ll;
ll dp[52][2502];
ll s[52][2502];
ll rec(int n, ll m){
if(n == 0) return 0;
ll res = rec(n - 1, m) * n;
for(int i = 1; i <= n; i++){
for(int j = i + 1; j <= n; j++){
for(int k = j - i; k <= n * (n - 1) / 2 + 1; k++){
res = (res + dp[n - 1][k] * s[n - 1][k - (j - i)]) % m;
}
}
}
return res;
}
int main()
{
int n, m;
cin >> n >> m;
dp[0][0] = 1;
for(int i = 1; i <= n; i++){
ll d[2502]{0};
for(int j = 1; j <= i; j++){
for(int k = j - 1; k <= n * n; k++) d[k] = (d[k] + dp[i - 1][k - (j - 1)]) % m;
}
swap(dp[i], d);
}
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n * n + 1; j++) s[i][j] = (s[i][j - 1] + dp[i][j - 1]) % m;
}
cout << rec(n, m) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a, C b) {
a = min(a, b);
}
template <class C>
void maxi(C& a, C b) {
a = max(a, b);
}
void a() {
int n;
cin >> n;
set<set<char>> s;
string a;
for (int i = 0; i < n; i++) {
set<char> t;
cin >> a;
for (auto c : a) t.insert(c);
s.insert(t);
}
cout << s.size() << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
a();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isOk(long long n, long long E) {
long long k = (E + 1) / 2;
long long rem = n - k;
long long remE = E - k;
return remE <= rem * (rem - 1) / 2 && remE >= rem - 1 && rem >= 0 &&
remE >= 0;
}
long long ternarySearch(long long n) {
if (n == 1) return 0;
long long lo = n - 1, hi = n * (n + 1) / 2;
while (hi > lo + 1) {
long long mid = (hi + lo) >> 1;
if (isOk(n, mid)) {
lo = mid;
} else {
hi = mid;
}
}
if (isOk(n, lo + 1))
return lo + 1;
else if (isOk(n, lo))
return lo;
else
return lo - 1;
}
int main() {
int n;
scanf("%d", &(n));
long long q;
while (n--) {
cin >> q;
cout << ternarySearch(q) << endl;
}
}
| 6 |
#include <bits/stdc++.h>
const long long int maxn = 1e5 + 2;
using namespace std;
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i++) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
long long int lcmN(int a, int b) {
long long int large = max(a, b);
long long int small = min(a, b);
for (long long int i = large;; i += large) {
if (i % small == 0) {
return i;
}
}
}
void div() {
long long int b, k = 0, i, j;
cin >> b;
double y = sqrt(b);
double p = floor(y);
for (i = 1; i <= p; i++) {
j = b / i;
if (i * j == b) {
k++;
}
}
if (y == p) {
cout << 2 * k - 1;
} else {
cout << 2 * k;
}
}
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
long long int fgcd(long long int a[], int n) {
long long int res = a[0];
for (int i = 1; i < n; i++) {
res = gcd(res, a[i]);
if (res == 1) {
return 1;
}
}
return res;
}
long long int ans(long long int a[], int n) {
long long int res = fgcd(a, n);
int c = 0;
for (int i = 1; i <= sqrt(res); i++) {
if (res % i == 0) {
c++;
if (res / i != i) {
c++;
}
}
}
return c;
}
int prime[1000001];
void seive() {
for (int i = 0; i <= 1000000; ++i) {
prime[i] = 1;
}
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i <= 1000000; ++i) {
if (prime[i]) {
for (int j = i * i; j <= 1000000; j += i) {
prime[j] = false;
}
}
}
}
int csub(long long int a[], int b, int sz) {
int mf = 0, me = 0;
for (int i = b; i < sz; i++) {
me = me + a[i];
if (me < 0) {
me = 0;
} else if (mf < me) {
mf = me;
}
}
return mf;
}
int nond(int a, int b, int c) { return (a + b > c); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int xr = i ^ j;
if (xr >= j && xr <= n && nond(i, j, xr)) {
ans++;
}
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1600 + 100;
int n, m;
int a[maxn][maxn];
bool isPainted(int x, int y) {
return x >= 0 && y >= 0 && x < n && y < m && a[x][y];
}
int isInside(int x, int y) {
for (int dx = -3; dx <= 3; dx++)
for (int dy = -3; dy <= 3; dy++)
if (dx * dx + dy * dy != 18 && !isPainted(x + dx, y + dy)) return 0;
return 1;
}
bool isRay(int x, int y) {
if (a[x][y] != 1) return 0;
for (int dx = -5; dx <= 5; dx++)
for (int dy = -5; dy <= 5; dy++)
if (isPainted(x + dx, y + dy) && a[x + dx][y + dy] == 2) return 0;
return 1;
}
void dfsRay(int x, int y) {
if (!isPainted(x, y)) return;
if (a[x][y] != 8) return;
a[x][y] = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) dfsRay(x + dx, y + dy);
}
int dfs(int x, int y) {
if (!isPainted(x, y)) return 0;
int ret = 0;
if (a[x][y] == 8) dfsRay(x, y), ret++;
a[x][y] = 0;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) ret += dfs(x + dx, y + dy);
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++) cin >> a[i][j];
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (a[i][j]) a[i][j] += isInside(i, j);
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (isRay(i, j)) a[i][j] = 8;
vector<int> ans;
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (a[i][j] == 2) ans.push_back(dfs(i, j));
sort((ans).begin(), (ans).end());
cout << (int((ans).size())) << endl;
for (int i = 0, _n = (int)((int((ans).size()))); i < _n; i++)
cout << ans[i] << ' ';
cout << endl;
{
int _;
cin >> _;
return 0;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int ll_max(long long int a, long long int b, long long int c) {
return max(a, max(b, c));
}
int int_max(int a, int b, int c) { return max(a, max(b, c)); }
long long int ll_min(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
int int_min(int a, int b, int c) { return min(a, min(b, c)); }
long long int max(int a, long long int b) { return max((long long int)a, b); }
long long int min(int a, long long int b) { return min((long long int)a, b); }
long long int min(long long int a, int b) { return min(a, (long long int)b); }
long long int max(long long int a, int b) { return max(a, (long long int)b); }
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << ' ' << *it << " = " << a;
err(++it, args...);
}
template <typename T, typename U>
inline void min_self(T& x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void max_self(T& x, U y) {
if (x < y) x = y;
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << "[" << v.first << ", " << v.second << "]";
return out << ")";
}
template <class A, class B>
istream& operator>>(istream& in, pair<A, B>& a) {
return in >> a.first >> a.second;
}
template <class A>
istream& operator>>(istream& in, vector<A>& a) {
for (A& i : a) in >> i;
return in;
}
void solve() {
string str;
cin >> str;
set<long long int> s[2];
for (long long int i = 0; i < str.size(); i++) {
if (str[i] == '0')
s[0].insert(i + 1);
else
s[1].insert(i + 1);
}
vector<vector<long long int> > v;
while (!s[0].empty()) {
vector<long long int> x;
long long int t = 0;
long long int prev = 0;
while (1) {
auto it = s[t].lower_bound(prev);
if (t == 0 && it == s[t].end()) {
cout << -1 << '\n';
return;
} else if (t == 1 && it == s[t].end()) {
break;
}
prev = *it;
x.push_back(*it);
s[t].erase(*it);
t = 1 - t;
}
v.push_back(x);
}
if (!s[0].empty() || !s[1].empty()) {
cout << -1 << '\n';
return;
}
cout << v.size() << '\n';
for (long long int i = 0; i < v.size(); i++) {
cout << v[i].size() << " ";
for (long long int j = 0; j < v[i].size(); j++) {
cout << v[i][j] << " ";
}
cout << '\n';
}
return;
}
int main() {
(ios::sync_with_stdio(false), cin.tie(0));
long long int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5;
const int Magic = 5e2;
const int INF = 1e9;
int a[MaxN];
int n;
vector<pair<int, int> > res;
int sum[2][MaxN];
void solveMinT(int t) {
int score[2] = {0, 0};
int cur[2] = {0, 0};
for (int i = 0; i < n; i++) {
cur[a[i] - 1]++;
if (cur[a[i] - 1] == t) {
score[a[i] - 1]++;
cur[0] = cur[1] = 0;
}
}
if (cur[0] != 0 || cur[1] != 0) return;
if (score[0] == score[1]) return;
if (score[0] > score[1] && a[n - 1] == 1)
res.push_back(make_pair(score[0], t));
if (score[1] > score[0] && a[n - 1] == 2)
res.push_back(make_pair(score[1], t));
}
int getPos(int row, int score) {
int l = 0, r = n - 1;
if (sum[row][n - 1] < score) return INF;
while (l < r - 1) {
int mid = (l + r) / 2;
if (sum[row][mid] < score)
l = mid;
else
r = mid;
}
if (sum[row][l] == score) return l;
return r;
}
void solveMinS(int s, int t) {
int score1 = 0, score2 = 0;
int sets[2] = {0, 0};
int pos1, pos2;
while (sets[0] != s && sets[1] != s) {
pos1 = getPos(0, score1 + t);
pos2 = getPos(1, score2 + t);
if (pos1 == INF && pos2 == INF) return;
if (pos1 < pos2) {
sets[0]++;
score1 = sum[0][pos1];
score2 = sum[1][pos1];
} else {
sets[1]++;
score1 = sum[0][pos2];
score2 = sum[1][pos2];
}
}
if (min(pos1, pos2) != n - 1) return;
if (a[n - 1] == 1 && sets[0] == s && sets[1] < s && pos1 == n - 1)
res.push_back(make_pair(s, t));
if (a[n - 1] == 2 && sets[1] == s && sets[0] < s && pos2 == n - 1)
res.push_back(make_pair(s, t));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (i != 0) {
sum[0][i] = sum[0][i - 1];
sum[1][i] = sum[1][i - 1];
}
sum[a[i] - 1][i]++;
}
for (int t = 1; t <= min(Magic, n); t++) solveMinT(t);
for (int t = Magic + 1; t <= n; t++)
for (int s = 1; s * t <= n; s++) solveMinS(s, t);
sort(res.begin(), res.end());
printf("%d\n", (int)res.size());
for (int i = 0; i < (int)res.size(); i++)
printf("%d %d\n", res[i].first, res[i].second);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m, p = 0, q, i, j;
scanf("%d%d", &m, &q);
while (m--) {
scanf("%d", &i);
if (i == 1)
p++;
else
n++;
}
p = min(p, n);
while (q--) {
scanf("%d%d", &i, &j);
j -= i;
j++;
if (j % 2 == 1 || j / 2 > p)
printf("0\n");
else
printf("1\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int N = 100005;
int a[N * 2], ans[N];
stack<int> s;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++) {
char op;
scanf(" %c", &op);
if (op == '+') {
a[i] = -1;
} else {
scanf("%d", &a[i]);
}
}
int t = n;
for (int i = 2 * n; i >= 1; i--) {
if (a[i] == -1) {
if (s.empty()) return puts("NO"), 0;
ans[t--] = s.top();
s.pop();
} else {
if (!s.empty() && a[i] > s.top()) return puts("NO"), 0;
s.push(a[i]);
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn], b[maxn], cnt[maxn], dp[maxn], tot[maxn], fir[maxn], las[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b, b + n);
int sz = unique(b, b + n) - b;
for (int i = 0; i < n; i++) {
a[i] = lower_bound(b, b + sz, a[i]) - b;
cnt[a[i]]++;
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] > 0 && tot[a[i] - 1] == cnt[a[i] - 1])
dp[i] = max(dp[i], dp[fir[a[i] - 1] - 1] + cnt[a[i] - 1]);
if (las[a[i]]) dp[i] = max(dp[i], dp[las[a[i]] - 1] + 1);
if (a[i] > 0 && las[a[i] - 1]) dp[i] = max(dp[i], tot[a[i] - 1] + 1);
dp[i] = max(dp[i], 1);
ans = max(ans, dp[i]);
las[a[i]] = i + 1;
if (!fir[a[i]]) fir[a[i]] = i + 1;
tot[a[i]]++;
}
printf("%d\n", n - ans);
for (int i = 0; i < n; i++) {
dp[i] = 0;
fir[i] = las[i] = tot[i] = cnt[i] = 0;
}
}
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n % 2 == 0)
printf("white\n1 2\n");
else
printf("black\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long get() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const long long N = 4e5 + 5, P = 998244353, G = 3, iG = 332748118;
long long n, m, f[N], g[N], r[N];
long long fac[N], inv[N];
long long qpow(long long x, long long y) {
long long res = 1;
while (y) res = res * ((y & 1) ? x : 1) % P, x = x * x % P, y >>= 1;
return res;
}
void init() {
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % P;
inv[n] = qpow(fac[n], P - 2);
for (long long i = n; i >= 1; i--) inv[i - 1] = inv[i] * i % P;
}
void NTT(long long *A, long long lim, long long type) {
for (long long i = 0; i < lim; i++)
if (i < r[i]) swap(A[i], A[r[i]]);
for (long long mid = 1; mid < lim; mid <<= 1) {
long long Wn = qpow(type == 1 ? G : iG, (P - 1) / (mid << 1));
for (long long i = 0; i < lim; i += mid << 1) {
long long w = 1;
for (long long j = 0; j < mid; j++, w = w * Wn % P) {
long long x = A[i + j], y = A[i + mid + j] * w % P;
A[i + j] = (x + y) % P, A[i + mid + j] = (x - y + P) % P;
}
}
}
if (type == -1) {
long long ilim = qpow(lim, P - 2);
for (long long i = 0; i < lim; i++) A[i] = A[i] * ilim % P;
}
}
signed main() {
n = get(), m = get();
init();
for (long long i = 0; i <= n; i++)
f[n - i] = get() * fac[i] % P, g[i] = inv[i];
long long lim = 1, l = 0;
while (lim <= n * 2) lim <<= 1, l++;
for (long long i = 0; i < lim; i++)
r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(f, lim, 1), NTT(g, lim, 1);
for (long long i = 0; i < lim; i++) f[i] = f[i] * g[i] % P;
NTT(f, lim, -1);
for (long long i = 0; i <= n; i++)
f[n - i] = f[n - i] * qpow(qpow(i + 1, m), P - 2) % P;
for (long long i = n + 1; i < lim; i++) f[i] = 0;
memset(g, 0, sizeof(g));
for (long long i = 0; i <= n; i++)
g[i] = inv[i] * ((i & 1) ? (P - 1) : 1) % P;
NTT(f, lim, 1), NTT(g, lim, 1);
for (long long i = 0; i < lim; i++) f[i] = f[i] * g[i] % P;
NTT(f, lim, -1);
for (long long i = 0; i <= n; i++) printf("%lld ", f[n - i] * inv[i] % P);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
int main() {
long long n;
cin >> n;
for (long long i = ceil(sqrt(n)); i >= 1; i--) {
if (n % i == 0) {
if (gcd(n / i, i) == 1) {
cout << i << " " << n / i << endl;
break;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dfn[100010], idfn[100010], st[100010][18], n, dep[100010], tim = 0;
long long dis[100010];
vector<pair<int, int> > v[100010];
void dfs(int np, int fath) {
dfn[np] = ++tim;
idfn[tim] = np;
st[np][0] = fath;
dep[np] = dep[fath] + 1;
for (int i = 1; i < 18; i++) st[np][i] = st[st[np][i - 1]][i - 1];
for (auto &x : v[np]) {
if (x.first == fath) continue;
dis[x.first] = dis[np] + x.second;
dfs(x.first, np);
}
}
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 17; i >= 0; i--)
if (dep[st[x][i]] >= dep[y]) x = st[x][i];
if (x == y) return x;
for (int i = 17; i >= 0; i--)
if (st[x][i] != st[y][i]) x = st[x][i], y = st[y][i];
return st[x][0];
}
inline long long getdis(int x, int y) {
return dis[x] + dis[y] - 2 * dis[lca(x, y)];
}
set<int> S;
long long sum = 0;
int main() {
scanf("%d", &n);
for (int i = 1, ti, tj, tk; i < n; i++) {
scanf("%d%d%d", &ti, &tj, &tk);
v[ti].push_back(make_pair(tj, tk));
v[tj].push_back(make_pair(ti, tk));
}
dfs(1, 0);
int Q;
scanf("%d", &Q);
while (Q--) {
char opt[4];
scanf("%s", opt);
int x;
if (opt[0] == '+') {
scanf("%d", &x);
auto it = S.insert(dfn[x]).first;
auto prev = it;
if (prev != S.begin())
prev--;
else
prev = (--S.end());
auto nxt = it;
nxt++;
if (nxt == S.end()) nxt = S.begin();
sum -= getdis(idfn[*prev], idfn[*nxt]);
sum += getdis(idfn[*prev], x) + getdis(x, idfn[*nxt]);
} else if (opt[0] == '-') {
scanf("%d", &x);
auto it = S.find(dfn[x]);
auto prev = it;
if (prev != S.begin())
prev--;
else
prev = (--S.end());
auto nxt = it;
nxt++;
if (nxt == S.end()) nxt = S.begin();
sum += getdis(idfn[*prev], idfn[*nxt]);
sum -= getdis(idfn[*prev], x) + getdis(x, idfn[*nxt]);
S.erase(it);
} else {
printf("%lld\n", sum / 2);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
bool first = true;
os << "{";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ",";
os << v[i];
first = false;
}
return os << "}";
}
template <typename T>
inline ostream& operator<<(ostream& os, const set<T>& v) {
bool first = true;
os << "{";
for (typename set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
inline ostream& operator<<(ostream& os, const multiset<T>& v) {
bool first = true;
os << "{";
for (typename multiset<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const map<T1, T2>& v) {
bool first = true;
os << "{";
for (typename map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
bool isPrime(T n) {
T i, lmt = sqrt(n);
for (i = 2; i <= lmt; i++)
if (n % i == 0) return false;
return true;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0)
return 1 % m;
else if (p & 1)
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
else {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
}
template <typename T>
T power(T b, T p) {
if (p == 0)
return 1;
else if (p & 1)
return b * power(b, p - 1);
else {
T ret = power(b, p / 2);
return ret * ret;
}
}
template <typename T>
T ModInv(T b, T m) {
if (isPrime(b))
return BigMod(b, m - 2, m) % m;
else if (gcd(b, m) == 1)
return BigMod(b, m - 1, m) % m;
}
template <typename T>
T egcd(T a, T b, T& x, T& y) {
T d;
if (a == 0) {
x = 0;
y = 1;
return b;
} else {
T x1, y1;
d = egcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
}
return d;
}
int toint(string s) {
int i, j, l;
int num;
l = s.size();
for (i = l - 1, j = 0, num = 0; i >= 0; i--, j++) {
num += (s[i] - 48) * power(10, j);
}
return num;
}
const double pi = acos(-1);
const int inf = (1 << 30);
const long long INF = (1LL << 62) - 1;
const int mod = (int)1e9 + 7;
const long long MOD = (long long)1e9 + 7;
const double EPS = 1e-9;
const int dx8[] = {-1, 0, +1, -1, +1, -1, 0, +1};
const int dy8[] = {+1, +1, +1, 0, 0, -1, -1, -1};
const int dx4[] = {0, -1, +1, 0};
const int dy4[] = {+1, 0, 0, -1};
const int dx2[] = {+1, 0};
const int dy2[] = {0, +1};
const int dxkn[] = {1, -1, 1, -1, 2, -2, -2, 2};
const int dykn[] = {2, 2, -2, -2, 1, 1, -1, -1};
string str1 = "", str2 = "", first = "";
string solve(char p, char q, int val_p, int val_q) {
string str = "";
int i;
if (val_p == val_q) {
for (i = 0; i < val_p; i++) {
str += p;
str += q;
}
} else if (val_p == val_q + 1) {
for (i = 0; i < val_q; i++) {
str += p;
str += q;
}
str += p;
} else if (val_p + 1 == val_q) {
for (i = 0; i < val_p; i++) {
str += p;
str += q;
}
string tmp = str;
str = q;
str += tmp;
} else
str = "";
return str;
}
int main() {
int a, b, c, d, i;
cin >> a >> b >> c >> d;
if (a + b + c + d == 1) {
cout << "YES"
<< "\n";
if (a)
cout << "0"
<< "\n";
if (b)
cout << "1"
<< "\n";
if (c)
cout << "2"
<< "\n";
if (d)
cout << "3"
<< "\n";
return 0;
}
if (!a && !b && c && d) str1 = solve('2', '3', c, d);
if (!a && b && c && !d) str1 = solve('1', '2', b, c);
if (a && b && !c && !d) str1 = solve('0', '1', a, b);
if (str1 != "") {
cout << "YES"
<< "\n";
for (i = 0; i < str1.size(); i++) {
cout << str1[i] << " ";
}
cout << "\n";
return 0;
}
if (a > b || d > c) {
cout << "NO"
<< "\n";
} else {
for (i = 0; i < a; i++) {
str1 += "01";
}
b -= a;
for (i = 0; i < d; i++) {
str2 += "23";
}
c -= d;
if (b == c) {
for (i = 0; i < b; i++) {
str1 += "21";
}
} else if (b + 1 == c) {
for (i = 0; i < b; i++) {
str1 += "21";
}
str2 += "2";
} else if (c + 1 == b) {
for (i = 0; i < c; i++) {
str1 += "21";
}
first += "1";
} else {
cout << "NO"
<< "\n";
return 0;
}
cout << "YES"
<< "\n";
if (first != "") cout << first << " ";
str1 += str2;
for (i = 0; i < str1.size(); i++) {
cout << str1[i] << " ";
}
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e5 + 5;
int n, c, a[MAX], lft[MAX], rgt[MAX];
vector<int> v[MAX];
int main() {
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
v[x].push_back(i);
a[i] = x;
}
for (int i = 1; i <= n; i++) lft[i] = lft[i - 1] + (a[i] == c);
for (int i = n; i > 0; i--) rgt[i] = rgt[i + 1] + (a[i] == c);
int ans = 0;
for (int i = 1; i <= 5e5; i++) {
if (v[i].empty()) continue;
int mx = INT_MIN;
for (int k = (int)v[i].size() - 1; k >= 0; k--) {
int pos = v[i][k];
int val = rgt[pos + 1] + k;
mx = max(mx, val);
ans = max(ans, lft[pos - 1] - k + 1 + mx);
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
int even = 0, odd = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 != i % 2) {
if (i % 2 == 0)
even++;
else
odd++;
}
}
if (even == odd)
cout << even << endl;
else
cout << -1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10;
long long sum[MAXN], pre[MAXN];
int a[MAXN], cnt, N;
long long ans;
long long x[MAXN], y[MAXN], total;
inline long long calc(long long a, long long d, long long b, long long c) {
return a - b * d + c;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", &a[i]);
ans = 0;
for (int i = 1; i <= N; ++i) {
pre[i] = pre[i - 1];
pre[i] += (long long)i * (long long)a[i];
sum[i] = sum[i - 1];
sum[i] += (long long)a[i];
ans = max(ans, pre[i]);
{
ans = max(ans, calc(pre[i], sum[i], x[cnt], y[cnt]));
int l = 1, r = cnt - 1;
while (l <= r) {
int mid = (l + r) / 2;
ans = max(ans, calc(pre[i], sum[i], x[mid], y[mid]));
if ((y[mid + 1] - y[mid]) >= sum[i] * (x[mid + 1] - x[mid])) {
l = mid + 1;
} else
r = mid - 1;
}
}
long long delta = sum[i] * (long long)i - pre[i];
long long k = i;
long long tx1, tx2, ty1, ty2;
while (cnt > 1) {
tx1 = x[cnt] - x[cnt - 1];
ty1 = y[cnt] - y[cnt - 1];
tx2 = k - x[cnt - 1];
ty2 = delta - y[cnt - 1];
if (tx1 * ty2 - tx2 * ty1 >= 0)
--cnt;
else
break;
}
++cnt;
x[cnt] = k;
y[cnt] = delta;
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e4 + 50;
const int inf = 1e9;
namespace FastIO {
const int SIZE = 1 << 16;
char buf[SIZE], obuf[SIZE], str[60];
int bi = SIZE, bn = SIZE, opt;
int read(char* s) {
while (bn) {
for (; bi < bn && buf[bi] <= ' '; bi++)
;
if (bi < bn) break;
bn = fread(buf, 1, SIZE, stdin);
bi = 0;
}
int sn = 0;
while (bn) {
for (; bi < bn && buf[bi] > ' '; bi++) s[sn++] = buf[bi];
if (bi < bn) break;
bn = fread(buf, 1, SIZE, stdin);
bi = 0;
}
s[sn] = 0;
return sn;
}
bool read(int& x) {
int n = read(str), bf;
if (!n) return 0;
int i = 0;
if (str[i] == '-')
bf = -1, i++;
else
bf = 1;
for (x = 0; i < n; i++) x = x * 10 + str[i] - '0';
if (bf < 0) x = -x;
return 1;
}
}; // namespace FastIO
int b[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
map<int, int> a;
int n;
FastIO::read(n);
int M = 0;
for (int i = 0; i < n; ++i) {
int x;
FastIO::read(x);
if (!a.count(x)) a[x] = 0;
a[x]++;
M = max(M, x);
}
int ans1 = 0, ans2;
int cnt = 0;
for (map<int, int>::iterator it = a.begin(); it != a.end(); ++it) {
if (it->second >= 4) {
ans1 = ans2 = it->first;
break;
}
if (it->second >= 2) b[cnt++] = it->first;
}
if (!ans1) {
ans1 = M, ans2 = 1;
for (int i = 1; i < cnt; ++i) {
if (ans1 * b[i - 1] > ans2 * b[i]) {
ans1 = b[i];
ans2 = b[i - 1];
}
}
}
printf("%d %d %d %d\n", ans1, ans1, ans2, ans2);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
double lo = 0;
double hi = 1e20;
for (int i = 1; i <= n; i++) {
double pos;
scanf("%lf", &pos);
lo = max(lo, pos / i);
hi = min(hi, (pos + 1) / i);
}
lo *= n + 1;
hi *= n + 1;
if ((int)lo != (int)(hi - 1e-8)) {
puts("not unique");
} else {
puts("unique");
printf("%d\n", (int)lo);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
namespace CPTH {
template <typename valueType, typename modType>
struct SegmentTreeNode {
size_t id;
long long left, right;
valueType val;
modType mod;
};
template <typename valueType, typename modType,
bool elementModificationOnly = false>
class SegmentTree {
public:
SegmentTree() = default;
SegmentTree(
const std::vector<valueType> &_initValue,
std::function<valueType(const valueType &, const valueType &)> _merge,
std::function<void(SegmentTreeNode<valueType, modType> &,
const modType &)>
_update,
long long _startPoint = 1, const valueType &_valueZero = valueType(),
const modType &_modZero = modType());
void init(
const std::vector<valueType> &_initValue,
std::function<valueType(const valueType &, const valueType &)> _merge,
std::function<void(SegmentTreeNode<valueType, modType> &,
const modType &)>
_update,
long long _startPoint = 1, const valueType &_valueZero = valueType(),
const modType &_modZero = modType());
void modify(long long l, long long r, const modType &mod);
void modify(long long p, const modType &mod);
valueType query(long long l, long long r);
valueType query(long long p);
private:
void pushup(size_t cur);
void pushdown(size_t cur);
void build(size_t cur, long long l, long long r,
const std::vector<valueType> &initValue);
void m_init(
const std::vector<valueType> &_initValue,
std::function<valueType(const valueType &, const valueType &)> _merge,
std::function<void(SegmentTreeNode<valueType, modType> &,
const modType &)>
_update,
const valueType &_valueZero, const modType &_modZero);
void modify(size_t cur, long long l, long long r, long long L, long long R,
const modType &mod);
valueType query(size_t cur, long long l, long long r, long long L,
long long R);
std::function<valueType(const valueType &, const valueType &)> merge;
std::function<void(SegmentTreeNode<valueType, modType> &, const modType &)>
update;
std::vector<SegmentTreeNode<valueType, modType>> nodes;
long long leftRange = 0, rightRange = 0;
valueType valueZero;
modType modZero;
};
template <typename valueType, typename modType, bool elementModificationOnly>
SegmentTree<valueType, modType, elementModificationOnly>::SegmentTree(
const std::vector<valueType> &_initValue,
std::function<valueType(const valueType &, const valueType &)> _merge,
std::function<void(SegmentTreeNode<valueType, modType> &, const modType &)>
_update,
long long _startPoint, const valueType &_valueZero,
const modType &_modZero) {
init(_initValue, _merge, _update, _startPoint, _valueZero, _modZero);
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::init(
const std::vector<valueType> &_initValue,
std::function<valueType(const valueType &, const valueType &)> _merge,
std::function<void(SegmentTreeNode<valueType, modType> &, const modType &)>
_update,
long long _startPoint, const valueType &_valueZero,
const modType &_modZero) {
assert(_startPoint >= LLONG_MIN / 2);
assert(_startPoint <= LLONG_MAX / 2 - (long long)_initValue.size());
leftRange = _startPoint;
rightRange = _startPoint + _initValue.size();
m_init(_initValue, _merge, _update, _valueZero, _modZero);
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::modify(
long long l, long long r, const modType &mod) {
assert(!elementModificationOnly);
modify(1, leftRange, rightRange, l, r, mod);
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::modify(
long long p, const modType &mod) {
assert(p < LLONG_MAX);
modify(1, leftRange, rightRange, p, p + 1, mod);
}
template <typename valueType, typename modType, bool elementModificationOnly>
valueType SegmentTree<valueType, modType, elementModificationOnly>::query(
long long l, long long r) {
return query(1, leftRange, rightRange, l, r);
}
template <typename valueType, typename modType, bool elementModificationOnly>
valueType SegmentTree<valueType, modType, elementModificationOnly>::query(
long long p) {
return query(p, p + 1);
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::pushup(
size_t cur) {
nodes[cur].val = merge(nodes[cur << 1].val, nodes[cur << 1 | 1].val);
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::pushdown(
size_t cur) {
update(nodes[cur << 1], nodes[cur].mod);
update(nodes[cur << 1 | 1], nodes[cur].mod);
nodes[cur].mod = modZero;
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::build(
size_t cur, long long l, long long r,
const std::vector<valueType> &initValue) {
nodes[cur].id = cur;
nodes[cur].left = l;
nodes[cur].right = r;
nodes[cur].mod = modZero;
if (l == r - 1)
nodes[cur].val = initValue[l - leftRange];
else {
build(cur << 1, l, (l + r) >> 1, initValue);
build(cur << 1 | 1, (l + r) >> 1, r, initValue);
pushup(cur);
}
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::m_init(
const std::vector<valueType> &_initValue,
std::function<valueType(const valueType &, const valueType &)> _merge,
std::function<void(SegmentTreeNode<valueType, modType> &, const modType &)>
_update,
const valueType &_valueZero, const modType &_modZero) {
merge = _merge;
update = _update;
valueZero = _valueZero;
modZero = _modZero;
nodes.resize((rightRange - leftRange) << 2);
build(1, leftRange, rightRange, _initValue);
}
template <typename valueType, typename modType, bool elementModificationOnly>
void SegmentTree<valueType, modType, elementModificationOnly>::modify(
size_t cur, long long l, long long r, long long L, long long R,
const modType &mod) {
if (l >= R || r <= L) return;
if (L <= l && r <= R)
update(nodes[cur], mod);
else {
if (!elementModificationOnly) pushdown(cur);
modify(cur << 1, l, (l + r) >> 1, L, R, mod);
modify(cur << 1 | 1, (l + r) >> 1, r, L, R, mod);
pushup(cur);
}
}
template <typename valueType, typename modType, bool elementModificationOnly>
valueType SegmentTree<valueType, modType, elementModificationOnly>::query(
size_t cur, long long l, long long r, long long L, long long R) {
if (l >= R || r <= L) return valueZero;
if (L <= l && r <= R) return nodes[cur].val;
if (!elementModificationOnly) pushdown(cur);
return merge(query(cur << 1, l, (l + r) >> 1, L, R),
query(cur << 1 | 1, (l + r) >> 1, r, L, R));
}
} // namespace CPTH
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const double inf = 1e121;
const double eps = 1e-10;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int randint(int l, int r) {
int out = rng() % (r - l + 1) + l;
return out >= l ? out : out + r - l + 1;
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
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;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
template <typename A, typename B, typename C, typename D, typename E>
string to_string(tuple<A, B, C, D, E> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + "," +
to_string(get<4>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T>
struct is_pair {
static const bool value = false;
};
template <typename T, typename U>
struct is_pair<std::pair<T, U>> {
static const bool value = true;
};
const int INF = 0x3f3f3f3f;
template <typename T>
typename enable_if<!is_integral<T>::value && !is_pair<T>::value, void>::type
read(T &x) {
cin >> x;
}
long long read() {
char c;
long long out = 0, f = 1;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar()) {
}
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) out = (out << 3) + (out << 1) + c - '0';
return out * f;
}
template <typename T>
typename enable_if<is_integral<T>::value, T>::type read(T &x) {
char c;
T f = 1;
x = 0;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar()) {
}
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
return x *= f;
}
char read(char &x) {
for (x = getchar(); isspace(x); x = getchar()) {
}
return x;
}
double read(double &x) {
scanf("%lf", &x);
return x;
}
template <typename T>
typename enable_if<!is_integral<T>::value && !is_pair<T>::value, void>::type
write(const T &x) {
cout << x;
}
template <typename T>
typename enable_if<is_integral<T>::value, void>::type write(const T &x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void write(char x) { putchar(x); }
void write(double x) { printf("%.12lf", x); }
void write(long double x) { cout << fixed << setprecision(12) << x; }
template <typename T>
typename enable_if<is_pair<T>::value, void>::type read(T &x) {
read(x.first);
read(x.second);
}
template <typename T>
typename enable_if<is_pair<T>::value, void>::type write(const T &x) {
write(x.first);
putchar(' ');
write(x.second);
}
template <typename T, typename... Args>
void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <
typename OutputIt,
typename = typename enable_if<
is_same<output_iterator_tag,
typename iterator_traits<OutputIt>::iterator_category>::value ||
(is_base_of<forward_iterator_tag, typename iterator_traits<OutputIt>::
iterator_category>::value &&
!is_const<OutputIt>::value)>::type>
void read(OutputIt __first, OutputIt __last) {
for (; __first != __last; ++__first) read(*__first);
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wts(InputIt __first, InputIt __last) {
bool isFirst = true;
for (; __first != __last; ++__first) {
if (isFirst)
isFirst = false;
else
putchar(' ');
write(*__first);
}
putchar('\n');
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wtb(InputIt __first, InputIt __last) {
for (; __first != __last; ++__first) {
write(*__first);
putchar('\n');
}
}
template <typename T>
void wts(const T &x) {
write(x);
putchar(' ');
}
template <typename T>
void wtb(const T &x) {
write(x);
putchar('\n');
}
template <typename T>
void wte(const T &x) {
write(x);
exit(0);
}
template <typename T, typename... Args>
void wts(const T &x, Args... args) {
wts(x);
wts(args...);
}
template <typename T, typename... Args>
void wtb(const T &x, Args... args) {
wts(x);
wtb(args...);
}
template <typename T, typename... Args>
void wte(const T &x, Args... args) {
wts(x);
wte(args...);
}
template <typename T1, typename T2>
inline bool up(T1 &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T1, typename T2>
inline bool dn(T1 &x, const T2 &y) {
return y < x ? x = y, 1 : 0;
}
template <typename T1, typename T2, typename T3>
inline bool inRange(const T1 &x, const T2 &l, const T3 &r) {
return !(x < l) && !(r < x);
}
template <typename T1, typename T2>
inline auto minOfDifferentTypes(const T1 &x, const T2 &y)
-> decltype(x < y ? x : y) {
return x < y ? x : y;
}
template <typename T1, typename T2>
inline auto maxOfDifferentTypes(const T1 &x, const T2 &y)
-> decltype(x < y ? y : x) {
return x < y ? y : x;
}
template <typename T1, typename T2, typename T3>
inline T1 &madd(T1 &x, const T2 &y, const T3 &modulo) {
return x = (long long)(x + y + modulo) % modulo;
}
template <typename T1, typename T2, typename T3>
inline T1 &mmul(T1 &x, const T2 &y, const T3 &modulo) {
return x = (long long)x * y % modulo;
}
inline int modadd(int x, int y, int modulo) {
return x + y >= modulo ? x + y - modulo : x + y;
}
inline int isinf(int x) { return x < INF ? x : -1; }
inline void yesno(bool x) { wtb(x ? "Yes" : "No"); }
using namespace CPTH;
struct LCT {
struct Node {
int pa;
vector<int> ch;
bool rev;
Node() : pa(0), ch(2), rev(false) {}
};
vector<Node> t;
LCT(int n) : t(n + 1) {}
bool notRoot(int x) { return x == t[t[x].pa].ch[0] || x == t[t[x].pa].ch[1]; }
void rotate(int x) {
int y = t[x].pa;
int z = t[y].pa;
int k = x == t[y].ch[1];
if (notRoot(y)) t[z].ch[y == t[z].ch[1]] = x;
t[x].pa = z;
t[y].ch[k] = t[x].ch[k ^ 1];
t[t[x].ch[k ^ 1]].pa = y;
t[x].ch[k ^ 1] = y;
t[y].pa = x;
}
void reverse(int x) {
swap(t[x].ch[0], t[x].ch[1]);
t[x].rev ^= 1;
}
void pushdown(int x) {
if (t[x].rev) {
reverse(t[x].ch[0]);
reverse(t[x].ch[1]);
t[x].rev = false;
}
}
void splay(int x) {
static stack<int> stk;
stk.push(x);
for (int u = x; notRoot(u); u = t[u].pa) stk.push(t[u].pa);
while (!stk.empty()) {
pushdown(stk.top());
stk.pop();
}
while (notRoot(x)) {
int y = t[x].pa;
int z = t[y].pa;
if (notRoot(y)) rotate((x == t[y].ch[1]) ^ (y == t[z].ch[1]) ? x : y);
rotate(x);
}
}
void splay(int x, int goal) {
while (t[x].pa != goal) {
int y = t[x].pa;
int z = t[y].pa;
if (z != goal) rotate((x == t[y].ch[1]) ^ (y == t[z].ch[1]) ? x : y);
rotate(x);
}
}
void access(int x) {
for (int y = 0; x; x = t[y = x].pa) {
splay(x);
t[x].ch[1] = y;
}
}
void makeRoot(int x) {
access(x);
splay(x);
reverse(x);
}
int findRoot(int x) {
access(x);
splay(x);
while (t[x].ch[0]) {
pushdown(x);
x = t[x].ch[0];
}
splay(x);
return x;
}
bool link(int x, int y) {
makeRoot(x);
if (findRoot(y) == x) return false;
access(y);
splay(y);
t[x].pa = y;
return true;
}
void cut(int x, int y) {
makeRoot(x);
access(y);
t[x].ch[1] = t[y].pa = 0;
}
};
signed main() {
int n, m;
read(n, m);
vector<vector<int>> a(n, vector<int>(m + 1));
for (auto &x : a) read(((x).begin() + 1), (x).end());
LCT lct(n * m);
int r = 0;
vector<vector<int>> g(n * m + 1);
vector<pair<int, int>> dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
for (int i = (0), iend = (n - 1); i <= iend; ++i) {
for (int j = (1), jend = (m); j <= jend; ++j) {
for (int k = (0), kend = (3); k <= kend; ++k) {
int ni = i + dir[k].first;
int nj = j + dir[k].second;
if (inRange(ni, 0, n - 1) && inRange(nj, 1, m))
g[a[i][j]].push_back(a[ni][nj]);
}
}
}
vector<int> mxr(n * m + 1);
for (int l = (1), lend = (n * m); l <= lend; ++l) {
bool flag = true;
while (flag && r < n * m) {
++r;
for (int i = (0), iend = ((int)g[r].size() - 1); i <= iend; ++i) {
int v = g[r][i];
if (inRange(v, l, r - 1)) {
if (!lct.link(r, v)) {
for (int j = (0), jend = (i - 1); j <= jend; ++j) {
int w = g[r][j];
if (inRange(w, l, r - 1)) lct.cut(r, w);
}
--r;
flag = false;
break;
}
}
}
}
mxr[l] = r;
for (auto v : g[l]) {
if (inRange(v, l + 1, r)) {
lct.cut(l, v);
}
}
}
SegmentTree<pair<int, int>, int> seg(
vector<pair<int, int>>(n * m, pair<int, int>(0, 1)),
[](pair<int, int> x, pair<int, int> y) {
if (x.first == y.first)
return pair<int, int>(x.first, x.second + y.second);
return minOfDifferentTypes(x, y);
},
[](SegmentTreeNode<pair<int, int>, int> &u, int x) {
u.val.first += x;
u.mod += x;
},
1, pair<int, int>(INF, 0));
long long ans = 0;
for (int l = (n * m), lend = (1); l >= lend; --l) {
seg.modify(l, n * m + 1, 1);
for (auto v : g[l]) {
if (inRange(v, l + 1, mxr[l])) {
seg.modify(v, n * m + 1, -1);
}
}
pair<int, int> res = seg.query(l, mxr[l] + 1);
if (res.first == 1) ans += res.second;
}
wtb(ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
const int maxn = 1000001;
const int mod = 1000000007;
int binpow(long long a, int n) {
long long res = 1;
while (n) {
if (n & 1) res *= a, res %= mod;
a *= a, a %= mod;
n >>= 1;
}
return res;
}
int binpow2(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
int p[8];
short mask[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
bool able(int d, short k) {
if (k == 8)
for (int i = (0); i < (k); i++)
p[i] = ((d & ((1 << (3 * (i + 1))) - 1)) >> (3 * i)), mask[i] = -1;
else
for (int i = (0); i < (k); i++)
p[i] = (d % binpow2(k, i + 1)) / binpow2(k, i), mask[i] = -1;
for (int i = (0); i < (k); i++) {
if (mask[i] != -1) continue;
int cur = i;
mask[cur] = i;
cur = p[cur];
while (cur != 0) {
mask[cur] = i;
int t = p[cur];
if (t == 0 || (mask[t] < i && mask[t] != -1)) break;
if (mask[t] == i) return 0;
cur = t;
}
}
return true;
}
int g1(int k) {
int b = 1;
for (int i = (0); i < (k); i++) b *= k;
int cnt = 0;
for (int i = (0); i < (b); i++)
if (able(i, k)) cnt++;
return cnt;
}
int main() {
int n, k;
cin >> n >> k;
cout << (long long)g1(k) * binpow(n - k, n - k) % mod << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[300000];
long long f[300001];
long long mod = 998244353;
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
f[0] = 1;
for (long long i = 1; i <= n; ++i) {
f[i] = (f[i - 1] * i) % mod;
cin >> a[i - 1].first >> a[i - 1].second;
}
sort(a, a + n);
pair<long long, long long> p = a[0];
long long cp = 0, ca = 0, rp = 1, ra = 1;
for (long long i = 0; i <= n; ++i) {
if (i < n && a[i].second < p.second) rp = 0;
if (i == n || p != a[i]) {
if (i == n || p.first != a[i].first) {
ra = (ra * f[ca]) % mod;
ca = 1;
} else
++ca;
rp = (rp * f[cp]) % mod;
cp = 1;
if (i < n) p = a[i];
} else {
++cp;
++ca;
}
swap(a[i].first, a[i].second);
}
sort(a, a + n);
long long cb = 0, rb = 1;
p = a[0];
for (long long i = 0; i <= n; ++i) {
if (i == n || p.first != a[i].first) {
rb = (rb * f[cb]) % mod;
cb = 1;
if (i < n) p = a[i];
} else
++cb;
}
long long r = (f[n] + rp) % mod;
r = (r + mod - ra) % mod;
r = (r + mod - rb) % mod;
cout << r << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int f = 1;
int res = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -f;
} while (ch < '0' || ch > '9');
do {
res = res * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f == 1 ? res : -res;
}
const int N = 200005;
const long long INF = 2000000000000LL;
int n, m;
int p[N], b[N], inc[N], pb[N];
int dish[N], usr[N];
int head[N * 2], to[N * 4], nxt[N * 4], tot;
int match[N * 2], res[N];
bool visited[N * 2];
void addEdge(int u, int v) {
tot++;
nxt[tot] = head[u];
to[tot] = v;
head[u] = tot;
}
bool check(int x) {
for (int i = head[x]; i; i = nxt[i]) {
int j = to[i];
if (!visited[j]) {
visited[j] = true;
if (match[j] == -1 || check(match[j])) {
match[j] = x;
match[x] = j;
return true;
}
}
}
return false;
}
bool cmpd(int x, int y) { return p[x] < p[y]; }
bool cmpu(int x, int y) { return inc[x] < inc[y]; }
struct Splay {
int son[N][2], f[N], cou[N], siz[N], key[N];
int root, sz;
void clear(int x) {
son[x][0] = son[x][1] = cou[x] = f[x] = siz[x] = key[x] = 0;
}
bool get(int x) { return son[f[x]][1] == x; }
void update(int x) {
if (x) {
siz[x] = cou[x];
if (son[x][0]) siz[x] += siz[son[x][0]];
if (son[x][1]) siz[x] += siz[son[x][1]];
}
}
void rotate(int x) {
int old = f[x], oldf = f[old], whichson = get(x);
son[old][whichson] = son[x][whichson ^ 1], f[son[old][whichson]] = old;
son[x][whichson ^ 1] = old, f[old] = x;
f[x] = oldf;
if (oldf) {
son[oldf][son[oldf][1] == old] = x;
}
update(old);
update(x);
}
void splay(int x) {
for (int fa; (fa = f[x]); rotate(x)) {
if (f[fa]) {
rotate((get(x) == get(fa)) ? fa : x);
}
}
root = x;
}
void insert(int x) {
if (root == 0) {
sz++;
son[sz][0] = son[sz][1] = f[sz] = 0;
key[sz] = x;
cou[sz] = siz[sz] = 1;
root = sz;
return;
}
int now = root, fa = 0;
while (1) {
if (x == key[now]) {
cou[now]++;
update(now);
update(fa);
splay(now);
break;
}
fa = now;
now = son[now][key[now] < x];
if (now == 0) {
sz++;
f[sz] = fa;
son[sz][0] = son[sz][1] = 0;
cou[sz] = siz[sz] = 1;
son[fa][key[fa] < x] = sz;
key[sz] = x;
update(fa);
splay(sz);
break;
}
}
}
int find(int x) {
int now = root, ans = 0;
while (1) {
if (now == 0) return ans;
if (x < key[now]) {
now = son[now][0];
} else {
ans += (son[now][0] ? siz[son[now][0]] : 0);
if (x == key[now]) {
splay(now);
return ans + cou[now];
}
ans += cou[now];
now = son[now][1];
}
}
}
int findx(int x) {
int now = root;
while (1) {
if (son[now][0] && x <= siz[son[now][0]]) {
now = son[now][0];
} else {
int temp = (son[now][0] ? siz[son[now][0]] : 0) + cou[now];
if (x <= temp) return key[now];
x -= temp;
now = son[now][1];
}
}
}
int pre() {
int now = son[root][0];
while (son[now][1]) now = son[now][1];
return now;
}
int next() {
int now = son[root][1];
while (son[now][0]) now = son[now][0];
return now;
}
void del(int x) {
int whatever = find(x);
if (cou[root] > 1) {
cou[root]--;
update(root);
return;
}
if (!son[root][0] && !son[root][1]) {
clear(root);
root = 0;
return;
}
if (!son[root][0]) {
int oldroot = root;
root = son[root][1];
f[root] = 0;
clear(oldroot);
return;
}
if (!son[root][1]) {
int oldroot = root;
root = son[root][0];
f[root] = 0;
clear(oldroot);
return;
}
int leftbig = pre(), oldroot = root;
splay(leftbig);
son[root][1] = son[oldroot][1];
f[son[root][1]] = root;
clear(oldroot);
update(root);
return;
}
} splay[2];
int main() {
n = read();
m = read();
for (int i = 0; i < n; i++) {
p[i] = read();
}
for (int i = 0; i < n; i++) {
p[i + n] = read() + 1;
}
for (int i = 0; i < n; i++) {
b[i] = read();
}
for (int i = 0; i < m; i++) {
inc[i] = read();
}
for (int i = 0; i < m; i++) {
pb[i] = read();
}
for (int i = 0; i < n * 2; i++) dish[i] = i;
sort(dish, dish + (n * 2), cmpd);
for (int i = 0; i < m; i++) usr[i] = i;
sort(usr, usr + m, cmpu);
int id = 0;
for (int i = 0; i < m; i++) {
int ui = usr[i];
int in = inc[usr[i]];
for (; id < n * 2; id++) {
int idx = dish[id];
if (p[idx] > in) break;
if (idx < n) {
splay[0].insert(p[idx] + b[idx]);
splay[1].insert(b[idx] + 1 - p[idx]);
} else {
idx = idx - n;
splay[0].del(p[idx] + b[idx]);
splay[1].del(b[idx] + 1 - p[idx]);
}
}
int l = splay[0].find(in + pb[ui]);
int r = splay[1].find(pb[ui] - in);
res[ui] = l - r;
}
for (int i = 0; i < m; i++) printf("%d\n", res[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void _read(T& x) {
cin >> x;
}
void R() {}
template <typename T, typename... U>
void R(T& head, U&... tail) {
_read(head);
R(tail...);
}
template <typename T>
inline void _write(const T& x) {
cout << x << ' ';
}
void W() { cout << endl; }
template <typename T, typename... U>
void W(const T& head, const U&... tail) {
_write(head);
W(tail...);
}
void go();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
go();
return 0;
}
void fun() {
vector<int> cnt(26, 0);
string s;
R(s);
for (auto c : s) {
cnt[c - 'a']++;
}
s = "";
for (int i = 0; i <= 25; i++) {
if (cnt[i]) {
s += (char)i + 'a';
}
}
int len = s.length();
for (int t = 1; t <= 1000; t++) {
random_shuffle(s.begin(), s.end());
bool f = true;
for (int i = 1; i <= len - 1; i++) {
if (abs(s[i] - s[i - 1]) == 1) {
f = false;
break;
}
}
if (f) {
for (auto c : s) {
while (cnt[c - 'a']--) {
cout << c;
}
}
cout << endl;
return;
}
}
cout << "No answer" << endl;
return;
}
void go() {
int T;
R(T);
while (T--) {
fun();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int K = 30;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> cnt(K);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < K; ++j) {
if (a[i] & (1 << j)) {
++cnt[j];
}
}
}
int ans = -1, id = -1;
for (int i = 0; i < n; ++i) {
int cur = 0;
for (int j = 0; j < K; ++j) {
if (cnt[j] == 1 && (a[i] & (1 << j))) {
cur |= (1 << j);
}
}
if (cur > ans) {
ans = cur;
id = i;
}
}
cout << a[id] << ' ';
for (int i = 0; i < n; ++i) {
if (i != id) {
cout << a[i] << ' ';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e+7;
int t[maxn][2], sum[maxn], h;
long long ans, k;
void insert(int x) {
int i, j, p, u;
u = 1;
for (i = 30; i >= 0; i--) {
p = (x >> i) & 1;
if (!t[u][p]) t[u][p] = ++h;
sum[u]++;
u = t[u][p];
}
sum[u]++;
}
void get(int x) {
int i, j, p, u;
u = 1;
for (i = 30; i >= 0; i--) {
p = ((x >> i) & 1) ^ 1;
if (!((k >> i) & 1)) {
ans += sum[t[u][p]];
u = t[u][p ^ 1];
} else
u = t[u][p];
}
ans += sum[u];
}
int main() {
int i, j, n;
long long a, z;
memset(t, 0, sizeof(t));
memset(sum, 0, sizeof(sum));
scanf("%d%I64d", &n, &k);
h = 1;
z = 0;
ans = 0;
insert(0);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a);
z = z ^ a;
get(z);
insert(z);
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n % 2 == 0)
cout << n / 2 << "\n";
else
cout << n / 2 + 1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void cmin(T &a, T b) {
((a > b) && (a = b));
}
template <class T>
inline void cmax(T &a, T b) {
((a < b) && (a = b));
}
char IO;
template <class T = int>
T rd() {
T s = 0;
int f = 0;
while (!isdigit(IO = getchar())) f |= IO == '-';
do s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 2e5 + 10, INF = 1e9 + 10;
int n, m, a[N];
vector<int> G[N];
struct Node {
long long k, b;
Node() {}
Node(long long k, long long b) : k(k), b(b) {}
long long operator[](long long x) const { return k * x + b; }
} s[N];
int ls[N], rs[N], cnt;
int New() {
int u = ++cnt;
ls[u] = rs[u] = 0, s[u] = Node(-INF, -INF);
return u;
}
void Upd(int &p, int l, int r, Node x) {
if (x.k < 0) return;
if (!p) p = New();
int mid = (l + r) >> 1;
if (s[p][mid] < x[mid]) swap(s[p], x);
if (l == r) return;
if (x[l] > s[p][l]) Upd(ls[p], l, mid - 1, x);
if (x[r] > s[p][r]) Upd(rs[p], mid + 1, r, x);
}
long long Que(int p, int l, int r, int x) {
if (l == r) return s[p][x];
int mid = (l + r) >> 1;
return max(s[p][x],
x <= mid ? Que(ls[p], l, mid, x) : Que(rs[p], mid + 1, r, x));
}
int vis[N], mi = 1e9, rt, sz[N];
void FindRt(int n, int u, int f) {
int ma = 0;
sz[u] = 1;
for (int v : G[u])
if (v != f && !vis[v]) {
FindRt(n, v, u);
cmax(ma, sz[v]), sz[u] += sz[v];
}
cmax(ma, n - sz[u]);
if (mi > ma) mi = ma, rt = u;
}
long long s1[N], s2[N], s3[N], s4[N], dep[N];
int L[N], I[N], dfn, R[N];
void dfs(int u, int f) {
dep[u] = dep[f] + 1;
s2[u] = s2[f] + a[u], s1[u] = s1[f] + 1ll * a[u] * (dep[u] + 1);
s4[u] = s4[f] + a[u], s3[u] = s3[f] + s4[u];
I[L[u] = ++dfn] = u;
for (int v : G[u])
if (v != f && !vis[v]) dfs(v, u);
R[u] = dfn;
}
long long ans;
void Div(int n, int u) {
mi = 1e9, FindRt(n, u, 0), vis[u = rt] = 1;
s1[u] = s2[u] = a[u], s3[u] = s4[u] = dep[u] = 0;
I[L[u] = dfn = 1] = u;
for (int v : G[u])
if (!vis[v]) dfs(v, u);
R[u] = dfn;
cmax(ans, (long long)a[u]), cnt = rt = 0;
Upd(rt, 1, dfn, Node(s2[u], s1[u]));
for (int v : G[u])
if (!vis[v]) {
for (int j = L[v], jend = R[v]; j <= jend; ++j) {
int i = I[j];
cmax(ans, Que(rt, 1, dfn, dep[i]) + s3[i]);
}
for (int j = L[v], jend = R[v]; j <= jend; ++j) {
int i = I[j];
Upd(rt, 1, dfn, Node(s2[i], s1[i]));
}
}
cnt = rt = 0;
for (int k = G[u].size() - 1, kend = 0; k >= kend; --k) {
int v = G[u][k];
if (vis[v]) continue;
for (int j = L[v], jend = R[v]; j <= jend; ++j) {
int i = I[j];
cmax(ans, Que(rt, 1, dfn, dep[i]) + s3[i]);
}
for (int j = L[v], jend = R[v]; j <= jend; ++j) {
int i = I[j];
Upd(rt, 1, dfn, Node(s2[i], s1[i]));
}
}
cmax(ans, Que(rt, 1, dfn, dep[u]) + s3[u]);
for (int v : G[u])
if (!vis[v]) {
if (sz[v] > sz[u]) sz[v] = n - sz[u];
Div(sz[v], v);
}
}
int main() {
s[0] = Node(-1, -INF);
n = rd();
for (int i = 2, iend = n; i <= iend; ++i) {
int u = rd(), v = rd();
G[u].push_back(v), G[v].push_back(u);
}
for (int i = 1, iend = n; i <= iend; ++i) a[i] = rd();
Div(n, 1);
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, t;
cin >> s1 >> s2 >> t;
int i, j;
for (i = 0; i < t.length(); i++) {
char cc = tolower(t[i]);
for (j = 0; j < 26; j++) {
if (s1[j] == cc) {
if (t[i] >= 'a' && t[i] <= 'z') {
cout << s2[j];
} else if (t[i] >= 'A' && t[i] <= 'Z') {
char c = toupper(s2[j]);
cout << c;
}
} else if (t[i] >= '0' && t[i] <= '9') {
cout << t[i];
break;
}
}
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> rn;
int main() {
rn['.'] = 1;
int n, m, counter = 0;
char c, r[101][101];
cin >> n >> m >> c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> r[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (r[i][j] == c) {
if (r[i + 1][j] != c && rn[r[i + 1][j]] != 1 && i + 1 < n) {
rn[r[i + 1][j]] = 1;
counter++;
}
if (r[i][j + 1] != c && rn[r[i][j + 1]] != 1 && j + 1 < m) {
rn[r[i][j + 1]] = 1;
counter++;
}
if (r[i][j - 1] != c && rn[r[i][j - 1]] != 1 && j - 1 >= 0) {
rn[r[i][j - 1]] = 1;
counter++;
}
if (r[i - 1][j] != c && rn[r[i - 1][j]] != 1 && i - 1 >= 0) {
rn[r[i - 1][j]] = 1;
counter++;
}
}
}
}
cout << counter << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f[2010];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
int n, m, k;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = n;
for (int i = 1; i <= n; i++) {
int l = i;
int r = l + k - 1;
if (r > n) break;
while (l < r) {
int x = find(l);
int y = find(r);
if (x != y) cnt--;
f[x] = y;
l++;
r--;
}
}
long long ans = 1ll;
for (int i = 1; i <= cnt; i++) ans = ans * (long long)m % 1000000007;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, t, j, k, count = 0, q, r;
cin >> n >> m >> k;
long long int a[n + 1], b[n + 1];
for (i = 1; i <= n; i++) {
cin >> j;
a[j] = i;
b[i] = j;
}
for (i = 0; i < m; i++) {
cin >> t;
j = a[t];
count += (j) / k;
if (j % k == 0) {
count--;
}
count++;
if (j != 1) {
a[t] = j - 1;
q = b[j - 1];
long long int temp = b[j];
b[j] = b[j - 1];
b[j - 1] = temp;
a[q] = a[q] + 1;
}
}
cout << count;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char p[8];
p[1] = 'R';
p[2] = 'O';
p[3] = 'Y';
p[4] = 'G';
p[5] = 'B';
p[6] = 'I';
p[7] = 'V';
char javab[n + 5];
bool bj[n];
javab[0] = p[1];
javab[1] = p[2];
javab[2] = p[3];
javab[3] = p[4];
int y = 4;
int av = 4, akh = n - 1, s = 0, l = 0;
while (akh >= av) {
if (s == 0) {
javab[av] = p[1];
javab[av + 1] = p[2];
javab[av + 2] = p[3];
javab[av + 3] = p[4];
if (av + 4 > n - 1) {
av = n - 1;
} else
av += 4;
} else {
l = 1;
javab[akh] = p[4];
javab[akh - 1] = p[3];
javab[akh - 2] = p[2];
if (akh - 3 > 3) javab[akh - 3] = p[1];
if (akh - 3 > 3)
akh -= 4;
else
akh = 3;
}
s = 1 - s;
}
if (l == 1) {
javab[akh + 1] = p[5];
javab[akh + 2] = p[6];
javab[akh + 3] = p[7];
} else {
javab[av - 1] = p[5];
javab[av - 2] = p[6];
javab[av - 3] = p[7];
}
for (int i = 0; i < n; i++) cout << javab[i];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 70;
int n, m;
bool e[N][N];
pair<int, int> ans[N];
int ansN;
int p[N], deg[N];
int findpar(int u) { return (u == p[u] ? u : p[u] = findpar(p[u])); }
inline bool join(int u, int v) {
u = findpar(u);
v = findpar(v);
if (u == v) return false;
p[u] = v;
return true;
}
bool vis[N];
bool dfs(int u, int p) {
vis[u] = true;
bool ok = false;
for (int i = 0; i < n; i++)
if (e[u][i]) {
if (!vis[i])
ok |= dfs(i, u);
else if (i != p)
return true;
}
return ok;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
if (n == 1) {
if (m == 1)
cout << "YES\n0\n";
else if (m == 0)
cout << "YES\n1\n1 1\n";
else
cout << "NO\n";
return 0;
}
if (n == 2 && m == 2) {
int x, y, z, t;
cin >> x >> y >> z >> t;
if (x != y && z != t)
cout << "YES\n0\n";
else
cout << "NO\n";
return 0;
}
for (int i = 0; i < n; i++) p[i] = i;
int cnt = 0;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
if (!join(u, v)) cnt++;
deg[u]++;
deg[v]++;
e[u][v] = e[v][u] = true;
}
bool ok = true;
for (int i = 0; i < n; i++)
ok &= (deg[i] == 2 && (!i || findpar(i) == findpar(i - 1)));
if (ok) {
cout << "YES\n0\n";
return 0;
} else if (cnt) {
cout << "NO\n";
return 0;
}
for (int i = 0; i < n; i++)
if (deg[i] > 2) {
cout << "NO";
return 0;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (deg[i] < 2 && deg[j] < 2 && join(i, j)) {
ans[ansN++] = pair<int, int>(i, j);
deg[i]++;
deg[j]++;
}
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (deg[i] == 1 && deg[j] == 1) ans[ansN++] = pair<int, int>(i, j);
cout << "YES\n" << ansN << "\n";
for (int i = 0; i < ansN; i++)
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class _Tp>
_Tp gcd(_Tp a, _Tp b) {
return (b == 0) ? (a) : (gcd(b, a % b));
}
const long long Inf = 1000000000000000000ll;
const int inf = 1000000000;
char buf[1 << 25], *p1 = buf, *p2 = buf;
inline int getc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 25, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0, f = 0;
char c = getc();
while (!isdigit(c)) (c == '-') && (f = 1), c = getc();
while (isdigit(c)) x = x * 10 + (c & 15), c = getc();
return f ? -x : x;
}
const int mod = 1000000007;
const int N = 1000005;
inline void upt(int& x, int y) { (x += y) >= mod && (x -= mod); }
int n, fa[N], f[N], g[N], res;
long long s[N];
int main() {
n = read();
for (int i = 1; i <= n; ++i) s[i] = read();
for (int i = 2; i <= n; ++i) fa[i] = read();
for (int i = n; i >= 1; --i) s[fa[i]] += s[i];
for (int i = 1; i <= n; ++i) {
long long t = s[1] / gcd(s[1], s[i]);
if (t <= n) g[t]++;
}
for (int i = 1; i <= n; ++i)
if (g[i])
for (int j = i; j <= n; j += i) upt(f[j], g[i]);
for (int i = 1; i <= n; ++i) f[i] = (f[i] == i);
int ans = 1;
for (int i = n; i >= 2; --i) {
if (!f[i]) continue;
for (int j = i + i; j <= n; j += i) upt(f[i], f[j]);
upt(ans, f[i]);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, level;
cin >> n;
long long cur = 2;
for (level = 1; level < n + 1; level++) {
long long y = level * (level + 1) * (level + 1) - (cur / level);
cout << y << "\n";
cur = level * (level + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "no-stack-protector")
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
template <class T>
auto dud(T *x) -> decltype(cerr << *x, 0);
template <class T>
char dud(...);
struct debug {
template <class T>
debug &operator<<(const T &) {
return *this;
}
};
struct SuffixAutomaton {
vector<map<char, int> > trie;
vector<int> link, len;
vector<long long> occ, mem;
int last;
SuffixAutomaton() { last = newNode(); }
int newNode() {
trie.push_back({}), link.push_back(-1), len.push_back(0), occ.push_back(0),
mem.push_back(-1);
return int(trie.size()) - 1;
}
void extend(char c) {
int u = newNode();
occ[u] = 1;
len[u] = len[last] + 1;
int p = last;
while (p != -1 && !trie[p].count(c)) {
trie[p][c] = u;
p = link[p];
}
if (p == -1)
link[u] = 0;
else {
int q = trie[p][c];
if (len[p] + 1 == len[q])
link[u] = q;
else {
int clone = newNode();
len[clone] = len[p] + 1;
trie[clone] = trie[q];
link[clone] = link[q];
while (p != -1 && trie[p][c] == q) {
trie[p][c] = clone;
p = link[p];
}
link[q] = link[u] = clone;
}
}
last = u;
}
void occurs() {
vector<int> who;
for (auto u = (1) - ((1) > (int(trie.size())));
u != int(trie.size()) - ((1) > (int(trie.size())));
u += 1 - 2 * ((1) > (int(trie.size()))))
who.push_back(u);
sort(begin(who), end(who), [&](int u, int v) { return len[u] > len[v]; });
for (int u : who) occ[link[u]] += occ[u];
}
long long dp(int u) {
long long &ans = mem[u];
if (ans == -1) {
ans = 0;
for (auto &[c, v] : trie[u]) {
ans += dp(v);
ans += occ[v] * (occ[v] + 1) / 2;
}
}
return ans;
}
} sam;
string second;
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
while (cin >> second) {
sam = SuffixAutomaton();
for (char c : second) sam.extend(c);
sam.occurs();
cout << sam.dp(0) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000007;
void min_max(int a, int& cur_min, int& cur_max, bool three) {
if (three && a < 100) cur_min = 0;
while (a > 0) {
auto tmp = a % 10;
cur_min = min(cur_min, tmp);
cur_max = max(cur_max, tmp);
a /= 10;
}
}
int main() {
std::ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
string A;
long long int k;
cin >> A >> k;
int min_left = 9, max_left = 0;
for (int i = 0; i < int(A.size()) - 3; i++) {
min_left = min(min_left, A[i] - '0');
max_left = max(max_left, A[i] - '0');
}
int cur_min, cur_max;
int a = 0;
for (int i = A.size() - 1; i >= 0 && i >= int(A.size()) - 3; i--) {
a += (A[i] - '0') * pow(10, A.size() - 1 - i);
}
bool three = A.size() >= 3;
A.resize(max(0, int(A.size()) - 3));
for (int i = 1; i < k; i++) {
cur_min = min_left, cur_max = max_left;
min_max(a, cur_min, cur_max, three);
if (cur_min == 0) break;
a += cur_min * cur_max;
}
int resid = a / 1000;
for (int i = int(A.size()) - 1; i >= 0; i--) {
int tmp = A[i] - '0' + resid;
resid = tmp / 10;
A[i] = (tmp % 10) + '0';
}
if (resid) cout << resid;
cout << A;
a = a % 1000;
if (three)
cout << a / 100 << (a % 100) / 10 << a % 10 << endl;
else
cout << a << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef struct Computer {
int a;
int b;
} Computer;
bool comp(Computer a, Computer b) { return a.b > b.b; }
vector<Computer> computer(100010);
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &computer[i].a, &computer[i].b);
sort(computer.begin(), computer.begin() + n, comp);
int find = 0;
for (int i = 0; i < n - 1; i++)
if (computer[i].a < computer[i + 1].a) {
find = 1;
break;
}
if (find == 1)
printf("Happy Alex");
else
printf("Poor Alex");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
vector<int> id;
vector<int> val;
long long simula(int b, int e) {
set<int> compra;
set<int> vende;
set<int> nao_sei;
long long ret = 1;
for (int i = b; i <= e; i++) {
if (id[i] == 0) {
int x = val[i];
if (compra.upper_bound(x) != compra.end()) {
compra.insert(x);
} else if (!vende.empty() and (*vende.begin()) < x) {
vende.insert(x);
} else {
nao_sei.insert(x);
}
} else {
int x = val[i];
if (compra.count(x)) {
if (compra.upper_bound(x) != compra.end()) return 0;
compra.erase(x);
for (int y : nao_sei) {
if (y < x) {
compra.insert(y);
} else {
vende.insert(y);
}
}
nao_sei.clear();
} else if (vende.count(x)) {
if (vende.find(x) != vende.begin()) return 0;
vende.erase(x);
for (int y : nao_sei) {
if (y < x)
compra.insert(y);
else {
vende.insert(y);
}
}
nao_sei.clear();
} else {
int x = val[i];
if (compra.count(x)) {
if (compra.upper_bound(x) != compra.end()) return 0;
compra.erase(x);
} else if (vende.count(x)) {
if (vende.find(x) != vende.begin()) return 0;
vende.erase(x);
} else {
nao_sei.erase(x);
if (compra.upper_bound(x) != compra.end() and !vende.empty() and
(*vende.begin()) < x) {
return 0;
} else if (compra.upper_bound(x) != compra.end()) {
for (int y : nao_sei) {
if (y < x) return 0;
vende.insert(y);
}
} else if (!vende.empty() and (*vende.begin()) < x) {
for (int y : nao_sei) {
if (y > x) return 0;
compra.insert(y);
}
} else {
ret = (ret * 2) % MOD;
for (int y : nao_sei) {
if (y < x) {
compra.insert(y);
} else {
vende.insert(y);
}
}
}
}
nao_sei.clear();
}
}
}
if (nao_sei.size() > 0) {
ret = ret * (nao_sei.size() + 1);
ret %= MOD;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
int v;
cin >> s >> v;
if (s == "ADD")
id.push_back(0);
else
id.push_back(1);
val.push_back(v);
}
cout << simula(0, n - 1) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010], ans[100010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
ans[i] = 1000000;
scanf("%d", &a[i]);
}
ans[n] = 1000000;
ans[0] = -1;
for (int i = 0; i < n; ++i) {
int l = 0;
int r = i + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ans[mid] < a[i])
l = mid;
else
r = mid;
}
ans[l + 1] = min(ans[l + 1], a[i]);
}
for (int i = n; i > 0; --i)
if (ans[i] < 1000000) {
printf("%d\n", i);
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 100010;
using namespace std;
int n, s1, s2, x[N], m, h[N], cnt;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
int sumv[N << 2], addv[N << 2];
inline void pushup(int o) { sumv[o] = sumv[(o << 1)] + sumv[(o << 1 | 1)]; }
inline void pushdown(int o) {
if (!addv[o]) return;
addv[(o << 1)] = 1;
addv[(o << 1 | 1)] = 1;
sumv[(o << 1)] = 0;
sumv[(o << 1 | 1)] = 0;
addv[o] = 0;
}
inline void change(int o, int l, int r, int q, int v) {
if (l == r) return void(sumv[o] = v);
int mid = (l + r) >> 1;
pushdown(o);
if (q <= mid)
change((o << 1), l, mid, q, v);
else
change((o << 1 | 1), mid + 1, r, q, v);
pushup(o);
}
inline void optset(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
sumv[o] = 0;
addv[o] = 1;
return;
}
int mid = (l + r) >> 1;
pushdown(o);
if (ql <= mid) optset((o << 1), l, mid, ql, qr);
if (qr > mid) optset((o << 1 | 1), mid + 1, r, ql, qr);
pushup(o);
}
inline int check(int q) {
for (int i = 1; i <= 4 * m; i++) addv[i] = 0, sumv[i] = 0;
int p1 = lower_bound(h + 1, h + m + 1, s1) - h;
int p2 = lower_bound(h + 1, h + m + 1, s2) - h;
change(1, 1, m, p1, 1);
change(1, 1, m, p2, 1);
for (int i = 1; i <= n; i++) {
int l = 1, r = lower_bound(h + 1, h + m + 1, x[i] - q) - h - 1;
if (l <= r) optset(1, 1, m, l, r);
l = lower_bound(h + 1, h + m + 1, x[i] + q + 1) - h;
r = m;
if (l <= r) optset(1, 1, m, l, r);
if (sumv[1]) change(1, 1, m, lower_bound(h + 1, h + m + 1, x[i]) - h, 1);
}
return sumv[1];
}
int main() {
n = read();
s1 = read();
s2 = read();
for (int i = 1; i <= n; i++) x[i] = read(), h[i] = x[i];
int l = abs(s1 - s2), r = 1e9, ans = 0;
h[n + 1] = s1;
h[n + 2] = s2;
sort(h + 1, h + n + 3);
m = unique(h + 1, h + n + 3) - h - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<pair<pair<int, int>, int>, int> mp;
int n, ans, arr[5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int x = i ^ j;
arr[1] = i;
arr[2] = j;
arr[3] = x;
sort(arr + 1, arr + 4);
if (arr[1] == 0) continue;
if (arr[3] > n) continue;
if (arr[1] + arr[2] <= arr[3]) continue;
if (mp[{{arr[1], arr[2]}, arr[3]}] == 0) {
ans++;
mp[{{arr[1], arr[2]}, arr[3]}] = 1;
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int a, b, s;
scanf("%d %d %d", &a, &b, &s);
if (a < 0) a = -a;
if (b < 0) b = -b;
if (s >= a + b && (s - (a + b)) % 2 == 0)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, m, k, parent[maxn], siz[maxn], a, b, l, sigma;
int findparent(int x) {
if (x == parent[x])
return x;
else
return parent[x] = findparent(parent[x]);
}
void merg(int x, int y) {
x = findparent(x);
y = findparent(y);
if (x != y) {
parent[x] = y;
siz[y] = siz[y] + siz[x];
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
fill(siz, siz + n + 2, 1);
for (int i = 1; i <= n; i++) parent[i] = i;
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
merg(a, b);
}
for (int i = 1; i <= n; i++)
if (i == parent[i]) {
sigma = sigma + min(k, siz[i]);
l++;
}
if (k == 1)
printf("%d", max(0, l - 2));
else
printf("%d", max(0, l - sigma / 2 - 1));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
long long res = arr[0], energy = 0;
for (int i = 1; i < n; i++) {
if (arr[i - 1] >= arr[i]) {
energy += arr[i - 1] - arr[i];
} else {
if (energy - (arr[i] - arr[i - 1]) < 0)
res += (arr[i] - arr[i - 1]) - energy, energy = 0;
else
energy -= arr[i] - arr[i - 1];
}
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int fak[2][1000 * 1000 + 5];
long long int zos[2];
void rozloz(long long int a, int g) {
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
fak[g][i]++;
a /= i;
}
}
if (a > 1 && a <= 1000 * 1000)
fak[g][a]++;
else
zos[g] *= a;
}
long long int a, b, c, d;
int wynik = 0;
void third(int x) {
wynik++;
if (x == 0) {
if (a % 3 == 0) {
a /= 3;
a *= 2;
} else {
b /= 3;
b *= 2;
}
} else {
if (c % 3 == 0) {
c /= 3;
c *= 2;
} else {
d /= 3;
d *= 2;
}
}
fak[x][2]++;
}
void half(int x) {
wynik++;
if (x == 0) {
if (a % 2 == 0)
a /= 2;
else
b /= 2;
} else {
if (c % 2 == 0)
c /= 2;
else
d /= 2;
}
}
int main() {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
zos[0] = zos[1] = 1;
rozloz(a, 0);
rozloz(b, 0);
rozloz(c, 1);
rozloz(d, 1);
for (int i = 4; i <= 1000 * 1000; i++)
if (fak[0][i] != fak[1][i]) {
printf("-1");
return 0;
}
if (zos[1] != zos[0]) {
printf("-1");
return 0;
}
for (int i = 0; i < fak[1][3] - fak[0][3]; i++) third(1);
for (int i = 0; i < fak[0][3] - fak[1][3]; i++) third(0);
for (int i = 0; i < fak[1][2] - fak[0][2]; i++) half(1);
for (int i = 0; i < fak[0][2] - fak[1][2]; i++) half(0);
printf("%d\n%lld %lld\n%lld %lld\n", wynik, a, b, c, d);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
a = sqrt(n);
b = n / a;
while (n % a != 0) {
a = a - 1;
b = n / a;
}
cout << a << " " << b << endl;
}
| 0 |
#include <bits/stdc++.h>
void print(const std::vector<std::vector<int>>& answers) {
for (std::vector<int> vec : answers) {
for (int answer : vec) {
std::cout << answer << " ";
}
std::cout << std::endl;
}
}
std::vector<int> solve() {
int a, b, c, d;
std::cin >> a >> b >> c >> d;
int base = a, left = c, right = c;
return {base, left, right};
}
int main() {
int tests;
std::cin >> tests;
std::vector<std::vector<int>> answers;
while (tests--) {
answers.push_back(solve());
}
print(answers);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n[] = {0, 0, 0}, r;
string s;
cin >> s;
while (cin >> s) {
r = 0;
for (int i = 0; i < s.size(); r += s[i] - '0', ++i)
;
r %= 3;
n[r]++;
}
cout << n[0] / 2 + min(n[1], n[2]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, A, B, B2, sta[300005], topp, slen;
char ss[300005];
void preWork() {
topp = 0;
slen = strlen(ss + 1), B2 = B * 2;
int L = 1, R;
while (L <= slen) {
while (ss[L] == 'X') L++;
R = L;
while (ss[R] == '.') R++;
if (R - L >= B) sta[++topp] = R - L;
L = R;
}
sort(sta + 1, sta + topp + 1);
}
bool cut_1_or_3(int len) {
if (len <= A + 2 * B - 2) return true;
if (A * 3 <= len && len <= A + B2 * 2 - 2) return true;
return false;
}
bool cut_1_and_3(int len) {
if (A + A <= len && len <= B - 1 + A + B2 - 1) return true;
return false;
}
void solve() {
int cnt2 = 0, cnt3 = 0, cnt4 = 0;
for (int i = 1; i <= topp; i++) {
if (sta[i] < A) cnt2++;
if (A <= sta[i] && sta[i] < B2) cnt3++;
if (B2 <= sta[i]) cnt4++;
}
if (cnt2 || cnt4 >= 2) {
puts("NO");
return;
}
if (!cnt4) {
puts((cnt3 & 1) ? "YES" : "NO ");
return;
}
if ((cnt3 & 1) && cut_1_and_3(sta[topp]) == true) {
puts("YES");
return;
}
if (!(cnt3 & 1) && cut_1_or_3(sta[topp]) == true) {
puts("YES");
return;
}
puts("NO");
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &A, &B);
scanf("%s", ss + 1);
preWork();
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a, b;
cin >> k >> a >> b;
if (k > a && k > b || k > a && b % k != 0 || k > b && a % k != 0)
cout << "-1\n";
else
cout << a / k + b / k << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int pSet[105], n, m1, m2;
string s1, s2;
vector<int> graph[1000005];
bool vis[105];
vector<pair<char, char>> edge;
int findSet(int a) {
if (a == pSet[a])
return a;
else
return findSet(pSet[a]);
}
bool sameSet(int a, int b) {
if (findSet(a) == findSet(b))
return 1;
else
return 0;
}
void unionSet(int a, int b) { pSet[findSet(a)] = findSet(b); }
void init() {
for (int i = 0; i <= 26; i++) {
pSet[i] = i;
}
}
int main() {
memset(vis, 0, sizeof(vis));
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
cin >> n;
cin >> s1 >> s2;
init();
for (int i = 0; i < n; i++) {
if (s1[i] == s2[i]) continue;
m1 = (int)(s1[i] - 'a');
m2 = (int)(s2[i] - 'a');
if (sameSet(m1, m2) == 0) {
unionSet(m1, m2);
edge.push_back(make_pair(s1[i], s2[i]));
}
}
cout << edge.size() << "\n";
for (int i = 0; i < edge.size(); i++) {
cout << edge[i].first << " " << edge[i].second << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> b, s;
int bits(long long x) {
int ret = 0;
while (x != 0) {
ret += x & 1;
x >>= 1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
b.resize(n + 1, 0);
s.resize(n + 1, 0);
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
b[i] = bits(x);
s[i] = b[i] + s[i - 1];
}
long long ans = 0;
vector<int> cuenta(2, 0);
for (int i = 1; i < n + 1; i += 1) {
ans += cuenta[s[i] & 1];
for (int j = i - 2, m = b[i] > b[i - 1] ? b[i] : b[i - 1];
j >= 0 && i - j <= 60; --j) {
if ((s[j] & 1) == (s[i] & 1) && 2 * m > s[i] - s[j]) {
--ans;
}
m = m > b[j] ? m : b[j];
}
++cuenta[s[i - 1] & 1];
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int x;
cin >> n;
cin >> x;
int t = n * 2;
int* a = new int[t];
for (int i = 0; i < t; ++i) cin >> a[i];
bool check = true;
for (int i = 0; i < t; ++i) {
if ((a[i] == x) || (a[i] == 7 - x)) {
check = false;
break;
}
}
if (check == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[2000];
int main() {
for (int i = 2; i < 2000; i++) a[i] = i * (i - 1) / 2;
vector<int> ans;
int n;
cin >> n;
if (n == 0) {
cout << 'a' << endl;
return 0;
}
while (n) {
int index = upper_bound(a, a + 2000, n) - a;
n -= a[index - 1];
ans.push_back(index - 1);
}
int cnt = 0;
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < ans[i]; j++) printf("%c", 'a' + cnt);
cnt++;
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &x) {
x = 0;
register char c = getchar();
register bool f = 0;
while (!isdigit(c)) f ^= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
}
template <class T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void print(T x, char c) {
print(x), putchar(c);
}
template <class T>
inline void print(T a, int l, int r) {
for (int i = l; i <= r; i++) print(a[i], " \n"[i == r]);
}
const int N = 110;
int n, m, ans[N];
struct atom {
int a[26];
inline int length() const {
int s = 0;
for (int i = 0; i < 26; i++) s += a[i];
return s;
}
inline bool operator<(const atom &other) const {
for (int i = 0; i < 26; i++) {
if (a[i] != other.a[i]) return a[i] < other.a[i];
}
return false;
}
} res[N];
std::map<atom, int> map;
inline atom operator-(const atom &a, const atom &b) {
atom c;
for (int i = 0; i < 26; i++) c.a[i] = a.a[i] - b.a[i];
return c;
}
inline void read(atom &x) {
std::string s;
std::cin >> s;
for (int i = 0; i < s.length(); i++) x.a[s[i] - 'a']++;
}
std::vector<atom> ask(int l, int r) {
printf("? %d %d\n", l, r);
std::vector<atom> res((r - l + 1) * (r - l + 2) / 2);
for (int i = 0; i < res.size(); i++) read(res[i]);
return res;
}
int main() {
read(n);
if (n == 1) {
printf("? 1 1\n");
std::string s;
std::cin >> s;
std::cout << "! " << s << std::endl;
return 0;
}
auto S = ask(1, n), A = ask(1, 1), B = ask(2, n);
for (auto it : S) map[it]++;
for (auto it : A) map[it]--;
for (auto it : B) map[it]--;
res[1] = A[0];
for (auto it : map)
if (it.second) {
res[it.first.length()] = it.first;
}
for (int i = n; i >= 1; i--) {
res[i] = res[i] - res[i - 1];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++)
if (res[i].a[j]) {
ans[i] = j;
}
}
printf("! ");
for (int i = 1; i <= n; i++) putchar(ans[i] + 'a');
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int memo[1001][201][101];
int mhp, matk, mdef;
int yhp, yatk, ydef;
int hpp, atkp, defp;
int win(int hp, int atk, int def) {
int res;
atk -= mdef;
if (atk > 0) {
int k = mhp / atk;
if (mhp % atk) k++;
int dmg = k * (matk - def);
if (dmg < hp)
res = 0;
else
res = k;
} else
res = 1000000;
return res;
}
int solve(int hp, int atk, int def, int s) {
if (atk == 201 || def == 101 || hp == 1001) return 100000000;
if (memo[hp][atk][def] != -1)
return memo[hp][atk][def];
else {
int tmp = win(hp, atk, def);
if (!tmp) {
memo[hp][atk][def] = s;
return s;
} else {
if (tmp == 1000000) {
int res = solve(hp, atk + 1, def, s + atkp);
memo[hp][atk][def] = res;
return res;
} else {
int res = min(min(solve(hp + 1, atk, def, s + hpp),
solve(hp, atk + 1, def, s + atkp)),
solve(hp, atk, def + 1, s + defp));
memo[hp][atk][def] = res;
return res;
}
}
}
}
int main() {
memset(memo, -1, 4 * 1001 * 201 * 101);
cin >> yhp >> yatk >> ydef;
cin >> mhp >> matk >> mdef;
cin >> hpp >> atkp >> defp;
cout << solve(yhp, yatk, ydef, 0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int K = 5e3 + 5;
const int mod = 1e9 + 7;
long long s2[K][K];
int n, k;
long long fp(long long a, long long b) {
if (!b) return 1ll;
long long t = fp(a, b / 2);
if (b & 1)
return t * t % mod * a % mod;
else
return t * t % mod;
}
signed main() {
cin >> n >> k;
s2[0][0] = 1;
for (int i = 1; i <= k; i++)
for (int j = 1; j <= i; j++)
s2[i][j] = (s2[i - 1][j - 1] + j * s2[i - 1][j]) % mod;
long long pw2 = fp(2, n);
long long inv2 = fp(2, mod - 2);
long long downp = 1ll;
long long ans = 0ll;
for (int i = 0; i <= k; i++) {
(ans += downp * s2[k][i] % mod * pw2 % mod) %= mod;
(downp *= (n - i)) %= mod;
(pw2 *= inv2) %= mod;
}
if (!k) --ans;
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 998244353;
int n;
struct Vec {
long long x, y;
Vec(long long a = 0, long long b = 0) {
x = a;
y = b;
}
} A[110];
Vec operator+(const Vec& a, const Vec& b) { return Vec(a.x + b.x, a.y + b.y); }
Vec operator-(const Vec& a, const Vec& b) { return Vec(a.x - b.x, a.y - b.y); }
long long operator*(const Vec& a, const Vec& b) {
return a.x * b.y - a.y * b.x;
}
int dir(Vec v) {
if (v.x >= 0 && v.y >= 0) return 0;
if (v.x < 0 && v.y >= 0) return 1;
if (v.x < 0 && v.y < 0) return 2;
if (v.x >= 0 && v.y < 0) return 3;
}
bool check_left(int i, int j, int k) {
return (A[j] - A[i]) * (A[k] - A[i]) >= 0;
}
bool check_right(int i, int j, int k) {
return (A[j] - A[i]) * (A[k] - A[i]) < 0;
}
bool check_ok(Vec a, Vec b, Vec c) {
long long s1 = a * b;
long long s2 = a * c;
if (s1 >= 0 && s2 < 0) return true;
if (s1 < 0 && s2 > 0) return false;
return b * c > 0;
}
bool cmp(pair<int, int> a, pair<int, int> b) {
Vec va = A[a.second] - A[a.first];
Vec vb = A[b.second] - A[b.first];
if (dir(va) != dir(vb)) return dir(va) < dir(vb);
long long cross = va * vb;
if (cross != 0) return cross > 0;
return a < b;
}
vector<int> e[110];
vector<int> path[110][110];
bool good[110][110];
void find_path(int u, int lst, int s) {
path[s][u] = path[s][lst];
path[s][u].push_back(u);
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == lst) continue;
find_path(v, u, s);
}
return;
}
void dfs(int u, int lst) {
int pos = -1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == lst)
pos = i;
else
dfs(v, u);
}
if (pos != -1) {
swap(e[u][pos], e[u].back());
e[u].pop_back();
}
return;
}
bool check_good(int u, int v, vector<int>& vec) {
if (vec.size() < 3) return false;
for (int i = 0; i < vec.size(); i++)
if (!check_left(u, v, vec[i])) return false;
return true;
}
void init_good() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) good[i][j] = check_good(i, j, path[i][j]);
return;
}
long long dp[110];
long long value[110][110];
bool vis[110];
int calc_value(vector<int>& vec) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < vec.size(); i++) vis[vec[i]] = true;
long long res = 1;
for (int i = 0; i < vec.size(); i++) {
int u = vec[i];
Vec v1, v2;
if (i > 0)
v1 = A[vec[i - 1]] - A[u];
else
v1 = A[u] - A[vec[i + 1]];
if (i + 1 < vec.size())
v2 = A[vec[i + 1]] - A[u];
else
v2 = A[u] - A[vec[i - 1]];
for (int j = 0; j < e[u].size(); j++) {
int v = e[u][j];
if (vis[v]) continue;
if (check_ok(v1, A[v] - A[u], v2)) res = res * dp[v] % Mod;
}
}
return res;
}
long long f[210];
int id[110][110];
int first[110][110], last[110][110];
bool ok[110][110];
bool bl[210];
vector<int> solve(int u) {
vector<int> vec;
vec.push_back(u);
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
vector<int> to = solve(v);
for (int j = 0; j < to.size(); j++) vec.push_back(to[j]);
}
dp[u] = 0;
long long sum = 1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
sum = sum * dp[v] % Mod;
}
dp[u] = (dp[u] + sum) % Mod;
sum = 0;
for (int i = 0; i < e[u].size(); i++) {
long long tmp = 1;
for (int j = 0; j < e[u].size(); j++)
if (i != j) tmp = tmp * dp[e[u][j]] % Mod;
int v = e[u][i];
for (int j = 0; j < e[v].size(); j++) tmp = tmp * dp[e[v][j]] % Mod;
sum = (sum + tmp) % Mod;
}
dp[u] = (dp[u] + sum) % Mod;
int num = 0;
memset(bl, 0, sizeof(bl));
for (int i = 0; i < vec.size(); i++) {
int a = vec[i];
for (int j = 0; j < e[a].size(); j++) {
int b = e[a][j];
id[a][b] = ++num;
id[b][a] = ++num;
if (dir(A[b] - A[a]) <= 1)
bl[id[a][b]] = 1;
else
bl[id[b][a]] = 1;
}
}
vector<pair<int, int> > V;
for (int i = 0; i < vec.size(); i++)
for (int j = 0; j < vec.size(); j++) {
int a = vec[i], b = vec[j];
ok[a][b] = false;
if (!check_left(a, b, u)) continue;
if (!good[a][b]) continue;
V.push_back(make_pair(a, b));
int sz = path[a][b].size();
int x = path[a][b][0], y = path[a][b][1];
first[a][b] = id[x][y];
x = path[a][b][sz - 1];
y = path[a][b][sz - 2];
last[a][b] = id[x][y];
if (value[a][b] != -1) continue;
ok[a][b] = 1;
value[a][b] = calc_value(path[a][b]);
}
sort(V.begin(), V.end(), cmp);
for (int s = 1; s <= num; s++) {
for (int c = -1; c <= 1; c += 2) {
memset(f, 0, sizeof(f));
f[s] = 1;
for (int i = 0; i < V.size(); i++) {
int x = V[i].first;
int y = V[i].second;
if (c == -1 && ok[x][y]) continue;
int fr = first[x][y];
int to = last[x][y];
f[to] = (f[to] + f[fr] * value[x][y]) % Mod;
}
f[s] = (f[s] + Mod - 1) % Mod;
dp[u] = (dp[u] + c * f[s] + Mod) % Mod;
}
}
return vec;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d %I64d", &A[i].x, &A[i].y);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; i++) find_path(i, 0, i);
dfs(1, 0);
init_good();
memset(value, -1, sizeof(value));
solve(1);
printf("%I64d\n", dp[1]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n;
struct point {
int id, val;
} num[N];
inline int cmp(const point &a, const point &b) { return a.val > b.val; }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &num[i].val), num[i].id = i * 2 - 1;
sort(num + 1, num + n + 1, cmp);
int tot = n;
for (int i = 1; i <= n; ++i) {
if (i != n) printf("%d %d\n", num[i].id, num[i + 1].id);
if (num[i].val < i)
printf("%d %d\n", num[i].id + 1, num[i - num[i].val + 1].id);
else {
printf("%d %d\n", num[i].id + 1, num[i + num[i].val - 1].id);
if (num[i].val + i - 1 == tot) num[++tot].id = num[i].id + 1;
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long int MOD = 1e9 + 7;
const long long int INF = 1e18;
const long long int maxn = 1e6 + 4;
void solve() {
int n, x;
cin >> n >> x;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
sum += a;
}
sum += n - 1;
cout << (x == sum ? "YES" : "NO");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const long double MAXY = 100000, MAXX = 1005, null = 0;
int main() {
int n, r;
cin >> n >> r;
long double x[MAXN + 1];
long double yx[MAXN + 1];
vector<long double> y;
for (int i = 0; i < n; ++i) cin >> x[i];
for (int i = 0; i < MAXN; ++i) yx[i] = 0;
bool t;
long double mxy, mxx, delt, temp;
for (int i = 0; i < n; ++i) {
t = true;
mxy = 0;
for (int ix = max(null, x[i] - 2 * r); ix <= min(MAXX, x[i] + 2 * r);
++ix) {
delt = x[i] - ix;
if (yx[ix] == 0) continue;
temp = sqrt(4 * r * r - delt * delt) + yx[ix];
if (temp > mxy) {
mxy = temp;
}
}
if (mxy <= r) {
yx[int(x[i])] = r;
} else {
yx[int(x[i])] = mxy;
}
y.push_back(yx[int(x[i])]);
}
for (int i = 0; i < n; ++i) cout << fixed << setprecision(10) << y[i] << ' ';
}
| 3 |
#include"bits/stdc++.h"
using namespace std;
#define mod 998244353
#define eps 0.0000001
#define pb push_back
#define int long long int
#define sll signed long long
#define ull unsigned long long
#define u_map unordered_map<int,int>
#define vi vector<int>
#define vvi vector<vi>
#define ub upper_bound
#define lb lower_bound
#define mxi INT_MAX
#define mni INT_MIN
#define mxll LLONG_MAX
#define mnll LLONG_MIN
#define ins insert
#define ff first
#define ss second
#define check cout<<"Check ";
#define inf 100000000000000000
#define pie 3.1415926535
#define f(in,end,it) for(int i=in;i<end;i+=it)
#define fr(in,end,it) for(int i=in;i>=end;i-=it)
#define line cout<<'\n';
#define pii pair<int,int>
#define srt(x) sort(x.begin(),x.end())
#define tt int t;cin>>t;while(t--)
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);
int fact[100005];
int inv_fact[100005];
int powmod(int x, int y) {
int ans = 1;
while(y > 0){
if(y & 1) ans = (ans * x)%mod;
y = y >> 1;
x = (x * x)%mod;
}
return ans ;
}
int C(int n , int r){
if(n < r)return 0;
else return (fact[n] * (inv_fact[n-r]%mod * inv_fact[r]%mod)%mod )%mod;
}
void ans_nikalo(){
int n;
cin>>n;
string s;
cin>>s;
int ans=0 ;
int c=0 ,d =0;
for(int i=0;i< n;i++){
if (s[i] == '0') c++;
else if (i+1 < n && s[i+1] == '1') {
d++;
i++;
}
}
ans = C(c+d , d);
cout<<ans<<"\n";
}
int32_t main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fio
//SieveOfEratosthenes(1000001);
fact[0] = inv_fact[0] =1;
for(int i=1;i<= 100004 ;i++){
fact[i] = (fact[i-1] * i)%mod;
inv_fact[i] = powmod(fact[i] , mod-2)%mod;
}
tt ans_nikalo();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define DB double
#define U unsigned
#define P std::pair
#define LL long long
#define LD long double
#define pb emplace_back
#define MP std::make_pair
#define SZ(x) ((int)x.size())
#define all(x) x.begin(),x.end()
#define CLR(i,a) memset(i,a,sizeof(i))
#define FOR(i,a,b) for(int i = a;i <= b;++i)
#define ROF(i,a,b) for(int i = a;i >= b;--i)
#define DEBUG(x) std::cerr << #x << '=' << x << std::endl
const int MAXN = 1e6 + 5;
int n,m,q,a[MAXN],b[MAXN];
struct BIT{
#define lowbit(x) ((x)&((-(x))))
LL tree[MAXN];
inline void add(int pos,int x){
for(;pos;pos-=lowbit(pos)) tree[pos] += x;
}
inline LL query(int pos){
LL res = 0;pos = std::max(pos,1);
for(;pos<MAXN;pos+=lowbit(pos)) res += tree[pos];
return res;
}
}sa,ca,sb,cb;
std::multiset<int> A,B;
int main(){
scanf("%d%d%d",&n,&m,&q);
FOR(i,1,n) scanf("%d",a+i),++a[i],A.insert(a[i]),sa.add(a[i],a[i]),ca.add(a[i],1);
FOR(i,1,m) scanf("%d",b+i),++b[i],B.insert(b[i]),sb.add(b[i],b[i]),cb.add(b[i],1);
while(q--){
int opt,p,x;scanf("%d",&opt);
if(opt == 1){
scanf("%d%d",&p,&x);++x;
A.erase(A.find(a[p]));
sa.add(a[p],-a[p]);
ca.add(a[p],-1);
a[p] = x;
ca.add(a[p],1);
sa.add(a[p],a[p]);
A.insert(a[p]);
}
else if(opt == 2){
scanf("%d%d",&p,&x);++x;
B.erase(B.find(b[p]));
sb.add(b[p],-b[p]);
cb.add(b[p],-1);
b[p] = x;
cb.add(b[p],1);
sb.add(b[p],b[p]);
B.insert(b[p]);
}
else{
int k;scanf("%d",&k);
int mn = std::min(*A.begin(),*B.begin());
auto calc = [&](int t,int o){// 0:A 1:B
/* LL ans = 0;
FOR(i,1,m) ans -= std::max(0,b[i]+k-t);
FOR(i,1,n) ans += std::max(a[i]+k-t,a[i]-mn);
*/
LL ans = sa.query(1)+1ll*n*std::max(k-t,-mn);
ans -= sb.query(t-k)-cb.query(t-k)*(t-k);
if(o == 0) ans -= std::max(k,t-mn);// A 尽量小
else ans += k;
if(o == 0) ans += k;
else ans -= k;
return ans;
};
auto query = [&](int t,int o) -> LL{// select A
auto p = (o?B:A).lower_bound(t);
LL ans = -1e18;
if(p != (o?B:A).end()) ans = std::max(ans,calc(*p,o));
if(p != (o?B:A).begin()){
--p;
ans = std::max(ans,calc(*p,o));
++p;
}
if(p == (o?B:A).end()) return ans;
++p;
if(p != (o?B:A).end()){
ans = std::max(ans,calc(*p,o));
}
return ans;
};
/* LL ans = -1e18;
FOR(i,1,n) ans = std::max(ans,calc(a[i],0));
FOR(i,1,m) ans = std::max(ans,calc(b[i],1));*/
int mx = std::max(*A.rbegin(),*B.rbegin());
LL ans = std::max({query(mx,0),query(mx,1),query(mn,0),query(mn,1),query(*B.rbegin()+k,0),query(*B.rbegin()+k,1)});
// ans = std::max(ans,calc(*A.begin(),0));
// ans = std::max(ans,calc(*A.rbegin(),0));
// ans = std::max(ans,query(k+mn,1));
// ans = std::max(ans,calc(*B.rbegin(),1));
// ans = std::max(ans,calc(*B.begin(),1));
printf("%lld\n",ans);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int task(vector<int>& v) {
int r = v[0], n = 0, z;
for (int c = 1; c < v.size(); ++c) {
z = v[c] - v[c - 1];
if (z > n) {
r += z - n;
n = 0;
} else
n -= z;
}
return r;
}
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int c = 0; c < n; ++c) cin >> v[c];
cout << task(v);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int total, root[300000], lson[8000008], rson[8000008], size[8000008], n, m,
num[300000], suc[300000];
void add(int &x, int old, int l, int r, int y, int z) {
x = ++total;
lson[x] = lson[old];
rson[x] = rson[old];
size[x] = size[old] + z;
if (l == r) return;
int mid = (l + r) >> 1;
if (y <= mid)
add(lson[x], lson[old], l, mid, y, z);
else
add(rson[x], rson[old], mid + 1, r, y, z);
}
int ask(int x, int l, int r, int y) {
if (l == r) {
if (size[x] <= y) return r;
return -1;
}
int mid = (l + r) >> 1;
if (size[lson[x]] <= y)
return max(mid, ask(rson[x], mid + 1, r, y - size[lson[x]]));
return ask(lson[x], l, mid, y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", num + i);
for (int i = n; i >= 1; i--) {
add(root[i], root[i + 1], 1, n, i, 1);
if (suc[num[i]]) {
add(root[i], root[i], 1, n, suc[num[i]], -1);
}
suc[num[i]] = i;
}
for (int i = 1; i <= n; i++) {
int ans = 0, l = 1;
while (l <= n) {
++ans;
int r = ask(root[l], 1, n, i);
l = r + 1;
}
printf("%d%s", ans, i < n ? " " : "\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct smallarray {
long long int size;
vector<long long int> elements;
long long int leftmax;
long long int rightmax;
long long int totalsum;
long long int maxconsecsum;
};
void solve(struct smallarray &arr1) {
long long int size1 = arr1.size;
long long int sum = 0;
arr1.leftmax = -1000000000000000007;
for (long long int i = 0; i < size1; i++) {
sum = sum + arr1.elements[i];
arr1.leftmax = max(arr1.leftmax, sum);
}
arr1.totalsum = sum;
sum = 0;
arr1.rightmax = -1000000000000000007;
for (long long int i = size1 - 1; i >= 0; i--) {
sum = sum + arr1.elements[i];
arr1.rightmax = max(arr1.rightmax, sum);
}
arr1.maxconsecsum = -1000000000000000007;
sum = 0;
for (long long int i = size1 - 1; i >= 0; i--) {
sum = max(sum + arr1.elements[i], arr1.elements[i]);
arr1.maxconsecsum = max(arr1.maxconsecsum, sum);
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int smallno, concat, temp;
cin >> smallno >> concat;
struct smallarray arr1[smallno];
for (long long int i = 0; i < smallno; i++) {
cin >> arr1[i].size;
for (long long int j = 0; j < arr1[i].size; j++) {
cin >> temp;
arr1[i].elements.push_back(temp);
}
solve(arr1[i]);
}
long long int seq[concat];
for (long long int i = 0; i < concat; i++) {
cin >> seq[i];
seq[i]--;
}
long long int ans = -1000000000000000007;
for (long long int i = 0; i < concat; i++) {
ans = max(ans, arr1[seq[i]].maxconsecsum);
}
long long int store;
long long int dp1[concat];
long long int dp2[concat];
dp1[0] = arr1[seq[0]].leftmax;
dp2[0] = arr1[seq[0]].rightmax;
for (long long int i = 1; i < concat; i++) {
dp2[i] = arr1[seq[i]].rightmax;
dp2[i] = max(dp2[i], dp2[i - 1] + arr1[seq[i]].totalsum);
dp1[i] = max(0LL, dp2[i - 1]) + arr1[seq[i]].leftmax;
ans = max(ans, dp1[i]);
ans = max(ans, dp2[i]);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const long long MOD = 1e9 + 7;
const double EPS = 1e-9;
const int INF = 1e9;
long long addMod(long long a, long long b) {
if (a + b >= MOD) return a + b - MOD;
return a + b;
}
long long mulMod(long long a, long long b) { return (a * b) % MOD; }
long long fast(long long a, long long b) {
if (b == 0) return 1;
long long tmp = fast(a, b / 2);
tmp = mulMod(tmp, tmp);
if (b & 1) tmp = mulMod(tmp, a);
return tmp;
}
long long GCD(long long a, long long b) {
if (a > b) return GCD(b, a);
if (a == 0) return b;
return GCD(b % a, a);
}
const int N = 3e5;
long long arr[N + 5], tot[N + 5];
int n;
long long m, k;
long long best[N + 5];
long long sum(int l, int r) {
l = max(l, 1);
if (l > r) return 0;
return tot[r] - tot[l - 1];
}
long long solve() {
long long res = 0;
m = min(m, (long long)n);
for (int i = 1; i <= m; i += 1) res = max(res, sum(1, i) - k);
for (int i = 1; i <= n; i += 1) {
if (i >= m) {
long long tmp = sum(i - m + 1, i) - k;
if (i - m >= 0) tmp += best[i - m];
best[i] = max(best[i], tmp);
}
for (int len = 0; len < m && len + i <= n; len++) {
res = max(res, best[i] + sum(i + 1, i + len) - k * (len > 0));
}
}
return res;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(best, 0, sizeof best);
memset(tot, 0, sizeof tot);
cin >> n >> m >> k;
for (int i = 1; i <= n; i += 1) {
cin >> arr[i];
tot[i] = tot[i - 1] + arr[i];
}
cout << solve() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, K, v[2010], sol;
inline bool Posibil(int diff) {
int i, j, difmed, dif, moves[2010];
moves[1] = 0;
for (i = 2; i <= n; ++i) {
moves[i] = i - 1;
for (j = i - 1; j > 0; --j) {
dif = abs(v[i] - v[j]);
difmed = dif / (i - j);
if (dif % (i - j) != 0) difmed++;
if (difmed <= diff) moves[i] = min(moves[i], moves[j] + i - j - 1);
}
}
for (i = 1; i <= n; ++i)
if (moves[i] + n - i <= K) return true;
return false;
}
inline void CautareBinara() {
int st, dr, mij;
st = 0;
dr = sol;
while (st <= dr) {
mij = st + (dr - st) / 2;
if (Posibil(mij)) {
sol = mij;
dr = mij - 1;
} else
st = mij + 1;
}
}
int main() {
int i;
scanf("%d %d", &n, &K);
for (i = 1; i <= n; ++i) scanf("%d", v + i);
for (i = 1; i < n; ++i) sol = max(sol, abs(v[i] - v[i + 1]));
CautareBinara();
printf("%d\n", sol);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename tp>
inline void read(tp &x) {
x = 0;
char c = getchar();
int f = 0;
for (; c < '0' || c > '9'; f |= c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar())
;
if (f) x = -x;
}
const long long N = 3e5 + 233;
long long n, sum, S;
long long s[N], val[N], id[N], pval[N];
vector<long long> vec[233];
signed main(void) {
read(n);
for (register long long i = 1; i <= (n); i++)
read(val[i]), read(s[i]), sum += (pval[i] = val[i]);
if (sum < 0) {
for (register long long i = 1; i <= (n); i++) val[i] *= -1, pval[i] *= -1;
sum *= -1;
}
for (long long k = 61; k >= 0; k--) {
long long sum = 0;
for (register long long i = 1; i <= (n); i++)
if (s[i] == (1ll << k)) sum += val[i];
for (register long long i = 1; i <= (n); i++)
if (s[i] >> k & 1) {
if (sum > 0) val[i] = -val[i];
s[i] ^= 1ll << k;
}
if (sum > 0) S |= 1ll << k;
}
cerr << S << "\n";
long long cs = 0, sum = 0;
for (register long long i = 1; i <= (n); i++)
cs += __builtin_popcount(s[i] & S) & 1 ? -pval[i] : pval[i];
for (register long long i = 1; i <= (n); i++) sum += pval[i];
cerr << sum << " " << cs << "\n";
cout << S << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 2 * 1000000000;
long long int i, j;
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
long long int mod(long long a, long long b) { return (a % b + b) % b; }
long long int isPrime(long long int n) {
if (n <= 3) return (1);
if (n % 2 == 0 || n % 3 == 0) return (0);
for (i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return (0);
return (1);
}
long long int smallestDivisor(long long int n) {
if (n % 2 == 0) return 2;
for (i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
long long int tt = 1;
while (tt--) {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > v;
for (i = 0; i < n; i++) {
long long int a1, a2;
cin >> a1 >> a2;
v.push_back({a1, a2});
}
vector<long long int> vv;
for (i = 0; i < n; i++) {
long long int count = 0;
for (j = 0; j < n; j++) {
if (i != j) {
if (v[i].second <= v[j].first || v[i].first >= v[j].second) {
continue;
} else {
count++;
}
}
}
vv.push_back(count);
count = 0;
}
vector<pair<long long int, long long int> > anu;
long long int cnt = 0;
for (i = 0; i < vv.size(); i++) {
if (vv[i] > 1) {
anu.push_back({vv[i], i});
}
if (vv[i] == 1) {
cnt++;
}
}
if (anu.size() > 1) {
cout << 0 << "\n";
continue;
} else if (anu.size() == 1) {
cout << anu.size() << "\n";
cout << anu[0].second + 1 << "\n";
continue;
} else if (anu.size() == 0 && cnt == 2) {
cout << 2 << "\n";
for (i = 0; i < vv.size(); i++) {
if (vv[i] == 1) {
cout << i + 1 << " ";
}
}
return 0;
} else if (anu.size() == 0) {
cout << n << "\n";
for (i = 1; i <= n; i++) {
cout << i << " ";
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18;
const int maxn = 4e5 + 7;
const long long mod = 1e9 + 7;
inline long long read() {
long long x = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || '9' < ch) f |= ch == '-', ch = getchar();
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
void out(long long x) {
int stackk[20];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int top = 0;
while (x) stackk[++top] = x % 10, x /= 10;
while (top) putchar(stackk[top--] + '0');
}
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int n, a[maxn], cnt[maxn];
int mp[maxn];
int main() {
n = read();
int ma = 0, D = 0;
for (int i = (1); i <= (n); ++i) {
a[i] = read(), cnt[a[i]]++;
if (cnt[a[i]] > ma) {
ma = cnt[a[i]];
D = a[i];
}
}
int ans = 0;
int T = 200000;
mp[0] = 0;
for (int i = 1; i <= 100; i++) {
if (i == D) continue;
int s = T;
memset(mp, 0, sizeof(mp));
for (int j = 1; j <= n; j++) {
if (a[j] == D)
s++;
else if (a[j] == i)
s--;
if (s == T)
ans = max(ans, j);
else {
if (mp[s] == 0)
mp[s] = j;
else
ans = max(ans, j - mp[s]);
}
}
}
out(ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N;
struct EdgeNode {
int next, to;
} edge[5010];
int head[2020], cnt = 1, sz[2020];
void add(int u, int v) {
cnt++;
edge[cnt].next = head[u];
head[u] = cnt;
edge[cnt].to = v;
}
void insert(int u, int v) {
add(u, v);
add(v, u);
}
struct Point {
int x, y, id;
Point() {}
Point(int a, int b, int c) : x(a), y(b), id(c) {}
} p[2020], O;
int now, ans[2020];
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y, A.id); }
bool operator<(Point A, Point B) {
A = A - O;
B = B - O;
return 1LL * A.x * B.y - 1LL * A.y * B.x > 0;
}
int pl[2020], pr[2020], dfn;
void dfs1(int u, int last) {
sz[u] = 1;
pl[u] = ++dfn;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == last) continue;
sz[u] += sz[v];
dfs1(v, u);
}
pr[u] = dfn;
}
void dfs(int u, int last) {
int tmp = pl[u];
for (int i = pl[u]; i <= pr[u]; i++) {
if ((p[i].y < p[tmp].y) || (p[i].y == p[tmp].y && p[i].x < p[tmp].x))
tmp = i;
}
swap(p[pl[u]], p[tmp]);
ans[p[pl[u]].id] = u;
O = p[pl[u]];
sort(p + pl[u] + 1, p + pr[u] + 1);
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == last) continue;
dfs(v, u);
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
insert(x, y);
}
for (int i = 1; i <= N; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
p[i].id = i;
}
dfs1(1, 0);
dfs(1, 0);
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void add_me(long long int &a, long long int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void sub_me(long long int &a, long long int b) {
a -= b;
if (a < 0) a += 1000000007;
}
struct disjointset {
int parent[200001];
disjointset() {
for (int i = 1; i < 200001; i++) parent[i] = i;
}
int find(int x) {
int par = parent[x];
if (par == x) return x;
return find(parent[x]);
}
void union_(int x, int y) {
int par1 = find(x);
int par2 = find(y);
if (par1 == par2) return;
parent[par2] = par1;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, k, d;
cin >> n >> k >> d;
vector<vector<long long int>> dp(n + 1, vector<long long int>(2));
dp[0][0] = 1;
dp[0][1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= d - 1; j++) {
if (i >= j) {
add_me(dp[i][0], dp[i - j][0]);
add_me(dp[i][1], dp[i - j][1]);
}
}
for (int j = d; j <= k; j++) {
if (i >= j)
add_me(dp[i][1], ((dp[i - j][0] + dp[i - j][1])) % 1000000007);
}
}
cout << dp[n][1] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int p[n + 2];
p[0] = 1;
for (int i = 1; i < n + 2; i++) p[i] = p[i - 1] * 2;
int a[p[n + 1]];
int b[p[n]];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 2; i <= p[n + 1] - 1; i++) cin >> a[i];
int count = 0;
int i = p[n + 1] - 1;
while (i > 1) {
int diff = a[i] - a[i - 1];
if (i * 2 < p[n + 1]) diff += b[i] - b[i - 1];
if (diff > 0) {
count += diff;
a[i - 1] += diff;
} else {
count -= diff;
a[i] -= diff;
}
if (i * 2 < p[n + 1])
b[i / 2] = b[i] + a[i];
else
b[i / 2] = a[i];
i -= 2;
}
cout << count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mult(long long a, long long b, long long p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = 1000000007) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
int main() {
ios::sync_with_stdio(0);
long long n;
cin >> n;
string s1, s2;
cin >> s1;
cin >> s2;
long long onz = 0, ono = 0, zo = 0, ones = 0, zer = 0;
for (long long i = 0; i < s1.length(); i++) {
if (s1[i] == '0' && s2[i] == '0') {
onz++;
}
if (s1[i] == '1' && s2[i] == '0') {
ono++;
}
if (s1[i] == '0' && s2[i] == '1') {
zo++;
}
if (s1[i] == '1') {
ones++;
} else
zer++;
}
cout << onz * ones + ono * zo << "\n";
}
| 2 |
#include<stdio.h>
#define file_input freopen("D://Code//1_in.txt","r",stdin);
#define file_output freopen("D://Code//1_out.txt","w",stdout);
void sort(int *a,int n){
int i,j;
int temp;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(*(a+i)>*(a+j)){
temp = *(a+i);
*(a+i) = *(a+j);
*(a+j) = temp;
}
}
}
}
int main(){
//file_input
//file_output
int t; scanf("%d",&t);
while(t--){
int n,d; scanf("%d %d",&n,&d);
int a[n];
int will_check = 0;
int i;
for(i=0;i<n;i++){
scanf("%d",&a[i]);
if(a[i]>d) will_check = 1;
}
sort(&a[0],n);
if(!will_check) printf("yes\n");
else if(will_check && a[0]+a[1]<=d) printf("yes\n");
else printf("no\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 1e6 + 9;
long long x, y, z, l, r, n, m;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
if (n <= m) {
cout << n;
return 0;
}
l = 0;
r = n + m;
while (l + 1 < r) {
x = (l + r) / 2;
double v = 2.0 * (n - m) / x / (1.0 + x);
if (v > 1.0)
l = x;
else
r = x;
}
cout << m + r;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string str, tmpstr;
int ans[11111], cnt = 0;
int n;
string::iterator it;
int stk[11111] = {0};
int p = 0;
int main() {
n = 0;
while (cin >> tmpstr) {
str += tmpstr;
}
int len = str.length();
int i = 0;
while (i < len) {
if (str.substr(i, 7) == "<table>") {
i += 7;
p++;
} else if (str.substr(i, 4) == "<tr>") {
i += 4;
} else if (str.substr(i, 4) == "<td>") {
i += 4;
stk[p]++;
} else if (str.substr(i, 8) == "</table>") {
i += 8;
ans[cnt++] = stk[p];
stk[p] = 0;
p--;
} else if (str.substr(i, 5) == "</tr>") {
i += 5;
} else if (str.substr(i, 5) == "</td>") {
i += 5;
}
}
sort(ans, ans + cnt);
cout << ans[0];
for (int i = 1; i < cnt; i++) {
cout << " " << ans[i];
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 55;
char s[MAXN];
int main() {
long long n;
scanf("%lld", &n);
long long ans = 0;
long long tmp = -1;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
tmp = i;
break;
}
}
if (tmp == -1) tmp = n;
if (tmp == 2) {
printf("%lld\n", n / 2);
} else {
ans = 1;
printf("%lld\n", ans + (n - tmp) / 2);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n -= 43500;
puts(n > 0 ? (n > 2000 ? "3" : "2") : "1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, cnt = 0;
cin >> x >> y;
bool flag = 0;
while (true) {
if (cnt % 2 == 0) {
if (x >= 2 && y >= 2)
x -= 2, y -= 2;
else if (x >= 1 && y >= 12)
x -= 1, y -= 12;
else if (y >= 22)
y -= 22;
else
break;
} else {
if (y >= 22)
y -= 22;
else if (x >= 1 && y >= 12)
x -= 1, y -= 12;
else if (x >= 2 && y >= 2)
x -= 2, y -= 2;
else
break;
}
cnt++;
}
if (cnt % 2 == 1) {
cout << "Ciel";
} else {
cout << "Hanako";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int H = 1e9 + 7, MOD = 1e9 + 9, MAX = 600005;
int Mul(int a, int b) { return ((long long)a * b) % MOD; }
int Add(int a, int b) { return (a + b) % MOD; }
int Sub(int a, int b) { return (a - b + MOD) % MOD; }
void Stavi(int fen[MAX], int pos, int val) {
for (pos++; pos < MAX; pos += pos & -pos) fen[pos] = Add(fen[pos], val);
}
int Vrati(int fen[MAX], int pos) {
int ret = 0;
for (pos++; pos; pos -= pos & -pos) ret = Add(ret, fen[pos]);
return ret;
}
int raste[MAX], pada[MAX];
int p[MAX];
int pot[MAX];
int main() {
pot[0] = 1;
for (int i = 1; i < MAX; i++) pot[i] = Mul(pot[i - 1], H);
int n, rje = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) {
int lgran = 1, rgran = n;
if (p[i] - 1 < n - p[i])
rgran = 2 * p[i] - 1;
else
lgran = 2 * p[i] - n;
int hr = Sub(Vrati(raste, rgran), Vrati(raste, lgran - 1));
int hp = Sub(Vrati(pada, rgran), Vrati(pada, lgran - 1));
hr = Mul(hr, pot[MAX - rgran - lgran]);
if (hr != hp) rje = 1;
Stavi(raste, p[i], pot[p[i]]);
Stavi(pada, p[i], pot[MAX - p[i]]);
}
if (!rje)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, p = 2;
scanf("%d", &n);
for (int i = 3; i <= n; i++) {
ans += (p * i);
p = i;
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool debug;
const int inf = 1e9 + 5;
const int nax = 1e3 + 5;
int t[nax];
int n;
int h[nax], w[nax];
int main(int argc, char* argv[]) {
debug = argc > 1;
scanf("%d", &n);
int najm = 0;
for (int i = 0; i <= (n)-1; ++i) {
scanf("%d%d", &w[i], &h[i]);
najm = max(najm, min(h[i], w[i]));
}
int res = inf;
for (int i = 1000; i >= najm; --i) {
int ile_juz = 0;
int szer = 0;
int ile = 0;
for (int j = 0; j <= (n)-1; ++j)
if (h[j] > i) {
++ile_juz;
szer += h[j];
} else {
if (w[j] <= i && w[j] > h[j]) t[ile++] = h[j] - w[j];
szer += w[j];
}
sort(t, t + ile);
for (int j = 0; j <= (min(n / 2 - ile_juz, ile)) - 1; ++j) szer += t[j];
if (ile_juz <= n / 2) res = min(res, i * szer);
}
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = int(1e9) + 7;
const int N = 1010000;
int m, n, k, a[N], ans, c[N];
long long l, dp[N], ss[N];
pair<int, int> p[N];
inline long long in() {
int x = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int main() {
scanf("%d%I64d%d", &n, &l, &k);
for (int i = 0; i < n; ++i) a[i] = in();
m = n * k;
for (int i = 0; i < m; ++i) p[i] = make_pair(a[i % n], i);
sort(p, p + m);
for (int j = 0; j < m; ++j) {
int i = p[j].second;
if (i < n)
dp[i] = 1;
else
dp[i] = ss[i / n - 1];
ss[i / n] = (ss[i / n] + dp[i]) % Mod;
if (i < l) {
long long x = (l - 1 - i + n) / n;
ans = (ans + (x % Mod) * dp[i]) % Mod;
}
}
if (ans < 0) ans += Mod;
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, cnt = 0;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = j; k <= n; k++)
if ((i ^ j ^ k) == 0 && i + j > k && i + k > j && j + k > i) cnt++;
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
cin >> t;
while (t-- > 0) {
long long int n, m;
cin >> n >> m;
string s[n];
for (long long int i = 0; i < n; i++) cin >> s[i];
vector<vector<long long int> > ans;
long long int k = 0;
for (long long int j = 0; j < m - 2; j++) {
for (long long int i = 0; i < n; i++) {
if (s[i][j] == '0') continue;
if (i == 0) {
ans.push_back({i + 1, j + 1, i + 1, j + 2, i + 2, j + 2});
s[i][j] = '0';
if (s[i + 1][j + 1] == '0')
s[i + 1][j + 1] = '1';
else
s[i + 1][j + 1] = '0';
if (s[i][j + 1] == '0')
s[i][j + 1] = '1';
else
s[i][j + 1] = '0';
} else {
ans.push_back({i + 1, j + 1, i + 1, j + 2, i, j + 2});
s[i][j] = '0';
if (s[i - 1][j + 1] == '0')
s[i - 1][j + 1] = '1';
else
s[i - 1][j + 1] = '0';
if (s[i][j + 1] == '0')
s[i][j + 1] = '1';
else
s[i][j + 1] = '0';
}
}
}
for (long long int i = 0; i < n - 1; i++) {
if (s[i][m - 2] == '0' && s[i][m - 1] == '0')
continue;
else if (s[i][m - 2] == '1' && s[i][m - 1] == '0') {
ans.push_back({i + 1, m - 1, i + 2, m - 1, i + 2, m});
s[i][m - 2] = '0';
if (s[i + 1][m - 2] == '0')
s[i + 1][m - 2] = '1';
else
s[i + 1][m - 2] = '0';
if (s[i + 1][m - 1] == '0')
s[i + 1][m - 1] = '1';
else
s[i + 1][m - 1] = '0';
} else if (s[i][m - 2] == '0' && s[i][m - 1] == '1') {
ans.push_back({i + 1, m, i + 2, m - 1, i + 2, m});
s[i][m - 1] = '0';
if (s[i + 1][m - 2] == '0')
s[i + 1][m - 2] = '1';
else
s[i + 1][m - 2] = '0';
if (s[i + 1][m - 1] == '0')
s[i + 1][m - 1] = '1';
else
s[i + 1][m - 1] = '0';
} else {
if (s[i + 1][m - 2] == '1') {
ans.push_back({i + 1, m - 1, i + 1, m, i + 2, m - 1});
s[i + 1][m - 2] = '0';
} else {
ans.push_back({i + 1, m - 1, i + 1, m, i + 2, m});
if (s[i + 1][m - 1] == '0')
s[i + 1][m - 1] = '1';
else
s[i + 1][m - 1] = '0';
}
}
}
if (s[n - 1][m - 2] == '1' && s[n - 1][m - 1] == '1') {
ans.push_back({n, m - 1, n - 1, m, n - 1, m - 1});
ans.push_back({n - 1, m - 1, n, m, n - 1, m});
} else if (s[n - 1][m - 2] == '1') {
ans.push_back({n, m - 1, n, m, n - 1, m});
ans.push_back({n - 1, m - 1, n, m - 1, n, m});
ans.push_back({n - 1, m - 1, n, m - 1, n - 1, m});
} else if (s[n - 1][m - 1] == '1') {
ans.push_back({n - 1, m - 1, n - 1, m, n, m});
ans.push_back({n, m - 1, n, m, n - 1, m - 1});
ans.push_back({n, m - 1, n, m, n - 1, m});
}
cout << ans.size() << '\n';
for (long long int i = 0; i < ans.size(); i++) {
for (long long int j = 0; j < ans[i].size(); j++) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
}
cerr << "\nTime elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
}
| 3 |
#include <stdio.h>
#include <math.h>
#include<bits/stdc++.h>
using namespace std;
// C = a^2 - b and C^2 = a^2 + b^2 hence (a^2 - b)^2 = a^2 + b^2 , evaluate and subtract then, a^2 = 2*b+1
// Since a^2 - b = C , then 2*b+1 - b = C , then C = b+1 !!!!! , We can observe that the difference between b and c are just 1
// b and c are nearly equal , so we must find integer "a" so that its square is odd number since odd / 2 gives you two numbers
// the floor and the ceil , which are basically b and b+1 -> b and c ^^
int main() {
int t;
scanf("%d",&t);
while(t--) {
int n;
scanf("%d",&n);
int odd_Square = sqrt(n << 1); // --> sqrt ( n / 2 );
printf("%d\n",(odd_Square-1) >> 1); // --> (odd_Square - 1) / 2 ;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll a, b, c;
cin >> a >> b >> c;
for (ll i = 0; i < 10; i++) {
if (((a * 10) + i) % b == 0) {
cout << a << i;
cout << string(c - 1, '0') << endl;
return 0;
}
}
cout << -1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 9;
int a[MAX], n;
vector<int> ans;
double d, mi = 1e12, ma;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
d = 1.0 * a[i] / (i + 1);
if (ma < d) ma = d;
d = 1.0 * (a[i] + 1 - 1e-12) / (i + 1);
if (mi > d) mi = d;
}
if ((int)(mi * (n + 1)) == (int)(ma * (n + 1)))
cout << "unique\n" << (int)(ma * (n + 1));
else
cout << "not unique";
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 500001;
int n, tot, lnk1[maxn], lnk2[maxn], lst[maxn], dsu[maxn], seq1[maxn],
seq2[maxn], ans[maxn];
struct Edge {
int nxt, v;
} e[maxn << 2 | 1];
struct NewEdge {
int nxt, v, eid;
} g[maxn << 1 | 1];
inline int dsu_find(int x) {
return dsu[x] < 0 ? x : (dsu[x] = dsu_find(dsu[x]));
}
inline void dsu_merge(int u, int v) {
u = dsu_find(u);
v = dsu_find(v);
if (u == v) return;
if (dsu[u] < dsu[v]) std::swap(u, v);
if (dsu[u] == dsu[v]) --dsu[v];
dsu[u] = v;
}
void dfs(int u, int fa) {
int pre = -1;
for (int it = lst[u]; it != -1; it = g[it].nxt)
if (g[it].v != fa)
dfs(g[it].v, u);
else
pre = it;
if (pre == -1) return;
if (ans[u] == -1)
ans[u] = g[pre].eid;
else {
int it = g[pre].eid, jt = ans[u];
printf("%d %d %d %d\n", e[it].v, e[it ^ 1].v, e[jt].v, e[jt ^ 1].v);
}
}
inline bool cmp(int const &x, int const &y) { return e[x].v < e[y].v; }
int main() {
scanf("%d", &n);
memset(lnk1 + 1, -1, n * sizeof(int));
memset(lnk2 + 1, -1, n * sizeof(int));
memset(dsu + 1, -1, n * sizeof(int));
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[tot] = (Edge){lnk1[u], v};
lnk1[u] = tot++;
e[tot] = (Edge){lnk1[v], u};
lnk1[v] = tot++;
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[tot] = (Edge){lnk2[u], v};
lnk2[u] = tot++;
e[tot] = (Edge){lnk2[v], u};
lnk2[v] = tot++;
}
tot = (n - 1) << 1;
for (int i = 1; i <= n; ++i) {
int sz1 = 0, sz2 = 0;
for (int &it = lnk1[i]; it != -1; it = e[it].nxt) seq1[sz1++] = it;
for (int &it = lnk2[i]; it != -1; it = e[it].nxt) seq2[sz2++] = it;
std::sort(seq1, seq1 + sz1, cmp);
std::sort(seq2, seq2 + sz2, cmp);
int j = 0, k = 0;
while (j < sz1 && k < sz2)
if (e[seq1[j]].v < e[seq2[k]].v) {
e[seq1[j]].nxt = lnk1[i];
lnk1[i] = seq1[j++];
} else if (e[seq1[j]].v > e[seq2[k]].v) {
e[seq2[k]].nxt = lnk2[i];
lnk2[i] = seq2[k++];
} else {
--tot;
dsu_merge(i, e[seq1[j]].v);
++j;
++k;
}
while (j < sz1) {
e[seq1[j]].nxt = lnk1[i];
lnk1[i] = seq1[j++];
}
while (k < sz2) {
e[seq2[k]].nxt = lnk2[i];
lnk2[i] = seq2[k++];
}
}
printf("%d\n", tot >> 1);
tot = 0;
memset(lst + 1, -1, n * sizeof(int));
for (int i = 1; i <= n; ++i) {
int u = dsu_find(i);
for (int it = lnk2[i]; it != -1; it = e[it].nxt) {
int v = dsu_find(e[it].v);
if (u != v) {
g[tot] = (NewEdge){lst[u], v, it};
lst[u] = tot++;
}
}
}
memset(ans + 1, -1, n * sizeof(int));
dfs(dsu_find(1), -1);
tot = 0;
memset(lst + 1, -1, n * sizeof(int));
for (int i = 1; i <= n; ++i) {
int u = dsu_find(i);
for (int it = lnk1[i]; it != -1; it = e[it].nxt) {
int v = dsu_find(e[it].v);
if (u != v) {
g[tot] = (NewEdge){lst[u], v, it};
lst[u] = tot++;
}
}
}
dfs(dsu_find(1), -1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b;
int main() {
cin >> n >> m >> a >> b;
cout << min((m - (n % m)) * a, (n % m) * b);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.