solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n + 10);
for (int i = 0; i < n; i++) cin >> a[i];
int MAXN = *max_element(a.begin(), a.end());
bool done = false;
for (int i = 0; i < n; i++) {
if (a[i] == MAXN &&
((a[i + 1] < MAXN && i + 1 < n) || (a[i - 1] < MAXN && i - 1 >= 0))) {
cout << i + 1 << "\n";
done = true;
break;
}
}
if (!done) cout << -1 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
const int MAXN = 3969;
int N;
vector<int> edge[MAXN];
vector<int> ord;
int dsu[MAXN];
int net[MAXN];
int get(int u) { return (u == dsu[u] ? u : dsu[u] = get(dsu[u])); }
void merge(int u, int v) {
u = get(u);
v = get(v);
if (u == v) return;
dsu[u] = v;
return;
}
int getval(int x) {
if ('a' <= x && x <= 'z') return x - 'a';
if ('A' <= x && x <= 'Z') return 26 + x - 'A';
if ('0' <= x && x <= '9') return 52 + (x - '0');
assert(false);
}
char getc(int x) {
if (0 <= x && x < 26) return 'a' + x;
if (26 <= x && x < 52) return 'A' + x - 26;
if (52 <= x) return '0' + x - 52;
assert(false);
}
int32_t main() {
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
ios_base::sync_with_stdio(false);
cin.tie(0);
iota(dsu, dsu + 3844, 0);
cin >> N;
for (auto i = (0); i < (N); i++) {
string str;
cin >> str;
int x = getval(str[0]), y = getval(str[1]), z = getval(str[2]);
edge[62 * x + y].push_back(62 * y + z);
merge(62 * x + y, 62 * y + z);
}
N = 3844;
int need = -1;
for (auto i = (0); i < (N); i++) {
if (!edge[i].empty()) need = get(i);
}
for (auto i = (0); i < (N); i++) {
if (!edge[i].empty() && get(i) != need) {
cout << "NO\n";
return 0;
}
}
for (auto i = (0); i < (N); i++) {
net[i] += ((int)(edge[i]).size());
for (int j : edge[i]) {
net[j]--;
}
}
int neg = -1, pos = -1;
for (auto i = (0); i < (N); i++) {
if (net[i] < -1 || net[i] > 1) {
cout << "NO\n";
return 0;
}
if (net[i] == -1) {
if (neg != -1) {
cout << "NO\n";
return 0;
}
neg = i;
}
if (net[i] == 1) {
if (pos != -1) {
cout << "NO\n";
return 0;
}
pos = i;
}
}
swap(pos, neg);
if (neg != -1) {
edge[pos].push_back(neg);
}
vector<int> stk;
stk.push_back(need);
while (!stk.empty()) {
int u = stk.back();
if (edge[u].empty()) {
ord.push_back(u);
stk.pop_back();
} else {
stk.push_back(edge[u].back());
edge[u].pop_back();
}
}
reverse((ord).begin(), (ord).end());
if (neg != -1) {
ord.pop_back();
if (ord.back() == pos && ord.front() == neg) {
} else {
for (auto i = (0); i < (((int)(ord).size()) - 1); i++) {
if (ord[i] == pos && ord[i + 1] == neg) {
rotate(ord.begin(), ord.begin() + i + 1, ord.end());
break;
}
}
}
}
cout << "YES\n";
cout << getc(ord[0] / 62);
for (int x : ord) {
cout << getc(x % 62);
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k, x;
cin >> n >> k >> x;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
int i = 0;
int j = n - 1;
int ans = 0;
while (i < n && i < k) {
ans += x;
j--;
i++;
}
while (i < n) {
ans += a[j];
j--;
i++;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
int x;
long long sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
sum += x;
}
if (sum % n) {
cout << n - 1;
} else
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5000;
long long cumulative[N + 10], arr[N + 10][3];
signed main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q;
cin >> n >> q;
vector<pair<long long, long long> > pi;
for (long long i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
cumulative[a] += 1;
cumulative[b + 1] -= 1;
pi.push_back({a, b});
}
for (long long i = 1; i <= n; i++) {
cumulative[i] += cumulative[i - 1];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 3; j++) {
if (cumulative[i] == j) {
arr[i][j] += (arr[i - 1][j] + 1);
} else {
arr[i][j] += arr[i - 1][j];
}
}
}
long long sz = pi.size();
sort(pi.begin(), pi.end());
long long ans = 0;
for (long long i = 0; i < sz - 1; i++) {
long long x = pi[i].first;
long long y = pi[i].second;
for (long long j = i + 1; j < sz; j++) {
long long two = 0;
long long a = pi[j].first;
long long b = pi[j].second;
if (a <= y) {
long long ax = max(x, a);
long long by = min(y, b);
two = (arr[by][2] - arr[ax - 1][2]);
}
long long zero = (arr[n][0] - arr[0][0]);
long long one = (arr[y][1] - arr[x - 1][1]) + (arr[b][1] - arr[a - 1][1]);
long long total = one + two + zero;
long long res = n - total;
ans = max(ans, res);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
bool exmax(T &a, T b) {
return (b > a) ? (a = b) || 1 : 0;
}
template <typename T>
bool exmin(T &a, T b) {
return (b < a) ? (a = b) || 1 : 0;
}
using namespace std;
int main(void) {
int N, M;
scanf("%d%d", &N, &M);
int C;
scanf("%d", &C);
long long lu = -(1LL << 40), ru = -(1LL << 40), ld = -(1LL << 40),
rd = -(1LL << 40);
for (__typeof(C) i = 0; i < (C); i++) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
lu = max(lu, -x + y);
ru = max(ru, x + y);
ld = max(ld, -x - y);
rd = max(rd, x - y);
}
int ind;
long long km = 1LL << 40;
int H;
scanf("%d", &H);
for (__typeof(H) i = 0; i < (H); i++) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
long long tmp;
tmp = max(max(x - y + lu, -x - y + ru), max(x + y + ld, -x + y + rd));
if (tmp < km) {
km = tmp;
ind = i + 1;
}
}
printf("%I64d\n%d\n", km, ind);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 21;
int a[1 << maxn], n;
long long ans[maxn][2];
void mergesort(int l, int r, int dep) {
if (r - l <= 1) return;
int m = (l + r) / 2;
mergesort(l, m, dep - 1);
mergesort(m, r, dep - 1);
for (int i = l; i < m; i++) {
ans[dep][0] += lower_bound(a + m, a + r, a[i]) - a - m;
}
for (int i = m; i < r; i++) {
ans[dep][1] += lower_bound(a + l, a + m, a[i]) - a - l;
}
inplace_merge(a + l, a + m, a + r);
}
long long solve(int q) {
long long res = 0;
while (q) swap(ans[q][0], ans[q][1]), q--;
for (int i = 1; i <= n; i++) {
res += ans[i][0];
}
return res;
}
int main() {
int m, q;
cin >> n;
for (int i = 0; i < 1 << n; i++) scanf("%d", &a[i]);
cin >> m;
mergesort(0, 1 << n, n);
for (int i = 0; i < m; i++) {
scanf("%d", &q);
cout << solve(q) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const int INF = 1000000;
int n, x, y, a[N], b[N];
int main() {
cin >> n;
fill(a + 1, a + 1001, INF);
fill(b + 1, b + 1001, INF);
for (int i = 0; i < 100; i++) {
for (int j = 1000; j >= 4; j--) {
a[j] = min(a[j], 1 + a[j - 4]);
}
for (int j = 1000; j >= 9; j--) {
a[j] = min(a[j], 1 + a[j - 9]);
}
for (int j = 1000; j >= 49; j--) {
a[j] = min(a[j], 1 + a[j - 49]);
}
for (int j = 1000; j >= 49; j--) {
b[j] = min(b[j], 1 + b[j - 49]);
}
for (int j = 1000; j >= 45; j--) {
b[j] = min(b[j], 1 + b[j - 45]);
}
for (int j = 1000; j >= 40; j--) {
b[j] = min(b[j], 1 + b[j - 40]);
}
}
if (n <= 20) {
int ans = 0;
for (int i = 0; i <= 1000; i++) {
ans += a[i] <= n;
}
cout << ans << '\n';
} else {
long long ans = 49LL * n + 1;
for (int i = 0; i <= 1000; i++) {
ans -= a[i] == INF;
ans -= b[i] == INF;
}
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[100111];
long long pre[100010], suf[100010];
int trie[10000100][2];
int size = 0;
void Insert(long long x) {
int pos = 0;
for (int i = 39; i >= 0; i--) {
bool ch = 0;
if (x & (1ll << i)) ch = 1;
if (!trie[pos][ch]) trie[pos][ch] = ++size;
pos = trie[pos][ch];
}
}
long long Query(long long x) {
int pos = 0;
long long res = 0;
for (int i = 39; i >= 0; i--) {
bool ch = 1;
if (x & (1ll << i)) ch = 0;
if (trie[pos][ch])
res += 1ll << i;
else
ch ^= 1;
pos = trie[pos][ch];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pre[i] = pre[i - 1] ^ a[i];
ans = max(pre[i], ans);
}
for (int i = n; i; i--) {
suf[i] = suf[i + 1] ^ a[i];
ans = max(suf[i], ans);
}
for (int i = 1; i <= n + 1; i++) {
Insert(pre[i - 1]);
ans = max(ans, Query(suf[i]));
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
cout << n;
for (int i = 1; i < n; i++) cout << " " << i;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class graf {
public:
graf(int n) {
this->n = n;
vecini.resize(n + 1);
viz.resize(n + 1);
}
void AddEdge(int x, int y) {
vecini[x].push_back(y);
vecini[y].push_back(x);
}
void GetComp(vector<vector<int> > &ret) {
fill(viz.begin(), viz.end(), false);
for (int i = 1; i <= n; ++i) {
if (viz[i] == false) {
vector<int> comp;
DFS(comp, i);
ret.push_back(comp);
}
}
}
void DFS(vector<int> &comp, int current) {
viz[current] = true;
comp.push_back(current);
for (auto v : vecini[current])
if (!viz[v]) DFS(comp, v);
}
private:
int n;
vector<vector<int> > vecini;
vector<bool> viz;
};
bool Ciclu(vector<bool> &viz, vector<bool> &inStack,
const vector<vector<int> > &vecini, int current) {
if (inStack[current]) return true;
if (viz[current]) return false;
inStack[current] = true;
viz[current] = true;
for (auto v : vecini[current]) {
if (Ciclu(viz, inStack, vecini, v)) return true;
}
inStack[current] = false;
return false;
}
int rez(int n, const vector<int> &comp, const vector<vector<int> > &vecini,
const vector<int> &grad) {
vector<bool> inStack(n + 1, false);
vector<bool> viz(n + 1, false);
bool ok = false;
for (auto v : comp) {
if (viz[v]) continue;
if (Ciclu(viz, inStack, vecini, v)) return comp.size();
ok = true;
}
if (ok) return comp.size() - 1;
return comp.size();
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > vecini(n + 1);
vector<int> grad(n + 1, 0);
graf gr(n);
int a, b;
for (int i = 1; i <= m; ++i) {
cin >> a >> b;
vecini[a].push_back(b);
grad[b]++;
gr.AddEdge(a, b);
}
vector<vector<int> > comp;
gr.GetComp(comp);
int rasp = 0;
for (const auto &c : comp) rasp += rez(n, c, vecini, grad);
cout << rasp;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool lucky(const char *str) {
for (; *str; ++str) {
if (*str != '4' && *str != '7') return false;
}
return true;
}
int main() {
int l, sl = 0, sr = 0;
string ticket;
(cin >> l, l);
(cin >> ticket, ticket);
if (!lucky(ticket.c_str())) {
cout << ("NO");
} else {
for (int i = (0); i < (l / 2); ++i) sl += ticket[i] - '0';
for (int i = (l / 2); i < (l); ++i) sr += ticket[i] - '0';
if (sl != sr) {
cout << ("NO");
} else {
cout << ("YES");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 18;
int f[55];
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
f[1] = 4;
vector<int> a = {1, 5, 10, 50}, b;
for (int i = 2; i <= 50; ++i) {
for (int v : a) {
b.emplace_back(v + 1);
b.emplace_back(v + 5);
b.emplace_back(v + 10);
b.emplace_back(v + 50);
}
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
f[i] = b.size();
swap(a, b);
b.clear();
}
int n;
cin >> n;
if (n <= 50)
cout << f[n];
else
cout << 49ll * (n - 50) + f[50];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, d, first, second;
vector<pair<double, int> > w;
double D, r;
int Mashiro;
void solve(double R) {
if (D + R < r + 1e-10) {
++Mashiro;
return;
}
if (R + r < D - 1e-10) return;
if (R > D + r + 1e-10) return;
double del = acos((((R) * (R)) + ((D) * (D)) - ((r) * (r))) / 2.0 / R / D);
double agl = atan2((double)second, (double)first);
double l = agl - del, r = agl + del;
if (l < -M_PI)
w.push_back(make_pair(-M_PI, -1)), w.push_back(make_pair(l + M_PI * 2, -1)),
w.push_back(make_pair(M_PI, 1));
else
w.push_back(make_pair(l, -1));
if (r > M_PI)
w.push_back(make_pair(M_PI, 1)), w.push_back(make_pair(-M_PI, -1)),
w.push_back(make_pair(r - M_PI * 2, 1));
else
w.push_back(make_pair(r, 1));
}
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%lf", &first, &second, &r);
D = sqrt((double)((first) * (first)) + ((second) * (second)));
for (int k = max((int)((D - r) / d), 1); k <= (int)((D + r) / d + 1e-10);
++k)
solve(k * d);
}
int Tohka = 0;
sort(w.begin(), w.end());
for (int i = 0, s = 0; i < (int)w.size(); ++i) {
s += w[i].second;
Tohka = max(Tohka, -s);
}
cout << Tohka + Mashiro << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[10][10];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
}
int ans = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
ans = max(ans, a[i][j]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
template <class T>
inline void sort(T &a) {
sort((a).begin(), (a).end());
}
template <class T>
inline void rsort(T &a) {
sort((a).rbegin(), (a).rend());
}
template <class T>
inline void reverse(T &a) {
reverse((a).begin(), (a).end());
}
template <class T, class U>
inline void checkmin(T &x, U y) {
if (x > y) x = y;
}
template <class T, class U>
inline void checkmax(T &x, U y) {
if (x < y) x = y;
}
map<int, int> p;
map<int, int> xorp;
void make_set(int x) {
if (p.count(x)) return;
p[x] = x;
}
int findset(int x) {
if (p[x] == x) return x;
int a = findset(p[x]);
xorp[x] ^= xorp[p[x]];
p[x] = a;
return a;
}
int union_sets(int a, int b, int x) {
int c = findset(a);
int d = findset(b);
x ^= xorp[a] ^ xorp[b];
if (c != d) {
if (rand() & 1) {
p[c] = d;
xorp[c] = x;
} else {
p[d] = c;
xorp[d] = x;
}
}
}
int get(int a, int b) {
int c = findset(a);
int d = findset(b);
if (c != d) return -1;
return xorp[a] ^ xorp[b];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
srand(time(nullptr));
int q;
cin >> q;
int last = 0;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int l, r, x;
cin >> l >> r >> x;
l ^= last, r ^= last, x ^= last;
if (l > r) swap(l, r);
++r;
make_set(l);
make_set(r);
union_sets(l, r, x);
} else {
int l, r;
cin >> l >> r;
l ^= last;
r ^= last;
if (l > r) swap(l, r);
++r;
make_set(l);
make_set(r);
last = get(l, r);
cout << last << '\n';
if (last < 0) last = 1;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int mpw(long long int a, long long int b, long long int m) {
long long int ans = 1;
if (a == 0) return 0;
if (a == 1 || b == 0) return 1;
while (b) {
if (b & 1) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return ans;
}
long long int pw(long long int a, long long int b) {
long long int ans = 1;
if (a == 0) return 0;
if (a == 1 || b == 0) return 1;
while (b) {
if (b & 1) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
long long int mn(long long int a, long long int b) {
if (a <= b) {
return a;
}
return b;
}
long long int mx(long long int a, long long int b) {
if (a >= b) {
return a;
}
return b;
}
struct line {
long long int m, c;
long long int eval(long long int x) { return m * 1LL * x + c; }
long long int intersect(line l) { return (long double)(c - l.c) / (l.m - m); }
};
struct BIT {
vector<long long int> B1;
vector<long long int> B2;
int n;
BIT(int n) {
this->n = n;
B1.clear();
B1.resize(this->n, 0);
B2.clear();
B2.resize(this->n, 0);
}
BIT(vector<long long int> a) {
this->n = a.size();
B1.clear();
B1.resize(this->n, 0);
B2.clear();
B2.resize(this->n, 0);
for (int i = 0; i < a.size(); ++i) {
mdf(a[i], i);
}
}
void range_add(long long int val, int l, int r) {
add(1, l, val);
add(2, l, val * (l));
if (r < n - 1) {
add(1, r + 1, -1 * val);
add(2, r + 1, -1 * val * (r + 1));
}
return;
}
void mdf(long long int val, int indx) {
long long int tmp = org(indx);
range_add(val - tmp, indx, indx);
return;
}
void add(int id, int indx, long long int val) {
if (id == 1) {
while (indx < n) {
B1[indx] += val;
indx = (indx | (indx + 1));
}
return;
}
if (id == 2) {
while (indx < n) {
B2[indx] += val;
indx = (indx | (indx + 1));
}
return;
}
}
long long int range_sum(int l, int r) {
return sum(r) - (l == 0 ? 0 : sum(l - 1));
}
long long int sum(int r) {
int st = r;
long long int res = 0;
while (st >= 0) {
res += B2[st];
st = (st & (st + 1)) - 1;
}
return ((org(r) * (r + 1)) - res);
}
long long int org(int r) {
long long int res = 0;
while (r >= 0) {
res += B1[r];
r = (r & (r + 1)) - 1;
}
return res;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> nm;
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
int cnt = 0;
while (tmp) {
tmp /= 2;
cnt++;
}
nm.push_back(cnt);
}
unordered_map<int, int> mp;
long long int ans = 0;
for (int i = 0; i < n; ++i) {
ans += mp[nm[i]];
mp[nm[i]]++;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int mn = 1e9;
int n;
cin >> n;
string s;
cin >> s;
int tigers = count(s.begin(), s.end(), 'T');
s += s;
int cnt = count(s.begin(), s.begin() + tigers, 'H');
for (int i = 1; i + tigers - 1 < s.size(); ++i)
cnt += (s[i + tigers - 1] == 'H') - (s[i - 1] == 'H'), mn = min(mn, cnt);
cout << mn;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int q, dep[maxn], fa[19][maxn];
set<int> S1, S2;
int qlca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = (18), iend = (0); i >= iend; --i)
if (dep[fa[i][u]] >= dep[v]) u = fa[i][u];
if (u == v) return u;
for (int i = (18), iend = (0); i >= iend; --i)
if (fa[i][u] != fa[i][v]) u = fa[i][u], v = fa[i][v];
return fa[0][u];
}
int qdis(int u, int v) { return dep[u] + dep[v] - dep[qlca(u, v)] * 2; }
int main() {
cin >> q, dep[1] = 1;
int n = 1, cur = 0;
S1.insert(1), S2.insert(1);
while (q--) {
int f;
scanf("%d", &f), dep[++n] = dep[f] + 1, fa[0][n] = f;
for (int i = (1), iend = (18); i <= iend; ++i)
fa[i][n] = fa[i - 1][fa[i - 1][n]];
int d1 = qdis(n, *S1.begin()), d2 = qdis(n, *S2.begin());
if (d1 > cur) {
cur = d1;
for (int x : S2)
if (qdis(n, x) == d1) S1.insert(x);
S2.clear(), S2.insert(n);
} else if (d2 > cur) {
cur = d2;
for (int x : S1)
if (qdis(n, x) == d2) S2.insert(x);
S1.clear(), S1.insert(n);
} else if (d1 == cur)
S2.insert(n);
else if (d2 == cur)
S1.insert(n);
printf("%d\n", (int)(S1.size() + S2.size()));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int dp[2001][2001];
bool raining[2001];
int A, N, M;
int id[2001], weight[2001];
int w[2001];
int main() {
cin >> A >> N >> M;
for (int i = 0; i < N; i++) {
int l, r;
cin >> l >> r;
for (int j = l; j < r; j++) raining[j] = true;
}
for (int i = 1; i <= M; i++) {
int loc;
cin >> loc >> w[i];
if (weight[loc] == 0 || weight[loc] > w[i]) {
weight[loc] = w[i];
id[loc] = i;
}
}
for (int i = 0; i <= A; i++)
for (int j = 0; j <= M; j++) dp[i][j] = 2001001001;
dp[0][0] = 0;
for (int i = 0; i < A; i++) {
for (int j = 0; j <= M; j++) {
if (dp[i][j] == 2001001001) continue;
if (j != 0) {
if (raining[i] == false) dp[i + 1][0] = min(dp[i + 1][0], dp[i][j]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + w[j]);
if (weight[i] != 0)
dp[i + 1][id[i]] = min(dp[i + 1][id[i]], dp[i][j] + weight[i]);
} else {
if (raining[i] == false) dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
if (weight[i] != 0)
dp[i + 1][id[i]] = min(dp[i + 1][id[i]], dp[i][0] + weight[i]);
}
}
}
int ans = 2001001001;
for (int i = 0; i <= M; i++) ans = min(ans, dp[A][i]);
if (ans == 2001001001)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
vector<string> N(a), M(b);
for (auto& i : N) cin >> i;
for (auto& i : M) cin >> i;
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
cout << N[(n - 1) % a] << M[(n - 1) % b] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
long n = 0, tmp;
std::vector<char> arr;
int main() {
scanf("%ld", &n);
for (long i = 0; i < n; i++) {
scanf("%ld", &tmp);
for (long j = 0; j < tmp; j++) {
if (i < n - 1) {
arr.push_back('P');
arr.push_back('R');
arr.push_back('L');
} else {
arr.push_back('P');
arr.push_back('L');
arr.push_back('R');
}
}
if (i < n - 1) arr.push_back('R');
}
long s = (long)arr.size();
for (long i = 0; i < s; i++) {
printf("%c", arr[i]);
}
};
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, d[6], a[55][55], ans = 1000000007, res, f[55], cnt;
vector<pair<int, int> > v[105];
int get(int x) { return x == f[x] ? x : f[x] = get(f[x]); }
void sol() {
vector<int> V;
for (int i = 1; i <= n; ++i) V.push_back(f[i]);
int R = res, C = cnt;
vector<int> q;
for (int i = 1; i <= 100; ++i) {
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if (x <= k || y <= k || get(x) == get(y)) continue;
f[f[y]] = f[x];
res += a[x][y];
}
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if ((x > k && y > k) || get(x) == get(y)) continue;
if (x <= k) {
if (!d[x]) continue;
--d[x];
q.push_back(x);
++cnt;
}
if (y <= k) {
if (!d[y]) continue;
--d[y];
q.push_back(y);
++cnt;
}
f[f[y]] = f[x];
res += a[x][y];
}
}
for (int i = 0; i < q.size(); ++i) ++d[q[i]];
q.clear();
if (cnt == n - 1) ans = min(ans, res);
for (int _ = 0; _ < 100; ++_) {
for (int i = 1; i <= n; ++i) f[i] = V[i - 1];
res = R;
cnt = C;
for (int i = 1; i <= 100; ++i) {
random_shuffle(v[i].begin(), v[i].end());
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if (x <= k || y <= k || get(x) == get(y)) continue;
f[f[y]] = f[x];
res += a[x][y];
++cnt;
}
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if ((x > k && y > k) || get(x) == get(y)) continue;
if (rand() < 2000) continue;
if (x <= k) {
if (!d[x]) continue;
--d[x];
q.push_back(x);
}
if (y <= k) {
if (!d[y]) continue;
--d[y];
q.push_back(y);
}
f[f[y]] = f[x];
res += a[x][y];
++cnt;
}
}
if (cnt == n - 1) ans = min(ans, res);
for (int i = 0; i < q.size(); ++i) ++d[q[i]];
q.clear();
}
for (int _ = 0; _ < 100; ++_) {
for (int i = 1; i <= n; ++i) f[i] = V[i - 1];
res = R;
cnt = C;
for (int i = 1; i <= 100; ++i) {
random_shuffle(v[i].begin(), v[i].end());
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if (x <= k || y <= k || get(x) == get(y)) continue;
f[f[y]] = f[x];
res += a[x][y];
++cnt;
}
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if ((x > k && y > k) || get(x) == get(y)) continue;
if (rand() < 6000) continue;
if (x <= k) {
if (!d[x]) continue;
--d[x];
q.push_back(x);
}
if (y <= k) {
if (!d[y]) continue;
--d[y];
q.push_back(y);
}
f[f[y]] = f[x];
res += a[x][y];
++cnt;
}
}
if (cnt == n - 1) ans = min(ans, res);
for (int i = 0; i < q.size(); ++i) ++d[q[i]];
q.clear();
}
for (int _ = 0; _ < 100; ++_) {
for (int i = 1; i <= n; ++i) f[i] = V[i - 1];
res = R;
cnt = C;
for (int i = 1; i <= 100; ++i) {
random_shuffle(v[i].begin(), v[i].end());
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if (x <= k || y <= k || get(x) == get(y)) continue;
f[f[y]] = f[x];
res += a[x][y];
++cnt;
}
for (int j = 0; j < v[i].size(); ++j) {
int x = v[i][j].first, y = v[i][j].second;
if ((x > k && y > k) || get(x) == get(y)) continue;
if (rand() < 16000) continue;
if (x <= k) {
if (!d[x]) continue;
--d[x];
q.push_back(x);
}
if (y <= k) {
if (!d[y]) continue;
--d[y];
q.push_back(y);
}
f[f[y]] = f[x];
res += a[x][y];
++cnt;
}
}
if (cnt == n - 1) ans = min(ans, res);
for (int i = 0; i < q.size(); ++i) ++d[q[i]];
q.clear();
}
for (int i = 1; i <= n; ++i) f[i] = V[i - 1];
res = R;
cnt = C;
}
void dfs(int x, int y) {
if (x > k) {
sol();
return;
}
if (y > k) {
dfs(x + 1, x + 2);
return;
}
if (d[x] && d[y] && get(x) != get(y)) {
vector<int> V;
for (int i = 1; i <= n; ++i) V.push_back(f[i]);
f[f[y]] = f[x];
--d[x], --d[y];
res += a[x][y];
++cnt;
dfs(x, y + 1);
--cnt;
res -= a[x][y];
++d[x], ++d[y];
for (int i = 1; i <= n; ++i) f[i] = V[i - 1];
}
dfs(x, y + 1);
}
int main() {
srand(time(0));
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; ++i) scanf("%d", d + i);
for (int i = 1; i <= n; ++i) f[i] = i;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
scanf("%d", a[i] + j);
a[j][i] = a[i][j];
if (i > k || j > k) v[a[i][j]].push_back(make_pair(i, j));
}
}
dfs(1, 2);
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int ok, a, b, x, k, ans, cur, ar[50000], d, t;
int main() {
ios_base::sync_with_stdio(0);
cin >> x >> k;
for (int i = 0; i < k; i++) {
cin >> ok;
if (ok == 2) {
cin >> a;
t++;
ar[a] = 1;
} else {
cin >> a >> b;
t += 2;
ar[a] = 2;
ar[b] = 2;
}
}
ar[x] = 1;
for (int i = 1; i <= x; i++) {
if (ar[i] == 0)
cur++;
else {
if (cur % 2 == 0)
d = cur / 2;
else if (cur != 0)
d = cur / 2 + 1;
ans += d;
cur = 0;
}
}
cout << ans << " " << x - t - 1;
}
| 2 |
#include <bits/stdc++.h>
static const int MAXN = 1e3 + 4;
int n;
int a[MAXN], b[MAXN];
int pa[2][MAXN], pb[2][MAXN];
inline void try_recover(int *a, int *p1, int *p2) {
int dup_ct = 0;
int dup1 = -1, dup2 = -1, absent = -1;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (a[i] == a[j]) dup1 = i, dup2 = j;
for (absent = 1; absent <= n; ++absent) {
bool occurred = false;
for (int i = 0; i < n; ++i)
if (a[i] == absent) {
occurred = true;
break;
}
if (!occurred) break;
}
memcpy(p1, a, n * sizeof(int));
memcpy(p2, a, n * sizeof(int));
p1[dup1] = absent;
p2[dup2] = absent;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
try_recover(a, pa[0], pa[1]);
try_recover(b, pb[0], pb[1]);
int *ans = NULL;
if (memcmp(pa[0], pb[0], n * sizeof(int)) == 0 ||
memcmp(pa[0], pb[1], n * sizeof(int)) == 0)
ans = pa[0];
else
ans = pa[1];
for (int i = 0; i < n; ++i) printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n == 1) {
cout << "1";
return 0;
}
vector<long long> dv;
for (long long i = 2; i * i <= n; i++) {
bool ok = false;
while (n % i == 0) {
ok = true;
n /= i;
}
if (ok) dv.push_back(i);
}
if (n != 1) dv.push_back(n);
if (dv.size() > 1) {
cout << "1";
return 0;
}
cout << dv[0] << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct FastIO {
static const int S = 1310720;
int wpos;
char wbuf[S];
FastIO() : wpos(0) {}
inline int xchar() {
static char buf[S];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, S, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int xuint() {
int c = xchar(), x = 0;
while (c <= 32) c = xchar();
for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
return x;
}
inline int xint(int& in) {
int s = 1, c = xchar(), x = 0;
while (c <= 32) {
c = xchar();
if (c == -1) {
return 0;
}
}
if (c == '-') s = -1, c = xchar();
for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
int res = x * s;
in = res;
return 1;
}
inline void xstring(char* s) {
int c = xchar();
while (c <= 32) c = xchar();
for (; c > 32; c = xchar()) *s++ = c;
*s = 0;
}
inline void wchar(int x) {
if (wpos == S) fwrite(wbuf, 1, S, stdout), wpos = 0;
wbuf[wpos++] = x;
}
inline void wint(int x) {
if (x < 0) wchar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) wchar(s[n]);
}
inline void wstring(const char* s) {
while (*s) wchar(*s++);
}
~FastIO() {
if (wpos) fwrite(wbuf, 1, wpos, stdout), wpos = 0;
}
} io;
int n, m, tot;
struct E {
int a;
int nxt;
};
struct TR {
int x, y, z;
};
int g[100013 * 2];
E e[100013 * 2 << 1];
TR q[100013 * 2];
int ace[100013 * 2][19];
void addE(int x, int y) {
++tot;
e[tot].a = y;
e[tot].nxt = g[x];
g[x] = tot;
}
int siz[100013 * 2], top[100013 * 2], fa[100013 * 2], son[100013 * 2],
deep[100013 * 2], tid[100013 * 2];
void dfs1(int v, int p, int d) {
siz[v] = 1;
deep[v] = d;
fa[v] = p;
son[v] = -1;
for (int i = g[v]; i != -1; i = e[i].nxt) {
int w = e[i].a;
if (w == p) {
continue;
}
dfs1(w, v, d + 1);
siz[v] += siz[w];
if (son[v] == -1 || siz[w] > siz[son[v]]) {
son[v] = w;
}
}
return;
}
long long tr[1000013 * 2];
void ins(int d, int l, int r, int x, int c) {
if (l > r || x < l || x > r) return;
if (l == r) {
tr[d] = c;
return;
}
int o = l + r >> 1, ll = d << 1, rr = ll + 1;
if (x <= o)
ins(ll, l, o, x, c);
else
ins(rr, o + 1, r, x, c);
tr[d] = tr[ll] + tr[rr];
}
long long query(int d, int l, int r, int x, int y) {
if (l > r || x > y || x < l || y > r) return 0;
if (l == x && y == r) {
return tr[d];
}
int o = l + r >> 1, ll = d << 1, rr = ll + 1;
long long res = 0;
if (y <= o)
res = query(ll, l, o, x, y);
else if (x > o)
res = query(rr, o + 1, r, x, y);
else
res = query(ll, l, o, x, o) + query(rr, o + 1, r, o + 1, y);
return res;
}
std::vector<int> v[100013 * 2];
void dfs2(int v, int tp, int& k) {
top[v] = tp;
tid[v] = ++k;
if (son[v] == -1) {
return;
}
dfs2(son[v], tp, k);
for (int i = g[v]; i != -1; i = e[i].nxt) {
int w = e[i].a;
if (w == fa[v] || w == son[v]) {
continue;
}
dfs2(w, w, k);
}
}
long long ans[100013 * 2], sans[100013 * 2];
long long fts(int u, int v) {
long long ans = 0;
while (top[u] != top[v]) {
if (deep[top[u]] > deep[top[v]]) {
ans += query(1, 1, n, tid[top[u]], tid[u]);
u = fa[top[u]];
} else {
ans += query(1, 1, n, tid[top[v]], tid[v]);
v = fa[top[v]];
}
}
if (deep[u] < deep[v]) {
ans += query(1, 1, n, tid[u], tid[v]);
} else {
ans += query(1, 1, n, tid[v], tid[u]);
}
return ans;
}
void dfs(int x) {
sans[x] = 0;
for (int p = g[x]; p != -1; p = e[p].nxt) {
int y = e[p].a;
if (y != fa[x]) {
dfs(y);
sans[x] += ans[y];
}
}
ans[x] = sans[x];
for (int i = 0; i < v[x].size(); ++i) {
TR k = q[v[x][i]];
long long tmp;
tmp = fts(x, k.x) + fts(x, k.y) + sans[x] + k.z;
ans[x] = max(ans[x], tmp);
}
ins(1, 1, n, tid[x], sans[x] - ans[x]);
}
int acen(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
int j = 18;
while (deep[x] != deep[y]) {
if (ace[x][j] != 0) {
if (deep[ace[x][j]] >= deep[y]) x = ace[x][j];
}
--j;
}
if (x == y) return x;
j = 18;
int l = deep[x], r = 0, ac = 1;
while (r + 1 < l) {
int a = ace[x][j];
int b = ace[y][j];
if (a == b) {
if (a != 0 && deep[a] > r) r = deep[a], ac = a;
} else {
x = ace[x][j];
y = ace[y][j];
l = deep[x];
}
--j;
}
return ac;
}
int main() {
int T = 1;
for (int ci = 1; ci <= T; ++ci) {
scanf("%d%d", &n, &m);
tot = -1;
memset(g, -1, sizeof(g));
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
addE(i, x);
addE(x, i);
}
dfs1(1, 0, 0);
int k = 0;
dfs2(1, 1, k);
for (int i = 0; i < 19; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == 0)
ace[j][i] = fa[j];
else {
int t = ace[j][i - 1];
if (t == 0)
ace[j][i] = 0;
else
ace[j][i] = ace[t][i - 1];
}
}
}
for (int i = 1; i <= n; ++i) v[i].clear();
for (int i = 0; i < m; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
q[i].x = x;
q[i].y = y;
q[i].z = z;
int aa = acen(x, y);
v[aa].push_back(i);
}
memset(tr, 0, sizeof(tr));
dfs(1);
cout << ans[1] << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
const int MOD = 1000000007;
const int MOD1 = 998244353;
const int maxn = 100010;
const int lim = (int)1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 0, n = 0;
string s;
cin >> t;
while (t--) {
cin >> n;
cin >> s;
vector<int> a;
set<int> v[2];
int ct = 0;
for (int i = 0; i < n; ++i) {
int x = s[i] - '0';
if (v[x ^ 1].empty()) {
a.push_back(++ct);
v[x].insert(ct);
} else {
int y = *v[x ^ 1].begin();
a.push_back(y);
v[x ^ 1].erase(v[x ^ 1].begin());
v[x].insert(y);
}
}
cout << ct << endl;
for (auto &i : a) cout << i << " ";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int f[100005], n, m, cost[100005], value[100005], num[100005], cnt;
bool vst[100005];
vector<int> e[100005];
const int inf = (1 << 28);
bool ck(int i) {
while (i) {
int j = i % 10;
i /= 10;
if (j != 4 && j != 7) return false;
}
return true;
}
void dfs(int i) {
vst[i] = true;
cnt++;
for (vector<int>::iterator it = e[i].begin(); it != e[i].end(); it++) {
if (vst[*it]) continue;
dfs(*it);
}
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int i, j;
scanf("%d%d", &i, &j);
e[i].push_back(j);
e[j].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (vst[i]) continue;
cnt = 0;
dfs(i);
num[cnt]++;
}
cnt = 0;
for (int i = 1; i <= n; i++) {
if (num[i] == 0) continue;
int j = 1;
while (num[i] > j) {
value[cnt] = i * j;
cost[cnt++] = j;
num[i] -= j;
j <<= 1;
}
if (num[i]) {
value[cnt] = num[i] * i;
cost[cnt++] = num[i];
}
}
for (int i = 1; i <= n; i++) f[i] = inf;
for (int i = 0; i < cnt; i++)
for (int j = n; j >= value[i]; j--)
f[j] = min(f[j], f[j - value[i]] + cost[i]);
int ans = inf;
for (int i = 1; i <= n; i++)
if (ck(i)) ans = min(ans, f[i]);
if (ans == inf)
printf("-1\n");
else
printf("%d\n", ans - 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, k;
int main() {
scanf("%d%d", &n, &k);
int l = n - k - 1;
int m = l / k;
printf("%d\n", 2 * m + (l % k > 1 ? 2 : l % k) + 2);
if (l < k) {
for (int i = 0; i < l; ++i) {
printf("1 %d\n", i + 2);
printf("%d %d\n", i + 2, l + 1 + i + 1);
}
for (int i = 0; i < k - l; ++i) {
printf("1 %d\n", 2 * l + i + 2);
}
} else {
int add = l % k, cnt = 2;
for (int i = 0; i < k; ++i) {
printf("1 %d\n", cnt);
for (int j = 0; j < m - 1; ++j) {
printf("%d %d\n", cnt, cnt + 1);
cnt++;
}
if (add) {
printf("%d %d\n", cnt, cnt + 1);
cnt++;
add--;
}
printf("%d %d\n", cnt, cnt + 1);
cnt += 2;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
int vi[10];
int z1 = -1, z2 = -1;
int two = -1, five = -1, seven = -1;
int solve(int a, int b) {
int ans = 0;
int len = s.length();
int vb = -1;
for (int i = len - 1; i >= 0; i--) {
if (s[i] - '0' == b) {
vb = i;
break;
}
}
if (vb != -1) {
for (int i = vb; i < len - 1; i++) {
swap(s[i], s[i + 1]);
ans++;
}
}
int va = -1;
for (int i = len - 2; i >= 0; i--) {
if (s[i] - '0' == a) {
va = i;
break;
}
}
if (va != -1) {
for (int i = va; i < len - 2; i++) {
swap(s[i], s[i + 1]);
ans++;
}
}
int ind = 0;
while (s[ind] - '0' == 0) {
ind++;
}
for (int i = ind; i > 0; i--) {
swap(s[i], s[i - 1]);
ans++;
}
if (s[len - 1] - '0' == b && s[len - 2] - '0' == a) {
return ans;
}
return 10000;
}
int main() {
cin >> s;
int len = s.length();
for (int i = 0; i < len; i++) {
vi[s[i] - '0']++;
if (s[i] - '0' == 0) {
z2 = z1;
z1 = i;
}
if (s[i] - '0' == 2) {
two = i;
}
if (s[i] - '0' == 5) {
five = i;
}
if (s[i] - '0' == 7) {
seven = i;
}
}
if (!((vi[2] && vi[5]) || (vi[5] && vi[0]) || (vi[7] && vi[5]) ||
vi[0] >= 2)) {
puts("-1");
return 0;
}
if (two == len - 2 && five == len - 1 || five == len - 2 && z1 == len - 1 ||
seven == len - 2 && five == len - 1 || z2 == len - 2 && z1 == len - 1) {
puts("0");
return 0;
}
if (two == len - 1 && five == len - 2 || five == len - 1 && z1 == len - 2 ||
seven == len - 1 && five == len - 2) {
puts("1");
return 0;
}
int ans = 10000;
string s1 = s;
if (vi[2] && vi[5]) {
ans = min(ans, solve(2, 5));
s = s1;
}
if (vi[5] && vi[7]) {
ans = min(ans, solve(7, 5));
s = s1;
}
if (vi[5] && vi[0]) {
ans = min(ans, solve(5, 0));
s = s1;
}
if (vi[0] >= 2) {
ans = min(ans, solve(0, 0));
s = s1;
}
if (ans == 10000)
puts("-1");
else
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool z[1010][1010];
string res[1010][2];
int k = 0;
bool find(string s, string t) {
int i;
for (i = 0; i < k; i++)
if ((s == res[i][0] && t == res[i][1]) ||
(t == res[i][0] && s == res[i][1]))
return 1;
return 0;
}
int main() {
string s[1010], t[1010];
int i, j, n, d, x[1010], ans = 0;
for (i = 0; i < 1010; i++)
for (j = 0; j < 1010; j++) z[i][j] = 0;
cin >> n >> d;
for (i = 0; i < n; i++) cin >> s[i] >> t[i] >> x[i];
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (s[i] == t[j] && s[j] == t[i])
if (abs(x[i] - x[j]) > 0 && abs(x[i] - x[j]) <= d) {
ans++;
z[i][j] = 1;
}
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (z[i][j] && !find(s[i], t[i])) {
res[k][0] = s[i];
res[k][1] = t[i];
k++;
}
cout << k << endl;
for (i = 0; i < k; i++) cout << res[i][0] << ' ' << res[i][1] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string toStr(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <typename T>
T toNum(const string &Text) {
stringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
int inGrid(int x, int y, int r, int c) {
return (x >= 0 && x < r && y >= 0 && y < c ? 1 : 0);
}
int leap(int m) {
if (m % 4 == 0 && m % 100 != 0)
return 1;
else if (m % 400 == 0)
return 1;
else
return 0;
}
int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
string months[] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
int dx4[] = {-1, 0, 1, 0};
int dy4[] = {0, 1, 0, -1};
const double pi = acos(-1.0), eps = 1e-9;
const int N = 2e5 + 5, M = 1e9 + 7;
int xp, yp, xv, yv;
int main() {
cin >> xp >> yp >> xv >> yv;
int xx = xv, yy = yv;
vector<pair<int, int> > v;
v.push_back(make_pair(xv, yv));
for (;;) {
if (xv && yv)
v.push_back(make_pair(--xv, --yv));
else if (xv)
v.push_back(make_pair(--xv, yv));
else if (yv)
v.push_back(make_pair(xv, --yv));
else
break;
}
int f1 = 0, f2 = 0;
for (int i = 0; i < v.size(); i++) {
int c = abs(v[i].first - xp) + abs(v[i].second - yp);
if (c <= i) {
f1 = 1;
break;
}
}
v.clear();
xv = xx, yv = yy;
v.push_back(make_pair(xv, yv));
for (;;) {
if (xv && yv)
v.push_back(make_pair(--xv, --yv));
else if (yv)
v.push_back(make_pair(xv, --yv));
else if (xv)
v.push_back(make_pair(--xv, yv));
else
break;
}
for (int i = 0; i < v.size(); i++) {
int c = abs(v[i].first - xp) + abs(v[i].second - yp);
if (c <= i) {
f2 = 1;
break;
}
}
if (f1 && f2)
puts("Polycarp");
else
puts("Vasiliy");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
const long long mod = 998244353, modg = 3, modi = 332748118;
int a[maxn], b[maxn];
int pow_mod(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % mod;
a = (long long)a * a % mod, b >>= 1;
}
return ans;
}
class nubmer {
public:
int rev[maxn], len, pw;
long long wt[2][maxn << 1];
void init(int n) {
len = 1;
pw = 0;
while (len <= n) len <<= 1, pw++;
for (int i = 0; i <= len - 1; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (pw - 1));
for (int mid = 1; mid < len; mid <<= 1) {
long long wn1 = pow_mod(modg, (mod - 1) / (mid << 1));
long long wn2 = pow_mod(modi, (mod - 1) / (mid << 1));
wt[0][mid] = wt[1][mid] = 1;
long long wt1 = wn1, wt2 = wn2;
for (int j = 1; j <= mid; ++j) {
wt[0][mid + j] = wt1;
wt1 = wt1 * wn1 % mod;
wt[1][mid + j] = wt2;
wt2 = wt2 * wn2 % mod;
}
}
}
void transform(int *a, int flag) {
int f = flag == 1 ? 0 : 1;
for (int i = 0; i <= len - 1; ++i)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int mid = 1; mid < len; mid <<= 1) {
for (int r = mid << 1, j = 0; j < len; j += r) {
long long *p = wt[f] + mid;
int *p1 = a + j, *p2 = a + j + mid;
for (int k = 0; k < mid; ++k, ++p, ++p1, ++p2) {
long long x = *p1, y = (*p) * (*p2);
*p1 = (x + y) % mod, *p2 = (x - y) % mod;
}
}
}
if (flag == -1) {
long long inv = pow_mod(len, mod - 2);
for (int i = 0; i <= len; i++) {
a[i] = a[i] * inv % mod;
if (a[i] < 0) a[i] += mod;
}
}
}
} ntt;
int n, k;
int s1[maxn], s2[maxn];
vector<int> solve(int l, int r) {
if (l == r) {
return vector<int>{1, s2[l]};
}
int mid = (l + r) >> 1;
vector<int> x = solve(l, mid), y = solve(mid + 1, r);
ntt.init(x.size() + y.size());
for (int i = 0; i <= ntt.len + 5; i++) a[i] = 0, b[i] = 0;
for (int i = 0; i < x.size(); i++) a[i] = x[i];
for (int i = 0; i < y.size(); i++) b[i] = y[i];
ntt.transform(a, 1);
ntt.transform(b, 1);
for (int i = 0; i < ntt.len; i++) a[i] = (long long)a[i] * b[i] % mod;
ntt.transform(a, -1);
int len = x.size() + y.size();
int mi = min(ntt.len, min(k + 1, len));
vector<int> ans(mi);
for (int i = 0; i < mi; i++) {
ans[i] = a[i];
}
return ans;
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> s1[i];
}
int T;
cin >> T;
vector<int> tmp;
while (T--) {
int flag;
cin >> flag;
if (flag == 1) {
int q, i, d;
cin >> q >> i >> d;
for (int j = 1; j <= n; j++) s2[j] = (q - s1[j] + mod) % mod;
s2[i] = (q - d + mod) % mod;
tmp = solve(1, n);
cout << tmp[k] << "\n";
} else {
int q, l, r, d;
cin >> q >> l >> r >> d;
for (int j = 1; j <= n; j++) {
if (j >= l && j <= r)
s2[j] = ((q - s1[j] - d) % mod + mod) % mod;
else
s2[j] = (q - s1[j] + mod) % mod;
}
tmp = solve(1, n);
cout << tmp[k] << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
long long a[n + 1];
long long i, j;
for (i = 0; i < n + 1; i++) {
a[i] = 0;
}
set<long long> st;
for (i = 1; i <= n; i++) {
st.insert(i);
}
for (i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
auto it = st.lower_bound(x);
vector<long long> v;
for (; it != st.end(); it++) {
if (*it > y) {
break;
} else if (*it != w) {
a[*it] = w;
v.push_back(*it);
}
}
for (auto j : v) {
st.erase(j);
}
}
for (i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> operator+(const pair<int, int> &a, const pair<int, int> &b) {
return {a.first + b.first, a.second + b.second};
}
const int N = 200000;
int a[N];
struct SegmentTree {
struct element {
int val, l, r;
};
int sz;
vector<vector<element> > t;
SegmentTree() {}
SegmentTree(int n) {
sz = n;
t.resize((1 << (33 - __builtin_clz(n - 1))) - 1);
}
void build(int v, int tl, int tr, int *a);
pair<int, int> query(int l, int r, pair<int, int> val);
pair<int, int> query(int v, int tl, int tr, int l, int r, pair<int, int> pos);
} tr;
void SegmentTree::build(int v, int tl, int tr, int *a) {
if (tl == tr)
t[v] = {{a[tl], -1, -1}};
else {
build(v * 2 + 1, tl, (tl + tr) / 2, a);
build(v * 2 + 2, (tl + tr) / 2 + 1, tr, a);
vector<element> &l = t[v * 2 + 1];
vector<element> &r = t[v * 2 + 2];
t[v].resize(l.size() + r.size());
for (int i = 0, j = 0; i < l.size() || j < r.size();) {
if (i < l.size() && (j == r.size() || l[i].val < r[j].val)) {
t[v][i + j].val = l[i].val;
t[v][i + j].l = i;
t[v][i + j].r = i + j ? t[v][i + j - 1].r : -1;
++i;
} else {
t[v][i + j].val = r[j].val;
t[v][i + j].l = i + j ? t[v][i + j - 1].l : -1;
t[v][i + j].r = j;
++j;
}
}
}
}
pair<int, int> SegmentTree::query(int l, int r, pair<int, int> val) {
return query(0, 0, sz - 1, l, r, val);
}
pair<int, int> SegmentTree::query(int v, int tl, int tr, int l, int r,
pair<int, int> pos) {
if (tr < l || tl > r) return {0, 0};
if (tl >= l && tr <= r) return {pos.first + 1, pos.second + 1};
return query(v * 2 + 1, tl, (tl + tr) / 2, l, r,
{pos.first == -1 ? -1 : t[v][pos.first].l,
pos.second == -1 ? -1 : t[v][pos.second].l}) +
query(v * 2 + 2, (tl + tr) / 2 + 1, tr, l, r,
{pos.first == -1 ? -1 : t[v][pos.first].r,
pos.second == -1 ? -1 : t[v][pos.second].r});
}
int n;
void get_rect(int l, int r, int b1, int b2, int &put1, int &put2, int &put3) {
pair<int, int> ans = tr.query(l, r, make_pair(b1, b2));
put1 = ans.first;
put2 = ans.second - put1;
put3 = r - l + 1 - ans.second;
}
void rotate(int *s) {
int nw[9];
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j) nw[j * 3 + 3 - i - 1] = s[i * 3 + j];
for (int i = 0; i < 9; ++i) s[i] = nw[i];
}
void query() {
int l, d, r, u;
scanf("%d%d%d%d", &l, &d, &r, &u);
--l;
--r;
--d;
--u;
long long ans = 0;
int s[9];
get_rect(0, l - 1, d - 1, u, s[0], s[3], s[6]);
get_rect(l, r, d - 1, u, s[1], s[4], s[7]);
get_rect(r + 1, n - 1, d - 1, u, s[2], s[5], s[8]);
for (int i = 0; i < 4; ++i) {
ans += (long long)s[0] * (s[4] + s[5] + s[7] + s[8]);
ans += (long long)s[1] * (s[3] + s[4] + s[5] + s[6] + s[7] + s[8]);
rotate(s);
}
ans += (long long)s[4] * (n - 1);
ans /= 2;
printf("%lld\n", ans);
}
int main() {
int q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
--a[i];
}
tr = SegmentTree(n);
tr.build(0, 0, n - 1, a);
while (q--) query();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[22 + 10], dp[(1 << 22) + 10], que[(1 << 22) + 10], path[(1 << 22) + 10],
INF;
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') {
f = -1;
break;
}
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return f * x;
}
void get_path(int x) {
if (path[x]) get_path(path[x]);
printf("%d ", que[x]);
}
int main() {
memset(dp, 0x5f, sizeof(dp));
INF = dp[0];
int n = read(), m = read();
if (m * 2 == n * (n - 1)) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; i++) a[i] = 1 << (i - 1);
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if (x != y) a[x] |= 1 << (y - 1), a[y] |= 1 << (x - 1);
}
for (int i = 1; i <= n; i++) dp[a[i]] = 1, que[a[i]] = i;
for (int i = 0; i < (1 << n); i++) {
if (dp[i] == INF) continue;
for (int j = 1; j <= n; j++) {
if ((i & (1 << (j - 1))) && dp[i | a[j]] > dp[i] + 1) {
dp[i | a[j]] = dp[i] + 1, que[i | a[j]] = j, path[i | a[j]] = i;
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
get_path((1 << n) - 1);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
long long int power(long long int x, long long int n) {
long long int result = 1;
while (n) {
if (n % 2 == 1) result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
long long int gcd(long long int a, long long int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int BS(long long int a[], long long int s, long long int n,
long long int val) {
long long int mid, beg = s, end = n - 1;
while (beg <= end) {
mid = (beg + end) / 2;
if (val == a[mid]) {
break;
} else if (val > a[mid]) {
beg = mid + 1;
} else {
end = mid - 1;
}
}
return mid;
}
inline long long int mul(long long int x, long long int y, long long int m) {
long long int z = 1LL * x * y;
if (z >= m) {
z %= m;
}
return z;
}
long long int powmod(long long int x, long long int y, long long int m) {
long long int r = 1;
while (y) {
if (y & 1) {
r = mul(r, x, m);
}
y >>= 1;
x = mul(x, x, m);
}
return r;
}
using namespace std;
void start() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
}
int main() {
start();
long long int t;
cin >> (t);
while (t--) {
long long int n, k;
cin >> n >> k;
if (n >= k) {
if ((n % 2 == 1 && k % 2 == 0) || (n % 2 == 0 && k % 2 == 1)) {
cout << "1\n";
continue;
}
cout << "0\n";
continue;
}
if (k > n) cout << k - n << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
struct State {
int len, par, to[26], sz, ls;
};
State T[maxn];
int p, q, last, st;
int bh[maxn], bto[maxn], bnx[maxn], bt;
void belrel(int u, int b) {
bt++;
bto[bt] = b;
bnx[bt] = bh[u];
bh[u] = bt;
}
void mark(int p, int cur) {
for (int i = p; i; i = T[i].par)
if (T[i].ls != cur) {
T[i].ls = cur;
T[i].sz++;
} else
return;
}
void extend(char c, int cur) {
if (T[last].to[c - 'a']) {
q = T[last].to[c - 'a'];
if (T[q].len == T[last].len + 1) {
last = q;
mark(last, cur);
belrel(last, cur);
return;
} else {
T[++st].len = T[last].len + 1;
memcpy(T[st].to, T[q].to, sizeof(T[q].to));
T[st].sz = T[q].sz;
T[st].ls = T[q].ls;
T[st].par = T[q].par;
T[q].par = st;
p = last;
while (p && T[p].to[c - 'a'] == q) {
T[p].to[c - 'a'] = st;
p = T[p].par;
}
last = st;
mark(last, cur);
belrel(last, cur);
return;
}
}
T[++st].len = T[last].len + 1;
p = last;
while (p && !T[p].to[c - 'a']) {
T[p].to[c - 'a'] = st;
p = T[p].par;
}
q = T[p].to[c - 'a'];
if (p == 0 || T[q].len == T[p].len + 1) {
T[st].par = p == 0 ? 1 : q;
last = st;
mark(last, cur);
belrel(last, cur);
return;
}
T[++st].len = T[p].len + 1;
memcpy(T[st].to, T[q].to, sizeof(T[q].to));
T[st].sz = T[q].sz;
T[st].ls = T[q].ls;
T[st].par = T[q].par;
T[q].par = st;
T[st - 1].par = st;
while (p && T[p].to[c - 'a'] == q) {
T[p].to[c - 'a'] = st;
p = T[p].par;
}
last = st - 1;
mark(last, cur);
belrel(last, cur);
}
char s[maxn];
int n, k, i, j;
int h[maxn], to[maxn], nx[maxn], et;
void addedge(int u, int v) {
et++;
to[et] = v;
nx[et] = h[u];
h[u] = et;
}
long long key[maxn], ans[maxn];
void dfs(int u, int f) {
if (T[u].sz >= k) key[u] = T[u].len - T[f].len;
if (u == 1) key[u] = 0;
key[u] += key[f];
for (int i = h[u]; i; i = nx[i]) dfs(to[i], u);
}
int main() {
last = ++st;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (j = 1; s[j]; j++) extend(s[j], i);
last = 1;
}
for (i = 2; i <= st; i++) addedge(T[i].par, i);
dfs(1, 0);
for (i = 1; i <= st; i++)
for (j = bh[i]; j; j = bnx[j]) ans[bto[j]] += key[i];
for (i = 1; i <= n; i++) printf("%I64d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> v[N];
int maxi[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, x, k, l, r, cnt;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> x;
v[j].push_back(x);
}
}
for (int j = 1; j <= m; j++) {
cnt = 1;
for (int i = 2; i <= n; i++) {
if (v[j][i - 1] >= v[j][i - 2])
cnt++;
else {
maxi[i - cnt] = max(cnt, maxi[i - cnt]);
cnt = 1;
}
}
maxi[n - cnt + 1] = max(maxi[n - cnt + 1], cnt);
}
for (int i = 2; i <= n; i++) {
maxi[i] = max(maxi[i - 1] - 1, maxi[i]);
}
cin >> k;
while (k--) {
cin >> l >> r;
if (maxi[l] >= (r - l + 1))
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832;
void c_p_c() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
c_p_c();
int t;
cin >> t;
while (t--) {
long a;
cin >> a;
long arr[a];
for (int i = 0; i < a; i++) {
cout << 1 << " ";
}
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, s;
cin >> a >> b >> s;
c = abs(a) + abs(b);
if (s < c || (c % 2 != s % 2))
cout << "NO" << endl;
else if (s == c || (c % 2 == s % 2))
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long p, k, a[100001];
int main() {
cin >> p >> k;
int l = 0;
long long res = p;
while (1) {
long long d = (res % k + k) % k;
a[l++] = d;
res = (res - d) / (-k);
if (!res) break;
}
cout << l << endl;
for (int i = 0; i < l; ++i) cout << a[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, sl, ans, a[200010];
map<long long, long long> dp;
char gc() {
static char buf[1 << 16], *S, *T;
if (S == T) {
T = (S = buf) + fread(buf, 1, 1 << 16, stdin);
if (S == T) return EOF;
}
return *S++;
}
long long rd() {
sl = 0;
char ch = gc();
while (ch < '0' || '9' < ch) ch = gc();
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = gc();
return sl;
}
int main() {
n = rd();
for (int i = 1; i <= n; ++i) a[i] = rd();
dp[a[1] - 1] = 0;
for (int i = 1; i < n; ++i)
for (map<long long, long long>::iterator j = dp.lower_bound(a[i + 1]);
j != dp.end(); dp.erase(j++)) {
x = j->first;
y = j->second;
dp[x % a[i + 1]] = max(dp[x % a[i + 1]], y + i * (x - x % a[i + 1]));
dp[a[i + 1] - 1] = max(
dp[a[i + 1] - 1], y + i * ((x + 1) / a[i + 1] * a[i + 1] - a[i + 1]));
}
for (map<long long, long long>::iterator i = dp.begin(); i != dp.end(); ++i) {
x = i->first;
y = i->second;
ans = max(ans, x * n + y);
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
ifstream fi("test.txt");
ofstream fo("out.txt");
const long long MOD = 1e9 + 7;
const long long base = 269;
const int ooi = 1 << 30;
const int N = 1e5 + 5;
long long n, m, q, k, pos, rs, t, T, cnt, rs1;
long long maxx = -1e9, minn = 1e9;
long long a[N], b[N];
string vowel = "aeiouy";
int main() {
string s;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
getline(cin, s);
for (long long(i) = 0; (i) < (n); (i)++) {
getline(cin, s);
cnt = 0;
for (auto k : s)
for (auto j : vowel)
if (k == j) cnt++;
if (cnt != a[i]) return cout << "NO", 0;
}
cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int h[2][maxn], a[maxn];
queue<int> q;
vector<int> yal[maxn];
void bfs(int n, int c) {
for (int i = 1; i <= n; i++) {
if (a[i] % 2 != c) continue;
q.push(i);
h[c][i] = 0;
}
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 0; i < yal[x].size(); i++) {
int y = yal[x][i];
if (h[c][y] != -1) continue;
h[c][y] = h[c][x] + 1;
q.push(y);
}
}
return;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i - a[i] >= 1) yal[i - a[i]].push_back(i);
if (i + a[i] <= n) yal[i + a[i]].push_back(i);
}
fill(h[0], h[0] + n + 1, -1);
fill(h[1], h[1] + n + 1, -1);
bfs(n, 0);
bfs(n, 1);
for (int i = 1; i <= n; i++) cout << h[(a[i] % 2 ? 0 : 1)][i] << ' ';
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 1e5 + 8;
int val[maxn];
int main() {
memset(val, 0, sizeof val);
int n, a, b, T;
char ph;
scanf("%d%d%d%d", &n, &a, &b, &T);
getchar();
for (int i = 0; i < n; i++) {
scanf("%c", &ph);
if (i == 0) {
if (ph == 'w')
val[0] = b + 1;
else
val[0] = 1;
} else {
if (ph == 'w')
val[i] = b + a + 1;
else
val[i] = a + 1;
}
}
int l = 0, r = 0, sum = 0;
int ans = -1;
while (sum < T && r < n) {
sum += val[r++];
if (sum > T) r--;
}
ans = max(ans, (r - 0));
if (ans > n) ans = n;
if (sum != T) sum -= val[r];
r--;
bool first = true;
while (ans != n && ans != 0) {
while (sum <= T && -l + r <= n - 1 && l > -n) {
l--;
sum += val[(l + n) % n];
if (-l < r && first)
sum += a;
else {
if (first) {
sum -= a * (-l - 1);
sum += a * r;
first = false;
}
}
}
if (sum < T) break;
ans = max(ans, (r - l));
if (first)
sum -= val[r];
else
sum -= (val[r] + a);
if (r > 0) r--;
if (r == 0) break;
}
if (r == 0) {
l = 0, sum = 0;
sum += val[0];
while (sum < T && l > -n) {
l--;
sum += val[(l + n) % n];
}
if (sum == T) l--;
ans = max(ans, (0 - l));
if (ans > n) ans = n;
}
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int max_N = 1000005;
const int mod = 998244353;
long long n, a[max_N], fac[max_N], fac_inv[max_N];
long long read() {
char c = getchar();
long long ans = 0;
bool flag = true;
while (c < '0' || c > '9') flag &= (c != '-'), c = getchar();
while (c >= '0' && c <= '9') ans = ans * 10 + c - '0', c = getchar();
return flag ? ans : -ans;
}
void Write(long long x) {
if (x < 10)
putchar(x + '0');
else
Write(x / 10), putchar(x % 10 + '0');
}
long long max(long long x, long long y) { return x > y ? x : y; }
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
long long invs(long long x) {
return x == 1 ? 1 : (mod - mod / x) * invs(mod % x) % mod;
}
long long binom(long long x, long long y) {
return x < y || y < 0 ? 0 : fac[x] * fac_inv[y] % mod * fac_inv[x - y] % mod;
}
int main() {
n = read();
for (long long i = 1; i <= n * 2; i++) a[i] = read();
for (long long i = fac[0] = 1; i <= n * 2; i++) fac[i] = fac[i - 1] * i % mod;
fac_inv[n * 2] = invs(fac[n * 2]);
for (long long i = n * 2; i; i--) fac_inv[i - 1] = fac_inv[i] * i % mod;
std::sort(a + 1, a + 1 + n * 2);
long long sum = 0;
for (long long i = 1; i <= n; i++) sum -= a[i];
for (long long i = n + 1; i <= n * 2; i++) sum += a[i];
return Write(sum % mod * binom(2 * n, n) % mod), 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int k;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> k;
string res = "a";
if (k == 0) {
cout << res << "\n";
return 0;
}
char c = 'a';
while (k) {
int tmp = 1;
while (k - tmp >= 0) {
k -= tmp;
res += c;
++tmp;
if (k == 0) break;
}
++c;
res += c;
}
cout << res << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int l;
cin >> l;
string s;
cin >> s;
long long int a = count(s.begin(), s.end(), 'a'),
b = count(s.begin(), s.end(), 'b'), cnt = 0;
for (long long int i = 0; i < s.size(); i += 2)
if (s[i] == s[i + 1]) {
if (s[i] == 'a')
s[i + 1] = 'b';
else
s[i] = 'a';
++cnt;
}
cout << cnt << "\n";
cout << s << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> f(21);
long long fact(long long x) { return f[x]; }
long long solve(long long k) {
vector<long long> cnt(21), less(21);
long long d = 1, den = 1, num = 1, den1 = 1, num1 = 0;
while (k > 0) {
d += 1;
cnt[k % d] += 1;
k /= d;
}
less[d + 1] = d - 1;
den = fact(cnt[0]) * fact(cnt[1]);
for (long long i = d; i > 1LL; i--) {
den *= fact(cnt[i]);
less[i] = less[i + 1] - cnt[i];
num *= (less[i] - (i - 2LL));
}
if (cnt[0] > 0) {
num1 = 1;
cnt[0]--;
less[d] -= 1;
den1 = fact(cnt[0]) * fact(cnt[1]);
for (long long i = d - 1; i > 1; i--) {
den1 *= fact(cnt[i]);
less[i] = less[i + 1] - cnt[i];
num1 *= (less[i] - (i - 2LL));
}
}
long long res = (num / den) - (num1 / den1) - 1LL;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
f[0] = f[1] = 1;
for (long long i = 2; i < 21; i++) f[i] = i * f[i - 1];
long long t;
cin >> t;
while (t--) {
long long k;
cin >> k;
cout << solve(k) << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1000005];
long long n;
const long long MOD = 1e9 + 7;
long long modularExponentiation(long long x, long long nn, long long M) {
long long result = 1;
while (nn > 0) {
if (nn % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
nn = nn / 2;
}
return result;
}
long long modInverse(long long A, long long M) {
return modularExponentiation(A, M - 2, M);
}
void prec() {
dp[1] = 2;
for (long long i = 1; i <= 1000002; i++) {
dp[i + 1] =
(dp[i] * 2 % MOD * (i + i + 1) % MOD * modInverse(i + 1, MOD) % MOD) %
MOD;
}
}
int main() {
prec();
cin >> n;
n++;
cout << ((dp[n] - 1) % MOD + MOD) % MOD << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class L>
bool smax(T& x, L y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class L>
bool smin(T& x, L y) {
return x > y ? (x = y, 1) : 0;
}
const int maxn = 2e5 + 17;
int n, m, gp[maxn], rate[maxn], cnt, sz[maxn];
unordered_map<int, pair<int, int> > p;
set<int> s[maxn];
vector<int> ag[maxn];
void dfs(int v, int rt = 0) {
if (gp[v]) return;
gp[v] = cnt, rate[v] = rt;
s[cnt].insert(rt);
sz[cnt]++;
dfs((v + m) % n, rt + 1);
}
int main() {
long long ans = 0;
p.max_load_factor(0.25), p.reserve(512);
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
if (!gp[i]) cnt++, dfs(i);
int q;
cin >> q;
for (int id, h; q--;) {
char c;
scanf(" %c %d", &c, &id);
if (c == '+') {
scanf("%d", &h);
int g = gp[h], r = rate[h];
auto it = s[g].lower_bound(r);
if (it == s[g].end()) it = s[g].begin(), ans += sz[g];
ans += *it - r;
p[id] = {g, *it};
s[g].erase(it);
} else {
auto tmp = p[id];
s[tmp.first].insert(tmp.second);
}
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> v1, v2;
char a[n + 1][m + 1];
int c = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'B') {
v1.push_back(i);
v2.push_back(j);
c++;
}
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
int w, q;
if (!v1.empty()) {
q = (-v1[0] + v1[v1.size() - 1] + 1);
w = (-v2[0] + v2[v2.size() - 1] + 1);
} else {
q = 1;
w = 1;
}
q = max(q, w);
if (q > n || q > m)
cout << -1;
else
cout << q * q - c;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
namespace fastio {
template <class T>
istream &operator>>(istream &os, vector<T> &vec) {
for (auto &u : vec) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &u : vec) os << u << " ";
return os;
}
template <class T1, class T2>
inline istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &con) {
for (auto &u : con) os << u << " ";
return os;
}
void re() {}
template <typename T, typename... args>
void re(T &x, args &...tail) {
cin >> x;
re(tail...);
}
void pr() {}
template <typename T, typename... args>
void pr(T x, args... tail) {
cout << x << " ";
pr(tail...);
}
template <typename... args>
void prln(args... tail) {
pr(tail...);
cout << "\n";
}
} // namespace fastio
using namespace fastio;
namespace debug {
template <typename _T>
inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
} // namespace debug
using namespace debug;
constexpr int MOD = 1e9 + 7;
constexpr int INF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
const int N = 1e3 + 7;
char mapa[N][N];
int wdol[N][N], wprawo[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
re(n, m);
for (int i = (0); i < (N); i++)
for (int j = (0); j < (N); j++) mapa[i][j] = '#';
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
re(mapa[i][j]);
}
}
for (int j = (0); j < (m); j++) {
vi last(27, n);
for (int i = (n - 1); i >= (0); i--) {
wdol[i][j] = n;
for (int x = (0); x < (27); x++)
if (x != (mapa[i][j] - 'a')) {
setmin(wdol[i][j], last[x]);
}
last[mapa[i][j] - 'a'] = i;
}
}
for (int i = (0); i < (n); i++) {
vi last(27, m);
for (int j = (m - 1); j >= (0); j--) {
1999;
wprawo[i][j] = m;
for (int x = (0); x < (27); x++)
if (x != (mapa[i][j] - 'a')) {
setmin(wprawo[i][j], last[x]);
}
last[mapa[i][j] - 'a'] = j;
}
}
ll res = 0;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
1999;
int p1 = i;
int h1 = wdol[p1][j] - p1;
1999;
if (wdol[p1][j] == n) continue;
int p2 = wdol[p1][j];
int h2 = wdol[p2][j] - p2;
1999;
if (wdol[p2][j] == n) continue;
int p3 = wdol[p2][j];
int h3 = wdol[p3][j] - p3;
if (h3 > h2) {
h3 = h2;
}
1999;
if (h1 != h2 or h2 != h3) continue;
1999;
int x = m;
1999;
for (int k = (p1); k < (p3 + h3); k++) {
setmin(x, wprawo[k][j]);
}
1999;
res += x - j;
}
}
prln(res);
exit(0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
int main() {
long long int n, m, i, j, x, y, row[MAX], col[MAX];
long long int affrow = 0, affcol = 0;
cin >> n >> m;
for (i = 0; i < MAX; i++) row[i] = col[i] = 0;
for (i = 0; i < m; i++) {
cin >> x >> y;
if (row[y] == 0) {
row[y] = 1;
affrow++;
}
if (col[x] == 0) {
col[x] = 1;
affcol++;
}
long long int ans = (n * (affrow + affcol)) - (affrow * affcol);
long long sq = 1LL * n * n;
long long int kans = sq - ans;
if (kans < 0) kans = 0;
cout << kans << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int addmod(int x) { return x >= mod ? x - mod : x; }
inline int submod(int x) { return x < 0 ? x + mod : x; }
int fpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % mod;
x = 1ll * x * x % mod;
y /= 2;
}
return ans;
}
int n, m, a[4], p[4], pn = 51, f[105][105][105], g[105][105], c[105];
inline int check(int x, int y) { return x * x + y * y <= n * n; }
void gauss() {
for (int i = 0; i <= m; i++) {
int nw = i;
while (nw <= m && !g[nw][i]) nw++;
if (nw != i) {
for (int j = 0; j <= m + 1; j++) swap(g[i][j], g[nw][j]);
}
int inv = fpow(g[i][i], mod - 2);
for (int j = i; j <= m + 1; j++) g[i][j] = 1ll * g[i][j] * inv % mod;
for (int j = 0; j <= m; j++) {
if (i == j) continue;
int q = g[j][i];
for (int k = i; k <= m + 1; k++)
g[j][k] = submod(g[j][k] - 1ll * q * g[i][k] % mod);
}
}
for (int i = 0; i <= m; i++) c[i] = g[i][m + 1];
}
int main() {
scanf("%d%d%d%d%d", &n, &a[0], &a[1], &a[2], &a[3]);
int inv = fpow(a[0] + a[1] + a[2] + a[3], mod - 2);
for (int i = 0; i < 4; i++) p[i] = 1ll * a[i] * inv % mod;
int inv3 = fpow(p[3], mod - 2);
for (int i = -n; i <= n + 1; i++)
for (int j = -n; j <= n; j++) {
if (check(i, j) && !check(i - 1, j))
f[i + pn][j + pn][j + pn] = 1;
else if (check(i, j) || (!check(i, j) && check(i - 1, j))) {
for (int k = -n; k <= n + 1; k++) {
int q = (f[i - 1 + pn][j + pn][k + pn] -
1ll * f[i - 1 + pn][j - 1 + pn][k + pn] * p[0] -
1ll * f[i - 2 + pn][j + pn][k + pn] * p[1] -
1ll * f[i - 1 + pn][j + 1 + pn][k + pn] * p[2]) %
mod;
if (k == n + 1) q--;
q = (q + mod) % mod;
f[i + pn][j + pn][k + pn] = 1ll * q * inv3 % mod;
}
if (!check(i, j)) {
for (int k = -n; k <= n; k++)
g[j + n][k + n] = f[i + pn][j + pn][k + pn];
g[j + n][n + 1 + n] = (mod - f[i + pn][j + pn][n + 1 + pn]) % mod;
}
}
}
m = 2 * n;
gauss();
int ans = f[pn][pn][n + 1 + pn];
for (int i = -n; i <= n; i++)
ans = addmod(ans + 1ll * f[pn][pn][i + pn] * c[i + n] % mod);
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, mx = 0, sum = 0, p = 0;
cin >> n;
string s;
cin >> s;
map<char, int> mp;
for (int i = 0; i < n; i++) mp[s[i]]++;
int l = mp.size();
mp.clear();
int ans = 1e6, j = 0, x = 0;
for (int i = 0; i < n;) {
if (x < l) {
if (mp[s[i]] == 0) x++;
mp[s[i]]++;
p++;
i++;
}
while (x == l) {
ans = min(p, ans);
mp[s[j]]--;
if (mp[s[j]] == 0) x--;
p--, j++;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int w1, w2, h1, h2;
cin >> w1 >> h1 >> w2 >> h2;
cout << (w1 + h1 + h2) * 2 + 4 << '\n';
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int i, j;
int main() {
int r, l, a, num;
cin >> l >> r >> a;
if (l >= r) {
num = l - r;
if (a <= num) {
cout << 2 * (a + r);
return 0;
} else if (a > num) {
int b = a - num;
cout << (l + b / 2) * 2;
return 0;
}
} else {
num = r - l;
if (a <= num) {
cout << 2 * (a + l);
return 0;
} else if (a > num) {
int b = a - num;
cout << (r + b / 2) * 2;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, pos, v[N];
long long tot, s[N][2];
struct node {
long long x, v;
} a[N];
bool cmp(node x, node y) { return x.x < y.x; }
int lowbit(int x) { return x & (-x); }
void update(int x, int val) {
while (x <= n) {
s[x][0]++;
s[x][1] += val;
x += lowbit(x);
}
}
long long getsum(int x, int flag) {
long long res = 0;
while (x) {
res += s[x][flag];
x -= lowbit(x);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].x);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i].v);
v[i] = a[i].v;
}
sort(a + 1, a + n + 1, cmp);
sort(v + 1, v + n + 1);
m = unique(v + 1, v + n + 1) - v - 1;
for (int i = 1; i <= n; i++) {
pos = lower_bound(v + 1, v + m + 1, a[i].v) - v;
tot += getsum(pos, 0) * a[i].x - getsum(pos, 1);
update(pos, a[i].x);
}
printf("%lld", tot);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int n;
string op[1000000];
int lchild[1000000], rchild[1000000];
int in[1000000];
int parent[1000000];
vector<int> leafs;
int memo[1000000];
int calc(int x) {
if (op[x][0] == 'I')
return in[x];
else if (op[x][0] == 'A')
return in[x] = calc(lchild[x]) & calc(rchild[x]);
else if (op[x][0] == 'O')
return in[x] = calc(lchild[x]) | calc(rchild[x]);
else if (op[x][0] == 'X')
return in[x] = calc(lchild[x]) ^ calc(rchild[x]);
else
return in[x] = 1 - calc(lchild[x]);
}
int doit(int x) {
if (memo[x] >= 0) return memo[x];
int p = parent[x];
if (op[p][0] == 'A') {
int y = lchild[p] == x ? rchild[p] : lchild[p];
if (in[p] == ((1 - in[x]) & in[y]))
return memo[x] = in[0];
else
return memo[x] = doit(p);
} else if (op[p][0] == 'O') {
int y = lchild[p] == x ? rchild[p] : lchild[p];
if (in[p] == ((1 - in[x]) | in[y]))
return memo[x] = in[0];
else
return memo[x] = doit(p);
} else if (op[p][0] == 'X') {
int y = lchild[p] == x ? rchild[p] : lchild[p];
if (in[p] == ((1 - in[x]) ^ in[y]))
return memo[x] = in[0];
else
return memo[x] = doit(p);
} else {
return memo[x] = doit(p);
}
}
int main() {
io();
cin >> n;
fill(memo, memo + n, -1);
for (int i = 0; i < n; i++) {
cin >> op[i];
if (op[i][0] == 'I') {
cin >> in[i];
leafs.push_back(i);
} else if (op[i][0] == 'N') {
cin >> lchild[i];
lchild[i]--;
parent[lchild[i]] = i;
} else {
cin >> lchild[i] >> rchild[i];
lchild[i]--;
rchild[i]--;
parent[lchild[i]] = i;
parent[rchild[i]] = i;
}
}
calc(0);
memo[0] = 1 - in[0];
for (int leaf : leafs) {
cout << doit(leaf);
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int b, long long int mod) {
if (!b) return 1;
if (b & 1) return a * pw(a * a % mod, b / 2, mod) % mod;
return pw(a * a % mod, b / 2, mod) % mod;
}
const long long int MAXN = 1e2 + 10;
const long long int MAXM = 1e4 + 10;
const long long int INF = 8e18;
const long long int MOD = 1e9 + 7;
int n, m, cnt[MAXN], cost[MAXN][MAXN], dp[MAXN][MAXM], ps[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
memset(cost, -1, sizeof(cost));
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
cin >> cnt[i];
for (long long int j = 1; j <= cnt[i]; j++) {
cin >> ps[j];
ps[j] += ps[j - 1];
}
cost[i][cnt[i]] = ps[cnt[i]];
for (long long int len = 1; len <= cnt[i]; len++) {
for (long long int j = 1; j + len - 1 <= cnt[i]; j++) {
cost[i][cnt[i] - len] = max(cost[i][cnt[i] - len],
ps[j - 1] + ps[cnt[i]] - ps[j + len - 1]);
}
}
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
for (long long int k = 0; k <= cnt[i] && k <= j; k++) {
dp[i][j] = max(dp[i][j], cost[i][k] + dp[i - 1][j - k]);
}
}
}
cout << dp[n][m] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n >> a >> b;
n = n * 6;
if (a * b > n) {
cout << a * b << endl;
cout << a << " " << b << endl;
return 0;
}
long long lim;
lim = sqrt(n) + 1;
bool sw = false;
if (a > b) swap(a, b), sw = true;
long long y, ans = 1, savx, savy;
ans = 1 << 30;
ans = ans * ans;
for (long long i = a; i <= lim; i++) {
y = n / i;
if (n % i) y++;
if (y < b) y = b;
if (i > y) break;
if (i * y >= n && i * y <= ans) ans = i * y, savx = i, savy = y;
}
if (sw) swap(savx, savy);
cout << ans << endl;
cout << savx << " " << savy << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, k, val[(int)(5e5 + 10)], limit[(int)(5e5 + 10)],
newlimit[(int)(5e5 + 10)];
int worker[(int)(5e5 + 10)], par[(int)(5e5 + 10)], bad;
vector<int> adj[(int)(5e5 + 10)];
int seg[4 * (int)(5e5 + 10)];
int lazy[4 * (int)(5e5 + 10)];
void build(int l = 0, int r = k, int id = 1) {
if (l == (r - 1)) {
seg[id] = l - k;
return;
}
int mid = l + r >> 1;
build(l, mid, id << 1);
build(mid, r, id << 1 | 1);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
return;
}
inline void shift(int id) {
seg[id << 1] += lazy[id];
lazy[id << 1] += lazy[id];
seg[id << 1 | 1] += lazy[id];
lazy[id << 1 | 1] += lazy[id];
lazy[id] = 0;
}
void seg_upt(int s, int e, int val = 1, int l = 0, int r = k, int id = 1) {
if (l >= e || r <= s) return;
if (l >= s && r <= e) {
seg[id] += val;
lazy[id] += val;
return;
}
int mid = l + r >> 1;
shift(id);
seg_upt(s, e, val, l, mid, id << 1);
seg_upt(s, e, val, mid, r, id << 1 | 1);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
return;
}
int relax(int l = 0, int r = k, int id = 1) {
if (l == (r - 1)) {
if (seg[id] < 0) return l;
return -1;
}
int mid = l + r >> 1;
shift(id);
int local = relax(mid, r, id << 1 | 1);
if (~local) return local;
return relax(l, mid, id << 1);
}
void init_dfs(int v = 1, int p = 0) {
par[v] = p;
limit[v] = min(limit[p], val[v]);
seg_upt(0, (upper_bound(worker, worker + k, limit[v]) - worker));
for (auto e : adj[v])
if (e ^ p) init_dfs(e, v);
}
void dfs(int v, int p = -1) {
if (p == -1) {
newlimit[v] = bad;
p = par[v];
} else
newlimit[v] = min(val[v], newlimit[p]);
seg_upt(0, (upper_bound(worker, worker + k, limit[v]) - worker), -1);
seg_upt(0, (upper_bound(worker, worker + k, newlimit[v]) - worker));
for (auto e : adj[v])
if (e ^ p) dfs(e, v);
}
void rev_dfs(int v, int p = -1) {
p = par[v];
seg_upt(0, (upper_bound(worker, worker + k, limit[v]) - worker));
seg_upt(0, (upper_bound(worker, worker + k, newlimit[v]) - worker), -1);
for (auto e : adj[v])
if (e ^ p) rev_dfs(e, v);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
}
cin >> k;
for (int i = 0; i < k; i++) cin >> worker[i];
sort(worker, worker + k);
build();
limit[0] = newlimit[0] = 1e9 + 10;
init_dfs();
bad = relax();
if (bad == -1) return cout << 0 << endl, 0;
bad = worker[bad];
vector<int> qu;
for (int i = 1; i <= n; i++)
if (limit[i] < bad && limit[par[i]] >= bad) qu.push_back(i);
int answer = 1e9 + 10;
for (auto e : qu) {
dfs(e);
if (seg[1] >= 0) answer = min(answer, bad - val[e]);
rev_dfs(e);
}
if (answer > 1e9) answer = -1;
cout << answer << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> fillvec(int size) {
vector<int> ans;
for (int i = 0; i < size; i++) {
int temp;
cin >> temp;
ans.push_back(temp);
}
return ans;
}
long long gcd(long long a, long long b) { return !a ? b : gcd(b % a, a); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
vector<long long> getdivisors(long long n) {
vector<long long> ans;
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
ans.push_back(i);
} else {
ans.push_back(i);
ans.push_back(n / i);
}
}
}
sort(ans.begin(), ans.end());
return ans;
}
string DecToBin(int number) {
if (number == 0) return "0";
if (number == 1) return "1";
if (number % 2 == 0)
return DecToBin(number / 2) + "0";
else
return DecToBin(number / 2) + "1";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
char cl;
string s;
cin >> s;
vector<int> ca(26);
vector<char> t, u;
for (int i = 0; i < s.size(); i++) ca[s[i] - 97]++;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 26; j++)
if (ca[j] != 0) {
cl = j + 97;
break;
}
while (!t.empty() && (t.back() <= cl)) {
u.push_back(t.back());
t.pop_back();
}
if (s[i] == cl) {
ca[cl - 97]--;
u.push_back(s[i]);
} else {
t.push_back(s[i]);
ca[s[i] - 97]--;
}
}
while (!t.empty()) {
u.push_back(t.back());
t.pop_back();
}
for (int i = 0; i < u.size(); i++) cout << u[i];
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n;
cin >> n;
long long int a[n];
for (int i = int(0); i < int(n); i++) {
cin >> a[i];
}
long long int ans = 1e6;
long long int t = 0;
for (int i = int(1); i < int(102); i++) {
long long int res = 0;
for (int j = int(0); j < int(n); j++) {
if (a[j] < i) res += i - 1 - a[j];
if (a[j] > i) res += a[j] - i - 1;
}
if (res < ans) t = i;
ans = min(ans, res);
}
cout << t << " " << ans << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N;
cin >> N;
vector<long long> res(N);
map<long long, long long> mp;
long long a;
for (long long i = 0; i < N; i++) {
cin >> a;
mp[a] = i;
}
long long mx = -1;
for (long long i = 0; i < N; i++) {
cin >> a;
res[i] = max((long long)0, mp[a] - mx);
mx = max(mx, mp[a]);
}
for (long long i = 0; i < N; i++) {
if (i > 0) cout << " ";
cout << res[i];
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x, ans = 0;
vector<int> a, b;
bool cmp(const int &a, const int &b) { return a > b; }
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &x);
a.resize(n);
b.resize(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i]);
}
sort(a.begin(), a.end(), cmp);
sort(b.begin(), b.end(), cmp);
for (int i = 0, j = n - 1; i < n && j >= 0; ++i) {
for (; j >= 0 && a[i] + b[j] < x; --j)
;
if (j >= 0) {
++ans;
}
--j;
}
printf("1 %d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[100005], e[15];
int k[555];
int ft[4][11][11][100005];
void update(int c1, int c2, int c3, int i, int v) {
for (; i <= 100000; i += (i & -i)) ft[c1][c2][c3][i] += v;
}
int query(int c1, int c2, int c3, int i) {
int res = 0;
for (; i > 0; i -= (i & -i)) res += ft[c1][c2][c3][i];
return res;
}
int main() {
k['A'] = 0, k['C'] = 1, k['G'] = 2, k['T'] = 3;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 10; j++) {
int pos = i % j;
update(k[s[i]], j, pos, i, 1);
}
}
int q;
scanf("%d", &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
char c[2];
scanf("%d%s", &x, c);
for (int j = 1; j <= 10; j++) {
int pos = x % j;
update(k[s[x]], j, pos, x, -1);
}
s[x] = c[0];
for (int j = 1; j <= 10; j++) {
int pos = x % j;
update(k[s[x]], j, pos, x, 1);
}
} else {
int l, r;
scanf("%d%d%s", &l, &r, e);
int le = strlen(e);
int ans = 0;
for (int j = 0; j < le; j++) {
int pos = (l + j) % le;
ans += query(k[e[j]], le, pos, r) - query(k[e[j]], le, pos, l - 1);
}
printf("%d\n", ans);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, oN, oM, x, y, z, P;
cin >> oN >> oM >> x >> y >> z >> P;
x %= 4;
y %= 2;
z %= 4;
while (P--) {
int a, b;
cin >> a >> b;
N = oN;
M = oM;
for (int i = 0; i < x; ++i) {
int t = a;
a = b;
b = N - t + 1;
t = M;
M = N;
N = t;
}
for (int i = 0; i < y; ++i) {
b = M - b + 1;
}
for (int i = 0; i < (z * 3) % 4; ++i) {
int t = a;
a = b;
b = N - t + 1;
t = M;
M = N;
N = t;
}
cout << a << " " << b << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1, inf = 1111111111;
const int a = 1234567;
const int b = 123456;
const int c = 1234;
int n;
int main() {
cin >> n;
for (int i = 0; i <= n; i += a) {
for (int j = 0; i + j <= n; j += b) {
if ((n - i - j) % c == 0) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
long long n, m, i, j, ans, x;
map<long long, long long> dp, r;
set<long long> pre;
struct node {
long long ti, op, x;
bool operator<(const node &y) const { return ti < y.ti; }
};
set<node> s;
long long f(long long x) { return (--(dp.upper_bound(x)))->second; }
int main() {
dp[1] = 0;
dp[4] = 1;
dp[16] = 2;
dp[82] = 0;
dp[6724] = 3;
dp[50626] = 1;
dp[2562991876ll] = 2;
read(n);
while (n--) {
read(x);
ans ^= f(x);
}
if (ans)
puts("Furlo");
else
puts("Rublo");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n, m, x, y;
cin >> n >> m >> x >> y;
string s[n];
for (int a = 0; a < n; a++) cin >> s[a];
if (y > (2 * x)) y = 2 * x;
long long int xx, yy, zz, ans = 0;
for (int a = 0; a < n; a++) {
for (int b = 0; b < m; b++) {
if (s[a][b] == '.') {
if (b == m - 1)
ans += x;
else if (s[a][b + 1] == '.') {
ans += y;
b++;
} else
ans += x;
}
}
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b, q, t, x, y;
long long jdfbsdjb21sdfv[800020], uresd[800020], myarray[800020];
void upd1(long long v, long long l, long long r, long long x) {
if (l == r) {
jdfbsdjb21sdfv[v] = min(myarray[x], b);
return;
}
long long mid = (l + r) / 2;
if (x <= mid)
upd1(v * 2, l, mid, x);
else
upd1(v * 2 + 1, mid + 1, r, x);
jdfbsdjb21sdfv[v] = jdfbsdjb21sdfv[v * 2] + jdfbsdjb21sdfv[v * 2 + 1];
}
void update_2(long long v, long long l, long long r, long long x) {
if (l == r) {
uresd[v] = min(myarray[x], a);
return;
}
long long mid = (l + r) / 2;
if (x <= mid)
update_2(v * 2, l, mid, x);
else
update_2(v * 2 + 1, mid + 1, r, x);
uresd[v] = uresd[v * 2] + uresd[v * 2 + 1];
}
long long gte_items1(long long v, long long A, long long B, long long l,
long long r) {
if (l > B || r < A) return 0;
if (A == l && B == r) return jdfbsdjb21sdfv[v];
long long mid = (A + B) / 2;
long long L = gte_items1(v * 2, A, mid, l, min(mid, r));
long long R = gte_items1(v * 2 + 1, mid + 1, B, max(mid + 1, l), r);
return L + R;
}
long long gte_items2(long long v, long long A, long long B, long long l,
long long r) {
if (l > B || r < A) return 0;
if (A == l && B == r) return uresd[v];
long long mid = (A + B) / 2;
long long L = gte_items2(v * 2, A, mid, l, min(mid, r));
long long R = gte_items2(v * 2 + 1, mid + 1, B, max(mid + 1, l), r);
return L + R;
}
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> t;
if (t == 1) {
cin >> x >> y;
myarray[x] += y;
upd1(1, 1, n, x);
update_2(1, 1, n, x);
} else {
cin >> x;
long long ans = 0;
if (x > 1) ans = gte_items1(1, 1, n, 1, x - 1);
if (x + k <= n) ans += gte_items2(1, 1, n, x + k, n);
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string arr[1005];
int h[1005];
int cumh[1005];
int p[1005];
int cump[1005];
int n, m, x, y;
long long dp[1005][2005];
long long fun(int i, int cnt) {
if (i == m) return 0;
if (dp[i][cnt] != -1) return dp[i][cnt];
long long a = 1e9, b = 1e9;
if (cnt <= 1000 && i + x <= m) {
if (i == 0)
a = cumh[i + x - 1] + fun(i + x, 1000 + x);
else
a = (cumh[i + x - 1] - cumh[i - 1]) + fun(i + x, 1000 + x);
} else if (abs(cnt - 1000) < y && cnt > 1000)
a = h[i] + fun(i + 1, cnt + 1);
if (cnt >= 1000 && i + x <= m) {
if (i == 0)
b = cump[i + x - 1] + fun(i + x, 1000 - x);
else
b = (cump[i + x - 1] - cump[i - 1]) + fun(i + x, 1000 - x);
} else if (abs(cnt - 1000) < y && cnt < 1000)
b = p[i] + fun(i + 1, cnt - 1);
return dp[i][cnt] = min(a, b);
}
int main() {
cin >> n >> m >> x >> y;
string s;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) cin >> arr[i];
for (int j = 0; j < m; j++) {
int sumh = 0, sump = 0;
for (int i = 0; i < n; i++) {
if (arr[i][j] == '#')
sump++;
else
sumh++;
}
p[j] = sump;
h[j] = sumh;
}
cumh[0] = h[0];
cump[0] = p[0];
for (int i = 1; i < m; i++) {
cumh[i] = h[i] + cumh[i - 1];
cump[i] = p[i] + cump[i - 1];
}
cout << fun(0, 1000) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long n, q, v[400001], a, b, c;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> a >> b >> c;
int r = min({a, b - 1, c - 2});
cout << 3 * r + 3;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c = 0;
long long s = 0, x;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
s = s + a[i];
}
x = 0;
for (i = 0; i < (n - 1); i++) {
x = x + a[i];
if (x == (s - x)) c++;
}
cout << c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long> v1;
vector<long> temp, temp1;
string tstring;
vector<string> good[11000];
vector<long> digs;
long q, num;
string vts(vector<long> v) {
string r = "";
for (int i = 0; i < v.size(); i++) r += " ";
for (int i = 0; i < v.size(); i++) r[i] = v[i] + 48;
return r;
}
long gval(long l, long r) {
long rr = 0;
for (int i = l; i <= r; i++) rr = rr * 10 + digs[i];
return rr;
}
vector<long> solve(long l, long r) {
vector<long> res;
res.push_back(gval(l, r));
for (int cp = l; cp < r; cp++) {
vector<long> lv, rv;
lv = solve(l, cp);
rv = solve(cp + 1, r);
for (int i = 0; i < lv.size(); i++)
for (int j = 0; j < rv.size(); j++) {
res.push_back(lv[i] + rv[j]);
res.push_back(lv[i] - rv[j]);
res.push_back(lv[i] * rv[j]);
}
}
vector<long> res1;
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++)
if (i == 0 || res[i] != res[i - 1]) res1.push_back(res[i]);
return res1;
}
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i <= 9999; i++) {
long q = i;
v1.clear();
for (int j = 0; j < 4; j++) {
v1.push_back(q % 10);
q /= 10;
}
reverse(v1.begin(), v1.end());
digs = v1;
temp = solve(0, 3);
tstring = vts(v1);
sort(temp.begin(), temp.end());
temp1.clear();
for (int j = 0; j < temp.size(); j++)
if (j == 0 || temp[j] != temp[j - 1]) temp1.push_back(temp[j]);
for (int j = 0; j < temp1.size(); j++) {
if (temp1[j] >= 0) good[temp1[j]].push_back(tstring);
}
}
cin >> q >> num;
long usd = 0;
long sdg;
for (int fdg = 0; fdg <= 9999; fdg++) {
sdg = abs(fdg - q);
for (int j = 0; j < good[fdg].size(); j++)
for (int q = 0; q < good[sdg].size(); q++) {
if (usd >= num) break;
cout << good[fdg][j] << good[sdg][q] << endl;
++usd;
}
}
cin.get();
cin.get();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
int r[N];
int res[N];
vector<pair<int, int> > adj[N];
int n;
vector<pair<int, long long> > path;
int find(int u) {
if (u == 1) return 0;
int low = 0;
int high = path.size() - 1;
int ans = 0;
long long T = path[high].second;
while (low <= high) {
int mid = (low + high) / 2;
long long temp = T - path[mid].second;
if (temp > a[u]) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
return path[ans].first;
}
void dfs(int u, int p, long long val) {
path.push_back(make_pair(u, val));
r[u] = find(u);
for (auto x : adj[u]) {
if (x.first != p) {
dfs(x.first, u, val + x.second);
}
}
path.pop_back();
}
void solve(int u, int p) {
for (auto x : adj[u]) {
if (x.first != p) {
solve(x.first, u);
res[u] += res[x.first];
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i < n + 1; i++) {
int p, w;
scanf("%d", &p);
scanf("%d", &w);
adj[i].push_back(make_pair(p, w));
adj[p].push_back(make_pair(i, w));
}
path.push_back(make_pair(0, -1));
dfs(1, -1, 0LL);
for (int i = 1; i <= n; i++) {
res[i]++;
res[r[i]]--;
}
solve(1, -1);
for (int i = 1; i < n + 1; i++) {
printf("%d ", res[i] - 1);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, si, sj, yes = 0;
string s[10000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i][0] == 'O' && s[i][1] == 'O') {
si = i;
sj = 0;
yes++;
} else if (s[i][3] == 'O' && s[i][4] == 'O') {
si = i;
sj = 3;
yes++;
}
}
if (yes == 0)
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 5; j++) {
if (i == si && j == sj)
cout << '+';
else if (i == si && j == sj + 1)
cout << '+';
else
cout << s[i][j];
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 10;
struct edge {
int to;
pair<int, int> when;
};
vector<pair<int, int>> when_open(vector<pair<int, int>> segs, int par) {
if (segs.empty()) return vector<pair<int, int>>();
sort((segs).begin(), (segs).end());
int l = segs[0].first, r = segs[0].second;
vector<pair<int, int>> ans;
for (int i = 0; i < (int)((int)(segs).size()); ++i)
if (i) {
if (segs[i].first > r - (r % 2 != par)) {
ans.push_back(make_pair(l, r));
tie(l, r) = segs[i];
} else
r = max(r, segs[i].second);
}
ans.push_back(make_pair(l, r));
return ans;
}
void solve(int n) {
vector<vector<pair<int, int>>> open(2 * n);
int cnt = 0;
vector<pair<int, int>> belongs;
vector<vector<int>> num(2 * n);
vector<vector<edge>> edges;
auto get_num = [&](int v, int tm) -> int {
int pos =
upper_bound((open[v]).begin(), (open[v]).end(), make_pair(tm, inf)) -
open[v].begin() - 1;
if (pos != -1) {
assert(open[v][pos].first <= tm);
return (open[v][pos].second > tm ? pos : -1);
}
return -1;
};
{
int m;
cin >> m;
vector<vector<int>> orig(m, vector<int>(4));
for (int i = 0; i < (int)(m); ++i)
for (int j = 0; j < (int)(4); ++j) {
cin >> orig[i][j];
if (j < 2) --orig[i][j];
}
vector<vector<pair<int, int>>> orig_open(n);
for (int i = 0; i < (int)(m); ++i)
for (int j = 0; j < (int)(2); ++j)
orig_open[orig[i][j]].push_back(make_pair(orig[i][2], orig[i][3]));
for (int i = 0; i < (int)(n); ++i)
for (int par = 0; par < (int)(2); ++par)
open[2 * i + par] = when_open(orig_open[i], par);
for (int i = 0; i < (int)((int)(open).size()); ++i)
cnt += (int)(open[i]).size();
{
belongs.resize(cnt);
int cur = 0;
for (int v = 0; v < (int)((int)(open).size()); ++v) {
num[v].resize((int)(open[v]).size());
for (int i = 0; i < (int)((int)(open[v]).size()); ++i) {
num[v][i] = cur;
belongs[cur++] = make_pair(v, i);
}
}
assert(cur == cnt);
}
{
edges.resize(cnt);
for (int i = 0; i < (int)(m); ++i)
for (int j = 0; j < (int)(2); ++j)
for (int par = 0; par < (int)(2); ++par) {
int v = orig[i][j], to = orig[i][j ^ 1], l = orig[i][2],
r = orig[i][3];
int np = get_num(2 * v + par, l);
for (int rp = np - 1; rp <= np + 1; rp++)
if (0 <= rp && rp < (int)(open[2 * v + par]).size()) {
int nl = max(l, open[2 * v + par][rp].first);
int nr = min(r, open[2 * v + par][rp].second);
if (nl < nr)
edges[num[2 * v + par][rp]].push_back(
edge{2 * to + 1 - par, make_pair(nl, nr)});
}
}
}
}
vector<int> dist(cnt, inf);
set<pair<int, int>> bydist;
{
vector<pair<int, int>> start(cnt);
for (int i = 0; i < (int)(cnt); ++i) start[i] = make_pair(inf, i);
bydist = set<pair<int, int>>((start).begin(), (start).end());
}
if (n == 1) {
cout << 0 << endl;
return;
}
auto relax = [&](int v, int d) {
if (d < dist[v]) {
bydist.erase(make_pair(dist[v], v));
dist[v] = d;
bydist.insert(make_pair(dist[v], v));
}
};
int start = get_num(0, 0);
if (start != -1) relax(start, 0);
int ans = inf;
while (!bydist.empty()) {
int cur = bydist.begin()->second;
assert(dist[cur] == bydist.begin()->first);
bydist.erase(bydist.begin());
if (dist[cur] == inf) break;
if (belongs[cur].first / 2 == n - 1) {
cout << min(ans, dist[cur]) << endl;
return;
}
const int curt = dist[cur];
for (const edge &e : edges[cur]) {
int to = e.to, l, r;
tie(l, r) = e.when;
int jumpt = curt;
if (curt < l) jumpt = (((curt & 1) == (l & 1)) ? l : l + 1);
if (jumpt >= r) continue;
int pos = get_num(to, jumpt + 1);
if (pos != -1)
relax(num[to][pos], jumpt + 1);
else if (to / 2 == n - 1)
ans = min(ans, jumpt + 1);
}
}
cout << (ans == inf ? -1 : ans) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
while (cin >> n) solve(n);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
vector<char> vc;
vector<string> vs;
map<string, int> sm;
map<int, int> mp;
map<char, int> cm;
using namespace std;
double string_to_int(string s) {
stringstream x(s);
double a = 0;
x >> a;
return a;
}
long long int gcd(long long int a, long long int b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int main() {
int a, b, c = 0;
cin >> a;
while (a--) {
cin >> b;
if (b == 1) c = 1;
v.push_back(b);
}
if (c)
cout << "HARD" << endl;
else
cout << "EASY" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
inline void getInt(int* p);
const int maxn = 1000010;
const int inf = 0x3f3f3f3f;
int main() {
int n, m;
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
int l = 1;
int r = m;
while (l <= r) {
if (l < r) {
for (int i = 1; i <= n; i++) {
cout << i << " " << l << '\n';
cout << n - i + 1 << " " << r << '\n';
}
l++;
r--;
} else {
int u = 1;
int d = n;
for (int i = 1; i <= n; i++) {
if (i & 1) {
cout << u << " " << l << '\n';
u++;
} else {
cout << d << " " << l << '\n';
d--;
}
}
l++;
r--;
}
}
cout << endl;
return 0;
}
inline void getInt(int* p) {
char ch;
do {
ch = getchar();
} while (ch == ' ' || ch == '\n');
if (ch == '-') {
*p = -(getchar() - '0');
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 - ch + '0';
}
} else {
*p = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 + ch - '0';
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct expr {
bool ex;
unsigned char f;
string str;
int prec;
bool operator<(const expr& o) const {
if (!o.ex) return false;
if (!ex) return true;
if (str.length() != o.str.length()) return str.length() > o.str.length();
if (prec != o.prec) return prec > o.prec;
return str > o.str;
}
expr() : f(0), str(""), prec(0), ex(0) {}
expr(char f, string str, int prec) : f(f), str(str), prec(prec), ex(1) {}
};
vector<expr> sofar[3];
expr sol[256][3];
string usol[256];
priority_queue<expr> q;
void tryq(expr e) {
for (; e.prec < 3; e.prec++) {
if (sol[e.f][e.prec] < e) {
sol[e.f][e.prec] = e;
q.push(e);
}
}
}
void tryyyy(vector<expr>& v) {
for (expr e : v) {
if (e.prec == 0) {
tryq(expr(e.f, e.str, 1));
tryq(expr(~e.f, "!" + e.str, 0));
for (expr t : sofar[1]) {
tryq(expr(t.f & e.f, t.str + "&" + e.str, 1));
}
}
if (e.prec == 1) {
tryq(expr(e.f, e.str, 2));
for (expr f : sofar[0]) {
tryq(expr(e.f & f.f, e.str + "&" + f.str, 1));
}
for (expr ee : sofar[2]) {
tryq(expr(ee.f | e.f, ee.str + "|" + e.str, 2));
}
}
if (e.prec == 2) {
tryq(expr(e.f, "(" + e.str + ")", 0));
for (expr t : sofar[1]) {
tryq(expr(e.f | t.f, e.str + "|" + t.str, 2));
}
}
}
}
int main() {
expr x(15, "x", 0);
expr y(51, "y", 0);
expr z(85, "z", 0);
sol[15][0] = x;
sol[51][0] = y;
sol[85][0] = z;
int s = 0;
q.push(x);
q.push(y);
q.push(z);
while (!q.empty()) {
expr e = q.top();
q.pop();
if (e < sol[e.f][e.prec]) continue;
sofar[e.prec].push_back(e);
if (e.prec == 0) {
tryq(expr(e.f, e.str, 1));
tryq(expr(~e.f, "!" + e.str, 0));
for (expr t : sofar[1]) {
tryq(expr(t.f & e.f, t.str + "&" + e.str, 1));
}
}
if (e.prec == 1) {
tryq(expr(e.f, e.str, 2));
for (expr f : sofar[0]) {
tryq(expr(e.f & f.f, e.str + "&" + f.str, 1));
}
for (expr ee : sofar[2]) {
tryq(expr(ee.f | e.f, ee.str + "|" + e.str, 2));
}
}
if (e.prec == 2) {
tryq(expr(e.f, "(" + e.str + ")", 0));
for (expr t : sofar[1]) {
tryq(expr(e.f | t.f, e.str + "|" + t.str, 2));
}
}
}
for (int i = 0; i < 256; i++) {
usol[i] = sol[i][0].str;
if (sol[i][1].str.length() == usol[i].length())
usol[i] = min(usol[i], sol[i][1].str);
if (sol[i][1].str.length() < usol[i].length()) usol[i] = sol[i][1].str;
if (sol[i][2].str.length() == usol[i].length())
usol[i] = min(usol[i], sol[i][2].str);
if (sol[i][2].str.length() < usol[i].length()) usol[i] = sol[i][2].str;
}
ios::sync_with_stdio(false);
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int x = 0;
for (int j = 0; j < 8; j++) {
x *= 2;
char c;
cin >> c;
if (c != '0' && c != '1') {
j--;
continue;
}
x += (c - '0');
}
cout << usol[x] << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> vec;
int s1 = 0, s2 = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int br;
cin >> br;
for (int i = 0; i < br / 2; i++) {
int a;
cin >> a;
s1 += a;
}
if (br % 2) {
int a;
cin >> a;
vec.push_back(a);
}
for (int i = 0; i < br / 2; i++) {
int a;
cin >> a;
s2 += a;
}
}
sort(vec.begin(), vec.end());
for (int i = vec.size() - 1; i >= 0; i--)
if ((vec.size() - i) % 2)
s1 += vec[i];
else
s2 += vec[i];
cout << s1 << " " << s2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool myfunction(int i, int j) { return (i < j); }
istream &in = cin;
int n, m;
long long N[1001], M[1001];
int main() {
memset(N, 0, sizeof(N));
memset(M, 0, sizeof(M));
in >> n >> m;
for (int i = (0); i < (n); ++i) {
long long sum = 0;
for (int j = (0); j < (m); ++j) {
long long tmp;
in >> tmp;
M[j] += tmp;
sum += tmp;
}
N[i] = sum;
}
int idxM = -1;
long long mM = LLONG_MAX;
for (int i = 0; i <= m; ++i) {
long long sum = 0;
for (int j = 0; j < m; ++j)
sum += M[j] * (j * 4 + 2 - i * 4) * (j * 4 + 2 - i * 4);
if (sum < mM) {
mM = sum;
idxM = i;
}
}
int idxN = -1;
long long mN = LLONG_MAX;
for (int i = 0; i <= n; ++i) {
long long sum = 0;
for (int j = 0; j < n; ++j)
sum += N[j] * (j * 4 + 2 - i * 4) * (j * 4 + 2 - i * 4);
if (sum < mN) {
mN = sum;
idxN = i;
}
}
cout << mN + mM << endl;
cout << idxN << " " << idxM << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::string;
int main() {
int r, c, count = 0;
cin >> r >> c;
char s[r + 1][c + 1];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> s[i][j];
}
}
int flag;
for (int i = 0; i < r; i++) {
flag = 0;
for (int j = 0; j < c; j++) {
if (s[i][j] == 'S') {
flag = 1;
break;
}
}
if (flag == 0) {
count += c;
for (int j = 0; j < c; j++) {
s[i][j] = 'A';
}
}
}
for (int i = 0; i < c; i++) {
flag = 0;
for (int j = 0; j < r; j++) {
if (s[j][i] == 'S') {
flag = 1;
break;
}
}
if (flag == 0) {
count += r;
for (int j = 0; j < r; j++) {
if (s[j][i] == 'A') {
count--;
}
}
}
}
cout << count << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void print();
template <typename T, typename... Args>
void print(T x, Args... args);
void solve() {
int r, g;
cin >> r >> g;
const int M = 1e9 + 7;
int h = 0;
for (int add = 1 << 10; add; add >>= 1)
if ((h + add) * (h + add + 1) <= (r + g) * 2) h += add;
if (r > g) swap(r, g);
vector<vector<int>> dp(2, vector<int>(r + 1));
dp[0][0] = 1;
for (int i = 1; i <= h; ++i) {
auto &cur = dp[i & 1];
auto &prv = dp[(i & 1) ^ 1];
fill(cur.begin(), cur.end(), 0);
for (int j = 0; j <= r; ++j) {
cur[j] = (cur[j] + prv[j]) % M;
if (j + i <= r) cur[j + i] = (cur[j + i] + prv[j]) % M;
}
}
long long res = 0;
int k = h * (h + 1) / 2;
for (int i = 0; i <= r; ++i)
if (i <= k && i + g >= k) {
res = (res + dp[h & 1][i]) % M;
}
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
int t = 1;
while (t--) solve();
return 0;
}
void print() { cout << "\n"; }
template <typename T, typename... Args>
void print(T x, Args... args) {
if (sizeof...(args)) {
cout << x << ' ';
print(args...);
} else {
cout << x << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int w, h, u1, d1, u2, d2;
cin >> w >> h >> u1 >> d1 >> u2 >> d2;
for (int i = h; i > 0; i--) {
w += i;
if (d1 == i) {
w -= u1;
}
if (d2 == i) {
w -= u2;
}
if (w < 0) {
w = 0;
}
}
cout << w;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 10004205361450474ll;
long long query(vector<long long> V) {
printf("%lu ", V.size());
for (long long i = 0; i < V.size(); i++) printf("%lld ", V[i]);
putchar('\n');
fflush(stdout);
long long x;
scanf("%lld", &x);
if (x == -1) exit(0);
return x;
}
const long long mul_10001[] = {1, 10001, 100020001, 1000300030001ll,
10004000600040001ll};
long long F[10010][7];
long long Nxt(long long x, long long dep) {
if (dep == 0) return x;
if (x <= 10000 && F[x][dep] != -1) return F[x][dep];
if (dep == 1) return x + min(x, 10000ll);
long long res = min(x, 10000ll) + 1, i = x - 1;
if (x < 10000 && res)
for (;;) {
long long val = Nxt(i + 1, dep - 1);
i = val;
if (--res == 0) break;
if (i >= 10000) break;
}
if (res == 0) return x <= 10000 ? F[x][dep] = i : i;
return x <= 10000 ? F[x][dep] = i + res * mul_10001[dep - 1]
: i + res * mul_10001[dep - 1];
}
void Solve(long long l, long long r, long long dep) {
long long mx = min(l, 10000ll), res = mx;
vector<long long> tmp;
tmp.clear();
for (long long i = l - 1;;) {
long long nxt = Nxt(i + 1, 4 - dep);
if (nxt > r) break;
i = nxt;
tmp.push_back(i);
}
long long x = query(tmp);
tmp.push_back(r + 1);
if (x == 0)
Solve(l, tmp[0] - 1, dep + 1);
else
Solve(tmp[x - 1] + 1, tmp[x] - 1, dep + 1);
}
signed main() {
memset(F, -1, sizeof F);
vector<long long> Ans;
Ans.clear();
Ans.push_back(M - 10004000600040000ll);
long long x = query(Ans);
if (x == 0) {
Ans.clear();
Ans.push_back(2046);
long long x = query(Ans);
if (x == 0) {
Ans.clear();
Ans.push_back(6);
long long x = query(Ans);
if (x == 0) {
Ans.clear();
Ans.push_back(2);
long long x = query(Ans);
if (x == 0) {
Ans.clear();
Ans.push_back(1);
query(Ans);
} else
Solve(3, 5, 4);
} else
Solve(7, 2045, 3);
} else
Solve(2047, M - 10004000600040001ll, 2);
} else
Solve(M - 10004000600039999ll, M, 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e6 + 10, oo = 1e9;
int mod = oo + 7;
long long const OO = 1e18;
int n, wh, ed;
vector<pair<int, int> > st[2];
void mm(int idx, int msk1, int msk2) {
if (idx == ed) {
st[wh].push_back({msk1, msk2});
return;
}
for (int i = 0; i < n; i++) {
if ((1 << i) & msk1) continue;
int v = (i + idx) % n;
if ((1 << v) & msk2) continue;
mm(idx + 1, msk1 | (1 << i), msk2 | (1 << v));
}
}
int main() {
scanf("%d", &n);
if (n % 2 == 0) {
puts("0");
return 0;
}
if (n == 1) {
puts("1");
return 0;
}
if (n == 15) {
printf("150347555\n");
return 0;
}
wh = 0;
ed = (n + 1) / 2;
mm(0, 0, 0);
wh = 1;
ed = n;
mm((n + 1) / 2, 0, 0);
sort(st[1].begin(), st[1].end());
int an = 0;
for (int i = 0; i < (int)st[0].size(); i++) {
int c1 = ((1 << n) - 1) ^ st[0][i].first,
c2 = ((1 << n) - 1) ^ st[0][i].second;
an += upper_bound(st[1].begin(), st[1].end(), make_pair(c1, c2)) -
lower_bound(st[1].begin(), st[1].end(), make_pair(c1, c2));
}
for (int i = 1; i <= n; i++) an = 1LL * an * i % mod;
printf("%d", an);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
ifstream in("input.txt");
ofstream out("output.txt");
const int MAX_N = 100, D = 3;
const long double phi = (sqrt(5) + 1) / 2, phi2 = 2 - phi, e = 1e-7;
long double pnts[MAX_N][D];
int n;
long double base[D];
long double dist(long double *a, long double *b) {
long double sum = 0;
for (int i = 0; i < D; i++) sum += (a[i] - b[i]) * (a[i] - b[i]);
return sum;
}
long double maxi_dist() {
long double t = 0;
for (int i = 0; i < n; i++) t = max(t, dist(base, pnts[i]));
return t;
}
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int d = 0; d < D; d++) cin >> pnts[i][d];
}
}
long double f(long double val, int d);
long double tern(int d) {
if (d == D) return maxi_dist();
long double l = -1e4, r = 1e4;
while (r - l > e) {
long double x1 = l + (r - l) / 3;
long double x2 = r - (r - l) / 3;
if (f(x1, d) < f(x2, d))
r = x2;
else
l = x1;
}
base[d] = l;
return tern(d + 1);
}
long double f(long double val, int d) {
base[d] = val;
return tern(d + 1);
}
int main() {
input();
tern(0);
cout.precision(10);
cout << fixed;
for (int i = 0; i < D; i++) cout << base[i] << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
int move(int s, int& d, int from, int to) {
if (from == to) return 0;
int result;
if (d == 1) {
if (from < to) {
result = to - from;
} else {
result = s - from + s - to;
d = -1;
}
} else {
if (from < to) {
result = from + to;
d = 1;
} else {
result = from - to;
}
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12);
cin.tie(nullptr);
int s, x1, x2;
cin >> s >> x1 >> x2;
int t1, t2;
cin >> t1 >> t2;
int p, d;
cin >> p >> d;
int ans = abs(x2 - x1) * t2;
int m = 0;
m += move(s, d, p, x1);
m += move(s, d, x1, x2);
ans = min(ans, m * t1);
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long rez, h, q, n, i, j, k1, k2, k3, d, x, k, y, xx, yy, m, l, r, c, t,
sum, used[100500];
vector<long long> graph[100500], gr[100500], grb[100500];
vector<long long> comps[100500];
vector<long long> order;
void dfs(int v) {
if (used[v]) return;
used[v] = 1;
comps[j].push_back(v);
for (int i = 0; i < graph[v].size(); i++) dfs(graph[v][i]);
}
void dfs1(int v) {
if (used[v]) return;
used[v] = 1;
for (int i = 0; i < gr[v].size(); i++) dfs1(gr[v][i]);
order.push_back(v);
}
void dfs2(int v) {
if (used[v]) return;
used[v] = 1;
for (int i = 0; i < grb[v].size(); i++) dfs2(grb[v][i]);
}
int main() {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
graph[x].push_back(y);
graph[y].push_back(x);
gr[x].push_back(y);
grb[y].push_back(x);
}
for (i = 0; i < n; i++)
if (!used[i]) {
dfs(i);
j++;
}
k = j;
for (i = 0; i < k; i++) {
for (j = 0; j < comps[i].size(); j++) used[comps[i][j]] = 0;
l = 0;
r = 0;
order.clear();
for (j = 0; j < comps[i].size(); j++)
if (!used[comps[i][j]]) {
dfs1(comps[i][j]);
l++;
}
for (j = 0; j < comps[i].size(); j++) used[comps[i][j]] = 0;
for (j = 0; j < order.size(); j++) {
if (!used[order[order.size() - 1 - j]]) {
dfs2(order[order.size() - 1 - j]);
r++;
}
}
if (comps[i].size() != r)
rez += comps[i].size();
else
rez += comps[i].size() - 1;
}
cout << rez << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long h, w;
cin >> w >> h;
if (w == 1) {
cout << 0 << endl;
return 0;
}
vector<long long> a(w);
for (int i = 0; i < w; i++) cin >> a[i];
sort(a.begin(), a.end(), greater<long long>());
long long res = 0, need = a[0];
for (int i = 0; i < w; i++) {
if (a[i] >= need)
res += max(a[i] - 1, (long long)0);
else {
res += max(a[i] - 1, (long long)0);
res -= need - a[i];
need = a[i];
}
need--;
}
if (need > 0) res -= need;
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[100010];
int lowbit(int x) { return x & ~(x - 1); }
int main() {
int sum, limit, cnt = 0;
scanf("%d%d", &sum, &limit);
for (int i = limit; i >= 1 && sum; i--) {
int j = lowbit(i);
if (j <= sum) {
sum -= j;
ans[cnt++] = i;
}
}
if (sum > 0)
printf("-1\n");
else {
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) printf("%d ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
multiset<long long> s;
int n, k;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
int a, b;
for (int i = 0; i < k; i++) s.insert(0);
for (int i = 0; i < n; i++) {
cin >> a >> b;
long long x = *s.begin();
x = max(x, 1ll * a) + b;
cout << x << endl;
s.erase(s.begin());
s.insert(x);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int s, d;
cin >> s >> d;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
if (a > s)
s = a;
else
s = int(ceil((double(s + 1) - a) / b)) * b + a;
cerr << s << " ";
}
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sparse_or[200000][20], sparse_max_pos[200000][20], h[200000];
long long result = 0;
void process_range(int l, int r) {
int lev = 0;
while ((1 << (lev + 1)) <= r - l + 1) {
lev++;
}
int mid;
{
int mpos1 = sparse_max_pos[l][lev];
int mpos2 = sparse_max_pos[r - (1 << lev) + 1][lev];
if (h[mpos1] > h[mpos2]) {
mid = mpos1;
} else {
mid = mpos2;
}
}
int left = mid, right = mid + 1;
for (int lev = 19; lev >= 0; lev--) {
if (left - (1 << lev) >= l - 1 &&
(sparse_or[left - (1 << lev) + 1][lev] | h[mid]) == h[mid]) {
left -= (1 << lev);
}
}
for (int lev = 19; lev >= 0; lev--) {
if (right + (1 << lev) <= r + 1 &&
(sparse_or[right][lev] | h[mid]) == h[mid]) {
right += 1 << lev;
}
}
result += 1LL * (mid + 1 - l) * (r + 1 - right);
result += 1LL * (left + 1 - l) * (r + 1 - mid);
result -= 1LL * (left + 1 - l) * (r + 1 - right);
if (l < mid) {
process_range(l, mid - 1);
}
if (mid < r) {
process_range(mid + 1, r);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
sparse_or[i][0] = h[i];
sparse_max_pos[i][0] = i;
}
for (int lev = 1; lev < 20; lev++) {
for (int i = 0; i < n; i++) {
sparse_or[i][lev] = sparse_or[i][lev - 1];
sparse_max_pos[i][lev] = sparse_max_pos[i][lev - 1];
if (i + (1 << (lev - 1)) < n) {
sparse_or[i][lev] |= sparse_or[i + (1 << (lev - 1))][lev - 1];
if (h[sparse_max_pos[i][lev]] <
h[sparse_max_pos[i + (1 << (lev - 1))][lev - 1]]) {
sparse_max_pos[i][lev] =
sparse_max_pos[i + (1 << (lev - 1))][lev - 1];
}
}
}
}
process_range(0, n - 1);
cout << result << '\n';
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.