solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void getio();
void solve() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long one = 0, to = 0;
if (a % 2)
one++;
else
to++;
if (b % 2)
one++;
else
to++;
if (c % 2)
one++;
else
to++;
if (d % 2)
one++;
else
to++;
if (one == 1)
cout << "Yes";
else {
if (to == 4)
cout << "Yes";
else if (a == 0 or b == 0 or c == 0)
cout << "No";
else if (a % 2 and b % 2 and c % 2)
cout << "Yes";
else if (one == 3 and d % 2 == 1)
cout << "Yes";
else
cout << "No";
}
cout << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
getio();
long long t;
cin >> t;
while (t--) solve();
}
void getio() {}
| 1 |
#include <bits/stdc++.h>
#pragma Gpref optimize("O3")
using namespace std;
const long long MOD = (long long)1e9 + 7;
const long long N = 1e5 + 5;
long long modmul(long long a, long long b) {
long long res = 0;
a %= MOD;
while (b) {
if (b & 1) res = (res + a) % MOD;
a = (a << 1) % MOD;
b >>= 1;
}
return res;
}
long long power(long long x, unsigned long long y) {
long long res = 1;
x = x % MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1;
x = (x * x) % MOD;
}
return res;
}
long long modexpo(long long a, long long b) {
long long res = 1;
a %= MOD;
while (b > 0) {
if (b % 2 == 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b /= 2;
}
return res % MOD;
}
long long nCr(long long n, long long r) {
long long res = 1;
if (r > n >> 1) r = n - r;
for (long long i = 0; i < r; i++) {
res = (res * (n - i)) % MOD;
res = (res * modexpo(i + 1, MOD - 2)) % MOD;
}
return res;
}
clock_t time_c = clock();
void nuttela() {
time_c = clock() - time_c;
cerr << " Time : " << (float)(time_c) / CLOCKS_PER_SEC << "\n";
}
long long n;
long long a[N];
bool vis[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n, k;
string s;
cin >> n >> k >> s;
set<long long> idx;
for (long long i = 0; i < n; i++) {
if (s[i] == '0') idx.insert(i);
}
long long cur = 0;
for (long long i = 0; i < n;) {
if (idx.find(i) == idx.end() && s[i] == '0') {
i++;
continue;
}
if (idx.size()) {
long long nxt = *idx.begin();
if (nxt - cur <= k) {
k -= (nxt - cur);
cout << 0;
idx.erase(nxt);
cur++;
} else {
cout << s[i];
i++;
cur++;
}
} else {
cout << s[i];
i++;
cur++;
}
}
cout << endl;
}
nuttela();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
string s;
while (cin >> n) {
cin >> s;
int cnt8 = 0;
for (int i = 0; i < n; i++)
if (s[i] == '8') cnt8++;
int n8 = n - cnt8;
int ans = min(n / 11, cnt8);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (m >= n && k >= n) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200005;
const long long inf = (1e18) + 10;
long long a[MAX_N], b[MAX_N];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n / 2; i++) {
scanf("%I64d", &b[i]);
}
int l = 0, r = n + 1;
a[0] = -inf;
a[n + 1] = inf;
for (int i = 1; i <= n / 2; i++) {
l++;
r--;
long long first = max(0LL, a[l - 1]);
long long second = b[i] - first;
if (second > inf) {
second = inf - 10LL;
}
second = min(second, a[r + 1]);
first = b[i] - second;
a[l] = first;
a[r] = second;
}
for (int i = 1; i <= n; i++) {
printf("%I64d ", a[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int cnt, b, n, a, gnt, des, m;
int Max, Min;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int Gr = 0, Ins = 0;
cin >> n >> a;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'G') Gr = i;
if (s[i] == 'T') Ins = i;
}
if (abs(Gr - Ins) % a != 0) {
cout << "NO";
return 0;
}
if (abs(Gr - Ins) % a == 0) {
if (Gr > Ins) {
for (int i = Gr; i >= Ins; i -= a) {
if (s[i] == '#') {
cout << "NO";
return 0;
}
}
cout << "YES";
}
if (Gr < Ins) {
for (int i = Gr; i <= Ins; i += a) {
if (s[i] == '#') {
cout << "NO";
return 0;
}
}
cout << "YES";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 50;
const int M = 5e3 + 50;
int n, m, u, k, l, r, t, x, y;
int cnt, cnt1, cnt2, ans;
int mn = INT_MAX;
int mx = INT_MIN;
const int fx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int fy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int MOD = (1ll << 30);
const int mod = 1e9 + 7;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (abs(a.second) == abs(b.second)) {
return abs(a.first) < abs(b.first);
}
return abs(a.second) < abs(b.second);
}
bool cmp1(const pair<string, pair<int, int>> &a,
const pair<string, pair<int, int>> &b) {
return abs(a.second.first) < abs(b.second.first);
}
bool isPowerOfTwo(long long n) { return (ceil(log2(n)) == floor(log2(n))); }
int makedigit(string n, int x) {
int res = 0;
for (int i = 0; i < x; i++) {
res = res * 10 + (n[i] - '0');
}
return res;
}
string inttostrng(int a) {
ostringstream temp;
string str;
temp << a;
return temp.str();
}
void clearr(int vis[N], int n) {
for (int i = 0; i < n; i++) {
vis[i] = 0;
}
}
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % m;
}
b /= 2;
a = (a * a) % m;
}
return ans;
}
bool is_prime[N];
void prime() {
is_prime[0] = is_prime[1] = true;
for (int i = 2; i * i <= N; i++) {
if (is_prime[i] == false) {
for (int j = i * i; j <= N; j += i) {
is_prime[j] = true;
}
}
}
}
bool is_palidrome(string second) {
for (int i = 0; i < second.size() / 2; i++) {
if (second[i] != second[second.size() - i - 1]) {
return false;
}
}
return true;
}
long long sum(long long x) {
if (x < 0) {
return -1;
}
long long second = 0;
while (x) {
int rem = x % 10;
second += rem;
x /= 10;
}
return second;
}
long long poww(long long x, long long y) {
long long pw = 1;
for (int i = 1; i <= y; i++) {
pw *= x;
}
return pw;
}
long long pp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a);
}
b >>= 1;
a = (a * a);
}
return ans;
}
void dfs(int x, int y, char c[200][200], int n) {
if (x <= 0 or x > 2 or y <= 0 or y > n) {
return;
}
if (c[x][y] == '1' or c[x][y] == '.') {
return;
}
if (c[x][y] == '0') {
c[x][y] = '.';
}
dfs(x, y + 1, c, n);
dfs(x + 1, y, c, n);
dfs(x + 1, y + 1, c, n);
dfs(x - 1, y, c, n);
dfs(x - 1, y + 1, c, n);
dfs(x, y + 1, c, n);
}
int getPairsCount(int arr[], int n, int diff) {
int ret = 0;
map<int, int> m;
for (int i = 1; i <= n; i++) {
if (m.find(diff - arr[i]) != m.end()) {
ret += m[diff - arr[i]];
}
m[arr[i]]++;
}
return ret;
}
bool chk(int n) {
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) return false;
}
if (n == 1) return false;
return true;
}
void solve() {
cin >> n >> l >> r;
vector<int> v(n);
if (abs(l - r) > 1) {
cout << -1 << "\n";
return;
} else if ((l + r) > n - 2) {
cout << -1 << "\n";
return;
}
if (l == 0 and r == 0) {
for (int i = 0; i < n; i++) {
v[i] = i + 1;
}
} else if (l == r) {
int second = 1, e = n, a = l, b = r;
for (int i = 0; i < n; i++) {
if (b == 0) {
v[i] = e;
e--;
continue;
}
if (i % 2 == 1) {
v[i] = second;
second++;
} else {
v[i] = e;
e--;
}
if (i > 1 and i < n - 1 and b != 0) {
if (v[i - 1] < v[i] and v[i - 1] < v[i - 2]) {
b--;
}
}
}
} else if (l > r and r != 0) {
int second = 1, e = n, a = l, b = r;
for (int i = 0; i < n; i++) {
if (b == 0) {
v[i] = e;
e--;
continue;
}
if (i % 2 == 0) {
v[i] = second;
second++;
} else {
v[i] = e;
e--;
}
if (i > 1 and i < n - 1 and b != 0) {
if (v[i - 1] > v[i] and v[i - 1] > v[i - 2]) {
a--;
}
if (v[i - 1] < v[i] and v[i - 1] < v[i - 2]) {
b--;
}
}
}
} else if (l > r and r == 0) {
for (int i = 0; i < n; i++) {
v[i] = i + 1;
}
swap(v[n - 1], v[n - 2]);
} else if (l < r and l != 0) {
int second = 1, e = n, a = l, b = r;
for (int i = 0; i < n; i++) {
if (a == 0) {
v[i] = second;
second++;
continue;
}
if (i % 2 == 1) {
v[i] = second;
second++;
} else {
v[i] = e;
e--;
}
if (i > 1 and i < n - 1 and a != 0) {
if (v[i - 1] > v[i] and v[i - 1] > v[i - 2]) {
a--;
}
if (v[i - 1] < v[i] and v[i - 1] < v[i - 2]) {
b--;
}
}
}
} else if (l < r and l == 0) {
for (int i = 0; i < n; i++) {
v[i] = i + 1;
}
swap(v[0], v[1]);
}
int a = 0, b = 0;
for (int i = 1; i < n - 1; i++) {
if (v[i - 1] < v[i] and v[i] > v[i + 1]) {
a++;
}
if (v[i - 1] > v[i] and v[i] < v[i + 1]) {
b++;
}
}
if (a != l or b != r) {
cout << -1 << "\n";
} else {
for (int i = 0; i < n; i++) {
cout << v[i] << " ";
}
cout << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s1[105], s2[105], s3[105], s4[105];
struct ab {
string a;
string b;
} ans[105];
int an, a3, a4;
int cmp(const void *x, const void *y) {
ab xx = *(ab *)x;
ab yy = *(ab *)y;
if (xx.a > yy.a) return 1;
if (xx.a < yy.a) return -1;
if (xx.b > yy.b) return 1;
if (xx.b < yy.b) return -1;
return 0;
}
int main() {
int i, j, n;
while (scanf("%d", &n) != EOF) {
an = 0;
a3 = a4 = 0;
for (i = 0; i < n; i++) cin >> s1[i];
sort(s1, s1 + n);
for (i = 0; i < n; i++) cin >> s2[i];
sort(s2, s2 + n);
for (i = 0, j = 0; i < n && j < n;) {
if (s1[i][0] == s2[j][0]) {
ans[an].a = s1[i];
ans[an].b = s2[j];
an++;
i++;
j++;
} else {
if (s1[i][0] < s2[j][0]) {
s3[a3++] = s1[i];
i++;
} else {
s4[a4++] = s2[j];
j++;
}
}
}
while (i < n) {
s3[a3++] = s1[i++];
}
while (j < n) {
s4[a4++] = s2[j++];
}
for (i = 0, j = 0; i < a3 && j < a4; i++, j++) {
ans[an].a = s3[i];
ans[an].b = s4[j];
an++;
}
qsort(ans, an, sizeof(ans[0]), cmp);
for (i = 0; i < an; i++) {
for (j = i + 1; j < an; j++) {
if (ans[i].b[0] == ans[j].a[0] && ans[j].a[0] == ans[j].b[0]) {
if (ans[j].b < ans[i].b) {
string tt = ans[i].b;
ans[i].b = ans[j].b;
ans[j].b = tt;
}
}
if (ans[i].a[0] == ans[i].b[0] && ans[i].a[0] == ans[j].a[0]) {
if (ans[i].b > ans[j].b) {
string tt = ans[i].b;
ans[i].b = ans[j].b;
ans[j].b = tt;
}
}
}
}
for (i = 0; i < an - 1; i++) {
cout << ans[i].a << " " << ans[i].b << ", ";
}
cout << ans[i].a << " " << ans[i].b << endl;
}
}
| 6 |
#include <bits/stdc++.h>
const long long mxn = 1e6 + 7;
const long long mod = 1e9 + 9;
const long long inf = 1e18 + 9;
using namespace std;
vector<long long> v;
long long l, r, sum = 0;
void gen(long long x) {
if (x >= 10000000000) return;
v.push_back(x);
gen(x * 10 + 4);
gen(x * 10 + 7);
return;
}
int main() {
gen(4);
gen(7);
cin >> l >> r;
sort(v.begin(), v.end());
for (int i = l; i <= r; i++) {
long long x = *lower_bound(v.begin(), v.end(), i);
sum += x;
long long dist = min(x, r) - i;
sum += (dist * x);
i += dist;
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma loop_opt(on)
using namespace std;
template <class T>
using vec = vector<T>;
template <class T>
using stack = stack<T, vec<T> >;
template <class T>
using MaxHeap = priority_queue<T, vec<T>, less<T> >;
template <class T>
using MinHeap = priority_queue<T, vec<T>, greater<T> >;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string in, str;
int n, idx = 0, candy = 0, snow = 0, l, r, len, a, b, c;
cin >> str >> n;
for (auto &i : str) {
if (i == '?') candy++;
if (i == '*') snow++;
if (i != '*' && i != '?') in += i;
}
if ((int)in.size() == n) {
cout << in << '\n';
return 0;
}
len = (int)str.size() - candy - snow;
l = len - candy - snow;
r = (snow ? 1e9 : len);
if (n < l || r < n) {
cout << "Impossible\n";
return 0;
}
while (a < candy && len > n) a++, len--;
while (b < snow && len > n) b++, len--;
if (len < n) c = 1;
for (int i = 0; i < (int)str.size(); i++) {
if (str[i] == '?' || str[i] == '*') continue;
if (i == (int)str.size() - 1) {
cout << str[i] << '\n';
break;
}
char cc = str[i], oc = str[i + 1];
if (oc == '?') {
if (a)
a--;
else
cout << cc;
} else if (oc == '*') {
if (b)
b--;
else
cout << cc;
if (c) {
while (len < n) {
cout << cc;
len++;
}
}
} else
cout << cc;
}
}
| 2 |
#include<algorithm>
#include<iostream>
#include<vector>
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr int MAXN = 2e5;
int powMOD(int a, int b) {
if (b == 1) {
return a;
}
else if(b % 2 == 0) {
int t = powMOD(a, b / 2);
return 1LL * t * t % MOD;
}
else {
return 1LL * a * powMOD(a, b - 1) % MOD;
}
}
inline int C(int n, int k, const vector<int>& fact, const vector<int>& invfact) {
return (k == 0 ? 1 : 1LL * fact[n] * invfact[n - k] % MOD * invfact[k] % MOD);
}
void solve(const vector<int>& fact, const vector<int>& invfact) {
int n, l, r;
cin >> n >> l >> r;
int res = 0;
int start = min(r - n, 1 - l);
if (n % 2 == 0) {
res += 1LL * start * C(n, n / 2, fact, invfact) % MOD;
}
else {
res += 1LL * start * (1LL * C(n, n / 2, fact, invfact) + C(n, n / 2 + 1, fact, invfact)) % MOD;
}
for (int k = 1 + start; ; ++k) {
int forced_left = max(0, l + k - 1);
int forced_right = max(0, k - (r - n));
int free = n - forced_left - forced_right;
if (free < 0) {
break;
}
else if (free == 0) {
if (forced_left == n / 2 || forced_right == n / 2) {
res += 1;
}
}
else {
if (n % 2 == 0) {
if(free >= n / 2 - forced_left && n / 2 - forced_left >= 0)
res = (1LL * res + C(free, n / 2 - forced_left, fact, invfact)) % MOD;
}
else {
if (free >= n / 2 - forced_left && n / 2 - forced_left >= 0)
res = (1LL * res + C(free, n / 2 - forced_left, fact, invfact)) % MOD;
if (free >= n / 2 - forced_left + 1 && n / 2 - forced_left + 1 >= 0)
res = (1LL * res + C(free, n / 2 - forced_left + 1, fact, invfact)) % MOD;
}
}
}
cout << res % MOD << "\n";
}
int main()
{
vector<int> fact(MAXN + 1, 1);
vector<int> invfact(MAXN + 1, 1);
for (int i = 1; i <= MAXN; ++i) {
fact[i] = 1LL * fact[i - 1] * i % MOD;
invfact[i] = powMOD(fact[i], MOD - 2);
}
int tt;
cin >> tt;
for (int i = 0; i < tt; ++i) {
solve(fact, invfact);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int n, m, y[200011], p[200011], id;
int v[200011];
struct sgt {
int sum[800011];
void clear(int k, int l, int r) {
sum[k] = r - l + 1;
if (l == r) return;
int mid = (l + r) >> 1;
clear(k << 1, l, mid);
clear(k << 1 | 1, mid + 1, r);
}
void modify(int k, int l, int r, int w, int num) {
if (l == r) {
sum[k] = num;
return;
}
int mid = (l + r) >> 1;
if (w <= mid)
modify(k << 1, l, mid, w, num);
else
modify(k << 1 | 1, mid + 1, r, w, num);
sum[k] = sum[k << 1] + sum[k << 1 | 1];
}
int find(int k, int l, int r, int rk) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (mid - l + 1 - sum[k << 1] >= rk)
return find(k << 1, l, mid, rk);
else
return find(k << 1 | 1, mid + 1, r, rk - (mid - l + 1 - sum[k << 1]));
}
} t;
long long inp[400011];
long long pw(long long s1, long long s2) {
if (!s2) return 1;
if (s2 % 2) return s1 * pw(s1, s2 - 1) % mod;
long long ret = pw(s1, s2 / 2);
return ret * ret % mod;
}
void solve() {
id++;
int c = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &y[i], &y[i]);
for (int i = m; i >= 1; i--) {
int l = t.find(1, 1, n, y[i]), r = t.find(1, 1, n, y[i] + 1);
if (v[r] != id) c++;
v[r] = id;
t.modify(1, 1, n, l, 1);
p[i] = l;
}
for (int i = 1; i <= m; i++) t.modify(1, 1, n, p[i], 0);
cout << inp[2 * n - 1 - c] * pw(inp[n], mod - 2) % mod *
pw(inp[n - 1 - c], mod - 2) % mod
<< endl;
}
int main() {
inp[0] = 1;
for (int i = 1; i <= 400000; i++) inp[i] = inp[i - 1] * i % mod;
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, a[N + 1], segTree[4 * N][60];
void build_tree(int v, int l, int r) {
if (l == r) {
for (int Time = 0; Time < 60; Time++) {
if (Time % a[r] == 0) {
segTree[v][Time] = 2;
} else
segTree[v][Time] = 1;
}
return;
}
int mid = (l + r) >> 1;
build_tree(2 * v, l, mid);
build_tree(2 * v + 1, mid + 1, r);
for (int Time = 0; Time < 60; Time++) {
segTree[v][Time] = segTree[2 * v][Time] +
segTree[2 * v + 1][(Time + segTree[2 * v][Time]) % 60];
}
}
void update(int v, int l, int r, int idx, int upd) {
if (l > r) return;
if (l == r && r == idx) {
for (int Time = 0; Time < 60; Time++) {
if (Time % upd == 0) {
segTree[v][Time] = 2;
} else
segTree[v][Time] = 1;
}
return;
}
int mid = (l + r) >> 1;
if (idx <= mid)
update(2 * v, l, mid, idx, upd);
else
update(2 * v + 1, mid + 1, r, idx, upd);
for (int Time = 0; Time < 60; Time++) {
segTree[v][Time] = segTree[2 * v][Time] +
segTree[2 * v + 1][(Time + segTree[2 * v][Time]) % 60];
}
}
int query(int v, int tOffset, int l, int r, int start, int end) {
if (l > r || l > end || r < start) {
return 0;
}
if (l >= start && r <= end) {
return segTree[v][tOffset];
}
int mid = (l + r) >> 1;
int leftTime = query(2 * v, tOffset, l, mid, start, min(mid, end));
int rightTime = query(2 * v + 1, (tOffset + leftTime) % 60, mid + 1, r,
max(start, mid + 1), end);
return leftTime + rightTime;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
build_tree(1, 0, n - 1);
int q;
scanf("%d", &q);
for (int ii = 0; ii < q; ii++) {
char c;
int x, y;
scanf(" %c %d %d", &c, &x, &y);
if (c == 'A') {
x--;
y -= 2;
printf("%d\n", query(1, 0, 0, n - 1, x, y));
} else {
x--;
update(1, 0, n - 1, x, y);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
const int M = 1e6 + 9;
const long long INF = 1e9 + 7;
const int SM = 1e3 + 5;
const double EPS = 3e-16;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> d;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (find(d.begin(), d.end(), x) != d.end()) {
continue;
}
if (int(d.size()) == k) {
d.pop_back();
}
d.insert(d.begin(), x);
}
cout << int(d.size()) << "\n";
for (auto it : d) cout << it << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
const int inf = 1034567891;
const long long LL_INF = 1234567890123456789ll;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T>
T GCD(T a, T b) {
long long t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
string toString(T a) {
return to_string(a);
}
template <typename T>
void toInt(string s, T& x) {
stringstream str(s);
str >> x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, long long b) {
int x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
const int N = 1e3 + 5;
vector<int> adj[N];
int ww[N], bb[N];
vector<int> frnd[N];
bool vis[N];
int par[N];
int cur = 0, tw = 0, tb = 0;
int setW[N], setB[N], w;
void dfs(int s) {
vis[s] = true;
frnd[cur].push_back(s);
tw += ww[s];
tb += bb[s];
for (auto it : adj[s]) {
if (!vis[it]) {
dfs(it);
}
}
}
int dp[N][N];
int fun(int ind, int curw) {
if (curw > w) {
return -inf;
}
if (ind == cur) {
return 0;
}
if (dp[ind][curw] != -1) return dp[ind][curw];
int ans = fun(ind + 1, curw);
ans = max(ans, setB[ind] + fun(ind + 1, curw + setW[ind]));
for (auto it : frnd[ind]) {
ans = max(ans, bb[it] + fun(ind + 1, curw + ww[it]));
}
return dp[ind][curw] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m >> w;
for (int i = 1; i <= n; i++) {
cin >> ww[i];
}
for (int i = 1; i <= n; i++) {
cin >> bb[i];
}
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cur++;
tw = tb = 0;
dfs(i);
setW[cur] = tw;
setB[cur] = tb;
}
}
cur++;
memset(dp, -1, sizeof(dp));
int ans = fun(1, 0);
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, sum, cnt, ans, a[100005], b[100005];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + m);
reverse(a, a + n);
reverse(b, b + m);
if (n > m) {
printf("YES\n");
return 0;
}
for (int i = 0; i < n; i++)
if (a[i] > b[i]) return 0 * printf("YES\n");
return 0 * printf("NO\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
vector<int> arr(3);
cin >> arr[0] >> arr[1] >> arr[2];
sort(arr.begin(), arr.end());
if (arr[0] + arr[1] == arr[2]) {
cout << "YES" << endl;
return;
} else {
if (arr[0] == arr[1] && arr[2] % 2 == 0) {
cout << "YES" << endl;
return;
} else if (arr[1] == arr[2] && arr[0] % 2 == 0) {
cout << "YES" << endl;
return;
}
}
cout << "NO" << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, c = 0, k, u, d;
cin >> a >> b;
while (1) {
if (b > a) swap(a, b);
k = a / b;
c = c + k;
u = a % b;
a = b;
b = u;
a = a - b;
if (min(a, b) <= 0) break;
c++;
}
cout << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long large = 2000000000000000000LL;
int main() {
int n, k;
cin >> n >> k;
int z = (n - k) / 2;
int t = z;
while (n--) {
if (t) {
cout << 0;
t--;
} else {
cout << 1;
t--;
}
if (t < 0) t = z;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
int n, m;
char c[200004];
int cnt[23][26];
int mn[26], f[8400000];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", c), m = strlen(c);
for (int j = 0; j < m; j++) cnt[i][c[j] - 'a']++;
}
for (int i = 1; i < (1 << n); i++) {
for (int j = 0; j < 26; j++) mn[j] = 1e9;
for (int j = 0; j < n; j++)
if (i >> j & 1)
for (int k = 0; k < 26; k++) mn[k] = min(mn[k], cnt[j][k]);
f[i] = __builtin_parity(i) ? 1 : M - 1;
for (int j = 0; j < 26; j++) f[i] = (long long)f[i] * (mn[j] + 1) % M;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < (1 << n); j++)
if (j >> i & 1) (f[j] += f[j ^ (1 << i)]) %= M;
for (int i = 1; i < (1 << n); i++) {
int tmp = 0;
for (int j = 0; j < n; j++)
if (i >> j & 1) tmp += j + 1;
tmp *= __builtin_popcount(i);
ans ^= (long long)tmp * f[i];
}
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2002;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
int n, m, deg[N][N];
bool fail;
bool used[N][N];
char a[N][N], b[N][N];
queue<pair<int, int> > q;
bool valid(int x, int y) {
return x >= 1 && x <= n && y >= 1 && y <= m && used[x][y] == 0;
}
void add(int x, int y, int nx, int ny) {
used[nx][ny] = 1;
for (int it = 0; it < 4; it++) {
int xx = nx + dx[it];
int yy = ny + dy[it];
if (valid(xx, yy)) {
deg[xx][yy]--;
if (deg[xx][yy] == 1) q.push(make_pair(xx, yy));
}
}
if (nx == x) {
if (y > ny) swap(y, ny);
b[x][y] = '<';
b[x][ny] = '>';
} else {
if (x > nx) swap(x, nx);
b[x][y] = '^';
b[nx][y] = 'v';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '*') used[i][j] = 1, b[i][j] = '*';
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (used[i][j]) continue;
for (int it = 0; it < 4; it++) {
int nx = i + dx[it], ny = j + dy[it];
if (valid(nx, ny)) deg[nx][ny]++;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (deg[i][j] == 1) q.push(make_pair(i, j));
while (q.size()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
if (used[x][y]) continue;
used[x][y] = 1;
bool fail = 1;
for (int it = 0; it < 4; it++) {
int nx = x + dx[it];
int ny = y + dy[it];
if (valid(nx, ny)) {
fail = 0;
add(x, y, nx, ny);
break;
}
}
if (fail) {
used[x][y] = 0;
break;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!used[i][j]) fail = 1;
if (fail)
puts("Not unique");
else
for (int i = 1; i <= n; i++, cout << endl)
for (int j = 1; j <= m; j++) cout << b[i][j];
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int x1, y1, x2, y2, x3, y3;
scanf("%d %d %d %d %d %d", &x1, &y1, &x2, &y2, &x3, &y3);
printf("3\n%d %d\n%d %d\n%d %d", x2 + x3 - x1, y2 + y3 - y1, x1 + x3 - x2,
y1 + y3 - y2, x1 + x2 - x3, y1 + y2 - y3);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool tri(int a, int b, int c) {
if (a + b > c && a + c > b && b + c > a)
return true;
else
return false;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
if (tri(a[0], a[1], a[2])) {
cout << "YES";
return 0;
}
for (int i = n - 1; i > 1; i--) {
for (int u = i - 1; u > 0; u--) {
for (int y = u - 1; y >= 0; y--) {
if (tri(a[i], a[u], a[y])) {
cout << "YES";
return 0;
}
}
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-8;
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 * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
for (cin >> t; t; t--) {
int p, f, cnts, cntw, s, w;
cin >> p >> f >> cnts >> cntw >> s >> w;
int ans = 0, tmp, cs1, cw1, cs2, cw2, res1, res2, tp, tf;
for (int i = 0; i <= cnts && s * i <= p; i++) {
cs1 = cnts - i, tp = p - i * s, res1 = i;
tmp = min(tp / w, cntw);
cw1 = cntw - tmp;
res1 += tmp;
cs2 = cs1, cw2 = cw1, tf = f, res2 = 0;
tmp = min(tf / s, cs2);
cs2 -= tmp, tf -= tmp * s;
res2 += tmp;
tmp = min(tf / w, cw2);
cw2 -= tmp, tf -= tmp * w;
res2 += tmp;
ans = max(ans, res1 + res2);
cs2 = cs1, cw2 = cw1, tf = f, res2 = 0;
tmp = min(tf / w, cw2);
cw2 -= tmp, tf -= tmp * w;
res2 += tmp;
tmp = min(tf / s, cs2);
cs2 -= tmp, tf -= tmp * s;
res2 += tmp;
ans = max(ans, res1 + res2);
}
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
const int M = 1000005;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long fact(long long n) {
long long ret = 1;
for (int i = 1; i <= n; i++) ret *= i;
return ret;
}
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
return 0;
}
int n, arr[N], tmp[N];
vector<int> save;
void shift(int x) {
if (x == 0) return;
save.push_back(x);
for (int i = 0; i < x; ++i) {
tmp[i] = arr[n - x + i];
}
for (int i = n - x - 1; i >= 0; --i) {
arr[i + x] = arr[i];
}
for (int i = 0; i < x; ++i) {
arr[i] = tmp[x - i - 1];
}
}
int main() {
string a, b;
cin >> n >> a >> b;
string c = a, d = b;
sort(c.begin(), c.end());
sort(d.begin(), d.end());
if (c != d) {
cout << -1;
return 0;
}
memset(arr, -1, sizeof(arr));
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
if (a[i] == b[j] && arr[i] == -1) {
arr[i] = j;
break;
}
}
}
int high = (n) / 2;
int low = high - 1;
int e = 0;
bool is = 1;
while (low >= 0 || high < n) {
int to;
if (is) {
to = high;
high++;
} else {
to = low;
low--;
}
is = !is;
for (int j = 0; j < n; j++) {
if (arr[j] == to) {
shift(n - j - 1);
shift(j - e + 1);
shift(e);
e++;
break;
}
}
}
if (is) shift(n);
cout << save.size() << endl;
for (int i = 0; i < save.size(); i++) printf("%d ", save[i]);
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int N, M;
double e[1000][1000];
int main() {
scanf("%d%d", &N, &M);
int x, y;
scanf("%d%d", &x, &y);
if (x == N) {
printf("%.5f\n", 0.0);
return 0;
}
int loop_max = 100000000 / M / (N - x);
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(M); j++) e[i][j] = 0.0;
for (int i = N - 2; i >= x - 1; i--) {
for (int q = 0; q < (int)(loop_max); q++) {
for (int j = 0; j < (int)(M); j++) {
double s = 0.0;
int c = 0;
s += e[i][j] + 1;
c++;
s += e[i + 1][j] + 1;
c++;
if (j > 0) {
s += e[i][j - 1] + 1;
c++;
}
if (j < M - 1) {
s += e[i][j + 1] + 1;
c++;
}
e[i][j] = s / c;
}
}
}
printf("%.5f\n", e[x - 1][y - 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int n, m, k;
int spe[N];
vector<int> adj[N];
vector<int> comp[N];
int vis[N];
void dfs(int u, int num) {
vis[u] = 1;
comp[num].push_back(u);
for (auto v : adj[u]) {
if (!vis[v]) dfs(v, num);
}
}
long long C2(int x) { return (x * (x - 1)) / 2; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
spe[x] = 1;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int number_comp = 0;
long long ans = 0;
long long not_special = 0;
int maxx_special_size = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, number_comp);
int sp = 0;
for (auto j : comp[number_comp]) {
if (spe[j]) sp = 1;
}
if (sp == 0)
not_special += comp[number_comp].size();
else {
ans += C2(comp[number_comp].size());
maxx_special_size =
max(maxx_special_size, (int)comp[number_comp].size());
}
number_comp++;
}
}
ans += C2(not_special);
ans += (maxx_special_size * not_special);
ans -= m;
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
bool operator<(const Point &p) const { return x < p.x; }
} a[100001];
struct Q {
int l, r, y, type, rl, rr;
bool operator<(const Q &x) const { return y < x.y; }
} q[100001 << 1];
vector<int> tt;
int K, n;
long long ans[100001];
int main() {
scanf("%d%d", &n, &K);
int i, cnt = 0, j, tot = 0;
for (i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
int st =
(!tt.empty()) ? max(tt.back() + 1, a[i].x - K + 1) : a[i].x - K + 1;
for (j = st; j <= a[i].x; j++) tt.push_back(j);
}
for (i = 1; i <= n; i++) {
q[++tot].rl = a[i].x - K + 1;
q[tot].rr = a[i].x;
q[tot].y = a[i].y - K + 1;
q[tot].type = 1;
q[++tot].rl = a[i].x - K + 1;
q[tot].rr = a[i].x;
q[tot].y = a[i].y + 1;
q[tot].type = -1;
}
for (i = 1; i <= tot; i++) {
q[i].l = lower_bound(tt.begin(), tt.end(), q[i].rl) - tt.begin();
q[i].r = upper_bound(tt.begin(), tt.end(), q[i].rr) - tt.begin();
}
cnt = tt.size();
tt.clear();
tt.shrink_to_fit();
sort(q + 1, q + tot + 1);
vector<int> sum(cnt, 0);
vector<int> lst(cnt, 0x3f3f3f3f);
for (i = 1; i <= tot; i++) {
int l = q[i].l, r = q[i].r;
for (j = l; j < r; j++) {
if (lst[j] != 0x3f3f3f3f) {
ans[sum[j]] += q[i].y - lst[j];
}
sum[j] += q[i].type;
lst[j] = q[i].y;
}
}
for (i = 1; i <= n; i++) printf("%lld ", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
int count(int n) {
int i, count = 0;
for (i = 1; n != 0; i++) {
if (n % 2 == 1) count++;
n /= 2;
}
return count;
}
int main() {
int i, n, m, k, x, cnt = 0;
scanf("%d %d %d", &n, &m, &k);
int ara[m + 1];
for (i = 0; i < m + 1; i++) {
scanf("%d", &ara[i]);
}
for (i = 0; i < m; i++) {
x = ara[m] ^ ara[i];
if (count(x) <= k) cnt++;
}
printf("%d", cnt);
return 0;
}
| 1 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define sz(a) a.size()
#define all(a) a.begin(),a.end()
#define lb lower_bound
#define ub upper_bound
#define owo ios_base::sync_with_stdio(0);cin.tie(0);
#define MOD (ll)(998244353)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__),fflush(stderr)
#define time__(d) for(long blockTime = 0; (blockTime == 0 ? (blockTime=clock()) != 0 : false);\
debug("%s time : %.4fs\n", d, (double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> PII;
typedef pair<int,int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
ll gcd(ll a,ll b){if(!b)return a;else return gcd(b,a%b);}
vector<ll> fact;
vector<ll> ifact;
ll add(ll a,ll b)
{
a+=b;
while(a>=MOD) a-=MOD;
return a;
}
ll mult(ll a,ll b)
{
return (a*1LL*b)%MOD;
}
ll binpow(ll a, ll b)
{
ll r=1;
while(b)
{
if(b&1) r=mult(r,a);
a=mult(a,a);
b>>=1;
}
return r;
}
ll choose(ll a, ll b)
{
if(a<b) return 0;
if(b==0) return 1;
if(a==b) return 1;
ll r = mult(ifact[b],ifact[a-b]);
r = mult(r,fact[a]);
return r;
}
ll permute(ll a,ll b){
ll res = mult(fact[a],ifact[a-b]);
return res;
}
ll inv(int a){return binpow(a,MOD-2);}
void init(ll n)
{
fact.clear(); ifact.clear();
fact.resize(n+1);
ifact.resize(n+1);
ifact[0]=1;
fact[0]=1;
for(int i=1;i<=n;i++){fact[i]=mult(fact[i-1],i);}
ifact[n] = inv(fact[n]);
for(int i=n-1;i>=1;i--)
{
ifact[i] = mult(ifact[i + 1], i + 1);
}
}
int main()
{
int n;
cin>>n;
VII dp(4,vector<ll>(n+1));
dp[0][0] = 1;
for(int i=1;i<=n;i++){
ll x = (1 + dp[1][i-1] + dp[2][i-1])%MOD;
dp[3][i] = mult(mult(x+1,x+2),x) * inv(6) %MOD;
dp[2][i] = mult(mult(x+1,x),inv(2));
dp[1][i] = x;
}
ll ans = (dp[1][n] + dp[2][n] + dp[3][n] - dp[1][n-1] - dp[2][n-1] - dp[3][n-1])*2 - 1;
vector<ll>rdp(n+1);
for(int i=1;i<=n;i++)rdp[i] = (dp[2][i]-dp[2][i-1]+MOD )%MOD;
vector<ll>pref(n+1);
for(int i=1;i<=n;i++)pref[i] = (rdp[i]+pref[i-1]) %MOD;
for(int i=1;i<n;i++){
int r = n-i-1;
ans+=rdp[i] * pref[r]%MOD;
ans%=MOD;
}
cout<<(ans)%MOD;;
}
| 10 |
#include <bits/stdc++.h>
using std::abs;
using std::array;
using std::cerr;
using std::cin;
using std::cout;
using std::generate;
using std::make_pair;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::pair;
using std::reverse;
using std::set;
using std::sort;
using std::string;
using std::unique;
using std::vector;
template <typename T>
T input() {
T res;
cin >> res;
{};
return res;
}
template <typename IT>
void input_seq(IT b, IT e) {
std::generate(b, e,
input<typename std::remove_reference<decltype(*b)>::type>);
}
void dfs(const vector<vector<int>>& graph, vector<int>& par, vector<char>& mark,
vector<int>& blad, int v, int p) {
par[v] = p;
mark[v] = 1;
for (int u : graph[v])
if (mark[u] == 0) {
dfs(graph, par, mark, blad, u, v);
} else if (u != p and mark[u] == 1) {
int lo = u;
int hi = u;
for (int i = v; i != u; i = par[i]) {
lo = min(lo, i);
hi = max(hi, i);
}
blad[lo] = min(blad[lo], hi);
}
mark[v] = 2;
}
vector<int> tree[4 * (300 * 1000)];
vector<int64_t> sums[4 * (300 * 1000)];
void build_blad(int no, int nl, int nr, vector<int>& blad) {
tree[no].resize(nr - nl);
if (nr - nl == 1)
tree[no][0] = blad[nl];
else {
int mi = nl + (nr - nl) / 2;
build_blad(2 * no + 1, nl, mi, blad);
build_blad(2 * no + 2, mi, nr, blad);
std::merge(tree[2 * no + 1].begin(), tree[2 * no + 1].end(),
tree[2 * no + 2].begin(), tree[2 * no + 2].end(),
tree[no].begin());
}
sums[no].resize(nr - nl + 1);
for (int i = 0; i != nr - nl; ++i)
sums[no][i + 1] = sums[no][i] + tree[no][i];
}
int64_t req(int no, int nl, int nr, int l, int r, int lim) {
if (nr <= l or r <= nl) return 0;
if (l <= nl and nr <= r) {
int ptr = std::upper_bound(tree[no].begin(), tree[no].end(), lim) -
tree[no].begin();
return (nr - nl - ptr) * int64_t(lim) + sums[no][ptr];
}
int mi = nl + (nr - nl) / 2;
return req(2 * no + 1, nl, mi, l, r, lim) +
req(2 * no + 2, mi, nr, l, r, lim);
}
int main() {
std::iostream::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n = input<int>();
int m = input<int>();
vector<vector<int>> graph(n);
for (int i = 0; i != m; ++i) {
int v = input<int>() - 1;
int u = input<int>() - 1;
graph[v].push_back(u);
graph[u].push_back(v);
}
vector<int> par(n, -1);
vector<char> mark(n, 0);
vector<int> blad(n, std::numeric_limits<int>::max());
for (int i = 0; i != n; ++i)
if (mark[i] == 0) dfs(graph, par, mark, blad, i, -1);
for (int i = n - 2; i >= 0; --i) blad[i] = min(blad[i], blad[i + 1]);
for (int i = 0; i != n; ++i) --blad[i];
build_blad(0, 0, n, blad);
for (int q = input<int>(); q != 0; --q) {
int v = input<int>() - 1;
int u = input<int>() - 1;
int64_t ans = (u - v + 1) - (u - v + 1) * int64_t(u + v) / 2;
ans += req(0, 0, n, v, u + 1, u);
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int rev(int a) {
int res = 0;
for (int i = 0; i < 8; i++) {
res = res * 2 + a % 2;
a /= 2;
}
return res;
}
int main() {
string str;
getline(cin, str);
int old = 0;
for (int i = 0; i < str.size(); i++) {
for (int j = 0; j < 256; j++) {
int k = (old - j + 256) % 256;
if (rev(k) == str[i]) {
cout << j << endl;
old = k;
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 8;
const int INF = (int)1e+9;
int a[MAXN][MAXN];
int n, k;
int p[MAXN];
int ans;
int main() {
scanf("%d %d\n", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
char c;
scanf("%c", &c);
a[i][j] = c - '0';
}
scanf("\n");
}
for (int i = 0; i < k; i++) p[i] = i;
ans = INF;
do {
int mi = INF, ma = -INF;
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < k; j++) (x *= 10) += a[i][p[j]];
ma = max(ma, x);
mi = min(mi, x);
}
ans = min(ans, ma - mi);
} while (next_permutation(p, p + k));
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, ans = 0;
cin >> n >> s;
--s;
vector<int> a(n), b(n), o(n), f(n);
vector<vector<int>> bin(n + 1);
for (int i = 0; i < n; ++i) cin >> a[i], b[i] = a[i];
for (int i = 0; i < n; ++i)
if (!a[i]) a[i] = n;
if (a[s]) a[s] = 0;
for (int i = 0; i < n; ++i) bin[a[i]].push_back(i), o[a[i]] = 1;
int r = n;
while (bin[r].empty()) --r;
for (int i = 1; i < r; ++i) {
if (o[i]) continue;
int now = bin[r].back();
bin[r].pop_back();
a[now] = i;
while (bin[r].empty()) --r;
}
for (int i = 0; i < n; ++i) ans += a[i] != b[i];
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const int maxn = 100000 + 10;
char t(char c) {
if (c == 'L') return 'U';
if (c == 'U') return 'L';
if (c == 'R') return 'D';
if (c == 'D') return 'R';
}
vector<string> transpose(vector<string> A) {
int n = (int)A.size(), m = (int)A[0].length();
string s = "";
for (int i = 0; i < n; ++i) s += '0';
vector<string> T(m, s);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
T[j][i] = t(A[i][j]);
}
return T;
}
void apply(vector<string> &A, pair<int, int> p) {
if (A[p.first][p.second] == 'U') {
A[p.first][p.second] = 'L';
A[p.first + 1][p.second] = 'L';
A[p.first][p.second + 1] = 'R';
A[p.first + 1][p.second + 1] = 'R';
} else {
A[p.first][p.second] = 'U';
A[p.first][p.second + 1] = 'U';
A[p.first + 1][p.second] = 'D';
A[p.first + 1][p.second + 1] = 'D';
}
}
vector<pair<int, int> > solve(vector<string> &A) {
int n = (int)A.size(), m = (int)A[0].length();
vector<pair<int, int> > seq;
for (int i = 0; i < n; i += 2) {
for (int j = 0; j < m; ++j) {
if (A[i][j] == 'U') continue;
int x = i, y = j;
int c = 0;
vector<pair<int, int> > cur(1, pair<int, int>(x, y));
while (true) {
if (c == 0) {
x++;
if (A[x][y] == 'L') break;
} else {
y++;
if (A[x][y] == 'U') break;
}
cur.push_back(pair<int, int>(x, y));
c ^= 1;
}
reverse(cur.begin(), cur.end());
for (auto p : cur) {
seq.push_back(p);
apply(A, p);
}
}
}
return seq;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> A(n), B(n);
for (int i = 0; i < n; ++i) cin >> A[i];
for (int i = 0; i < n; ++i) cin >> B[i];
bool t = false;
if (n & 1) {
t = true;
A = transpose(A);
B = transpose(B);
}
vector<pair<int, int> > seqA = solve(A);
vector<pair<int, int> > seqB = solve(B);
reverse(seqB.begin(), seqB.end());
cout << seqA.size() + seqB.size() << '\n';
for (auto p : seqA) {
if (t) swap(p.first, p.second);
cout << p.first + 1 << " " << p.second + 1 << '\n';
}
for (auto p : seqB) {
if (t) swap(p.first, p.second);
cout << p.first + 1 << " " << p.second + 1 << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans[100005], tra[100005];
struct que {
int xl, xr, yl, yr, z, id;
bool operator<(const que &A) const { return z < A.z; }
} q[100005];
struct Point {
int x, y, id;
} g[100005];
struct node {
int xl, xr, yl, yr, id;
node() {}
node(int A, int B, int C, int D, int E) : xl(A), xr(B), yl(C), yr(D), id(E) {}
} cans, tr[100005 << 2];
bool cmpX(Point X, Point Y) { return X.x < Y.x; }
bool cmpY(Point X, Point Y) { return X.y < Y.y; }
void build(int p, int l, int r, bool opt) {
if (l == r) {
tr[p].xl = tr[p].xr = g[l].x;
tr[p].yl = tr[p].yr = g[l].y;
tr[p].id = g[l].id;
return;
}
int mid(l + r >> 1);
nth_element(g + l, g + mid, g + r + 1, (!opt) ? cmpX : cmpY);
build(p << 1, l, mid, !opt);
build(p << 1 | 1, mid + 1, r, !opt);
tr[p].xl = min(tr[p << 1].xl, tr[p << 1 | 1].xl);
tr[p].xr = max(tr[p << 1].xr, tr[p << 1 | 1].xr);
tr[p].yl = min(tr[p << 1].yl, tr[p << 1 | 1].yl);
tr[p].yr = max(tr[p << 1].yr, tr[p << 1 | 1].yr);
tr[p].id = min(tr[p << 1].id, tr[p << 1 | 1].id);
}
void modify(int p, int l, int r, int x) {
if (l == r) {
tr[p].id = m + 1;
return;
}
int mid(l + r >> 1);
if (x <= mid)
modify(p << 1, l, mid, x);
else
modify(p << 1 | 1, mid + 1, r, x);
tr[p].id = min(tr[p << 1].id, tr[p << 1 | 1].id);
}
void calc(int p) {
if (tr[p].id >= cans.id || tr[p].xl > cans.xr || tr[p].xr < cans.xl ||
tr[p].yl > cans.yr || tr[p].yr < cans.yl)
return;
if (cans.xl <= tr[p].xl && tr[p].xr <= cans.xr && cans.yl <= tr[p].yl &&
tr[p].yr <= cans.yr) {
cans.id = tr[p].id;
return;
}
if (tr[p << 1].id < tr[p << 1 | 1].id)
calc(p << 1), calc(p << 1 | 1);
else
calc(p << 1 | 1), calc(p << 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%d%d%d%d", &q[i].xl, &q[i].xr, &q[i].yl, &q[i].yr, &q[i].z),
q[i].id = i;
sort(q + 1, q + n + 1);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) scanf("%d%d", &g[i].x, &g[i].y), g[i].id = i;
build(1, 1, m, 0);
for (int i = 1; i <= m; ++i) tra[g[i].id] = i;
for (int i = 1; i <= n; ++i) {
cans = node(q[i].xl, q[i].xr, q[i].yl, q[i].yr, m + 1);
calc(1);
if (cans.id == m + 1) continue;
ans[cans.id] = q[i].id;
modify(1, 1, m, tra[cans.id]);
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_T = 100 * 1000;
int tab[MAX_T];
int tab_inc[MAX_T];
int tab_dec[MAX_T];
int tab_f[MAX_T];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &tab[i]);
int prec = 0;
for (int i = 0; i < n; i++) {
tab_inc[i] = max(prec, tab[i]);
prec = tab_inc[i] + 1;
}
prec = 0;
for (int i = n - 1; i >= 0; i--) {
tab_dec[i] = max(prec, tab[i]);
prec = tab_dec[i] + 1;
}
long long somme = 0;
for (int i = 0; i < n; i++) {
tab_f[i] = min(tab_inc[i], tab_dec[i]);
somme += (long long)(tab_f[i] - tab[i]);
}
for (int i = 1; i < n; i++) {
if (tab_f[i] == tab_f[i - 1]) somme++;
}
printf("%I64d\n", somme);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, a[100010], kol[2000005], anser;
bool cmp(pair<pair<long long, long long>, long long> x,
pair<pair<long long, long long>, long long> y) {
long long lx = x.first.first / 316;
long long ly = y.first.first / 316;
if (lx != ly) return lx < ly;
if (lx & 1) return x.first.second > y.first.second;
return x.first.second < y.first.second;
}
void add(long long pos) {
long long x = a[pos];
anser += kol[x ^ k];
kol[x]++;
}
void del(long long pos) {
long long x = a[pos];
kol[x]--;
anser -= kol[x ^ k];
}
int main() {
ios_base::sync_with_stdio(0);
istream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
if (i == 0)
a[i] = x;
else
a[i] = a[i - 1] ^ x;
}
vector<pair<pair<long long, long long>, long long> > g;
g.clear();
for (long long j = 0; j < m; j++) {
long long l, r;
cin >> l >> r;
l--;
g.push_back({{l, r}, j});
}
sort(g.begin(), g.end(), cmp);
long long l = 0, r = -1, ans[m];
for (long long i = 0; i < m; i++) {
long long L = g[i].first.first, R = g[i].first.second, nm = g[i].second;
while (l < L) {
del(l);
l++;
}
while (r < R) {
r++;
add(r);
}
while (l > L) {
l--;
add(l);
}
while (r > R) {
del(r);
r--;
}
ans[nm] = anser;
}
for (long long i = 0; i < m; i++) cout << ans[i] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
;
vector<int> v(n);
set<int> s;
for (int i = 0; i < n; i++) {
cin >> v[i];
s.insert(v[i]);
}
v.clear();
for (auto i : s) {
v.push_back(i);
}
sort(v.begin(), v.end());
n = (int)v.size();
int ans = 0;
int maxel = v[n - 1] * 2;
for (int i = 0; i < n; i++) {
for (int j = 2 * v[i]; j <= maxel; j += v[i]) {
vector<int>::iterator lower = lower_bound(v.begin(), v.end(), j);
int can = v[lower - v.begin() - 1];
ans = max(ans, can % v[i]);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int power(int x, long long y) {
int p;
if (y == 0) return 1;
p = power(x, y / 2);
p = (long long)p * p % 1000000007;
if (y % 2 == 1) p = (long long)p * x % 1000000007;
return p;
}
int main() {
int k, p, x, y, even;
scanf("%d", &k);
p = 2;
even = 0;
while (k-- > 0) {
long long a;
scanf("%lld", &a);
if (a % 2 == 0) even = 1;
p = power(p, a);
}
y = (long long)p * 500000004 % 1000000007;
x = (long long)(even ? y + 1 : y + 1000000007 - 1) * 333333336 % 1000000007;
printf("%d/%d\n", x, y);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
string s;
int mod = 1000000007;
bool check(int a, int b, int c) {
int t[3] = {0};
if (a == 3) t[1]++;
if (b == 3) {
t[0]++;
t[2]++;
}
if (c == 3) t[1]++;
if (a == 3) t[0] = 3;
if (b == 3) t[1] = 3;
if (c == 3) t[2] = 3;
if (t[1] != b) return false;
if (c - t[2] == 1 || t[2] == c) return true;
return false;
}
int memo[1000100][4][4];
int f(int ind, int pre, int prepre) {
if (ind == s.size()) {
if (pre == 2) return 0;
if (pre == 1 && prepre != 3) return 0;
if (pre == 0 && (prepre == 2 || prepre == 3)) return 0;
return 1;
}
long long res = 0;
int &ret = memo[ind][pre][prepre];
if (ret != -1) return ret;
if (s[ind] == '?') {
if (check(prepre, pre, 0)) res = (res + f(ind + 1, 0, pre)) % mod;
if (check(prepre, pre, 1)) res = (res + f(ind + 1, 1, pre)) % mod;
if (check(prepre, pre, 2)) res = (res + f(ind + 1, 2, pre)) % mod;
if (check(prepre, pre, 3)) res = (res + f(ind + 1, 3, pre)) % mod;
} else if (s[ind] == '0') {
if (check(prepre, pre, 0)) res = (res + f(ind + 1, 0, pre)) % mod;
} else if (s[ind] == '1') {
if (check(prepre, pre, 1)) res = (res + f(ind + 1, 1, pre)) % mod;
} else if (s[ind] == '2') {
if (check(prepre, pre, 2)) res = (res + f(ind + 1, 2, pre)) % mod;
} else if (s[ind] == '*') {
if (check(prepre, pre, 3)) res = (res + f(ind + 1, 3, pre)) % mod;
}
return ret = (int)res;
}
int main() {
memset((memo), (-1), sizeof(memo));
cin >> s;
int res = ((long long)f(0, 0, 0) + f(0, 1, 0)) % mod;
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long s, ans, f[130][2], g[130][2];
long long calc(int one, long long sum, int lena, int lenb) {
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int i = 0; (1LL << i) <= sum; i++) {
for (int j = 0; j <= one; j++)
for (int k = 0; k <= 1; k++) g[j][k] = f[j][k], f[j][k] = 0;
for (int j = 0; j <= 1; j++)
for (int a = 0; a <= 1; a++)
if (i < lena || !a)
for (int b = 0; b <= 1; b++)
if (i < lenb || !b) {
int bit = j + a + b;
if ((bit & 1) != ((sum >> i) & 1)) continue;
for (int k = 0; k <= one - a - b; k++)
f[k + a + b][bit >> 1] += g[k][j];
}
}
return f[one][0];
}
int main() {
scanf("%I64d", &s);
for (int a = 0; a <= 60; a++)
for (int b = 0; b <= 60; b++)
if ((1LL << (a + 1)) + (1LL << (b + 1)) - 3 <= s) {
long long rem =
s % ((1LL << (a + 1)) + (1LL << (b + 1)) - 3) - (1LL << b) + 1;
if (rem < 0) continue;
for (int one = 0; one <= a + b; one++)
if ((rem + one) % 2 == 0)
ans += calc(one, (rem + one) >> 1, a - 1, b - 1);
}
printf("%I64d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
string s;
int w[5005][26][26], ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) w[j][s[i] - 'a'][s[(i + j) % n] - 'a']++;
for (int i = 0; i < 26; i++) {
int mx = 0;
for (int j = 0; j < n; j++) {
int o = 0;
for (int k = 0; k < 26; k++)
if (w[j][i][k] == 1) o++;
mx = max(mx, o);
}
ans += mx;
}
printf("%.15f\n", (double)ans / n);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 15;
const int INF = 1e9;
int n, k, m;
unordered_map<string, int> mp;
int cost[MaxN];
int group[MaxN], groupCost[MaxN];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> m;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
mp[s] = i;
}
for (int i = 1; i <= n; ++i) cin >> cost[i];
for (int i = 1; i <= k; ++i) {
int x;
cin >> x;
for (int j = 0; j < x; ++j) {
int a;
cin >> a;
group[a] = i;
groupCost[i] = min(cost[a], groupCost[i] ? groupCost[i] : INF);
}
}
long long ans = 0;
for (int i = 1; i <= m; ++i) {
string s;
cin >> s;
ans += groupCost[group[mp[s]]];
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline bool mina(A &x, B y) {
return (x > y) ? (x = y, 1) : 0;
}
template <typename A, typename B>
inline bool maxa(A &x, B y) {
return (x < y) ? (x = y, 1) : 0;
}
const int K = 200002;
int N;
int X[(200004)];
int Y[(200004)];
int XY[(200004)];
int sol[(200004)];
vector<int> E[(400010)];
int deg[(400010)];
int main() {
cin >> N;
for (int _b = (N), i = (0); i < _b; ++i) {
int x, y;
scanf("%d %d", &x, &y);
X[i] = x;
Y[i] = y;
XY[i] = x ^ (y + K);
E[x].push_back(i);
++deg[x];
E[y + K].push_back(i);
++deg[y + K];
}
queue<int> Q1, Q2;
for (int _b = ((400010)), i = (0); i < _b; ++i) {
if (deg[i] == 1) Q1.push(i);
if (deg[i] >= 2) Q2.push(i);
}
memset(sol, -1, sizeof(sol));
int n = N;
while (n > 0) {
int s = -1, t;
int f = 0;
while (!Q1.empty()) {
t = Q1.front();
Q1.pop();
if (deg[t] != 1)
continue;
else {
f = 1;
s = t;
break;
}
}
if (s == -1) {
while (!Q2.empty()) {
t = Q2.front();
Q2.pop();
if (deg[t] < 2)
continue;
else {
f = 2;
s = t;
break;
}
}
assert(s != -1);
}
int u = s, v, e;
int p = 0;
while (1) {
v = -1;
while (E[u].size() > 0) {
e = E[u].back();
E[u].pop_back();
if (sol[e] == -1) {
v = XY[e] ^ u;
break;
}
}
if (v == -1) break;
--deg[u];
if (deg[u] == 1) Q1.push(u);
--deg[v];
if (deg[v] == 1) Q1.push(v);
u = v;
sol[e] = p;
p ^= 1;
--n;
}
if (f == 2 && deg[s] > 0) {
u = s;
p = 1;
while (1) {
v = -1;
while (E[u].size() > 0) {
e = E[u].back();
E[u].pop_back();
if (sol[e] == -1) {
v = XY[e] ^ u;
break;
}
}
if (v == -1) break;
--deg[u];
if (deg[u] == 1) Q1.push(u);
--deg[v];
if (deg[v] == 1) Q1.push(v);
u = v;
sol[e] = p;
p ^= 1;
--n;
}
}
}
for (int _b = (N), i = (0); i < _b; ++i) assert(sol[i] >= 0);
for (int _b = (N), i = (0); i < _b; ++i) putchar("rb"[sol[i]]);
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 3e5 + 10;
const int mod = (int)1e9 + 9;
int n, m;
int a[M];
int fib[M][2];
int sumfib[M][2];
void add(int &a, int b) {
a += b;
if (a < 0) a += mod;
if (a >= mod) a -= mod;
}
struct Node {
int f[2];
int sum;
bool mk;
void Init() { f[0] = f[1] = sum = mk = 0; }
void mark(int *_f, int n) {
mk = true;
add(sum,
(1ll * _f[0] * sumfib[n][0] % mod + 1ll * _f[1] * sumfib[n][1] % mod) %
mod);
add(f[0], _f[0]);
add(f[1], _f[1]);
}
} T[M << 2];
int getfib(long long f0, long long f1, int n) {
return (f0 * fib[n][0] + f1 * fib[n][1]) % mod;
}
struct Segtree {
void up(int o) { T[o].sum = (T[o << 1].sum + T[o << 1 | 1].sum) % mod; }
void down(int o, int l, int r) {
if (T[o].mk == false) return;
int mid = l + r >> 1;
T[o << 1].mark(T[o].f, mid - l + 1);
int _f[2] = {getfib(T[o].f[0], T[o].f[1], mid - l + 2),
getfib(T[o].f[0], T[o].f[1], mid - l + 3)};
T[o << 1 | 1].mark(_f, r - mid);
T[o].f[0] = T[o].f[1] = 0;
T[o].mk = false;
}
void build(int o, int l, int r) {
T[o].Init();
if (l == r) {
scanf("%d", &T[o].sum);
return;
}
int mid = l + r >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
up(o);
}
void update(int o, int l, int r, int pl, int pr) {
if (pl <= l && r <= pr) {
int _f[2] = {getfib(1, 1, l - pl + 1), getfib(1, 1, l - pl + 2)};
T[o].mark(_f, r - l + 1);
return;
}
down(o, l, r);
int mid = l + r >> 1;
if (pl <= mid) update(o << 1, l, mid, pl, pr);
if (pr > mid) update(o << 1 | 1, mid + 1, r, pl, pr);
up(o);
}
int ask(int o, int l, int r, int pl, int pr) {
if (pl <= l && r <= pr) {
return T[o].sum;
}
down(o, l, r);
int mid = l + r >> 1;
int ret = 0;
if (pl <= mid) add(ret, ask(o << 1, l, mid, pl, pr));
if (pr > mid) add(ret, ask(o << 1 | 1, mid + 1, r, pl, pr));
return ret;
}
} sgt;
int main() {
fib[1][0] = 1, fib[2][1] = 1;
for (int i = 3; i < M; ++i) {
fib[i][0] = (1ll * fib[i - 1][0] + fib[i - 2][0]) % mod;
fib[i][1] = (1ll * fib[i - 1][1] + fib[i - 2][1]) % mod;
}
for (int i = 1; i < M; ++i) {
add(sumfib[i][0], fib[i][0]);
add(sumfib[i][0], sumfib[i - 1][0]);
add(sumfib[i][1], fib[i][1]);
add(sumfib[i][1], sumfib[i - 1][1]);
}
scanf("%d%d", &n, &m);
sgt.build(1, 1, n);
int op, l, r;
while (m--) {
scanf("%d%d%d", &op, &l, &r);
if (op == 2)
printf("%d\n", sgt.ask(1, 1, n, l, r));
else {
sgt.update(1, 1, n, l, r);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
signed main() {
fast();
long long t;
cin >> t;
while (t--) {
long long i, n, a, b;
cin >> n;
set<long long> second;
for (i = 0; i < n; i++) {
cin >> a;
second.insert(a);
}
cout << ((long long)second.size()) << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, ans;
int dp[77][77][77][2];
string s;
vector<int> V, K, O;
void mini(int &a, int b) { a = min(a, b); }
int count_remaining(const vector<int> &List, int from, int limit_val) {
int cnt = 0;
for (int i = from; i < List.size() && List[i] < limit_val; ++i) ++cnt;
return cnt;
}
void init() {
cin >> n;
cin >> s;
for (int i = 0; i < n; ++i) {
switch (s[i]) {
case 'V':
V.push_back(i);
break;
case 'K':
K.push_back(i);
break;
default:
O.push_back(i);
break;
}
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= n; ++k)
for (int z = 0; z < 2; ++z) dp[i][j][k][z] = INF;
dp[0][0][0][0] = 0;
}
void process() {
for (int v = 0; v <= (int)V.size(); ++v)
for (int k = 0; k <= (int)K.size(); ++k)
for (int o = 0; o <= (int)O.size(); ++o)
for (int type = 0; type < 2; ++type) {
auto moving_cost = [&](int where) {
return count_remaining(V, v, where) + count_remaining(K, k, where) +
count_remaining(O, o, where);
};
int already = dp[v][k][o][type];
if (v < (int)V.size())
mini(dp[v + 1][k][o][1], already + moving_cost(V[v]));
if (k < (int)K.size() && type == 0)
mini(dp[v][k + 1][o][0], already + moving_cost(K[k]));
if (o < (int)O.size())
mini(dp[v][k][o + 1][0], already + moving_cost(O[o]));
}
ans = INF;
for (int i = 0; i < 2; ++i) {
mini(ans, dp[V.size()][K.size()][O.size()][i]);
}
}
int main() {
ios_base::sync_with_stdio(false);
init();
process();
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int sq = 646;
const int INF = 1031231234;
struct block : vector<pair<long long, int> > {
long long inc = 0;
bool invalid = false;
};
void modifyPartial(block &b, int l, int r, int x) {
if (b.invalid) return;
for (int i = 0; i < b.size(); i++) {
if (b[i].second >= l and b[i].second <= r) b[i].first += x;
}
sort(b.begin(), b.end());
}
int findnum(block &b, long long n, bool findFirst) {
int pos = -1, val = -1;
if (!b.invalid) {
n -= b.inc;
if (findFirst) {
pair<long long, int> wanted = {n, -INF};
auto it = lower_bound(b.begin(), b.end(), wanted);
if (it != b.end()) pos = it->second, val = it->first;
} else {
pair<long long, int> wanted = {n, INF};
auto it = upper_bound(b.begin(), b.end(), wanted);
if (it != b.begin()) --it, pos = it->second, val = it->first;
}
}
if (pos != -1 and val == n)
return pos;
else
return findFirst ? INF : -INF;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
int nb = n / sq + 1;
vector<block> blocks(nb);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
blocks[i / sq].push_back({a, i});
}
for (int i = 0; i < nb; i++) sort(blocks[i].begin(), blocks[i].end());
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
int l, r, x;
cin >> l >> r >> x;
--l, --r;
int lb = l / sq, rb = r / sq;
if (lb == rb)
modifyPartial(blocks[lb], l, r, x);
else {
modifyPartial(blocks[lb], l, (lb + 1) * sq - 1, x), lb++;
modifyPartial(blocks[rb], rb * sq, r, x), rb--;
for (int i = lb; i <= rb; i++)
if (!blocks[i].invalid) {
blocks[i].inc += x;
}
}
} else {
int y;
cin >> y;
int first = INF, last = -INF;
for (int i = 0; i < nb; i++) {
first = min(first, findnum(blocks[i], y, true));
last = max(last, findnum(blocks[i], y, false));
}
if (first == INF or last == -INF)
cout << -1 << '\n';
else
cout << last - first << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const long long INFLL = (long long)INF * (long long)INF;
const long double EPS = 10e-9;
const unsigned int M = 1000000007;
long double pi = 2 * acos(0.0);
void solve() {
long long n;
cin >> n;
std::map<long long, long long> need;
while (n > 0) {
long long rem = n % 10;
if (rem == 5) rem = 2;
if (rem == 9) rem = 6;
need[rem]++;
n /= 10;
}
string s;
cin >> s;
std::map<long long, long long> have;
for (long long i = 0; i < s.size(); ++i) {
long long temp = s[i] - '0';
if (temp == 5) temp = 2;
if (temp == 9) temp = 6;
have[temp]++;
}
long long ans = INFLL;
for (auto ash : need) {
long long a = ash.second;
long long b = have[ash.first];
ans = min(ans, b / a);
}
cout << ans << endl;
}
int32_t main() {
clock_t start, end;
start = clock();
long long t = 1;
while (t--) solve();
end = clock();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long modx(long long Base, long long exponent) {
long long ans = 1;
if (Base == 1) return Base;
while (exponent) {
if (exponent & 1) ans = (ans * Base) % 1000000007LL;
Base = (Base * Base) % 1000000007LL;
exponent = exponent >> 1;
}
return ans;
}
long long inmodx(long long num) { return (modx(num, 1000000007LL - 2LL)); }
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.second < b.first.second) return 1;
if (a.first.second > b.first.second) return 0;
if (a.first.first <= b.first.first) return 1;
return 0;
}
const int N = (1e3) + 9;
const int M = (N << 2) + 9;
const int LOGN = ((int)log2(N)) + 3;
const int LOGM = ((int)log2(M)) + 3;
const int BUCK = 450;
int dp[N][N];
pair<int, int> par[N][N];
string a, b;
void dfs(int x, int y) {
if (x == 0 && y == 0) return;
if (par[x][y] == make_pair(x - 1, y - 1)) {
dfs(x - 1, y - 1);
if (dp[x][y] != dp[x - 1][y - 1])
cout << "REPLACE " << y << " " << b[y - 1] << '\n';
} else if (par[x][y] == make_pair(x, y - 1)) {
dfs(x, y - 1);
cout << "INSERT " << y << " " << b[y - 1] << '\n';
} else {
cout << "DELETE " << x << '\n';
dfs(x - 1, y);
}
return;
}
void solve() {
int n, m, i, j;
cin >> a >> b;
n = a.length();
m = b.length();
for (i = (0); i < (n + 1); i++)
for (j = (0); j < (m + 1); j++) dp[i][j] = 1000000011;
for (i = (0); i < (n + 1); i++)
for (j = (0); j < (m + 1); j++) {
if (i == 0 && j == 0)
dp[i][j] = 0;
else if (i == 0) {
dp[i][j] = dp[i][j - 1] + 1;
par[i][j] = {i, j - 1};
} else if (j == 0) {
dp[i][j] = dp[i - 1][j] + 1;
par[i][j] = {i - 1, j};
} else {
if (dp[i - 1][j] + 1 < dp[i][j]) {
dp[i][j] = dp[i - 1][j] + 1;
par[i][j] = {i - 1, j};
}
if (dp[i][j - 1] + 1 < dp[i][j]) {
dp[i][j] = dp[i][j - 1] + 1;
par[i][j] = {i, j - 1};
}
if (dp[i - 1][j - 1] + (a[i - 1] != b[j - 1]) < dp[i][j]) {
dp[i][j] = dp[i - 1][j - 1] + (a[i - 1] != b[j - 1]);
par[i][j] = {i - 1, j - 1};
}
}
}
cout << dp[n][m] << '\n';
dfs(n, m);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
clock_t clk;
clk = clock();
int t = 1, cs;
cout << fixed << setprecision(3);
for (cs = (1); cs < (t + 1); cs++) {
solve();
}
clk = clock() - clk;
cerr << fixed << setprecision(6) << "Time: " << ((double)clk) / CLOCKS_PER_SEC
<< "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MOD = 9973;
const int INF = 99999999;
using namespace std;
int n, m, k;
int a[20];
int c[20][20];
long long int dp[1 << 18][20];
int count(int i) {
int nums = 0;
while (i) {
i &= (i - 1);
nums++;
}
return nums;
}
int main() {
while (~scanf("%d %d %d", &n, &m, &k)) {
for (int i = 0; i < n; i++) scanf("%d", a + i);
memset(c, 0, sizeof(c));
int x, y, z;
for (int i = 0; i < k; i++) {
scanf("%d %d %d", &x, &y, &z);
c[x - 1][y - 1] = z;
}
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) dp[1 << i][i] = a[i];
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
for (int k = 0; k < n; k++) {
if (i & (1 << k)) continue;
dp[i | (1 << k)][k] =
max(dp[i | (1 << k)][k], dp[i][j] + c[j][k] + a[k]);
}
}
}
}
long long int ans = 0;
for (int i = 0; i < (1 << n); i++) {
if (count(i) == m) {
for (int j = 0; j < n; j++) ans = max(ans, dp[i][j]);
}
}
printf("%lld\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
for (int i = 0; i < n - ((n + 3) / 4); i++) s.push_back('9');
for (int i = 0; i < (n + 3) / 4; i++) s.push_back('8');
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
const int p = 1e9 + 7;
int n;
long long mul[N], inv[N];
void read(int &x) {
char ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 3) + (x << 1) + ch - '0';
}
long long power(long long a, int n) {
long long ans = 1;
for (long long sum = a; n; n >>= 1, sum = sum * sum % p)
if (n & 1) ans = ans * sum % p;
return ans;
}
void init() {
mul[0] = 1;
for (int i = 1; i < N; i++) mul[i] = mul[i - 1] * i % p;
inv[N - 1] = power(mul[N - 1], p - 2);
for (int i = N - 2; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % p;
}
long long C(int n, int m) { return mul[n] * inv[m] % p * inv[n - m] % p; }
int main() {
init();
read(n);
cout << (C(2 * n - 1, n - 1) * 2 - n + p) % p << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int mod1 = 998244353;
long long fact(long long n) {
long long f = 1;
for (long long i = 1; i <= n; i++) f = (f * i) % mod;
return f;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return (a * b) / gcd(a, b);
}
bool isPrime(long long n) {
if (n <= 1) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long ModPow(long long a, long long b, long long M) {
if (M == 1) return 0;
a %= M;
long long ans = 1, t = 1;
while (t > 0 && t <= b) {
if (t & b) {
ans *= a;
ans %= M;
}
t <<= 1;
a *= a;
a %= M;
}
return ans;
}
long long modInverse(long long n, long long p) { return ModPow(n, p - 2, p); }
long long nCrModP(long long n, long long r, long long p) {
if (n < r) return 0;
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
int aux(vector<int>& a, int p, int r) {
int ma = a[p], ind = p;
for (int i = p; i <= r; i++) {
if (a[i] > ma) {
ma = a[i];
ind = i;
}
}
return ind;
}
void MAX(vector<int>& a, int p, int r, int d, vector<int>& ans) {
if (p <= r) {
int q = aux(a, p, r);
ans[q] = d;
MAX(a, p, q - 1, d + 1, ans);
MAX(a, q + 1, r, d + 1, ans);
}
}
struct Comparator {
bool operator()(const pair<int, int>& value, const int& key) {
return (value.first < key);
}
bool operator()(const int& key, const pair<int, int>& value) {
return (key < value.first);
}
};
bool revsort(long long a, long long b) { return a > b; }
bool check(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
return false;
else
return true;
}
template <typename T>
T debug(vector<T>& ans) {
for (long long i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << "\n";
}
void solve() {
int n;
cin >> n;
string s;
cin >> s;
for (long long i = 0; i < n; i++) {
int a = 0, b = 0;
for (long long j = i; j < n; j++) {
if (s[j] == 'a')
a++;
else
b++;
if (a == b) {
cout << i + 1 << " " << j + 1 << "\n";
return;
}
}
}
cout << "-1 -1\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x7f7f7f7f7f7f;
template <typename _T>
void read(_T &x) {
_T f = 1;
x = 0;
char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
long long n, ans, m[2000005], t[2000005];
signed main() {
read(n);
for (long long i = 1; i <= n; i++) read(m[i]), t[i] = max(t[i - 1], m[i] + 1);
for (long long i = n - 1; i > 0; i--)
if (t[i + 1] - 1 > t[i]) t[i] = t[i + 1] - 1;
for (long long i = 1; i <= n; i++) ans += t[i] - m[i] - 1;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n;
vector<int> id[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
id[x].push_back(i + 1);
}
int cur = 0;
vector<int> ans;
while (n && cur >= 0) {
while (cur >= 0 && !id[cur].size()) cur -= 3;
if (cur < 0) return cout << "Impossible\n", 0;
ans.push_back(id[cur].back());
id[cur].pop_back();
n--, cur++;
}
cout << "Possible\n";
for (auto i : ans) cout << i << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 300000005, B = 41000;
int pre[] = {
0, 2127, 3996, 5753, 7490, 9181, 10827, 12468,
14086, 15695, 17279, 18864, 20424, 22003, 23532, 25112,
26628, 28145, 29652, 31137, 32651, 34178, 35662, 37146,
38613, 40118, 41592, 43073, 44528, 46039, 47493, 48936,
50397, 51834, 53284, 54737, 56173, 57631, 59061, 60495,
61935, 63371, 64797, 66200, 67633, 69055, 70491, 71911,
73317, 74737, 76146, 77572, 78972, 80384, 81767, 83140,
84542, 85927, 87295, 88696, 90084, 91464, 92888, 94305,
95666, 97061, 98443, 99825, 101203, 102581, 103989, 105334,
106671, 108059, 109416, 110825, 112199, 113584, 114971, 116355,
117713, 119059, 120416, 121795, 123168, 124510, 125847, 127166,
128554, 129919, 131291, 132655, 133976, 135352, 136720, 138065,
139418, 140772, 142112, 143500, 144830, 146167, 147531, 148862,
150195, 151541, 152870, 154211, 155566, 156907, 158262, 159559,
160910, 162238, 163573, 164929, 166267, 167578, 168941, 170242,
171601, 172918, 174251, 175572, 176895, 178225, 179542, 180853,
182177, 183484, 184776, 186100, 187443, 188762, 190088, 191395,
192721, 194025, 195364, 196679, 197996, 199294, 200606, 201905,
203237, 204599, 205891, 207215, 208509, 209819, 211116, 212453,
213754, 215069, 216423, 217706, 218985, 220283, 221591, 222882,
224171, 225492, 226810, 228100, 229448, 230752, 232038, 233375,
234695, 235988, 237313, 238611, 239917, 241223, 242519, 243804,
245082, 246379, 247682, 248959, 250235, 251530, 252808, 254071,
255384, 256666, 257976, 259284, 260588, 261872, 263153, 264459,
265748, 267017, 268304, 269604, 270870, 272184, 273442, 274741,
276014, 277322, 278586, 279891, 281150, 282425, 283697, 284980,
286298, 287587, 288890, 290147, 291451, 292758, 294062, 295353,
296615, 297886, 299180, 300443, 301691, 302926, 304244, 305539,
306822, 308128, 309377, 310656, 311959, 313238, 314503, 315757,
317029, 318311, 319619, 320891, 322161, 323405, 324695, 325974,
327265, 328520, 329778, 331035, 332294, 333547, 334842, 336123,
337406, 338676, 339917, 341202, 342443, 343700, 344994, 346258,
347535, 348762, 350049, 351325, 352593, 353868, 355167, 356404,
357643, 358912, 360185, 361464, 362707, 363960, 365239, 366510,
367743, 369036, 370314, 371563, 372837, 374100, 375379, 376650,
377923, 379151, 380459, 381721, 383010, 384267, 385531, 386774,
388075, 389330, 390609, 391870, 393139, 394389, 395652, 396891,
398134, 399381, 400652, 401909, 403209, 404454, 405750, 407015,
408253, 409462, 410705, 411947, 413214, 414473, 415734, 416990,
418259, 419525, 420799, 422010, 423245, 424461, 425714, 426961,
428186, 429432, 430716, 431949, 433184, 434439, 435712, 436956,
438210, 439446, 440709, 441930, 443194, 444438, 445680, 446907,
448155, 449430, 450647, 451925, 453165, 454391, 455624, 456857,
458087, 459371, 460621, 461823, 463081, 464334, 465589, 466848,
468093, 469346, 470568, 471806, 473062, 474275, 475527, 476781,
478050, 479271, 480533, 481759, 482966, 484203, 485453, 486679,
487929, 489157, 490418, 491619, 492858, 494102, 495325, 496533,
497718, 498938, 500175, 501422, 502643, 503889, 505116, 506359,
507609, 508862, 510105, 511388, 512626, 513840, 515094, 516342,
517553, 518786, 520034, 521258, 522480, 523734, 524980, 526185,
527422, 528678, 529911, 531161, 532379, 533608, 534852, 536066,
537259, 538500, 539747, 541005, 542231, 543481, 544731, 545955,
547172, 548411, 549629, 550843, 552061, 553324, 554574, 555790,
557011, 558252, 559454, 560726, 561953, 563202, 564411, 565627,
566881, 568085, 569328, 570529, 571767, 572983, 574223, 575479,
576703, 577900, 579106, 580334, 581560, 582828, 584072, 585314,
586500, 587726, 588945, 590150, 591364, 592551, 593787, 595054,
596250, 597495, 598724, 599947, 601187, 602407, 603628, 604832,
606048, 607285, 608518, 609751, 610979, 612203, 613405, 614654,
615871, 617085, 618326, 619561, 620759, 621945, 623159, 624394,
625597, 626809, 628022, 629276, 630473, 631702, 632932, 634204,
635406, 636619, 637826, 639031, 640259, 641453, 642663, 643876,
645096, 646307, 647501, 648731, 649933, 651167, 652400, 653595,
654805, 656053, 657291, 658471, 659655, 660899, 662116, 663311,
664542, 665777, 666999, 668190, 669387, 670586, 671796, 673033,
674285, 675491, 676729, 677953, 679196, 680359, 681566, 682770,
683985, 685199, 686440, 687666, 688860, 690091, 691308, 692546,
693752, 694987, 696203, 697377, 698555, 699780, 700973, 702173,
703396, 704578, 705792, 706967, 708158, 709377, 710630, 711831,
713048, 714218, 715441, 716671, 717874, 719094, 720319, 721523,
722723, 723928, 725158, 726381, 727602, 728806, 730009, 731209,
732448, 733664, 734872, 736057, 737255, 738463, 739652, 740840,
742094, 743296, 744497, 745682, 746888, 748067, 749231, 750464,
751689, 752876, 754074, 755267, 756456, 757658, 758896, 760121,
761346, 762604, 763787, 765006, 766212, 767406, 768617, 769820,
771012, 772180, 773396, 774621, 775845, 777034, 778212, 779441,
780637, 781844, 783060, 784234, 785462, 786689, 787857, 789046,
790220, 791416, 792640, 793814, 795016, 796217, 797410, 798607,
799818, 801038, 802213, 803461, 804660, 805863, 807066, 808252,
809471, 810643, 811870, 813061, 814281, 815477, 816650, 817835,
819047, 820228, 821409, 822636, 823881, 825079, 826268, 827493,
828710, 829913, 831129, 832340, 833535, 834698, 835912, 837112,
838321, 839508, 840716, 841916, 843093, 844320, 845510, 846724,
847896, 849074, 850274, 851450, 852633, 853835, 855045, 856214,
857451, 858652, 859856, 861041, 862228, 863449, 864613, 865841,
867007, 868207, 869405, 870602, 871837, 873035, 874223, 875417,
876589, 877791, 878983, 880196, 881372, 882540, 883750, 884982,
886168, 887350, 888542, 889741, 890933, 892139, 893332, 894504,
895702, 896917, 898090, 899293, 900471, 901650, 902861, 904041,
905226, 906402, 907632, 908858, 910043, 911251, 912425, 913615,
914791, 915978, 917167, 918331, 919529, 920748, 921901, 923090,
924287, 925511, 926700, 927921, 929139, 930309, 931511, 932694,
933889, 935100, 936279, 937487, 938702, 939886, 941100, 942261,
943438, 944657, 945862, 947077, 948283, 949440, 950616, 951816,
953014, 954216, 955421, 956566, 957757, 958938, 960113, 961282,
962491, 963649, 964856, 966016, 967218, 968410, 969580, 970794,
971968, 973138, 974321, 975507, 976703, 977880, 979077, 980242,
981428, 982644, 983807, 984986, 986174, 987331, 988532, 989743,
990951, 992110, 993264, 994445, 995638, 996816, 997984, 999149,
1000317, 1001508, 1002679, 1003899, 1005087, 1006270, 1007460, 1008637,
1009828, 1010973, 1012163, 1013361, 1014550, 1015770, 1016932, 1018112,
1019326, 1020522, 1021687, 1022894, 1024091, 1025260, 1026436, 1027616,
1028820, 1029983, 1031149, 1032367, 1033520, 1034683, 1035858, 1037055,
1038246, 1039460, 1040669, 1041857, 1043029, 1044194, 1045351, 1046509,
1047687, 1048863, 1050002, 1051182, 1052378, 1053540, 1054712, 1055875,
1057061, 1058249, 1059426, 1060597, 1061800, 1062942, 1064102, 1065279,
1066443, 1067649, 1068790, 1070010, 1071215, 1072406, 1073550, 1074737,
1075914, 1077110, 1078266, 1079455, 1080649, 1081817, 1083026, 1084179,
1085388, 1086550, 1087733, 1088942, 1090079, 1091249, 1092450, 1093630,
1094848, 1096013, 1097181, 1098348, 1099516, 1100679, 1101840, 1103038,
1104214, 1105406, 1106550, 1107738, 1108905, 1110128, 1111301, 1112488,
1113644, 1114816, 1116018, 1117184, 1118384, 1119608, 1120749, 1121923,
1123089, 1124280, 1125466, 1126607, 1127772, 1128939, 1130135, 1131331,
1132504, 1133707, 1134935, 1136109, 1137277, 1138448, 1139633, 1140802,
1141960, 1143124, 1144272, 1145461, 1146625, 1147780, 1148949, 1150139,
1151295, 1152455, 1153657, 1154866, 1156010, 1157223, 1158382, 1159541,
1160715, 1161944, 1163106, 1164317, 1165501, 1166680, 1167862, 1169064,
1170225, 1171375, 1172571, 1173716, 1174888, 1176036, 1177222, 1178383,
1179560, 1180750, 1181957, 1183147, 1184334, 1185492, 1186680, 1187831,
1188980, 1190159, 1191318, 1192529, 1193694, 1194862, 1196007, 1197200,
1198402, 1199575, 1200776, 1201942, 1203133, 1204291, 1205461, 1206667,
1207843, 1209010, 1210168, 1211339, 1212520, 1213678, 1214827, 1215986,
1217142, 1218308, 1219515, 1220688, 1221835, 1222991, 1224144, 1225344,
1226509, 1227686, 1228858, 1230029, 1231228, 1232414, 1233545, 1234698,
1235881, 1237055, 1238266, 1239458, 1240657, 1241783, 1242933, 1244092,
1245272, 1246434, 1247589, 1248781, 1249954, 1251128, 1252277, 1253427,
1254606, 1255767, 1256946, 1258106, 1259293, 1260462, 1261628, 1262769,
1263920, 1265113, 1266261, 1267444, 1268628, 1269794, 1270943, 1272080,
1273243, 1274402, 1275536, 1276714, 1277898, 1279073, 1280245, 1281434,
1282642, 1283763, 1284953, 1286129, 1287286, 1288473, 1289602, 1290744,
1291866, 1293052, 1294207, 1295366, 1296545, 1297689, 1298857, 1299990,
1301160, 1302312, 1303447, 1304643, 1305804, 1306987, 1308162, 1309302,
1310454, 1311630, 1312793, 1313988, 1315166, 1316345, 1317498, 1318704,
1319850, 1320988, 1322141, 1323303, 1324445, 1325642, 1326852, 1327981,
1329165, 1330364, 1331542, 1332725, 1333848, 1335005, 1336161, 1337321,
1338517, 1339666, 1340803, 1341958, 1343133, 1344320, 1345456, 1346608,
1347796, 1348964, 1350105, 1351281, 1352461, 1353604, 1354746, 1355947,
1357131, 1358275, 1359439, 1360592, 1361746, 1362898, 1364031, 1365182,
1366365, 1367557, 1368735, 1369904, 1371021, 1372230, 1373374, 1374535,
1375715, 1376889, 1378023, 1379203, 1380367, 1381531, 1382666, 1383856,
1385018, 1386175, 1387308, 1388447, 1389607, 1390767, 1391885, 1393073,
1394229, 1395392, 1396544, 1397702, 1398907, 1400054, 1401214, 1402368,
1403510, 1404681, 1405839, 1407044, 1408187, 1409366, 1410524, 1411668,
1412867, 1414028, 1415214, 1416389, 1417494, 1418643, 1419816, 1421002,
1422163, 1423324, 1424504, 1425644, 1426794, 1427967, 1429118, 1430317,
1431460, 1432622, 1433791, 1434929, 1436105, 1437243, 1438443, 1439612,
1440809, 1441959, 1443103, 1444252, 1445408, 1446573, 1447771, 1448925,
1450049, 1451187, 1452337, 1453481, 1454671, 1455839, 1456981, 1458172,
1459336, 1460486, 1461682, 1462823, 1463940, 1465086, 1466237, 1467434,
1468575, 1469707, 1470884, 1472058, 1473228, 1474365, 1475528, 1476658,
1477838, 1479001, 1480158, 1481319, 1482463, 1483624, 1484757, 1485951,
1487117, 1488266, 1489448, 1490614, 1491754, 1492897, 1494055, 1495225,
1496409, 1497568, 1498709, 1499864, 1500997, 1502142, 1503302, 1504500,
1505662, 1506765, 1507930, 1509076, 1510260, 1511384, 1512503, 1513679,
1514856, 1516028, 1517190, 1518347, 1519506, 1520642, 1521833, 1522988,
1524123, 1525283, 1526429, 1527584, 1528726, 1529855, 1530999, 1532180,
1533311, 1534447, 1535597, 1536740, 1537887, 1539082, 1540274, 1541406,
1542578, 1543714, 1544905, 1546038, 1547152, 1548264, 1549455, 1550620,
1551780, 1552919, 1554058, 1555183, 1556347, 1557524, 1558705, 1559846,
1561007, 1562163, 1563311, 1564451, 1565555, 1566714, 1567881, 1569040,
1570153, 1571303, 1572476, 1573627, 1574797, 1575935, 1577089, 1578256,
1579412, 1580545, 1581684, 1582838, 1583954, 1585133, 1586262, 1587401,
1588577, 1589746, 1590874, 1592050, 1593212, 1594363, 1595508, 1596646,
1597777, 1598912, 1600077, 1601194, 1602325, 1603507, 1604658, 1605821,
1606951, 1608093, 1609221, 1610404, 1611549, 1612734, 1613866, 1615010,
1616180, 1617361, 1618498, 1619631, 1620770, 1621918, 1623065, 1624187,
1625349, 1626479, 1627630, 1628792, 1629954, 1631136, 1632258, 1633391,
1634547, 1635701, 1636823, 1637966, 1639129, 1640318, 1641496, 1642661,
1643843, 1644952, 1646082, 1647261, 1648396, 1649536, 1650670, 1651808,
1652959, 1654114, 1655249, 1656384, 1657511, 1658698, 1659840, 1660991,
1662163, 1663296, 1664488, 1665615, 1666762, 1667887, 1669060, 1670177,
1671356, 1672541, 1673707, 1674892, 1676024, 1677156, 1678300, 1679457,
1680590, 1681737, 1682871, 1684025, 1685162, 1686287, 1687432, 1688631,
1689794, 1690908, 1692060, 1693177, 1694335, 1695464, 1696564, 1697733,
1698866, 1699998, 1701137, 1702303, 1703430, 1704614, 1705790, 1706972,
1708110, 1709266, 1710405, 1711551, 1712709, 1713864, 1715008, 1716162,
1717300, 1718399, 1719533, 1720705, 1721880, 1723026, 1724174, 1725307,
1726442, 1727586, 1728726, 1729846, 1730990, 1732154, 1733273, 1734436,
1735613, 1736725, 1737870, 1739002, 1740173, 1741322, 1742504, 1743608,
1744756, 1745891, 1747018, 1748202, 1749339, 1750467, 1751633, 1752742,
1753895, 1755021, 1756145, 1757297, 1758453, 1759576, 1760710, 1761842,
1762970, 1764091, 1765270, 1766397, 1767537, 1768689, 1769856, 1771008,
1772137, 1773273, 1774415, 1775561, 1776745, 1777902, 1779029, 1780177,
1781339, 1782481, 1783625, 1784753, 1785901, 1787065, 1788189, 1789335,
1790501, 1791644, 1792817, 1793946, 1795109, 1796231, 1797386, 1798565,
1799726, 1800853, 1802029, 1803163, 1804340, 1805443, 1806582, 1807717,
1808857, 1810001, 1811151, 1812265, 1813365, 1814521, 1815672, 1816811,
1817888, 1819048, 1820184, 1821359, 1822528, 1823636, 1824749, 1825865,
1827013, 1828146, 1829318, 1830436, 1831563, 1832694, 1833822, 1834991,
1836140, 1837321, 1838462, 1839626, 1840782, 1841923, 1843069, 1844196,
1845381, 1846535, 1847637, 1848778, 1849902, 1851029, 1852149, 1853271,
1854378, 1855531, 1856701, 1857850, 1858991, 1860121, 1861266, 1862404,
1863539, 1864671, 1865787, 1866972, 1868086, 1869255, 1870398, 1871543,
1872658, 1873786, 1874953, 1876096, 1877252, 1878370, 1879504, 1880624,
1881771, 1882908, 1884043, 1885198, 1886380, 1887539, 1888685, 1889822,
1890972, 1892103, 1893210, 1894403, 1895548, 1896708, 1897852, 1899012,
1900180, 1901326, 1902448, 1903616, 1904733, 1905866, 1907006, 1908136,
1909239, 1910364, 1911533, 1912663, 1913781, 1914950, 1916086, 1917207,
1918361, 1919506, 1920668, 1921812, 1922969, 1924069, 1925203, 1926357,
1927508, 1928677, 1929796, 1930888, 1932077, 1933249, 1934345, 1935493,
1936618, 1937784, 1938908, 1940049, 1941199, 1942343, 1943482, 1944613,
1945756, 1946865, 1948020, 1949144, 1950294, 1951418, 1952577, 1953739,
1954880, 1955993, 1957149, 1958287, 1959447, 1960570, 1961712, 1962844,
1963987, 1965135, 1966288, 1967428, 1968579, 1969695, 1970810, 1971932,
1973041, 1974197, 1975338, 1976455, 1977597, 1978717, 1979836, 1980993,
1982131, 1983270, 1984444, 1985593, 1986726, 1987882, 1989043, 1990166,
1991293, 1992447, 1993573, 1994692, 1995840, 1996976, 1998108, 1999245,
2000372, 2001533, 2002686, 2003836, 2004962, 2006065, 2007188, 2008343,
2009490, 2010616, 2011771, 2012892, 2014024, 2015175, 2016334, 2017471,
2018580, 2019735, 2020853, 2022015, 2023160, 2024314, 2025457, 2026571,
2027703, 2028822, 2029959, 2031106, 2032240, 2033369, 2034516, 2035684,
2036837, 2037936, 2039047, 2040205, 2041362, 2042495, 2043634, 2044766,
2045933, 2047067, 2048198, 2049347, 2050502, 2051613, 2052756, 2053856,
2054999, 2056113, 2057255, 2058364, 2059486, 2060627, 2061759, 2062908,
2064046, 2065165, 2066312, 2067446, 2068572, 2069688, 2070840, 2071962,
2073118, 2074256, 2075416, 2076529, 2077670, 2078811, 2079919, 2081044,
2082143, 2083288, 2084383, 2085526, 2086652, 2087792, 2088931, 2090095,
2091201, 2092343, 2093483, 2094642, 2095764, 2096895, 2098042, 2099193,
2100285, 2101444, 2102567, 2103722, 2104839, 2105972, 2107101, 2108179,
2109340, 2110516, 2111644, 2112782, 2113869, 2115022, 2116156, 2117273,
2118415, 2119561, 2120687, 2121816, 2122973, 2124113, 2125232, 2126383,
2127523, 2128667, 2129826, 2130923, 2132078, 2133230, 2134362, 2135479,
2136646, 2137793, 2138907, 2140038, 2141155, 2142295, 2143438, 2144569,
2145673, 2146756, 2147890, 2149015, 2150149, 2151276, 2152428, 2153564,
2154675, 2155816, 2156934, 2158093, 2159199, 2160361, 2161507, 2162638,
2163758, 2164897, 2166026, 2167148, 2168259, 2169395, 2170512, 2171605,
2172726, 2173851, 2175004, 2176119, 2177252, 2178357, 2179541, 2180700,
2181821, 2182929, 2184081, 2185213, 2186381, 2187484, 2188600, 2189736,
2190891, 2192014, 2193136, 2194292, 2195421, 2196535, 2197658, 2198794,
2199922, 2201030, 2202161, 2203294, 2204434, 2205561, 2206681, 2207837,
2209001, 2210140, 2211298, 2212429, 2213549, 2214677, 2215785, 2216928,
2218074, 2219206, 2220366, 2221475, 2222613, 2223776, 2224895, 2226040,
2227128, 2228262, 2229393, 2230535, 2231639, 2232737, 2233846, 2235016,
2236150, 2237263, 2238392, 2239546, 2240656, 2241810, 2242901, 2244074,
2245175, 2246287, 2247432, 2248549, 2249672, 2250833, 2251964, 2253118,
2254236, 2255357, 2256508, 2257629, 2258801, 2259905, 2261027, 2262193,
2263286, 2264401, 2265560, 2266661, 2267782, 2268901, 2270007, 2271119,
2272251, 2273370, 2274498, 2275592, 2276736, 2277849, 2278992, 2280098,
2281239, 2282364, 2283479, 2284623, 2285779, 2286889, 2288019, 2289149,
2290298, 2291410, 2292507, 2293648, 2294792, 2295923, 2297009, 2298141,
2299262, 2300419, 2301547, 2302638, 2303730, 2304859, 2306009, 2307115,
2308247, 2309398, 2310540, 2311658, 2312767, 2313896, 2315013, 2316133,
2317240, 2318398, 2319525, 2320663, 2321802, 2322912, 2324000, 2325147,
2326295, 2327445, 2328558, 2329655, 2330791, 2331910, 2333021, 2334137,
2335218, 2336362, 2337530, 2338659, 2339756, 2340871, 2342016, 2343166,
2344315, 2345435, 2346562, 2347695, 2348843, 2349930, 2351060, 2352173,
2353265, 2354378, 2355527, 2356668, 2357782, 2358943, 2360050, 2361178,
2362345, 2363466, 2364617, 2365749, 2366876, 2367999, 2369132, 2370224,
2371346, 2372474, 2373608, 2374742, 2375866, 2376969, 2378110, 2379247,
2380364, 2381525, 2382643, 2383757, 2384877, 2385991, 2387133, 2388291,
2389450, 2390585, 2391723, 2392838, 2393937, 2395039, 2396152, 2397253,
2398411, 2399522, 2400624, 2401753, 2402894, 2404009, 2405150, 2406235,
2407387, 2408523, 2409643, 2410734, 2411920, 2413080, 2414179, 2415327,
2416457, 2417613, 2418717, 2419827, 2420907, 2422000, 2423114, 2424240,
2425399, 2426498, 2427581, 2428718, 2429825, 2430977, 2432108, 2433229,
2434356, 2435475, 2436592, 2437745, 2438837, 2440012, 2441146, 2442268,
2443449, 2444593, 2445707, 2446775, 2447925, 2449031, 2450134, 2451274,
2452376, 2453525, 2454652, 2455762, 2456892, 2458062, 2459155, 2460283,
2461395, 2462489, 2463609, 2464711, 2465871, 2466976, 2468099, 2469211,
2470357, 2471482, 2472583, 2473707, 2474823, 2475943, 2477059, 2478166,
2479290, 2480431, 2481563, 2482705, 2483874, 2485003, 2486140, 2487269,
2488367, 2489461, 2490602, 2491701, 2492848, 2493966, 2495076, 2496207,
2497307, 2498419, 2499503, 2500659, 2501804, 2502935, 2504020, 2505162,
2506246, 2507383, 2508484, 2509628, 2510726, 2511876, 2513003, 2514143,
2515248, 2516383, 2517480, 2518579, 2519707, 2520798, 2521921, 2523047,
2524156, 2525262, 2526391, 2527548, 2528678, 2529783, 2530891, 2532052,
2533162, 2534303, 2535404, 2536511, 2537613, 2538726, 2539829, 2540987,
2542131, 2543252, 2544386, 2545511, 2546633, 2547750, 2548883, 2550020,
2551147, 2552259, 2553403, 2554546, 2555687, 2556798, 2557902, 2559015,
2560159, 2561269, 2562398, 2563523, 2564645, 2565792, 2566918, 2568025,
2569097, 2570176, 2571347, 2572471, 2573582, 2574715, 2575828, 2576945,
2578067, 2579217, 2580331, 2581417, 2582529, 2583650, 2584778, 2585933,
2587060, 2588182, 2589337, 2590458, 2591538, 2592684, 2593777, 2594897,
2596026, 2597147, 2598266, 2599355, 2600460, 2601548, 2602653, 2603814,
2604944, 2606069, 2607162, 2608267, 2609374, 2610464, 2611569, 2612695,
2613806, 2614932, 2616053, 2617200, 2618324, 2619489, 2620562, 2621701,
2622834, 2623959, 2625065, 2626169, 2627251, 2628385, 2629514, 2630610,
2631713, 2632837, 2633958, 2635051, 2636145, 2637279, 2638397, 2639513,
2640641, 2641788, 2642907, 2644077, 2645167, 2646279, 2647348, 2648465,
2649592, 2650692, 2651769, 2652893, 2654005, 2655155, 2656237, 2657365,
2658437, 2659572, 2660688, 2661818, 2662923, 2664061, 2665182, 2666309,
2667432, 2668566, 2669664, 2670798, 2671915, 2673043, 2674137, 2675309,
2676427, 2677529, 2678675, 2679776, 2680917, 2682046, 2683172, 2684307,
2685440, 2686563, 2687690, 2688802, 2689876, 2690951, 2692053, 2693162,
2694298, 2695427, 2696524, 2697643, 2698755, 2699903, 2701018, 2702113,
2703263, 2704378, 2705503, 2706570, 2707701, 2708784, 2709877, 2711006,
2712099, 2713206, 2714319, 2715483, 2716597, 2717744, 2718907, 2720017,
2721102, 2722239, 2723346, 2724450, 2725559, 2726662, 2727762, 2728854,
2729966, 2731073, 2732196, 2733316, 2734467, 2735585, 2736699, 2737800,
2738921, 2740096, 2741206, 2742346, 2743477, 2744603, 2745687, 2746815,
2747905, 2749004, 2750134, 2751287, 2752375, 2753497, 2754595, 2755712,
2756871, 2758002, 2759122, 2760234, 2761344, 2762457, 2763571, 2764649,
2765751, 2766881, 2768032, 2769131, 2770254, 2771372, 2772494, 2773608,
2774733, 2775840, 2776996, 2778051, 2779164, 2780284, 2781403, 2782511,
2783629, 2784735, 2785810, 2786958, 2788075, 2789224, 2790335, 2791457,
2792595, 2793689, 2794815, 2795937, 2797024, 2798151, 2799278, 2800394,
2801527, 2802621, 2803738, 2804812, 2805954, 2807067, 2808179, 2809258,
2810360, 2811474, 2812598, 2813743, 2814874, 2815977, 2817079, 2818159,
2819316, 2820425, 2821547, 2822642, 2823777, 2824928, 2826009, 2827114,
2828203, 2829331, 2830426, 2831551, 2832676, 2833780, 2834889, 2835982,
2837100, 2838188, 2839333, 2840454, 2841587, 2842700, 2843810, 2844925,
2846034, 2847123, 2848224, 2849345, 2850483, 2851554, 2852659, 2853773,
2854923, 2856056, 2857151, 2858283, 2859318, 2860446, 2861547, 2862666,
2863781, 2864883, 2865966, 2867108, 2868217, 2869348, 2870511, 2871588,
2872684, 2873814, 2874904, 2876015, 2877112, 2878239, 2879361, 2880481,
2881619, 2882729, 2883806, 2884933, 2886051, 2887177, 2888274, 2889375,
2890468, 2891550, 2892669, 2893802, 2894888, 2896006, 2897131, 2898240,
2899366, 2900478, 2901586, 2902683, 2903784, 2904884, 2905997, 2907145,
2908262, 2909391, 2910486, 2911600, 2912689, 2913831, 2914952, 2916049,
2917180, 2918264, 2919353, 2920482, 2921588, 2922717, 2923791, 2924939,
2926045, 2927153, 2928237, 2929345, 2930434, 2931562, 2932688, 2933823,
2934910, 2936025, 2937164, 2938221, 2939351, 2940487, 2941605, 2942731,
2943869, 2945015, 2946114, 2947208, 2948312, 2949426, 2950542, 2951679,
2952789, 2953898, 2955008, 2956101, 2957227, 2958337, 2959451, 2960546,
2961645, 2962790, 2963921, 2964998, 2966095, 2967159, 2968262, 2969390,
2970474, 2971593, 2972697, 2973830, 2974930, 2976033, 2977155, 2978233,
2979343, 2980462, 2981566, 2982655, 2983749, 2984843, 2985964, 2987082,
2988218, 2989350, 2990483, 2991585, 2992734, 2993811, 2994954, 2996087,
2997188, 2998301, 2999424, 3000523, 3001616, 3002746, 3003870, 3004950,
3006072, 3007181, 3008287, 3009367, 3010493, 3011626, 3012741, 3013849,
3014914, 3016036, 3017168, 3018271, 3019376, 3020480, 3021591, 3022697,
3023807, 3024919, 3026028, 3027143, 3028257, 3029357, 3030456, 3031568,
3032680, 3033799, 3034888, 3036028, 3037107, 3038216, 3039312, 3040416,
3041522, 3042628, 3043749, 3044861, 3045955, 3047045, 3048173, 3049314,
3050404, 3051523, 3052601, 3053708, 3054822, 3055934, 3057048, 3058150,
3059268, 3060355, 3061481, 3062563, 3063648, 3064753, 3065899, 3067001,
3068067, 3069188, 3070285, 3071414, 3072541, 3073653, 3074769, 3075892,
3076989, 3078106, 3079228, 3080337, 3081478, 3082576, 3083701, 3084790,
3085872, 3086993, 3088123, 3089235, 3090368, 3091462, 3092577, 3093672,
3094791, 3095854, 3096922, 3098006, 3099140, 3100257, 3101377, 3102480,
3103577, 3104687, 3105810, 3106932, 3108037, 3109149, 3110294, 3111417,
3112548, 3113641, 3114775, 3115881, 3116977, 3118101, 3119212, 3120324,
3121399, 3122517, 3123625, 3124725, 3125830, 3126945, 3128068, 3129195,
3130311, 3131421, 3132535, 3133623, 3134714, 3135852, 3136967, 3138101,
3139190, 3140288, 3141397, 3142503, 3143607, 3144726, 3145840, 3146970,
3148069, 3149145, 3150285, 3151445, 3152549, 3153645, 3154726, 3155851,
3156924, 3157996, 3159121, 3160208, 3161276, 3162399, 3163518, 3164623,
3165700, 3166801, 3167918, 3169039, 3170165, 3171280, 3172371, 3173465,
3174575, 3175713, 3176806, 3177918, 3179027, 3180146, 3181235, 3182336,
3183467, 3184570, 3185637, 3186750, 3187859, 3188987, 3190097, 3191162,
3192307, 3193409, 3194492, 3195595, 3196711, 3197864, 3198984, 3200091,
3201214, 3202351, 3203433, 3204551, 3205659, 3206776, 3207922, 3209051,
3210131, 3211285, 3212380, 3213492, 3214598, 3215706, 3216798, 3217875,
3218956, 3220030, 3221159, 3222242, 3223383, 3224482, 3225587, 3226736,
3227837, 3228931, 3230041, 3231127, 3232226, 3233343, 3234466, 3235562,
3236712, 3237780, 3238872, 3239957, 3241081, 3242193, 3243278, 3244354,
3245463, 3246567, 3247680, 3248737, 3249845, 3250959, 3252045, 3253131,
3254253, 3255342, 3256409, 3257492, 3258604, 3259683, 3260785, 3261859,
3262989, 3264119, 3265199, 3266292, 3267401, 3268505, 3269614, 3270720,
3271825, 3272913, 3274006, 3275076, 3276239, 3277379, 3278467, 3279574,
3280684, 3281770, 3282887, 3283959, 3285068, 3286163, 3287269, 3288398,
3289498, 3290583, 3291702, 3292826, 3293931, 3295024, 3296094, 3297219,
3298296, 3299430, 3300511, 3301635, 3302744, 3303850, 3304935, 3306057,
3307147, 3308239, 3309301, 3310415, 3311535, 3312654, 3313764, 3314868,
3315984, 3317091, 3318169, 3319270, 3320387, 3321471, 3322617, 3323720,
3324821, 3325898, 3326962, 3328078, 3329173, 3330264, 3331388, 3332470,
3333558, 3334629, 3335736, 3336836, 3337910, 3339061, 3340172, 3341263,
3342363, 3343434, 3344523, 3345626, 3346744, 3347875, 3348981, 3350075,
3351167, 3352300, 3353392, 3354488, 3355634, 3356719, 3357825, 3358915,
3359992, 3361111, 3362235, 3363312, 3364407, 3365511, 3366618, 3367723,
3368841, 3369956, 3371063, 3372186, 3373288, 3374405, 3375499, 3376578,
3377712, 3378826, 3379905, 3381048, 3382123, 3383230, 3384325, 3385427,
3386501, 3387575, 3388677, 3389755, 3390855, 3391958, 3393055, 3394173,
3395289, 3396410, 3397466, 3398609, 3399699, 3400797, 3401922, 3403034,
3404147, 3405240, 3406349, 3407461, 3408546, 3409673, 3410770, 3411867,
3412962, 3414084, 3415168, 3416272, 3417370, 3418447, 3419559, 3420683,
3421757, 3422884, 3423954, 3425011, 3426123, 3427261, 3428352, 3429433,
3430490, 3431607, 3432719, 3433803, 3434895, 3435976, 3437091, 3438188,
3439320, 3440420, 3441490, 3442595, 3443736, 3444842, 3445929, 3447038,
3448173, 3449288, 3450385, 3451482, 3452568, 3453675, 3454750, 3455825,
3456955, 3458032, 3459128, 3460279, 3461356, 3462460, 3463591, 3464667,
3465720, 3466836, 3467950, 3469027, 3470135, 3471220, 3472329, 3473418,
3474539, 3475648, 3476758, 3477834, 3478917, 3480028, 3481119, 3482186,
3483282, 3484407, 3485504, 3486600, 3487710, 3488780, 3489887, 3491017,
3492119, 3493214, 3494336, 3495429, 3496557, 3497679, 3498785, 3499875,
3500974, 3502054, 3503160, 3504280, 3505410, 3506514, 3507606, 3508739,
3509807, 3510915, 3512041, 3513167, 3514236, 3515345, 3516436, 3517561,
3518651, 3519748, 3520858, 3521951, 3523055, 3524149, 3525231, 3526352,
3527457, 3528606, 3529687, 3530757, 3531827, 3532950, 3534048, 3535170,
3536298, 3537408, 3538509, 3539588, 3540698, 3541783, 3542884, 3543946,
3545071, 3546161, 3547249, 3548367, 3549474, 3550564, 3551647, 3552787,
3553872, 3554972, 3556063, 3557159, 3558256, 3559380, 3560473, 3561603,
3562686, 3563787, 3564870, 3565977, 3567041, 3568141, 3569214, 3570308,
3571418, 3572496, 3573603, 3574707, 3575826, 3576952, 3578013, 3579120,
3580221, 3581343, 3582440, 3583537, 3584660, 3585752, 3586848, 3587969,
3589074, 3590160, 3591237, 3592303, 3593419, 3594521, 3595569, 3596697,
3597817, 3598917, 3599998, 3601118, 3602200, 3603296, 3604398, 3605469,
3606570, 3607694, 3608805, 3609934, 3611057, 3612148, 3613227, 3614329,
3615398, 3616503, 3617628, 3618698, 3619804, 3620952, 3622045, 3623153,
3624246, 3625335, 3626426, 3627527, 3628638, 3629723, 3630808, 3631941,
3633008, 3634096, 3635224, 3636341, 3637456, 3638566, 3639644, 3640738,
3641838, 3642912, 3644001, 3645120, 3646211, 3647267, 3648355, 3649488,
3650602, 3651716, 3652800, 3653927, 3655049, 3656160, 3657266, 3658408,
3659526, 3660604, 3661717, 3662780, 3663878, 3664950, 3666071, 3667191,
3668322, 3669403, 3670486, 3671570, 3672680, 3673780, 3674931, 3676005,
3677089, 3678200, 3679304, 3680385, 3681513, 3682642, 3683739, 3684810,
3685864, 3686950, 3688028, 3689167, 3690251, 3691322, 3692382, 3693494,
3694595, 3695662, 3696729, 3697831, 3698933, 3700060, 3701128, 3702228,
3703279, 3704384, 3705479, 3706586, 3707695, 3708821, 3709929, 3711002,
3712111, 3713205, 3714331, 3715441, 3716551, 3717628, 3718726, 3719822,
3720907, 3722021, 3723136, 3724234, 3725361, 3726463, 3727551, 3728654,
3729771, 3730868, 3731946, 3733055, 3734193, 3735318, 3736367, 3737471,
3738486, 3739600, 3740705, 3741825, 3742925, 3744036, 3745104, 3746203,
3747291, 3748398, 3749524, 3750632, 3751696, 3752800, 3753903, 3754997,
3756103, 3757205, 3758315, 3759389, 3760482, 3761580, 3762676, 3763770,
3764882, 3766011, 3767055, 3768135, 3769221, 3770320, 3771449, 3772567,
3773666, 3774740, 3775787, 3776860, 3777970, 3779083, 3780156, 3781300,
3782376, 3783492, 3784581, 3785667, 3786736, 3787832, 3788904, 3789986,
3791102, 3792191, 3793256, 3794370, 3795472, 3796570, 3797675, 3798756,
3799882, 3800937, 3802073, 3803168, 3804287, 3805383, 3806482, 3807573,
3808714, 3809829, 3810885, 3811965, 3813084, 3814147, 3815266, 3816376,
3817454, 3818544, 3819630, 3820751, 3821849, 3822950, 3824050, 3825173,
3826290, 3827345, 3828435, 3829557, 3830626, 3831717, 3832789, 3833892,
3834991, 3836097, 3837141, 3838216, 3839300, 3840378, 3841480, 3842592,
3843670, 3844766, 3845836, 3846933, 3848037, 3849114, 3850189, 3851277,
3852322, 3853445, 3854545, 3855623, 3856692, 3857781, 3858875, 3859994,
3861113, 3862269, 3863324, 3864439, 3865538, 3866669, 3867744, 3868851,
3869947, 3871007, 3872080, 3873171, 3874280, 3875333, 3876441, 3877529,
3878611, 3879695, 3880766, 3881843, 3882921, 3884050, 3885124, 3886229,
3887370, 3888467, 3889573, 3890664, 3891785, 3892886, 3893966, 3895056,
3896146, 3897275, 3898344, 3899425, 3900530, 3901572, 3902606, 3903703,
3904783, 3905871, 3906955, 3908056, 3909114, 3910180, 3911292, 3912389,
3913482, 3914584, 3915656, 3916765, 3917878, 3918945, 3920056, 3921124,
3922212, 3923304, 3924390, 3925512, 3926600, 3927698, 3928812, 3929898,
3930997, 3932092, 3933223, 3934316, 3935364, 3936456, 3937577, 3938678,
3939772, 3940908, 3942013, 3943109, 3944217, 3945322, 3946401, 3947519,
3948626, 3949702, 3950823, 3951915, 3952988, 3954093, 3955212, 3956338,
3957462, 3958559, 3959638, 3960728, 3961802, 3962887, 3963957, 3965056,
3966153, 3967225, 3968305, 3969389, 3970460, 3971554, 3972659, 3973770,
3974869, 3975940, 3977005, 3978083, 3979153, 3980209, 3981309, 3982430,
3983504, 3984548, 3985646, 3986748, 3987833, 3988911, 3990052, 3991155,
3992245, 3993370, 3994425, 3995510, 3996587, 3997725, 3998820, 3999918,
4000999, 4002110, 4003227, 4004293, 4005375, 4006491, 4007589, 4008674,
4009765, 4010864, 4011975, 4013050, 4014151, 4015272, 4016349, 4017413,
4018531, 4019663, 4020736, 4021828, 4022889, 4023972, 4025046, 4026146,
4027241, 4028332, 4029437, 4030498, 4031605, 4032709, 4033768, 4034860,
4035943, 4037059, 4038166, 4039244, 4040327, 4041406, 4042533, 4043633,
4044741, 4045840, 4046939, 4048041, 4049121, 4050203, 4051286, 4052400,
4053485, 4054567, 4055676, 4056771, 4057838, 4058919, 4060033, 4061170,
4062244, 4063350, 4064426, 4065532, 4066607, 4067713, 4068827, 4069904,
4071027, 4072111, 4073237, 4074345, 4075421, 4076494, 4077561, 4078665,
4079760, 4080868, 4081970, 4083026, 4084121, 4085201, 4086272, 4087378,
4088436, 4089551, 4090637, 4091745, 4092844, 4093933, 4094992, 4096121,
4097205, 4098271, 4099352, 4100474, 4101566, 4102643, 4103745, 4104814,
4105899, 4106999, 4108067, 4109159, 4110253, 4111339, 4112454, 4113535,
4114646, 4115752, 4116831, 4117933, 4119030, 4120103, 4121213, 4122303,
4123420, 4124494, 4125580, 4126687, 4127746, 4128872, 4129944, 4131058,
4132122, 4133201, 4134308, 4135392, 4136481, 4137581, 4138670, 4139758,
4140890, 4141978, 4143064, 4144149, 4145267, 4146322, 4147394, 4148502,
4149584, 4150685, 4151833, 4152888, 4153956, 4155074, 4156169, 4157287,
4158364, 4159451, 4160517, 4161569, 4162668, 4163732, 4164818, 4165889,
4167019, 4168109, 4169174, 4170278, 4171376, 4172472, 4173554, 4174611,
4175701, 4176794, 4177878, 4178950, 4180058, 4181128, 4182245, 4183349,
4184400, 4185514, 4186604, 4187676, 4188780, 4189866, 4190950, 4192058,
4193140, 4194199, 4195280, 4196355, 4197442, 4198513, 4199600, 4200704,
4201778, 4202868, 4203953, 4205066, 4206137, 4207251, 4208313, 4209411,
4210509, 4211572, 4212640, 4213723, 4214857, 4215975, 4217068, 4218158,
4219255, 4220360, 4221414, 4222479, 4223553, 4224659, 4225755, 4226822,
4227911, 4228982, 4230080, 4231162, 4232262, 4233331, 4234420, 4235528,
4236616, 4237683, 4238732, 4239817, 4240936, 4242024, 4243117, 4244168,
4245258, 4246335, 4247418, 4248474, 4249561, 4250642, 4251723, 4252811,
4253918, 4255025, 4256085, 4257180, 4258261, 4259332, 4260438, 4261524,
4262589, 4263701, 4264785, 4265861, 4266922, 4268031, 4269135, 4270243,
4271336, 4272406, 4273504, 4274631, 4275716, 4276773, 4277861, 4278898,
4279993, 4281055, 4282131, 4283191, 4284268, 4285329, 4286403, 4287492,
4288579, 4289659, 4290740, 4291882, 4292946, 4294012, 4295109, 4296218,
4297301, 4298368, 4299425, 4300536, 4301621, 4302741, 4303828, 4304886,
4305977, 4307028, 4308094, 4309195, 4310253, 4311370, 4312449, 4313548,
4314622, 4315750, 4316844, 4317958, 4319081, 4320149, 4321279, 4322364,
4323442, 4324537, 4325674, 4326741, 4327802, 4328881, 4329979, 4331101,
4332158, 4333264, 4334362, 4335411, 4336521, 4337616, 4338682, 4339739,
4340838, 4341879, 4342980, 4344086, 4345139, 4346257, 4347333, 4348412,
4349481, 4350593, 4351679, 4352763, 4353863, 4354952, 4356033, 4357129,
4358181, 4359269, 4360353, 4361468, 4362554, 4363640, 4364674, 4365749,
4366837, 4367918, 4369051, 4370156, 4371263, 4372321, 4373392, 4374432,
4375553, 4376631, 4377710, 4378808, 4379899, 4380986, 4382099, 4383210,
4384347, 4385443, 4386500, 4387574, 4388660, 4389776, 4390870, 4391953,
4393022, 4394126, 4395232, 4396287, 4397364, 4398462, 4399578, 4400669,
4401775, 4402819, 4403920, 4405024, 4406115, 4407189, 4408270, 4409311,
4410394, 4411491, 4412536, 4413643, 4414748, 4415817, 4416886, 4418001,
4419084, 4420200, 4421303, 4422413, 4423478, 4424559, 4425612, 4426705,
4427764, 4428858, 4429973, 4431002, 4432086, 4433201, 4434264, 4435370,
4436468, 4437559, 4438580, 4439711, 4440809, 4441848, 4442965, 4444047,
4445136, 4446216, 4447285, 4448350, 4449378, 4450434, 4451501, 4452586,
4453649, 4454724, 4455838, 4456918, 4457972, 4459075, 4460184, 4461273,
4462375, 4463467, 4464543, 4465617, 4466689, 4467742, 4468859, 4469947,
4471006, 4472099, 4473196, 4474312, 4475399, 4476484, 4477533, 4478627,
4479723, 4480813, 4481908, 4483016, 4484076, 4485162, 4486262, 4487337,
4488401, 4489441, 4490531, 4491670, 4492744, 4493843, 4494917, 4495992,
4497095, 4498169, 4499286, 4500383, 4501445, 4502539, 4503633, 4504708,
4505787, 4506835, 4507923, 4509031, 4510154, 4511194, 4512301, 4513384,
4514519, 4515621, 4516717, 4517776, 4518873, 4519954, 4521020, 4522114,
4523172, 4524240, 4525312, 4526387, 4527488, 4528551, 4529655, 4530731,
4531820, 4532916, 4533989, 4535062, 4536133, 4537190, 4538273, 4539358,
4540431, 4541496, 4542604, 4543672, 4544755, 4545879, 4546960, 4548035,
4549129, 4550223, 4551307, 4552399, 4553473, 4554548, 4555657, 4556729,
4557825, 4558931, 4560015, 4561079, 4562139, 4563255, 4564322, 4565401,
4566495, 4567580, 4568655, 4569745, 4570802, 4571915, 4573019, 4574103,
4575184, 4576266, 4577333, 4578412, 4579509, 4580618, 4581710, 4582839,
4583920, 4585017, 4586095, 4587202, 4588279, 4589400, 4590472, 4591555,
4592654, 4593716, 4594807, 4595858, 4596938, 4598022, 4599108, 4600227,
4601312, 4602390, 4603474, 4604526, 4605606, 4606691, 4607788, 4608890,
4609974, 4611056, 4612119, 4613193, 4614272, 4615352, 4616432, 4617505,
4618581, 4619651, 4620721, 4621770, 4622871, 4623957, 4625044, 4626110,
4627192, 4628288, 4629346, 4630432, 4631546, 4632656, 4633700, 4634771,
4635837, 4636894, 4637980, 4639075, 4640129, 4641191, 4642298, 4643384,
4644488, 4645612, 4646669, 4647698, 4648781, 4649863, 4650922, 4652016,
4653124, 4654196, 4655292, 4656394, 4657507, 4658616, 4659675, 4660755,
4661825, 4662921, 4663959, 4665016, 4666114, 4667204, 4668276, 4669335,
4670440, 4671510, 4672614, 4673689, 4674768, 4675852, 4676950, 4677973,
4679092, 4680155, 4681224, 4682320, 4683436, 4684539, 4685620, 4686685,
4687756, 4688813, 4689890, 4690985, 4692073, 4693137, 4694209, 4695327,
4696435, 4697477, 4698578, 4699655, 4700735, 4701804, 4702878, 4703998,
4705046, 4706132, 4707225, 4708309, 4709374, 4710462, 4711546, 4712611,
4713682, 4714817, 4715915, 4716995, 4718072, 4719130, 4720206, 4721279,
4722390, 4723456, 4724540, 4725658, 4726726, 4727839, 4728940, 4730041,
4731078, 4732212, 4733288, 4734385, 4735478, 4736580, 4737688, 4738766,
4739875, 4740909, 4741993, 4743059, 4744136, 4745234, 4746292, 4747397,
4748468, 4749546, 4750578, 4751701, 4752773, 4753863, 4754977, 4756069,
4757124, 4758184, 4759272, 4760362, 4761450, 4762527, 4763622, 4764707,
4765796, 4766848, 4767906, 4768960, 4770035, 4771106, 4772168, 4773269,
4774351, 4775407, 4776529, 4777613, 4778690, 4779780, 4780873, 4781953,
4783029, 4784121, 4785207, 4786250, 4787338, 4788464, 4789533, 4790624,
4791703, 4792782, 4793858, 4794909, 4795994, 4797087, 4798170, 4799240,
4800339, 4801401, 4802481, 4803543, 4804633, 4805738, 4806809, 4807877,
4808985, 4810049, 4811146, 4812207, 4813285, 4814391, 4815466, 4816514,
4817623, 4818696, 4819807, 4820868, 4821951, 4823047, 4824102, 4825221,
4826271, 4827358, 4828437, 4829502, 4830594, 4831711, 4832739, 4833825,
4834933, 4836016, 4837076, 4838183, 4839296, 4840394, 4841469, 4842568,
4843659, 4844757, 4845836, 4846920, 4847991, 4849085, 4850143, 4851183,
4852269, 4853328, 4854420, 4855480, 4856599, 4857686, 4858782, 4859853,
4860935, 4861991, 4863075, 4864157, 4865230, 4866333, 4867411, 4868464,
4869569, 4870654, 4871713, 4872774, 4873832, 4874879, 4875983, 4877091,
4878153, 4879247, 4880336, 4881380, 4882472, 4883559, 4884664, 4885742,
4886813, 4887893, 4888975, 4890062, 4891184, 4892252, 4893311, 4894408,
4895492, 4896567, 4897635, 4898752, 4899810, 4900890, 4901965, 4903053,
4904102, 4905219, 4906250, 4907323, 4908420, 4909506, 4910569, 4911657,
4912733, 4913788, 4914866, 4915943, 4917033, 4918090, 4919215, 4920302,
4921370, 4922434, 4923516, 4924586, 4925648, 4926729, 4927831, 4928906,
4929997, 4931080, 4932143, 4933223, 4934296, 4935403, 4936473, 4937581,
4938675, 4939758, 4940835, 4941910, 4942983, 4944077, 4945149, 4946265,
4947314, 4948391, 4949498, 4950518, 4951618, 4952668, 4953756, 4954844,
4955915, 4957013, 4958091, 4959185, 4960260, 4961364, 4962447, 4963528,
4964643, 4965724, 4966821, 4967908, 4968989, 4970045, 4971097, 4972178,
4973225, 4974317, 4975391, 4976480, 4977554, 4978625, 4979728, 4980824,
4981910, 4982968, 4984092, 4985194, 4986247, 4987320, 4988387, 4989473,
4990590, 4991673, 4992753, 4993805, 4994855, 4995956, 4997039, 4998128,
4999209, 5000299, 5001391, 5002457, 5003533, 5004594, 5005679, 5006791,
5007903, 5008991, 5010103, 5011208, 5012285, 5013355, 5014453, 5015506,
5016597, 5017666, 5018742, 5019810, 5020905, 5021995, 5023035, 5024124,
5025179, 5026258, 5027336, 5028387, 5029496, 5030585, 5031637, 5032714,
5033783, 5034876, 5035941, 5036998, 5038062, 5039129, 5040204, 5041244,
5042334, 5043431, 5044498, 5045569, 5046611, 5047695, 5048816, 5049912,
5050984, 5052057, 5053142, 5054191, 5055311, 5056356, 5057383, 5058495,
5059590, 5060692, 5061757, 5062856, 5063898, 5064977, 5066079, 5067171,
5068273, 5069344, 5070406, 5071480, 5072589, 5073623, 5074719, 5075802,
5076845, 5077885, 5078932, 5080021, 5081067, 5082149, 5083229, 5084364,
5085396, 5086474, 5087550, 5088617, 5089688, 5090755, 5091836, 5092879,
5093990, 5095065, 5096144, 5097212, 5098302, 5099343, 5100398, 5101481,
5102559, 5103647, 5104715, 5105793, 5106882, 5107956, 5109036, 5110115,
5111189, 5112297, 5113347, 5114449, 5115519, 5116596, 5117648, 5118729,
5119796, 5120886, 5121958, 5123008, 5124115, 5125191, 5126287, 5127376,
5128440, 5129529, 5130619, 5131689, 5132783, 5133896, 5134979, 5136042,
5137137, 5138212, 5139295, 5140382, 5141461, 5142517, 5143614, 5144709,
5145772, 5146858, 5147908, 5149004, 5150128, 5151203, 5152247, 5153353,
5154419, 5155501, 5156599, 5157695, 5158727, 5159811, 5160865, 5161931,
5162994, 5164064, 5165110, 5166174, 5167281, 5168372, 5169421, 5170494,
5171588, 5172672, 5173747, 5174861, 5175947, 5177013, 5178100, 5179168,
5180207, 5181271, 5182354, 5183454, 5184548, 5185597, 5186661, 5187731,
5188802, 5189900, 5190971, 5192044, 5193115, 5194202, 5195306, 5196371,
5197454, 5198524, 5199631, 5200679, 5201752, 5202844, 5203950, 5205033,
5206101, 5207177, 5208229, 5209345, 5210454, 5211532, 5212597, 5213632,
5214707, 5215743, 5216801, 5217862, 5218953, 5220052, 5221091, 5222176,
5223271, 5224336, 5225441, 5226539, 5227608, 5228698, 5229802, 5230859,
5231929, 5232969, 5234046, 5235139, 5236205, 5237296, 5238370, 5239411,
5240497, 5241579, 5242706, 5243742, 5244820, 5245915, 5246949, 5248009,
5249087, 5250146, 5251230, 5252301, 5253402, 5254498, 5255608, 5256692,
5257752, 5258835, 5259936, 5261006, 5262092, 5263177, 5264253, 5265325,
5266386, 5267480, 5268536, 5269610, 5270687, 5271763, 5272828, 5273929,
5274982, 5276092, 5277188, 5278257, 5279358, 5280433, 5281504, 5282551,
5283598, 5284682, 5285762, 5286819, 5287930, 5288981, 5290033, 5291092,
5292145, 5293202, 5294275, 5295337, 5296410, 5297451, 5298504, 5299563,
5300605, 5301685, 5302739, 5303819, 5304907, 5305997, 5307072, 5308119,
5309189, 5310251, 5311313, 5312391, 5313466, 5314549, 5315607, 5316720,
5317766, 5318837, 5319893, 5320945, 5321997, 5323056, 5324163, 5325243,
5326292, 5327348, 5328433, 5329495, 5330558, 5331627, 5332698, 5333752,
5334822, 5335883, 5336963, 5338043, 5339124, 5340196, 5341265, 5342347,
5343427, 5344497, 5345605, 5346692, 5347796, 5348861, 5349952, 5351039,
5352149, 5353216, 5354280, 5355366, 5356458, 5357534, 5358625, 5359698,
5360781, 5361801, 5362862, 5363934, 5364999, 5366073, 5367155, 5368232,
5369323, 5370399, 5371468, 5372563, 5373654, 5374755, 5375806, 5376880,
5377957, 5379026, 5380100, 5381161, 5382257, 5383330, 5384413, 5385469,
5386554, 5387624, 5388677, 5389751, 5390836, 5391906, 5393015, 5394090,
5395133, 5396208, 5397259, 5398298, 5399390, 5400495, 5401566, 5402635,
5403725, 5404814, 5405879, 5406983, 5408061, 5409151, 5410228, 5411297,
5412383, 5413465, 5414535, 5415572, 5416609, 5417681, 5418771, 5419849,
5420898, 5421994, 5423091, 5424150, 5425255, 5426294, 5427391, 5428481,
5429524, 5430600, 5431678, 5432765, 5433815, 5434925, 5436008, 5437072,
5438110, 5439183, 5440261, 5441284, 5442365, 5443421, 5444493, 5445594,
5446686, 5447755, 5448858, 5449930, 5450973, 5452021, 5453075, 5454144,
5455226, 5456343, 5457421, 5458462, 5459515, 5460587, 5461640, 5462717,
5463764, 5464833, 5465892, 5466962, 5468065, 5469154, 5470184, 5471210,
5472304, 5473372, 5474449, 5475488, 5476545, 5477605, 5478673, 5479734,
5480794, 5481891, 5482969, 5484040, 5485119, 5486208, 5487257, 5488319,
5489380, 5490444, 5491519, 5492586, 5493646, 5494745, 5495811, 5496905,
5497980, 5499037, 5500117, 5501195, 5502304, 5503389, 5504480, 5505540,
5506638, 5507716, 5508765, 5509816, 5510889, 5511933, 5512975, 5514033,
5515119, 5516199, 5517249, 5518309, 5519392, 5520472, 5521581, 5522686,
5523805, 5524860, 5525912, 5526994, 5528031, 5529131, 5530176, 5531255,
5532296, 5533341, 5534416, 5535476, 5536581, 5537656, 5538768, 5539846,
5540963, 5542054, 5543162, 5544250, 5545317, 5546405, 5547433, 5548479,
5549552, 5550614, 5551683, 5552770, 5553856, 5554931, 5555998, 5557025,
5558098, 5559195, 5560276, 5561350, 5562401, 5563477, 5564519, 5565609,
5566696, 5567805, 5568908, 5569976, 5571038, 5572111, 5573154, 5574274,
5575355, 5576408, 5577507, 5578542, 5579616, 5580657, 5581766, 5582824,
5583881, 5584936, 5586024, 5587090, 5588177, 5589272, 5590359, 5591432,
5592517, 5593599, 5594665, 5595756, 5596852, 5597899, 5598972, 5600063,
5601145, 5602207, 5603261, 5604320, 5605377, 5606445, 5607516, 5608598,
5609644, 5610715, 5611776, 5612900, 5613947, 5615014, 5616080, 5617132,
5618162, 5619246, 5620336, 5621418, 5622503, 5623562, 5624625, 5625714,
5626827, 5627914, 5629024, 5630071, 5631150, 5632207, 5633236, 5634315,
5635415, 5636452, 5637555, 5638620, 5639700, 5640755, 5641847, 5642944,
5644006, 5645066, 5646125, 5647161, 5648257, 5649312, 5650373, 5651404,
5652508, 5653547, 5654642, 5655720, 5656836, 5657890, 5658974, 5660067,
5661141, 5662221, 5663265, 5664333, 5665445, 5666504, 5667573, 5668655,
5669724, 5670760, 5671817, 5672900, 5673969, 5675046, 5676113, 5677178,
5678242, 5679317, 5680359, 5681423, 5682495, 5683531, 5684597, 5685679,
5686736, 5687796, 5688887, 5689972, 5691051, 5692099, 5693190, 5694219,
5695291, 5696395, 5697471, 5698529, 5699608, 5700684, 5701759, 5702855,
5703925, 5704947, 5706029, 5707085, 5708149, 5709227, 5710325, 5711388,
5712444, 5713485, 5714545, 5715629, 5716713, 5717812, 5718887, 5719934,
5721022, 5722091, 5723135, 5724197, 5725272, 5726303, 5727397, 5728497,
5729572, 5730669, 5731704, 5732801, 5733884, 5734945, 5736030, 5737098,
5738170, 5739230, 5740301, 5741362, 5742450, 5743494, 5744545, 5745596,
5746655, 5747724, 5748784, 5749832, 5750925, 5752011, 5753060, 5754144,
5755203, 5756249, 5757273, 5758366, 5759469, 5760542, 5761574, 5762632,
5763687, 5764782, 5765838, 5766895, 5768013, 5769071, 5770139, 5771193,
5772266, 5773320, 5774403, 5775469, 5776526, 5777578, 5778627, 5779686,
5780733, 5781794, 5782932, 5784000, 5785090, 5786183, 5787247, 5788287,
5789357, 5790469, 5791592, 5792681, 5793749, 5794823, 5795882, 5796926,
5797981, 5799073, 5800144, 5801212, 5802272, 5803341, 5804458, 5805521,
5806601, 5807679, 5808758, 5809851, 5810909, 5811950, 5813001, 5814084,
5815117, 5816212, 5817296, 5818351, 5819393, 5820453, 5821502, 5822568,
5823633, 5824722, 5825758, 5826847, 5827911, 5828994, 5830093, 5831202,
5832255, 5833330, 5834413, 5835493, 5836585, 5837671, 5838733, 5839809,
5840870, 5841918, 5843024, 5844103, 5845150, 5846216, 5847268, 5848376,
5849431, 5850488, 5851557, 5852616, 5853701, 5854757, 5855818, 5856895,
5857937, 5859020, 5860106, 5861203, 5862272, 5863326, 5864388, 5865488,
5866565, 5867618, 5868736, 5869806, 5870859, 5871942, 5872978, 5874063,
5875110, 5876210, 5877297, 5878393, 5879472, 5880531, 5881609, 5882678,
5883729, 5884801, 5885852, 5886910, 5887994, 5889088, 5890147, 5891240,
5892286, 5893330, 5894439, 5895505, 5896578, 5897647, 5898700, 5899736,
5900789, 5901865, 5902925, 5904006, 5905091, 5906183, 5907240, 5908345,
5909400, 5910454, 5911485, 5912581, 5913654, 5914711, 5915747, 5916796,
5917873, 5918917, 5919994, 5921081, 5922157, 5923245, 5924299, 5925384,
5926423, 5927517, 5928617, 5929710, 5930784, 5931857, 5932949, 5934028,
5935108, 5936176, 5937234, 5938282, 5939379, 5940453, 5941531, 5942608,
5943678, 5944724, 5945789, 5946858, 5947925, 5949025, 5950123, 5951154,
5952209, 5953272, 5954361, 5955423, 5956526, 5957631, 5958674, 5959782,
5960853, 5961912, 5962999, 5964090, 5965167, 5966222, 5967295, 5968406,
5969465, 5970511, 5971582, 5972628, 5973687, 5974753, 5975825, 5976888,
5977946, 5979042, 5980100, 5981147, 5982203, 5983278, 5984345, 5985413,
5986468, 5987533, 5988590, 5989633, 5990733, 5991829, 5992931, 5993997,
5995046, 5996088, 5997133, 5998177, 5999225, 6000264, 6001380, 6002462,
6003509, 6004556, 6005619, 6006682, 6007743, 6008805, 6009898, 6010960,
6012056, 6013133, 6014214, 6015295, 6016333, 6017389, 6018451, 6019521,
6020545, 6021567, 6022649, 6023712, 6024800, 6025898, 6026924, 6027986,
6029036, 6030123, 6031173, 6032234, 6033332, 6034385, 6035438, 6036535,
6037594, 6038627, 6039669, 6040780, 6041855, 6042933, 6044004, 6045069,
6046144, 6047198, 6048274, 6049329, 6050405, 6051474, 6052560, 6053607,
6054664, 6055684, 6056748, 6057816, 6058862, 6059929, 6061016, 6062106,
6063143, 6064245, 6065313, 6066402, 6067457, 6068523, 6069599, 6070702,
6071760, 6072782, 6073856, 6074894, 6075977, 6077046, 6078128, 6079199,
6080254, 6081296, 6082355, 6083459, 6084497, 6085533, 6086584, 6087689,
6088786, 6089808, 6090870, 6091928, 6093034, 6094160, 6095204, 6096249,
6097313, 6098358, 6099433, 6100488, 6101557, 6102597, 6103696, 6104761,
6105868, 6106900, 6107996, 6109022, 6110083, 6111179, 6112202, 6113304,
6114388, 6115447, 6116490, 6117571, 6118679, 6119732, 6120816, 6121849,
6122903, 6123933, 6125011, 6126092, 6127177, 6128281, 6129359, 6130453,
6131523, 6132591, 6133652, 6134702, 6135748, 6136829, 6137897, 6138976,
6140056, 6141110, 6142157, 6143243, 6144338, 6145413, 6146454, 6147530,
6148565, 6149610, 6150685, 6151775, 6152851, 6153946, 6155018, 6156107,
6157177, 6158244, 6159287, 6160370, 6161410, 6162488, 6163526, 6164529,
6165634, 6166698, 6167735, 6168807, 6169860, 6170927, 6172006, 6173087,
6174160, 6175255, 6176309, 6177379, 6178476, 6179519, 6180588, 6181653,
6182706, 6183760, 6184820, 6185878, 6186952, 6188075, 6189130, 6190260,
6191339, 6192418, 6193495, 6194557, 6195610, 6196688, 6197714, 6198749,
6199781, 6200863, 6201900, 6202956, 6204006, 6205075, 6206152, 6207201,
6208283, 6209338, 6210411, 6211472, 6212576, 6213663, 6214737, 6215782,
6216851, 6217934, 6218998, 6220088, 6221115, 6222174, 6223238, 6224293,
6225391, 6226423, 6227476, 6228554, 6229639, 6230683, 6231745, 6232801,
6233879, 6234967, 6236057, 6237151, 6238197, 6239279, 6240392, 6241466,
6242518, 6243568, 6244670, 6245720, 6246812, 6247871, 6248955, 6250017,
6251068, 6252157, 6253221, 6254268, 6255333, 6256381, 6257432, 6258479,
6259507, 6260540, 6261569, 6262621, 6263675, 6264743, 6265794, 6266861,
6267922, 6268979, 6270010, 6271091, 6272164, 6273250, 6274309, 6275378,
6276419, 6277465, 6278507, 6279577, 6280626, 6281676, 6282737, 6283791,
6284840, 6285928, 6287031, 6288086, 6289168, 6290221, 6291260, 6292319,
6293409, 6294481, 6295575, 6296629, 6297657, 6298734, 6299814, 6300894,
6301923, 6303000, 6304063, 6305091, 6306189, 6307253, 6308315, 6309353,
6310423, 6311468, 6312543, 6313555, 6314600, 6315717, 6316751, 6317803,
6318885, 6319967, 6321052, 6322147, 6323190, 6324246, 6325319, 6326390,
6327448, 6328508, 6329556, 6330607, 6331689, 6332772, 6333824, 6334874,
6335979, 6337030, 6338106, 6339178, 6340258, 6341360, 6342394, 6343475,
6344521, 6345552, 6346581, 6347646, 6348705, 6349788, 6350861, 6351897,
6352968, 6354011, 6355098, 6356156, 6357224, 6358304, 6359350, 6360407,
6361426, 6362534, 6363648, 6364676, 6365766, 6366833, 6367866, 6368914,
6370004, 6371114, 6372191, 6373235, 6374287, 6375357, 6376437, 6377497,
6378547, 6379623, 6380692, 6381756, 6382823, 6383880, 6384982, 6386040,
6387091, 6388133, 6389229, 6390270, 6391358, 6392444, 6393517, 6394579,
6395650, 6396695, 6397804, 6398831, 6399851, 6400912, 6401951, 6403038,
6404101, 6405156, 6406187, 6407260, 6408312, 6409371, 6410416, 6411487,
6412562, 6413637, 6414722, 6415792, 6416840, 6417928, 6418987, 6420024,
6421090, 6422119, 6423190, 6424244, 6425303, 6426372, 6427426, 6428525,
6429568, 6430649, 6431704, 6432749, 6433769, 6434832, 6435877, 6436955,
6437993, 6439081, 6440144, 6441215, 6442279, 6443359, 6444419, 6445483,
6446583, 6447666, 6448700, 6449766, 6450822, 6451906, 6452949, 6454029,
6455068, 6456118, 6457206, 6458291, 6459360, 6460433, 6461508, 6462576,
6463638, 6464728, 6465801, 6466880, 6467927, 6468976, 6470017, 6471081,
6472099, 6473196, 6474236, 6475318, 6476356, 6477463, 6478508, 6479575,
6480648, 6481741, 6482819, 6483856, 6484920, 6485995, 6487058, 6488084,
6489166, 6490216, 6491289, 6492371, 6493425, 6494475, 6495565, 6496638,
6497745, 6498797, 6499871, 6500946, 6502025, 6503067, 6504153, 6505174,
6506257, 6507299, 6508367, 6509422, 6510498, 6511539, 6512616, 6513691,
6514730, 6515799, 6516891, 6517975, 6519026, 6520102, 6521144, 6522216,
6523259, 6524344, 6525402, 6526467, 6527516, 6528573, 6529632, 6530704,
6531806, 6532875, 6533947, 6534995, 6536070, 6537133, 6538185, 6539262,
6540317, 6541387, 6542420, 6543489, 6544548, 6545636, 6546726, 6547789,
6548848, 6549940, 6551007, 6552042, 6553096, 6554150, 6555208, 6556261,
6557316, 6558380, 6559446, 6560482, 6561571, 6562629, 6563679, 6564748,
6565822, 6566910, 6567970, 6569017, 6570058, 6571132, 6572193, 6573262,
6574281, 6575337, 6576379, 6577468, 6578513, 6579574, 6580626, 6581718,
6582796, 6583827, 6584906, 6585976, 6587042, 6588114, 6589204, 6590276,
6591332, 6592423, 6593496, 6594580, 6595650, 6596685, 6597750, 6598794,
6599854, 6600893, 6601974, 6603045, 6604085, 6605141, 6606220, 6607254,
6608318, 6609397, 6610488, 6611574, 6612634, 6613713, 6614808, 6615857,
6616881, 6617952, 6619027, 6620094, 6621176, 6622236, 6623255, 6624294,
6625348, 6626404, 6627466, 6628526, 6629605, 6630667, 6631736, 6632802,
6633837, 6634887, 6635971, 6636984, 6638024, 6639070, 6640140, 6641169,
6642236, 6643295, 6644356, 6645415, 6646470, 6647534, 6648526, 6649597,
6650638, 6651726, 6652777, 6653875, 6654940, 6656010, 6657060, 6658116,
6659166, 6660217, 6661259, 6662305, 6663344, 6664433, 6665515, 6666546,
6667599, 6668650, 6669696, 6670776, 6671858, 6672915, 6673983, 6675060,
6676130, 6677173, 6678249, 6679277, 6680400, 6681447, 6682531, 6683586,
6684619, 6685658, 6686693, 6687775, 6688859, 6689940, 6690984, 6692040,
6693082, 6694135, 6695206, 6696261, 6697319, 6698415, 6699491, 6700517,
6701616, 6702679, 6703746, 6704831, 6705935, 6707018, 6708059, 6709148,
6710207, 6711283, 6712316, 6713401, 6714465, 6715525, 6716593, 6717673,
6718729, 6719799, 6720851, 6721935, 6723004, 6724083, 6725146, 6726168,
6727249, 6728293, 6729334, 6730423, 6731474, 6732538, 6733580, 6734629,
6735695, 6736755, 6737779, 6738840, 6739872, 6740966, 6741994, 6743052,
6744116, 6745191, 6746244, 6747302, 6748343, 6749401, 6750499, 6751560,
6752609, 6753644, 6754713, 6755764, 6756813, 6757904, 6758959, 6760029,
6761075, 6762130, 6763177, 6764239, 6765302, 6766370, 6767420, 6768434,
6769506, 6770565, 6771628, 6772696, 6773751, 6774793, 6775854, 6776940,
6777985, 6779010, 6780056, 6781111, 6782177, 6783215, 6784266, 6785311,
6786419, 6787487, 6788528, 6789568, 6790623, 6791679, 6792768, 6793861,
6794921, 6795994, 6797058, 6798132, 6799181, 6800267, 6801322, 6802385,
6803445, 6804511, 6805556, 6806620, 6807695, 6808761, 6809849, 6810888,
6811944, 6813004, 6814072, 6815116, 6816187, 6817262, 6818323, 6819369,
6820427, 6821474, 6822543, 6823610, 6824630, 6825670, 6826714, 6827821,
6828848, 6829909, 6830963, 6832043, 6833087, 6834127, 6835203, 6836255,
6837328, 6838399, 6839454, 6840507, 6841545, 6842586, 6843660, 6844761,
6845819, 6846874, 6847923, 6848969, 6850012, 6851050, 6852111, 6853163,
6854236, 6855300, 6856356, 6857461, 6858512, 6859589, 6860644, 6861725,
6862832, 6863915, 6864983, 6866061, 6867081, 6868118, 6869136, 6870216,
6871274, 6872311, 6873375, 6874464, 6875482, 6876525, 6877596, 6878642,
6879717, 6880782, 6881865, 6882899, 6883933, 6884982, 6886028, 6887084,
6888163, 6889217, 6890230, 6891296, 6892401, 6893474, 6894504, 6895587,
6896659, 6897691, 6898699, 6899748, 6900811, 6901889, 6902940, 6904008,
6905066, 6906112, 6907143, 6908178, 6909226, 6910286, 6911354, 6912428,
6913487, 6914549, 6915596, 6916621, 6917692, 6918775, 6919816, 6920906,
6921940, 6923002, 6924101, 6925160, 6926229, 6927314, 6928356, 6929439,
6930513, 6931594, 6932661, 6933740, 6934758, 6935826, 6936878, 6937930,
6938980, 6940025, 6941094, 6942131, 6943196, 6944248, 6945285, 6946361,
6947433, 6948511, 6949596, 6950623, 6951709, 6952744, 6953819, 6954894,
6955934, 6957026, 6958082, 6959155, 6960241, 6961286, 6962322, 6963393,
6964474, 6965538, 6966631, 6967682, 6968751, 6969824, 6970856, 6971923,
6972951, 6974011, 6975067, 6976088, 6977149, 6978256, 6979309, 6980367,
6981446, 6982508, 6983541, 6984605, 6985658, 6986742, 6987793, 6988863,
6989900, 6990968, 6992043, 6993101, 6994155, 6995228, 6996265, 6997344,
6998414, 6999465, 7000542, 7001608, 7002668, 7003682, 7004724, 7005797,
7006849, 7007901, 7008931, 7009963, 7011040, 7012113, 7013135, 7014201,
7015277, 7016321, 7017409, 7018481, 7019579, 7020675, 7021716, 7022750,
7023845, 7024908, 7025993, 7027071, 7028137, 7029194, 7030262, 7031290,
7032334, 7033430, 7034459, 7035520, 7036610, 7037633, 7038664, 7039696,
7040752, 7041812, 7042857, 7043939, 7045012, 7046092, 7047163, 7048209,
7049252, 7050293, 7051385, 7052432, 7053483, 7054499, 7055575, 7056683,
7057728, 7058806, 7059836, 7060923, 7061987, 7063054, 7064158, 7065216,
7066287, 7067371, 7068427, 7069466, 7070521, 7071562, 7072640, 7073674,
7074729, 7075818, 7076852, 7077907, 7079008, 7080056, 7081127, 7082197,
7083250, 7084287, 7085351, 7086419, 7087493, 7088504, 7089569, 7090595,
7091652, 7092698, 7093739, 7094805, 7095851, 7096894, 7097965, 7099023,
7100069, 7101115, 7102188, 7103277, 7104353, 7105355, 7106444, 7107500,
7108537, 7109611, 7110679, 7111732, 7112826, 7113868, 7114917, 7115989,
7117041, 7118134, 7119188, 7120241, 7121335, 7122403, 7123480, 7124545,
7125582, 7126650, 7127760, 7128792, 7129843, 7130916, 7131955, 7133018,
7134113, 7135169, 7136208, 7137265, 7138328, 7139386, 7140433, 7141491,
7142540, 7143559, 7144639, 7145692, 7146734, 7147790, 7148845, 7149912,
7150949, 7152011, 7153085, 7154162, 7155225, 7156303, 7157388, 7158441,
7159502, 7160605, 7161682, 7162742, 7163828, 7164881, 7165930, 7166984,
7168001, 7169045, 7170114, 7171223, 7172277, 7173339, 7174390, 7175453,
7176519, 7177606, 7178686, 7179750, 7180832, 7181905, 7182914, 7183980,
7185040, 7186088, 7187131, 7188194, 7189261, 7190256, 7191331, 7192372,
7193431, 7194496, 7195565, 7196646, 7197676, 7198741, 7199778, 7200810,
7201873, 7202909, 7203977, 7205049, 7206133, 7207198, 7208251, 7209308,
7210389, 7211454, 7212507, 7213564, 7214604, 7215668, 7216694, 7217773,
7218825, 7219868, 7220906, 7221971, 7223050, 7224140, 7225199, 7226273,
7227295, 7228325, 7229374, 7230433, 7231524, 7232593, 7233646, 7234735,
7235798, 7236906, 7237979, 7239026, 7240091, 7241146, 7242187, 7243227,
7244325, 7245375, 7246427, 7247511, 7248568, 7249632, 7250708, 7251790,
7252828, 7253871, 7254903, 7256012, 7257060, 7258127, 7259131, 7260195,
7261249, 7262279, 7263361, 7264409, 7265456, 7266485, 7267551, 7268547,
7269604, 7270675, 7271722, 7272778, 7273802, 7274860, 7275977, 7277026,
7278051, 7279111, 7280179, 7281238, 7282260, 7283324, 7284391, 7285446,
7286498, 7287564, 7288606, 7289669, 7290717, 7291780, 7292861, 7293916,
7294957, 7296020, 7297085, 7298113, 7299144, 7300232, 7301287, 7302353,
7303419, 7304471, 7305510, 7306630, 7307634, 7308713, 7309731, 7310768,
7311807, 7312852, 7313936, 7314988, 7316061, 7317126, 7318199, 7319298,
7320329, 7321388, 7322476, 7323515, 7324561, 7325586, 7326670, 7327777,
7328848, 7329906, 7330955, 7332024, 7333046, 7334133, 7335156, 7336240,
7337312, 7338386, 7339435, 7340493, 7341531, 7342576, 7343616, 7344646,
7345686, 7346702, 7347762, 7348820, 7349851, 7350897, 7351925, 7353028,
7354077, 7355126, 7356185, 7357203, 7358226, 7359319, 7360369, 7361422,
7362477, 7363550, 7364614, 7365691, 7366758, 7367848, 7368879, 7369952,
7371013, 7372084, 7373165, 7374185, 7375234, 7376286, 7377340, 7378403,
7379439, 7380505, 7381547, 7382592, 7383597, 7384646, 7385707, 7386743,
7387802, 7388857, 7389913, 7390973, 7392009, 7393040, 7394086, 7395126,
7396214, 7397325, 7398347, 7399425, 7400496, 7401582, 7402610, 7403692,
7404743, 7405770, 7406840, 7407898, 7408934, 7409978, 7411028, 7412073,
7413127, 7414172, 7415239, 7416309, 7417375, 7418444, 7419506, 7420576,
7421606, 7422686, 7423726, 7424771, 7425797, 7426846, 7427889, 7428959,
7429998, 7431035, 7432066, 7433136, 7434188, 7435245, 7436277, 7437326,
7438338, 7439388, 7440448, 7441536, 7442590, 7443665, 7444740, 7445813,
7446853, 7447924, 7448983, 7450039, 7451111, 7452145, 7453216, 7454253,
7455330, 7456360, 7457439, 7458517, 7459589, 7460646, 7461689, 7462750,
7463816, 7464880, 7465938, 7467019, 7468056, 7469138, 7470175, 7471205,
7472264, 7473348, 7474391, 7475476, 7476552, 7477608, 7478656, 7479708,
7480760, 7481769, 7482861, 7483934, 7484976, 7486000, 7487040, 7488117,
7489141, 7490186, 7491264, 7492304, 7493365, 7494446, 7495496, 7496547,
7497588, 7498671, 7499730, 7500775, 7501827, 7502889, 7503953, 7505003,
7506064, 7507128, 7508164, 7509233, 7510279, 7511332, 7512404, 7513424,
7514452, 7515544, 7516637, 7517686, 7518773, 7519826, 7520859, 7521891,
7522936, 7524022, 7525042, 7526057, 7527098, 7528173, 7529243, 7530322,
7531355, 7532410, 7533472, 7534522, 7535595, 7536639, 7537694, 7538738,
7539788, 7540828, 7541879, 7542951, 7543986, 7545030, 7546106, 7547180,
7548237, 7549287, 7550336, 7551428, 7552472, 7553533, 7554603, 7555677,
7556721, 7557776, 7558792, 7559851, 7560910, 7561970, 7563030, 7564064,
7565093, 7566111, 7567184, 7568221, 7569272, 7570344, 7571386, 7572414,
7573440, 7574497, 7575579, 7576651, 7577697, 7578751, 7579787, 7580828,
7581897, 7582940, 7583985, 7585015, 7586110, 7587138, 7588169, 7589247,
7590311, 7591366, 7592412, 7593469, 7594519, 7595583, 7596642, 7597677,
7598689, 7599727, 7600776, 7601838, 7602915, 7603991, 7605026, 7606135,
7607213, 7608246, 7609284, 7610309, 7611371, 7612458, 7613496, 7614519,
7615567, 7616628, 7617689, 7618743, 7619797, 7620847, 7621915, 7622931,
7624016, 7625049, 7626145, 7627200, 7628300, 7629319, 7630397, 7631422,
7632488, 7633505, 7634603, 7635614, 7636677, 7637676, 7638715, 7639762,
7640829, 7641876, 7642931, 7643992, 7645075, 7646147, 7647183, 7648212,
7649290, 7650363, 7651420, 7652471, 7653516, 7654584, 7655630, 7656711,
7657771, 7658827, 7659893, 7660940, 7661987, 7663017, 7664073, 7665105,
7666110, 7667176, 7668223, 7669266, 7670337, 7671393, 7672463, 7673512,
7674572, 7675642, 7676651, 7677699, 7678760, 7679812, 7680839, 7681881,
7682962, 7683994, 7685043, 7686091, 7687146, 7688188, 7689249, 7690305,
7691388, 7692435, 7693486, 7694521, 7695557, 7696627, 7697670, 7698776,
7699817, 7700875, 7701880, 7702976, 7704030, 7705128, 7706195, 7707233,
7708288, 7709364, 7710402, 7711452, 7712500, 7713569, 7714617, 7715655,
7716716, 7717753, 7718791, 7719873, 7720933, 7722001, 7723053, 7724128,
7725153, 7726187, 7727248, 7728278, 7729298, 7730402, 7731459, 7732509,
7733551, 7734610, 7735691, 7736759, 7737820, 7738844, 7739887, 7740939,
7741959, 7743002, 7744041, 7745064, 7746096, 7747145, 7748191, 7749275,
7750357, 7751433, 7752507, 7753525, 7754580, 7755637, 7756688, 7757740,
7758790, 7759858, 7760905, 7761969, 7763004, 7764040, 7765056, 7766131,
7767193, 7768267, 7769317, 7770356, 7771392, 7772446, 7773487, 7774535,
7775591, 7776634, 7777670, 7778700, 7779758, 7780815, 7781854, 7782902,
7783941, 7785012, 7786052, 7787089, 7788168, 7789213, 7790304, 7791355,
7792385, 7793455, 7794537, 7795611, 7796721, 7797765, 7798793, 7799831,
7800928, 7801978, 7802999, 7804066, 7805136, 7806168, 7807242, 7808268,
7809310, 7810382, 7811430, 7812453, 7813508, 7814584, 7815631, 7816679,
7817716, 7818810, 7819854, 7820943, 7821988, 7822983, 7824051, 7825086,
7826144, 7827190, 7828274, 7829337, 7830377, 7831438, 7832474, 7833527,
7834620, 7835671, 7836725, 7837782, 7838820, 7839883, 7840948, 7842015,
7843065, 7844124, 7845183, 7846195, 7847213, 7848214, 7849236, 7850286,
7851323, 7852399, 7853464, 7854495, 7855566, 7856608, 7857670, 7858738,
7859788, 7860868, 7861939, 7862996, 7864056, 7865084, 7866134, 7867187,
7868236, 7869301, 7870346, 7871392, 7872447, 7873462, 7874526, 7875600,
7876637, 7877687, 7878742, 7879838, 7880895, 7881939, 7882999, 7884014,
7885060, 7886087, 7887160, 7888223, 7889304, 7890355, 7891417, 7892503,
7893552, 7894630, 7895715, 7896776, 7897844, 7898912, 7899987, 7901021,
7902065, 7903094, 7904169, 7905211, 7906254, 7907285, 7908307, 7909336,
7910391, 7911426, 7912463, 7913520, 7914575, 7915647, 7916712, 7917781,
7918824, 7919899, 7920967, 7922032, 7923063, 7924111, 7925182, 7926207,
7927282, 7928359, 7929398, 7930456, 7931528, 7932577, 7933614, 7934636,
7935670, 7936723, 7937756, 7938802, 7939846, 7940897, 7941948, 7942970,
7944007, 7945051, 7946089, 7947120, 7948171, 7949251, 7950331, 7951370,
7952445, 7953534, 7954565, 7955628, 7956647, 7957707, 7958750, 7959794,
7960831, 7961894, 7962918, 7963993, 7965060, 7966080, 7967142, 7968197,
7969245, 7970296, 7971386, 7972414, 7973492, 7974500, 7975560, 7976615,
7977675, 7978760, 7979819, 7980860, 7981895, 7982974, 7984030, 7985096,
7986146, 7987202, 7988253, 7989309, 7990323, 7991397, 7992479, 7993510,
7994547, 7995595, 7996679, 7997725, 7998772, 7999809, 8000833, 8001872,
8002935, 8003950, 8005018, 8006050, 8007109, 8008165, 8009216, 8010265,
8011346, 8012402, 8013453, 8014520, 8015541, 8016592, 8017642, 8018708,
8019755, 8020784, 8021815, 8022874, 8023930, 8024991, 8026025, 8027065,
8028098, 8029137, 8030181, 8031200, 8032242, 8033297, 8034370, 8035421,
8036482, 8037529, 8038599, 8039654, 8040751, 8041846, 8042888, 8043935,
8044965, 8045994, 8047071, 8048099, 8049122, 8050158, 8051238, 8052273,
8053306, 8054363, 8055467, 8056517, 8057574, 8058625, 8059646, 8060725,
8061750, 8062801, 8063837, 8064866, 8065927, 8066973, 8068026, 8069087,
8070121, 8071155, 8072197, 8073280, 8074345, 8075418, 8076468, 8077504,
8078560, 8079608, 8080631, 8081666, 8082732, 8083816, 8084864, 8085910,
8086999, 8088052, 8089087, 8090155, 8091193, 8092186, 8093271, 8094290,
8095349, 8096376, 8097422, 8098444, 8099500, 8100523, 8101571, 8102596,
8103655, 8104682, 8105727, 8106767, 8107767, 8108820, 8109874, 8110908,
8111999, 8113068, 8114078, 8115138, 8116157, 8117210, 8118250, 8119334,
8120422, 8121457, 8122518, 8123531, 8124600, 8125649};
bitset<MX> K;
inline int o(int& x) {
int k = K[x - 1];
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) return 0;
k |= K[x - i * i];
}
return k;
}
int daj(int x) {
int a = x / B;
int p = a * B + 1;
a = pre[a];
for (int i = p; i <= x; ++i)
if (o(i)) ++a;
return a;
}
int main() {
for (int i = 1; i * i < MX; ++i) K[i * i] = 1;
int l, r, ans;
scanf("%d%d", &l, &r);
ans = daj(r) - daj(l - 1);
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int maxn = 1e5 + 5;
long long c[maxn], w[maxn];
int pay1[maxn], pay2[maxn];
struct node {
long long cnt, val, id;
bool operator<(const node& rhs) const {
return cnt * val < rhs.cnt * rhs.val;
}
};
multiset<node> s;
int main() {
int n;
long long m;
memset(pay1, 0, sizeof(pay1));
memset(pay2, 0, sizeof(pay2));
scanf("%d %lld", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &c[i]);
pay1[i] = c[i] / 100;
c[i] %= 100;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
long long ans = 0;
set<node>::iterator it;
for (int i = 1; i <= n; i++) {
node st = {100LL - c[i], w[i], i}, f;
if (st.cnt == 100) continue;
s.insert(st);
if (m >= c[i]) {
m -= c[i];
pay2[i] = c[i];
} else {
m = m + 100 - c[i];
pay2[i] = c[i];
it = s.begin();
f = *it;
ans += f.cnt * f.val;
++pay1[f.id];
pay2[f.id] = 0;
s.erase(it);
}
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) {
printf("%d %d\n", pay1[i], pay2[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5e3 + 5;
const long long Mod = 51123987;
const long long inf = 0x3f3f3f3f3f3f3f;
int f[155][55][55][55] = {}, Next[151][3] = {};
int main() {
long long n, ans = 0;
string s;
cin >> n >> s;
f[0][0][0][0] = 1;
int a[300] = {};
a['a'] = n + 1;
a['b'] = n + 1;
a['c'] = n + 1;
for (int i = n - 1; i >= 0; i--) {
a[s[i]] = i;
for (int j = 0; j < 3; j++) Next[i][j] = a[j + 'a'];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= n / 3 + 1; j++)
for (int k = 0; k <= n / 3 + 1; k++)
for (int l = 0; l <= n / 3 + 1; l++) {
if (f[i][j][k][l]) {
f[Next[i][0]][j + 1][k][l] += f[i][j][k][l];
f[Next[i][1]][j][k + 1][l] += f[i][j][k][l];
f[Next[i][2]][j][k][l + 1] += f[i][j][k][l];
f[Next[i][0]][j + 1][k][l] %= Mod;
f[Next[i][1]][j][k + 1][l] %= Mod;
f[Next[i][2]][j][k][l + 1] %= Mod;
}
if (j + k + l == n && abs(j - k) <= 1 && abs(j - l) <= 1 &&
abs(k - l) <= 1) {
ans = (ans + f[i][j][k][l]) % Mod;
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MOD = 1000000007;
int h = 1, r, g;
int dp[2][200005];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> r >> g;
int l = 1, high = 900;
while (l <= high) {
int med = (l + high) >> 1;
if ((med * (med + 1)) <= 2 * (r + g))
h = med, l = med + 1;
else
high = med - 1;
}
if (r >= h) dp[(h - 1) & 1][h] = 1;
if (g >= h) dp[(h - 1) & 1][0] = 1;
for (int i = h - 1; i > 0; i--) {
for (int j = 0; j <= r; ++j) {
if (i <= (r - j))
dp[(i - 1) & 1][j + i] = (dp[(i - 1) & 1][j + i] + dp[i & 1][j]) % MOD;
if ((g - ((h * (h + 1)) / 2 - (i * (i + 1)) / 2 - j)) >= i)
dp[(i - 1) & 1][j] = (dp[(i - 1) & 1][j] + dp[i & 1][j]) % MOD;
}
for (int j = 0; j <= r; ++j) dp[i & 1][j] = 0;
}
int ans = 0;
for (int j = 0; j <= r; ++j) ans = (ans + dp[0][j]) % MOD;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T f = 1, x = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int N = 3e3 + 7;
int n, k, num[N];
long long f[N], ans;
vector<long long> a[N];
inline void dp(int x) {
for (int(i) = (k); (i) >= (num[x]); --(i))
f[i] = max(f[i], f[i - num[x]] + a[x][num[x]]);
}
inline void solve(int l, int r) {
if (l == r) {
for (int(i) = (1); (i) <= (min(k, num[l])); ++(i))
ans = max(ans, f[k - i] + a[l][i]);
return;
}
int mid = (l + r) >> 1;
long long tmp[N];
memset(tmp, 0, sizeof(tmp));
for (int(i) = (0); (i) <= (k); ++(i)) tmp[i] = f[i];
for (int(i) = (l); (i) <= (mid); ++(i)) dp(i);
solve(mid + 1, r);
for (int(i) = (0); (i) <= (k); ++(i)) f[i] = tmp[i];
for (int(i) = (mid + 1); (i) <= (r); ++(i)) dp(i);
solve(l, mid);
for (int(i) = (0); (i) <= (k); ++(i)) f[i] = tmp[i];
}
int main() {
n = read<int>(), k = read<int>();
for (int(i) = (1); (i) <= (n); ++(i)) {
num[i] = read<int>(), a[i].push_back(0);
for (int(j) = (1); (j) <= (num[i]); ++(j)) {
int x = read<int>();
a[i].push_back(a[i][j - 1] + x);
}
}
solve(1, n);
return printf("%lld", ans), 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long ans, a[100010], x;
int n;
int get(int u) {
while (u & (u - 1)) u &= u - 1;
return u;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%llu", &x);
a[i] += x;
ans += a[i];
printf("%llu\n", ans);
a[i + get(n - i)] += a[i];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int e, c;
scanf("%d %d", &e, &c);
if (e == 0 && c == 0) {
puts("0 0");
return 0;
}
if (e == 0 && c != 0) {
puts("Impossible");
return 0;
}
int mx = (c == 0) ? e : c + (e - 1);
int mn = (c == 0 || c <= e) ? e : c;
printf("%d %d", mn, mx);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
if (a > 5 && b > 5) {
if (b - a > 10) {
cout << "0";
return 0;
} else {
long long int k = 1;
for (long long int i = a + 1; i <= b; i++) {
long long int x = i % 10;
k = k * x;
k = k % 10;
}
cout << k;
return 0;
}
}
if (b > 5 && a <= 5) {
if (a == 2)
cout << "5";
else
cout << "0";
}
if (b <= 5) {
int p = 1;
int f[6];
for (int i = 1; i <= b; i++) {
p = p * i;
f[i] = p;
}
if (a == 0) {
if (b != 0)
cout << f[b] % 10;
else
cout << "1";
} else
cout << (f[b] / f[a]) % 10;
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char str[300007];
int main() {
memset(str, '\0', sizeof(str));
long long n;
long long ans = 0;
long long pos = 1;
cin >> n;
scanf("%s", str);
for (int i = 1; i < n; i++) {
if (str[i - 1] == str[i]) {
pos++;
}
if (str[i - 1] != str[i]) {
ans += pos;
pos = 1;
}
}
pos = 1;
for (int i = n - 2; i >= 0; i--) {
if (str[i + 1] == str[i]) {
pos++;
}
if (str[i + 1] != str[i]) {
ans += pos;
pos = 1;
}
}
for (int i = 1; i < n; i++) {
if (str[i - 1] != str[i]) {
ans--;
}
}
printf("%lld\n", (n * (n - 1)) / 2 - ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 1005;
long long a[N], m[N];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void extend_Euclid(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
extend_Euclid(b, a % b, x, y);
long long tmp = x;
x = y;
y = tmp - (a / b) * y;
}
long long Inv(long long a, long long b) {
long long d = gcd(a, b);
if (d != 1) return -1;
long long x, y;
extend_Euclid(a, b, x, y);
return (x % b + b) % b;
}
bool merge(long long a1, long long m1, long long a2, long long m2,
long long &a3, long long &m3) {
long long d = gcd(m1, m2);
long long c = a2 - a1;
if (c % d) return false;
c = (c % m2 + m2) % m2;
m1 /= d;
m2 /= d;
c /= d;
c *= Inv(m1, m2);
c %= m2;
c *= m1 * d;
c += a1;
m3 = m1 * m2 * d;
a3 = (c % m3 + m3) % m3;
return true;
}
long long CRT(long long a[], long long m[], int n) {
long long a1 = a[1];
long long m1 = m[1];
for (int i = 2; i <= n; i++) {
long long a2 = a[i];
long long m2 = m[i];
long long m3, a3;
if (!merge(a1, m1, a2, m2, a3, m3)) return -1;
a1 = a3;
m1 = m3;
}
return (a1 % m1 + m1) % m1;
}
int a1, b1, a2, b2, L, R;
int main() {
long long ans, res, l, r, d, n;
while (~scanf("%d %d %d %d %d %d", &a1, &b1, &a2, &b2, &L, &R)) {
L = max(L, b1);
L = max(L, b2);
n = 2;
a[1] = b1, a[2] = b2;
m[1] = a1, m[2] = a2;
ans = CRT(a, m, n);
if (ans == -1) {
puts("0");
continue;
}
d = m[1] * m[2] / gcd(m[1], m[2]);
l = (L - ans) / d * d + ans;
while (l < L) l += d;
r = (R - ans) / d * d + ans;
while (r <= R) r += d;
r -= d;
if (l > r)
res = 0;
else
res = (r - l) / d + 1;
cout << res << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a, b;
cin >> a >> b;
int n = s.size();
vector<int> v(n);
v[0] = (s[0] - '0') % a;
for (int i = 1; i < n - 1; i++) v[i] = (v[i - 1] * 10 + s[i] - '0') % a;
int rem = 0, p = 1;
for (int i = n - 1; i > 0; i--) {
rem = (p * (s[i] - '0') + rem) % b;
p = (p * 10) % b;
if (rem == 0 && s[i] != '0' && v[i - 1] == 0) {
cout << "YES" << endl;
cout << s.substr(0, i) << endl << s.substr(i) << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans[1001];
void mark(int st, int mn) {
for (int i = 1; i <= n; i++) {
ans[i] = 0;
if (i >= mn && i != st) ans[i] = 1;
}
}
int ask(int st, int mn) {
mark(st, mn);
int tot = 0, tmp, sum = 0;
for (int i = 1; i <= n; i++)
if (ans[i] == 1) tot++;
printf("%d %d ", 1, tot);
printf("%d ", st);
for (int i = 1; i <= n; i++)
if (ans[i] == 1 && sum != tot)
printf("%d ", i), sum++;
else if (ans[i] == 1)
printf("%d\n", i);
cout << endl;
scanf("%d", &tmp);
return tmp;
}
signed main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
int mx = ask(1, 1);
int l = 1, r = n + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ask(1, mid) == mx)
l = mid;
else
r = mid;
}
int res = ask(l, 1);
printf("-1 %d", res);
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n;
int t = n / 2 + 1;
int d = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (j < t - d || j > d + t) {
cout << "*";
} else {
cout << "D";
}
}
cout << endl;
if (i < t) {
d = d + 1;
} else {
d = d - 1;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<vector<int>> adj;
vector<long long> subtree;
int dfs(int v, int parent) {
int sum = 1;
for (auto u : adj[v])
if (u != parent) {
subtree.push_back(dfs(u, v));
sum += subtree.back();
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
adj = vector<vector<int>>(n + 1);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, -1);
for (auto &it : subtree) {
it = 1LL * it * (n - it);
}
sort(subtree.begin(), subtree.end());
int m;
cin >> m;
vector<int> primes(m);
for (auto &x : primes) cin >> x;
n = n - 1;
if (m < n) {
int dif = n - m;
for (int i = 0; i < dif; i++) primes.push_back(1), m++;
}
sort(primes.begin(), primes.end());
if (n < m) {
int dif = m - n;
for (int i = 0; i < dif; i++) {
int x = primes.back();
primes.pop_back();
primes[primes.size() - 1] = (1LL * primes[primes.size() - 1] * x) % mod;
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
res = (res + (1LL * subtree[i] % mod * primes[i] % mod)) % mod;
}
cout << res % mod << "\n";
subtree.clear();
adj.clear();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string adj[] = {"lios", "liala"};
string noun[] = {"etr", "etra"};
string verb[] = {"initis", "inites"};
bool suffix(const string &a, const string &sufijo) {
int idx = a.rfind(sufijo);
if (idx < 0) return false;
return idx + sufijo.size() == a.size();
}
vector<string> data;
bool solve(bool flag) {
int idx = 0;
int n = data.size();
while (idx < n && suffix(data[idx], adj[flag])) idx++;
if (idx < n && suffix(data[idx], noun[flag]))
idx++;
else if (n > 1)
return false;
while (idx < n && suffix(data[idx], verb[flag])) idx++;
return idx == n;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string cad;
getline(cin, cad);
stringstream ss(cad);
while (ss >> cad) data.push_back(cad);
cout << (solve(true) || solve(false) ? "YES" : "NO") << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
scanf("%d %d", &n, &k);
if (n < (2 * k + 1)) {
printf("-1\n");
return 0;
}
printf("%d\n", (n * k));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
printf("%d ", i);
if ((i + j) <= n) {
printf("%d", i + j);
} else {
printf("%d", (i + j) - n);
}
printf("\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q, dfn[N], ed[N], pr[N], clk = -1, add[N << 2];
int fa[N][20], mn[N << 2], cnt[N << 2];
vector<int> g[N];
map<int, map<int, int> > r;
inline void dfs(int x, int ff) {
pr[x] = ff;
dfn[x] = ++clk;
for (auto u : g[x]) {
if (u == ff) continue;
dfs(u, x);
}
ed[x] = clk;
}
inline void pushdown(int x) {
if (!add[x]) return;
mn[(x << 1)] += add[x];
mn[(x << 1 | 1)] += add[x];
add[(x << 1)] += add[x];
add[(x << 1 | 1)] += add[x];
add[x] = 0;
return;
}
inline void fix(int x, int l, int r, int ql, int qr, int v) {
if (ql >= r || qr <= l) return;
if (ql <= l && r <= qr) {
mn[x] += v;
add[x] += v;
return;
}
int mid = l + r >> 1;
pushdown(x);
fix((x << 1 | 1), mid, r, ql, qr, v);
fix((x << 1), l, mid, ql, qr, v);
if (mn[(x << 1)] == mn[(x << 1 | 1)]) {
cnt[x] = cnt[(x << 1)] + cnt[(x << 1 | 1)];
mn[x] = mn[(x << 1)];
return;
} else if (mn[(x << 1)] < mn[(x << 1 | 1)]) {
cnt[x] = cnt[(x << 1)];
mn[x] = mn[(x << 1)];
return;
}
cnt[x] = cnt[(x << 1 | 1)];
mn[x] = mn[(x << 1 | 1)];
}
inline void build(int x, int l, int r) {
cnt[x] = r - l;
if (r - l == 1) return;
int mid = l + r >> 1;
build((x << 1), l, mid);
build((x << 1 | 1), mid, r);
return;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1, x, y; i < n; i++)
scanf("%d%d", &x, &y), g[x].push_back(y), g[y].push_back(x);
dfs(1, 0);
build(1, 0, n);
for (int i = 0, x, y; i < q; i++) {
scanf("%d%d", &x, &y);
int v = 1;
if (r[x][y])
r[x][y] = 0, r[y][x] = 0, v = -1;
else
r[x][y] = r[y][x] = 1;
if (dfn[y] > dfn[x]) swap(x, y);
if (dfn[y] <= dfn[x] && ed[x] <= ed[y]) {
int sp = 0;
for (auto k : g[y]) {
if (k == pr[y]) continue;
if (dfn[k] <= dfn[x] && ed[x] <= ed[k]) {
sp = k;
break;
}
}
fix(1, 0, n, dfn[sp], ed[sp] + 1, v);
fix(1, 0, n, dfn[x], ed[x] + 1, -v);
} else {
fix(1, 0, n, 0, n, v);
fix(1, 0, n, dfn[x], ed[x] + 1, -v);
fix(1, 0, n, dfn[y], ed[y] + 1, -v);
}
int ans = cnt[1];
if (mn[1]) ans = 0;
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int dx[8] = {0, -1, 0, 1, -1, -1, 1, 1},
dy[8] = {1, 0, -1, 0, -1, 1, -1, 1};
long long dp[200005];
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
dp[i] = dp[i - 1] + x;
}
long long maxx = dp[n];
for (int i = n - 1; i > 1; i--) {
maxx = max(maxx, dp[i] - maxx);
}
cout << maxx << endl;
}
int main() {
ios::sync_with_stdio(0);
;
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 3;
int n, ans1, h[N];
bool par[N], mark[N], vis[N];
vector<int> adj[N];
void input() {
cin >> n;
for (int i = 0; i + 1 < n; i++) {
int u, v;
cin >> u >> v;
adj[--u].push_back(--v);
adj[v].push_back(u);
}
}
void dfs2(int u) {
vis[u] = true;
for (auto v : adj[u])
if (vis[v] == false) {
h[v] = h[u] + 1;
dfs2(v);
}
if (adj[u].size() == 1 && h[u] % 2 == 0) ans1 = 3;
}
void dfs1(int u) {
mark[u] = true;
for (auto v : adj[u])
if (mark[v] == false) {
if (adj[v].size() == 1) par[u] = true;
dfs1(v);
}
}
void solve() {
ans1 = 1;
for (int i = 0; i < n; i++)
if (adj[i].size() == 1) {
dfs1(adj[i][0]);
dfs2(adj[i][0]);
return;
}
}
void output() {
cout << ans1 << ' ';
int ans = n - 1;
for (int i = 0; i < n; i++) {
if (adj[i].size() == 1) ans--;
if (par[i] == true) ans++;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
input(), solve(), output();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> c(n), ans(n);
for (int i = 0; i < n; i++) cin >> c[i];
priority_queue<pair<int, int> > pq;
for (int i = 0; i < n + k; i++) {
if (i < n) pq.push({c[i], i});
if (i >= k) {
auto pi = pq.top();
pq.pop();
ans[pi.second] = i;
}
}
long long cost = 0;
for (int i = 0; i < n; i++) cost += 1LL * c[i] * (ans[i] - i);
cout << cost << endl;
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1e5) + 10;
long long n, sum, mx, tmp;
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &tmp);
mx = max(tmp, mx);
sum += tmp;
}
long long ans = ceil(1.0 * sum / (n - 1));
ans = max(mx, ans);
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> mySet;
int n;
cin >> n;
char dig[n][n];
char x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> dig[i][j];
if (i == 0 && j == 1) x = dig[i][j];
if (j != i && j != (n - i - 1)) {
if (dig[i][j] != x) {
cout << "NO" << endl;
return 0;
}
}
mySet.insert(dig[i][j]);
}
}
if (mySet.size() != 2) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (dig[i][i] != dig[i + 1][i + 1]) {
cout << "NO" << endl;
return 0;
}
}
for (int i = 0, j = n - 1; i<n - 1, j> 0; i++, j--) {
if (dig[i][j] != dig[i + 1][j - 1]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long int x, d;
cin >> x >> d;
long long int num = 1;
vector<long long int> v;
while (x > 0) {
long long int z = 0;
while ((pow(2, z) - 1) <= x) {
z++;
}
x -= (pow(2, z - 1) - 1);
for (int i = 1; i < z; i++) {
v.push_back(num);
}
num += (d + 1);
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using VV = vector<vector<T>>;
template <class T>
inline T SMIN(T& a, const T b) {
return a = (a > b) ? b : a;
}
template <class T>
inline T SMAX(T& a, const T b) {
return a = (a < b) ? b : a;
}
template <class Iter>
void dumpc(Iter begin, Iter end) {
if (true) {
for (; begin != end; ++begin) {
cerr << *begin << ',';
}
cerr << endl;
}
}
const int MAX_N = 1e6 + 1;
long long A[MAX_N];
int N, M;
void solve() {
string res(M, '0');
vector<int> cnt(N, 0);
unordered_set<int> S;
for (int i = 0; i < (M); ++i) {
int l = A[i];
cnt[l]++;
S.emplace(l);
if (int((S).size()) == N) {
res[i] = '1';
for (int j = 0; j < (N); ++j) {
cnt[j]--;
if (cnt[j] == 0) S.erase(j);
}
}
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(12) << fixed;
cin >> N >> M;
for (int i = 0; i < (M); ++i) cin >> A[i], A[i]--;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 1e9 + 5, MOD = 1e9 + 7;
long long int t, n, m, k, f, x, freq[N], b[N], c, mn = 1e9, mx, ans;
long long int sum = 0;
struct node {
long long int v, p;
} a[N];
bool cmp(node a, node b) { return a.v > b.v; }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].v;
a[i].p = i;
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= k; i++) {
sum += a[i].v;
b[i] = a[i].p;
}
cout << sum << '\n';
sort(b + 1, b + k + 1);
b[1] = 1, b[k + 1] = n + 1;
for (int i = 1; i < k; i++) {
cout << b[i + 1] - b[i] << " ";
}
cout << b[k + 1] - b[k];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void minimize(X &x, const Y &y) {
if (x > y) x = y;
}
template <class X, class Y>
void maximize(X &x, const Y &y) {
if (x < y) x = y;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
const int base = 16;
const long long INF = (long long)1e18 + 7LL;
long long comb[175][175];
long long f[175][175];
int cnt[175], lim;
long long pos;
void prepare(void) {
for (int i = 0, _n = (175); i < _n; i = i + 1) comb[0][i] = 1;
for (int i = (1), _b = (175 - 1); i <= _b; i = i + 1)
for (int j = (1), _b = (175 - 1); j <= _b; j = j + 1) {
if (i == j) comb[i][j] = 1;
if (i < j) {
comb[i][j] = comb[i][j - 1] + comb[i - 1][j - 1];
minimize(comb[i][j], INF);
}
}
}
char getDigit(int x) { return x < 10 ? x + '0' : x - 10 + 'a'; }
long long product(long long a, long long b) {
if (a == 0 || b == 0) return 0;
return INF / a <= b ? INF : a * b;
}
long long cntWay(int length) {
memset(f, 0, sizeof f);
f[0][0] = 1;
for (int i = 0, _n = (base); i < _n; i = i + 1)
for (int j = 0, _n = (length + 1); j < _n; j = j + 1)
if (f[i][j] > 0)
for (int k = 0, _n = (cnt[i] + 1); k < _n; k = k + 1)
if (j + k <= length) {
f[i + 1][j + k] += product(f[i][j], comb[k][j + k]);
minimize(f[i + 1][j + k], INF);
}
return f[base][length];
}
long long cntWayDigit(int dig) {
long long res = 0;
for (int i = (1), _b = (base - 1); i <= _b; i = i + 1)
if (cnt[i] > 0) {
cnt[i]--;
res += cntWay(dig - 1);
cnt[i]++;
}
return res;
}
void process(long long p, int l) {
pos = p;
lim = l;
for (int i = 0, _n = (base); i < _n; i = i + 1) cnt[i] = lim;
int numDigit = 1;
while (true) {
long long tmp = cntWayDigit(numDigit);
if (pos > tmp) {
pos -= tmp;
numDigit++;
} else
break;
}
string digits;
for (int love = 0, _n = (numDigit); love < _n; love = love + 1) {
for (int i = (love == 0 ? 1 : 0), _b = (base - 1); i <= _b; i = i + 1)
if (cnt[i] > 0) {
cnt[i]--;
long long tmp = cntWay(numDigit - love - 1);
if (tmp >= pos) {
digits.push_back(getDigit(i));
break;
} else {
pos -= tmp;
cnt[i]++;
}
}
}
cout << digits << endl;
}
int main(void) {
prepare();
long long pos;
int lim;
cin >> pos >> lim;
process(pos, lim);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e7 + 10;
long long dp[mx][2];
const int mod = 1e9 + 7;
int main() {
int n;
cin >> n;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = (dp[i - 1][1]) % mod;
dp[i][1] = (dp[i - 1][0] * 3 + dp[i - 1][1] * 2) % mod;
}
cout << dp[n][0] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c = 0, d = 0;
int main() {
int n, i, j, k = 1, cot = 0;
scanf("%d", &n);
for (i = b = 0; i < n; i++) {
scanf("%d", &a);
a--;
if (i && (b + k + n) % n != a) {
if (k + 1)
c = i + 1, k = -1;
else
d = i, k = 1;
cot++;
}
if (i && n == 2 && b > a) {
c = 1, d = 2, cot = 1;
break;
}
b = a;
}
if (cot < 3 && cot > 0)
printf("%d %d\n", c, d ? d : n);
else
puts("0 0");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n % 2 != 0) {
cout << n / 2 << endl;
} else {
cout << (n / 2 - 1) << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct EDGE {
int x, y, v, c;
double r;
EDGE(int _x = 0, int _y = 0, int _v = 0, int _c = 0, double _r = 0) {
x = _x;
y = _y;
v = _v;
c = _c;
r = _r;
}
} ee[100000];
int en, used[2000], tt;
double an;
vector<EDGE*> e[2000];
void add(int x, int y, int v, double r) {
ee[en] = EDGE(x, y, 0, v, r);
e[x].push_back(&ee[en]);
e[y].push_back(&ee[en]);
en++;
}
bool fresh(double& x, double v) {
if (x > v + 1e-9) {
x = v;
return 1;
}
return 0;
}
int lastNo[900], lastV[900];
EDGE* lastE[900];
double mi[20000];
int bfs[1000000];
bool flow(int n) {
int i, ll = 0, rr = 0;
for (i = 0; i <= n; i++) mi[i] = 1e18;
mi[0] = 0;
queue<int> qq;
bfs[rr++] = 0;
while (ll < rr) {
int x = bfs[ll];
ll++;
used[x] = 0;
for (i = 0; i < e[x].size(); i++) {
int y;
if (x == e[x][i]->x) {
y = e[x][i]->y;
if (e[x][i]->v < e[x][i]->c) {
if (fresh(mi[y], mi[x] + e[x][i]->r)) {
lastNo[y] = x;
lastE[y] = e[x][i];
lastV[y] = 1;
if (!used[y]) {
bfs[rr++] = y;
used[y] = 1;
}
}
}
} else {
y = e[x][i]->x;
if (e[x][i]->v > 0) {
if (fresh(mi[y], mi[x] - e[x][i]->r)) {
lastNo[y] = x;
lastE[y] = e[x][i];
lastV[y] = -1;
if (!used[y]) {
bfs[rr++] = y;
used[y] = 1;
}
}
}
}
}
}
if (mi[n] > 1e17) return 0;
an += mi[n];
int now = n;
while (now) {
lastE[now]->v += lastV[now];
now = lastNo[now];
}
return 1;
}
int xx[900], yy[900];
int main() {
int i, j, k, n, top = -1000000;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &xx[i], &yy[i]);
top = max(top, yy[i]);
}
k = 0;
for (i = 1; i <= n; i++) {
add(n + i, n + n + 1, 2, 0);
if (yy[i] == top) {
k++;
} else {
add(0, i, 1, 0);
}
}
if (k > 1) {
puts("-1");
return 0;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
if (yy[i] < yy[j])
add(i, j + n, 1,
sqrt((xx[i] - xx[j]) * (xx[i] - xx[j]) +
(yy[i] - yy[j]) * (yy[i] - yy[j])));
}
for (i = 1; i < n; i++) {
if (!flow(n + n + 1)) {
puts("-1");
return 0;
}
}
printf("%.12lf\n", an);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int u, j, v, c = 0, d = 0;
cin >> u >> v;
int w[u];
for (j = 0; j < u; j++) {
cin >> w[j];
}
sort(w, w + u);
for (int k = u - 1; k >= 0; k--) {
c += w[k];
d++;
if (c >= v) {
break;
}
}
cout << d << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int n, maxn = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int mid = n % 2 == 1 ? n / 2 + 1 : n / 2;
for (int i = 1; i <= mid; i++)
if (a[i] + 1 - i > 0) b[a[i] + 1 - i]++;
for (int i = mid + 1; i <= n; i++)
if (a[i] + i - n > 0) b[a[i] + i - n]++;
for (int i = 1; i <= 100000; i++) maxn = max(maxn, b[i]);
printf("%d\n", n - maxn);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n == 3)
cout << 5;
else {
for (int i = 1; i <= 100; i++)
if (i % 2 == 1 && (i * i + 1) / 2 >= n) {
cout << i;
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<pair<int, int>>> graph(n);
long long total = 0;
for (int i = 0; i < n - 1; i++) {
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
graph[x].emplace_back(y, z);
graph[y].emplace_back(x, z);
total += z;
}
vector<vector<int>> at_deg(n);
vector<int> deg(n);
for (int i = 0; i < n; i++) {
deg[i] = (int)graph[i].size();
at_deg[deg[i]].push_back(i);
}
vector<vector<pair<int, int>>> g(n);
vector<int> alive(n, 0);
vector<multiset<int>> extra_small(n);
vector<multiset<int>> extra_big(n);
vector<long long> sum_extra_big(n, 0);
vector<long long> res(n, 0);
set<int> lovers;
long long saved = total;
vector<int> was(n, -1);
for (int dd = n - 1; dd >= 1; dd--) {
auto BalanceOver = [&](int v) {
while ((int)extra_big[v].size() > dd) {
auto it = extra_big[v].begin();
sum_extra_big[v] -= *it;
extra_small[v].insert(*it);
extra_big[v].erase(it);
}
};
auto BalanceUnder = [&](int v) {
while ((int)extra_big[v].size() < dd && !extra_small[v].empty()) {
auto it = prev(extra_small[v].end());
sum_extra_big[v] += *it;
extra_big[v].insert(*it);
extra_small[v].erase(it);
}
};
auto Add = [&](int x, int y) {
extra_big[x].insert(y);
sum_extra_big[x] += y;
BalanceOver(x);
};
auto Remove = [&](int x, int y) {
auto it = extra_small[x].find(y);
if (it != extra_small[x].end()) {
extra_small[x].erase(it);
} else {
it = extra_big[x].find(y);
assert(it != extra_big[x].end());
extra_big[x].erase(it);
sum_extra_big[x] -= y;
BalanceUnder(x);
}
};
for (int v : lovers) {
BalanceOver(v);
}
function<pair<long long, long long>(int, int)> dfs =
[&](int v, int pr) -> pair<long long, long long> {
was[v] = dd;
vector<long long> saveable;
long long overall = 0;
long long total_saveable = 0;
int up_cost = 0;
for (auto& p : g[v]) {
int to = p.first;
int cost = p.second;
if (to == pr) {
up_cost = cost;
continue;
}
auto z = dfs(to, v);
overall += z.first;
if (z.second > z.first) {
saveable.push_back(z.second - z.first);
total_saveable += z.second - z.first;
}
}
sort(saveable.begin(), saveable.end());
int cnt = (int)saveable.size() + (int)extra_big[v].size();
long long val = overall + total_saveable + sum_extra_big[v];
int i = 0;
auto it = extra_big[v].begin();
long long tmp0 = -1;
long long tmp1 = -1;
for (int rot = 0; rot < 2; rot++) {
while (cnt > dd - rot) {
if (it == extra_big[v].end() ||
(i < (int)saveable.size() && saveable[i] < *it)) {
val -= saveable[i];
++i;
} else {
val -= *it;
++it;
}
cnt--;
}
if (rot == 0) {
tmp0 = val;
} else {
tmp1 = val;
}
}
return make_pair(tmp0, tmp1 + up_cost);
};
long long dp = 0;
for (int v : lovers) {
if (was[v] == dd) {
continue;
}
auto p = dfs(v, -1);
dp += p.first;
}
res[dd] = total - (saved + dp);
for (int v : at_deg[dd]) {
for (auto& p : graph[v]) {
int u = p.first;
int cost = p.second;
if (alive[u]) {
g[v].emplace_back(u, cost);
g[u].emplace_back(v, cost);
Remove(u, cost);
} else {
Add(v, cost);
saved -= cost;
}
}
alive[v] = 1;
lovers.insert(v);
}
}
res[0] = total;
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << res[i];
}
cout << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int pr[100000 + 10];
vector<unsigned long long> prv;
void sev() {
pr[1] = 1;
for (int i = 2; i <= 100000; ++i) {
if (pr[i]) continue;
prv.push_back(i);
for (int j = i; j <= 100000; j += i) {
pr[j] = i;
}
}
}
int main() {
int n, t;
cin >> t;
sev();
vector<unsigned long long> a;
vector<int> v[111];
int cnt = 0;
while (a.size() < 22) {
unsigned long long tmp = 1;
while (1) {
unsigned long long tmp1 = 1;
while (tmp1 <= 3000) {
tmp1 *= (unsigned long long)prv[cnt];
}
tmp1 /= prv[cnt];
if (tmp > 1000000000000000000 / tmp1) {
break;
}
tmp *= tmp1;
v[(int)a.size()].push_back(prv[cnt]);
++cnt;
}
a.push_back(tmp);
}
while (t--) {
unsigned long long ans = 1;
int x;
for (int i = 0; i < 22; ++i) {
printf("? %lld\n", a[i]);
cout.flush();
scanf("%d", &x);
for (auto it : v[i]) {
unsigned long long cnt = 0;
while (1) {
if (x % it == 0) {
++cnt;
x /= it;
} else {
break;
}
}
ans *= cnt + 1;
}
}
ans = max(ans + 7, ans * 2);
printf("! %lld\n", ans);
cout.flush();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
int x = 1;
while (x <= n) {
int k = (n - x) / 2;
for (int i = 0; i < k; i++) cout << "*";
for (int i = 0; i < x; i++) cout << "D";
for (int i = 0; i < k; i++) cout << "*";
cout << endl;
x += 2;
}
x = x - 4;
while (x >= 1) {
int k = (n - x) / 2;
for (int i = 0; i < k; i++) cout << "*";
for (int i = 0; i < x; i++) cout << "D";
for (int i = 0; i < k; i++) cout << "*";
cout << endl;
x -= 2;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 0x3f3f3f3f3f3f3f3fll;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int i, a[n];
long long int ans = 0;
map<map<int, int>, int> mp;
for (i = 0; i < n; i++) {
cin >> a[i];
map<int, int> cur;
for (int j = 2; j * j <= a[i]; j++) {
int cnt = 0;
while (a[i] % j == 0) {
cnt++;
a[i] /= j;
}
if (cnt % k == 0) continue;
cnt = cnt % k;
cur[j] = cnt;
}
if (a[i] > 1) cur[a[i]] = 1;
map<int, int> req;
for (auto j : cur) {
req[j.first] = k - j.second;
}
ans += mp[req];
mp[cur]++;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[2][2];
int main() {
int T;
scanf("%d", &T);
while (T--) {
a[0][0] = a[0][1] = a[1][0] = a[1][1] = 0;
int n;
scanf("%d", &n);
int t;
for (int i(0); i < n; i++) {
scanf("%d", &t);
if (t % 2) {
a[0][0]++;
} else
a[0][1]++;
}
scanf("%d", &n);
for (int i(0); i < n; i++) {
scanf("%d", &t);
if (t % 2) {
a[1][0]++;
} else
a[1][1]++;
}
long long sum = 0;
sum = sum + (a[0][0] * 1LL * a[1][0] + a[0][1] * 1LL * a[1][1]);
printf("%I64d\n", sum);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long intersect(pair<long long, long long> segmentA,
pair<long long, long long> segmentB) {
long long res;
if (segmentA.first > segmentA.second) {
swap(segmentA.first, segmentA.second);
}
if (segmentB.first > segmentB.second) {
swap(segmentB.first, segmentB.second);
}
if (segmentA.second < segmentB.first || segmentB.second < segmentA.first) {
res = 0;
} else if (segmentB.first >= segmentA.first &&
segmentB.second <= segmentA.second) {
res = segmentB.second - segmentB.first;
} else if (segmentA.first >= segmentB.first &&
segmentA.second <= segmentB.second) {
res = segmentA.second - segmentA.first;
} else if (segmentA.second >= segmentB.first &&
segmentA.first <= segmentB.first) {
res = segmentA.second - segmentB.first;
} else {
res = segmentB.second - segmentA.first;
}
return res;
}
int main() {
int t;
long long c, r;
cin >> t;
pair<long long, long long> segmentA, segmentB;
for (int i = 0; i < t; ++i) {
cin >> segmentA.first >> segmentA.second;
cin >> c >> r;
segmentB.first = c - r;
segmentB.second = c + r;
cout << abs(segmentA.second - segmentA.first) -
intersect(segmentA, segmentB)
<< '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 5e-7;
const double Inf = 1e9;
const int Maxn = 105;
const int Maxl = 3;
const double lim = 10000;
int n;
int x[Maxn], y[Maxn], z[Maxn];
double c[Maxl];
double ternarySearch(int lvl, double l, double r) {
if (lvl == Maxl) {
double X = c[0], Y = c[1], Z = c[2];
double mx = 0.0;
for (int i = 0; i < n; i++)
mx = max(mx, (c[0] - x[i]) * (c[0] - x[i]) +
(c[1] - y[i]) * (c[1] - y[i]) +
(c[2] - z[i]) * (c[2] - z[i]));
return mx;
} else {
if (l + eps > r) return Inf;
double p1 = (2.0 * l + r) / 3.0, p2 = (l + 2.0 * r) / 3.0;
c[lvl] = p1;
double val1 = ternarySearch(lvl + 1, -lim, lim);
c[lvl] = p2;
double val2 = ternarySearch(lvl + 1, -lim, lim);
if (val1 < val2) {
c[lvl] = p1;
return min(val1, ternarySearch(lvl, l, p2 - eps));
}
return min(val2, ternarySearch(lvl, p1 + eps, r));
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i] >> z[i];
ternarySearch(0, -lim, lim);
cout << fixed << setprecision(8);
cout << c[0] << " " << c[1] << " " << c[2] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int s, x1, x2, t1, t2, p, d;
int go(int p, int& d, int x) {
int ans = 0;
int dd = (x - p);
if (dd * d < 0) {
int to = (d > 0) ? s : 0;
ans += 2 * abs(to - p) * t1;
d *= -1;
}
ans += abs(x - p) * t1;
return ans;
}
int main() {
assert(cin >> s >> x1 >> x2 >> t1 >> t2 >> p >> d);
int ans1 = abs(x1 - x2) * t2;
int ans2 = go(p, d, x1) + go(x1, d, x2);
cout << min(ans1, ans2) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 10;
int AAAAAA[MAX];
int IIIANS[MAX];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int MAXXXXXXX = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &AAAAAA[i]);
MAXXXXXXX = max(MAXXXXXXX, AAAAAA[i]);
}
sort(AAAAAA + 1, AAAAAA + n + 1);
int cnt = 1, num = n;
for (int j = 1; j <= MAXXXXXXX; j++) {
while (j > AAAAAA[cnt] && cnt <= n) cnt++, num--;
IIIANS[j] = num;
}
int ONS_ABNS = 0;
sort(IIIANS + 1, IIIANS + 1 + MAXXXXXXX);
int POSSSS = MAXXXXXXX;
for (int i = 1; i <= MAXXXXXXX; i++) {
if (IIIANS[i] == n) {
POSSSS = i - 1;
break;
}
}
MAXXXXXXX = POSSSS;
for (int i = 1; i <= MAXXXXXXX; i++) {
int tmp = m, TTTMMMPPPP = i;
while (TTTMMMPPPP <= MAXXXXXXX && tmp >= IIIANS[TTTMMMPPPP]) {
tmp -= IIIANS[TTTMMMPPPP];
TTTMMMPPPP++;
}
i = TTTMMMPPPP - 1;
ONS_ABNS++;
}
printf("%d\n", ONS_ABNS);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, mx[500200], p[500200], ind[500200], ans[500200], f[500200], d[500200];
vector<pair<int, int> > g[500200];
unordered_map<int, int> mp[500200];
char c[500200];
void Merge(int a, int b, int vert) {
unordered_map<int, int>::iterator it = mp[a].begin();
while (it != mp[a].end()) {
int x = (it->first) ^ f[a] ^ f[b];
for (int i = 0; i < 23; i++) {
if (it->second + mx[vert] - d[vert] <= ans[vert]) continue;
if (i != 22 && mp[b].count(x ^ (1 << i)))
ans[vert] =
max(ans[vert], it->second + mp[b][x ^ (1 << i)] - 2 * d[vert]);
if (i == 22 && mp[b].count(x))
ans[vert] = max(ans[vert], it->second + mp[b][x] - 2 * d[vert]);
}
++it;
}
it = mp[a].begin();
while (it != mp[a].end()) {
int x = it->first ^ f[a] ^ f[b];
if (!mp[b].count(x))
mp[b][x] = it->second;
else
mp[b][x] = max(mp[b][x], it->second);
++it;
}
mp[a].clear();
}
void dfs(int v) {
int i;
ind[v] = v;
mx[v] = d[v];
mp[ind[v]][0] = d[v];
for (i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
d[to] = d[v] + 1;
dfs(to);
mx[v] = max(mx[v], mx[to]);
ans[v] = max(ans[v], ans[to]);
f[ind[to]] ^= g[v][i].second;
if (mp[ind[to]].size() < mp[ind[v]].size()) {
Merge(ind[to], ind[v], v);
} else {
Merge(ind[v], ind[to], v);
ind[v] = ind[to];
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%s", &p[i], &c[i]);
g[--p[i]].push_back({i, 1 << (c[i] - 'a')});
}
dfs(0);
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.