solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[100100];
vector<int> d[100100];
vector<int> v[100100][22];
int T[100100][22];
int Niv[100100];
int niv[200100];
bool bf[100100];
int lim;
int rmq[200200][22], eul[200200], lg[200200], st[200200];
int nn = -1, n;
vector<int> interclasare(vector<int> v1, vector<int> v2) {
vector<int> sol;
int cn = 0;
int i1 = 0, i2 = 0;
while (cn < 10 && i1 < v1.size() && i2 < v2.size()) {
if (v1[i1] <= v2[i2]) {
sol.push_back(v1[i1]);
cn++;
i1++;
} else {
sol.push_back(v2[i2]);
cn++;
i2++;
}
}
while (cn < 10 && i1 < v1.size()) {
sol.push_back(v1[i1]);
cn++;
i1++;
}
while (cn < 10 && i2 < v2.size()) {
sol.push_back(v2[i2]);
cn++;
i2++;
}
return sol;
}
void pre() {
int i, j;
lim = 0;
int p = 1;
while (p * 2 <= n) {
p *= 2;
lim++;
}
for (j = 1; j <= lim; j++) {
for (i = 1; i <= n; i++) {
int T1, T2;
T1 = T[i][j - 1];
if (T1 != -1) T1 = T[T1][1];
if (T1 != -1) T2 = T[T1][j - 1];
if (T1 != -1 && T2 != -1) {
T[i][j] = T2;
int cn = 0;
int i1 = 0, i2 = 0;
v[i][j] = interclasare(v[i][j - 1], v[T1][j - 1]);
} else
T[i][j] = -1;
}
}
}
void dfs(int x, int nv, int t) {
int i;
Niv[x] = nv;
T[x][1] = t;
bf[x] = true;
eul[++nn] = x;
st[x] = nn;
niv[nn] = nv;
for (i = 0; i < a[x].size(); i++)
if (bf[a[x][i]] == false) {
dfs(a[x][i], nv + 1, x);
eul[++nn] = x;
niv[nn] = nv;
}
}
void pre_rmq() {
int i, j;
for (i = 2; i <= nn; i++) lg[i] = lg[i >> 1] + 1;
for (i = 0; i <= nn; i++) rmq[i][0] = i;
for (j = 1, i = 0; (1 << j) < nn; j++)
for (i = 0; i <= nn - (1 << j); i++)
if (niv[rmq[i][j - 1]] < niv[rmq[i + (1 << (j - 1))][j - 1]])
rmq[i][j] = rmq[i][j - 1];
else
rmq[i][j] = rmq[i + (1 << (j - 1))][j - 1];
}
int get_lca(int x, int y) {
int nr;
x = st[x];
y = st[y];
if (x > y) {
int ax = x;
x = y;
y = ax;
}
nr = lg[y - x + 1];
if (niv[rmq[x][nr]] < niv[rmq[y - (1 << nr) + 1][nr]])
return (eul[rmq[x][nr]]);
else
return (eul[rmq[y - (1 << nr) + 1][nr]]);
}
vector<int> query(int x, int y) {
vector<int> sol1;
vector<int> sol2;
int i, j;
int lca = get_lca(x, y);
i = lim;
while (true) {
while (T[x][i] == -1 || Niv[T[x][i]] < Niv[lca]) i--;
sol1 = interclasare(sol1, v[x][i]);
x = T[x][i];
if (x == lca) break;
x = T[x][1];
}
i = lim;
while (y != lca) {
while (T[y][i] == -1 || Niv[T[y][i]] <= Niv[lca]) i--;
sol2 = interclasare(sol2, v[y][i]);
y = T[y][i];
y = T[y][1];
}
return interclasare(sol1, sol2);
}
int main() {
int m, q, i;
scanf("%d%d%d", &n, &m, &q);
for (i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
for (i = 1; i <= n; i++) T[i][0] = i;
for (i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
v[x][0].push_back(i);
}
for (i = 1; i <= n; i++)
if (v[i][0].size()) {
sort(v[i][0].begin(), v[i][0].end());
while (v[i][0].size() > 10) v[i][0].pop_back();
}
dfs(1, 0, -1);
pre_rmq();
pre();
for (i = 1; i <= q; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
vector<int> s = query(x, y);
printf("%d ", min(z, (int)s.size()));
for (int j = 0; j < min(z, (int)s.size()); j++) printf("%d ", s[j]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[52][15][4][15][4][15][4];
map<int, int> mp;
int check(char *a, char *b, int *v, int n) {
if (n == 0) return 1;
if (n > 1) {
if (dp[n][mp[a[n]]][mp[b[n]]][mp[a[n - 1]]][mp[b[n - 1]]][mp[a[n - 2]]]
[mp[b[n - 2]]])
return dp[n][mp[a[n]]][mp[b[n]]][mp[a[n - 1]]][mp[b[n - 1]]][mp[a[n - 2]]]
[mp[b[n - 2]]];
}
int x;
char y;
int f = -1;
if (v[n - 1] == 0 && (a[n] == a[n - 1] || b[n] == b[n - 1])) {
x = a[n - 1];
y = b[n - 1];
a[n - 1] = a[n];
b[n - 1] = b[n];
if (check(a, b, v, n - 1) == 1) {
f = 1;
}
a[n - 1] = x;
b[n - 1] = y;
if (n > 2)
dp[n][mp[a[n]]][mp[b[n]]][mp[a[n - 1]]][mp[b[n - 1]]][mp[a[n - 2]]]
[mp[b[n - 2]]] = f;
if (f == 1) return f;
}
if (n < 3) return 0;
if (v[n - 3] == 0 && (a[n] == a[n - 3] || b[n] == b[n - 3])) {
x = a[n - 3];
y = b[n - 3];
a[n - 3] = a[n];
b[n - 3] = b[n];
if (check(a, b, v, n - 1) == 1) return 1;
a[n - 3] = x;
b[n - 3] = y;
dp[n][mp[a[n]]][mp[b[n]]][mp[a[n - 1]]][mp[b[n - 1]]][mp[a[n - 2]]]
[mp[b[n - 2]]] = f;
}
return f;
}
int main() {
for (int i = 1; i <= 9; i++) mp[i + '0'] = i;
mp['T'] = 10;
mp['J'] = 11;
mp['Q'] = 12;
mp['K'] = 13;
mp['A'] = 0;
mp['S'] = 0;
mp['D'] = 1;
mp['H'] = 2;
mp['C'] = 3;
int n;
cin >> n;
char a[n];
char b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
int ans[n];
memset(ans, 0, sizeof ans);
if (check(a, b, ans, n - 1) == 1)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 55;
const int K = 200010;
const int LIT = 2500;
const int INF = 1 << 30;
const int dir[6][2] = {{2, 0}, {-2, 0}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
bool check(long long x, long long y, long long n) {
long long dist = x * x + 3 * y * y;
long long cmp = 4 * n * n;
return dist <= cmp;
}
bool inside(long long x, long long y, long long n) {
for (int j = 0; j < 6; j++) {
long long xx = x + dir[j][0];
long long yy = y + dir[j][1];
if (!check(xx, yy, n)) return 0;
}
return 1;
}
void solve(int n) {
long long x = 0, y = 0;
long long res = 1;
while (1) {
y += 2;
if (!inside(x, y, n)) break;
res += 2;
}
while (y >= 0) {
x += 3, y++;
while (y >= 0) {
if (inside(x, y, n)) {
res += (y + 1) * 2;
break;
}
y -= 2;
}
}
cout << res << endl;
}
int main() {
int n;
while (cin >> n) {
solve(n);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e3 + 5;
int const MOD = 1000000007;
int q, x, cs[N], k;
vector<int> v, ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> q >> k;
while (q--) {
cin >> x;
v.push_back(x);
}
for (int i = 1; i < v.size(); ++i) {
ans.push_back(v[i] - v[i - 1]);
}
sort(ans.begin(), ans.end());
reverse(ans.begin(), ans.end());
int sum = 0;
for (int i = k - 1; i < ans.size(); ++i) {
sum += ans[i];
}
cout << sum;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c;
int p[501];
double ans;
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", p + i);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
ans = max(ans, (double)(p[a] + p[b]) / c);
}
printf("%.15f\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int ln;
vector<int> a[2005];
vector<int> b[2005];
long long before[2005] = {0};
long long after[2005] = {0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
ln = (int)s.length();
a[0].push_back(0);
before[0] = 1;
for (int i = 1; i < ln; i++) {
a[i].push_back(i);
for (int j = 0; j < (int)a[i - 1].size(); j++) {
if (a[i - 1][j] > 0 && (s[i] == (s[a[i - 1][j] - 1])))
a[i].push_back(a[i - 1][j] - 1);
}
if (s[i] == s[i - 1]) a[i].push_back(i - 1);
before[i] = (int)a[i].size();
}
b[ln - 1].push_back(ln - 1);
after[ln - 1] = 1;
for (int i = ln - 2; i >= 0; i--) {
b[i].push_back(i);
for (int j = 0; j < (int)b[i + 1].size(); j++) {
if (b[i + 1][j] < (ln - 1) && (s[i] == (s[b[i + 1][j] + 1])))
b[i].push_back(b[i + 1][j] + 1);
}
if (s[i] == s[i + 1]) b[i].push_back(i + 1);
after[i] = (int)b[i].size();
after[i] += after[i + 1];
}
long long ans = 0;
for (int i = 0; i < ln - 1; i++) ans += before[i] * after[i + 1];
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long f, res = 0;
cin >> f;
while (1) {
f++;
res++;
long long ff = abs(f);
while (ff > 0) {
int d = ff % 10;
if (d == 8) {
cout << res << "\n";
return 0;
}
ff /= 10;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 28);
const long long MOD = 1000000007LL;
long long pow2(int n) {
if (n == 0) return 1;
if (n == 1) return 2;
if (n % 2 == 0) return pow2(n / 2) * pow2(n / 2) % MOD;
if (n % 2 == 1) return pow2(n / 2) * pow2(n / 2) * 2 % MOD;
}
int main() {
string x;
cin >> x;
reverse((x).begin(), (x).end());
long long ans = 0LL;
for (int i = 0; i < (int)(x.size()); i++) {
if (x[i] == '0')
ans = 2 * ans % MOD;
else
ans = (2 * ans + pow2(2 * i)) % MOD;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* na, Arg1&& arg1, Args&&... args) {
const char* c = strchr(na + 1, ',');
cerr.write(na, c - na) << " : " << arg1 << " , ";
__f(c + 1, args...);
}
const int MOD = 1e9 + 7;
const int inf = 1e9;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const long long INF = 1e18;
const int N = 3e5 + 5;
int n;
long long int a[N], b[N];
long long int dp[N][5];
long long int solve(int idx, int inc) {
if (idx > n) return 0;
if (dp[idx][inc] != -1) return dp[idx][inc];
long long int ret = INF;
long long int last = a[idx - 1] + inc;
for (int i = 0; i <= 2; i++) {
if ((a[idx] + i) != last) ret = min(ret, solve(idx + 1, i) + i * b[idx]);
}
return dp[idx][inc] = ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 2; j++) {
dp[i][j] = -1;
}
}
cout << min(solve(2, 0), min(solve(2, 1) + b[1], solve(2, 2) + 2 * b[1]))
<< "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[5000][5000];
int n, m;
int main() {
string s;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
int k = 0;
while (k < m) {
while (k < m && s[k] == '0') k++;
int t = k;
if (k == m) break;
while (k < m && s[k] == '1') k++;
p[t][k - 1]++;
}
}
for (int j = 0; j < m; j++)
for (int i = m - 1; i > j; i--) p[j][i - 1] += p[j][i];
for (int i = m - 1; i >= 0; i--)
for (int j = 0; j < i; j++) p[j + 1][i] += p[j][i];
int best = 0;
for (int i = 0; i < m; i++)
for (int j = i; j < m; j++) best = max(best, (j - i + 1) * p[i][j]);
cout << best;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int l[105];
int a[105];
int blah(int x, int y) { return x == y ? n : (y + n - x) % n; }
int main() {
cin >> n >> m;
memset(a, -1, sizeof(a));
for (int i = 0; i < m; i++) {
cin >> l[i];
if (i > 0) {
int x = blah(l[i - 1], l[i]);
if (a[l[i - 1]] == -1)
a[l[i - 1]] = x;
else if (a[l[i - 1]] != x) {
cout << "-1\n";
return 0;
}
}
}
for (int i = 1; i <= n; i++) {
int ind = -1;
int num = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == -1)
ind = j;
else if (a[j] == i)
num++;
}
if (num == 0)
a[ind] = i;
else if (num > 1) {
cout << "-1\n";
return 0;
}
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool check(vector<long long> &v1, vector<long long> &v2) {
for (long long k = 0; k < 26; k++) {
if (v1[k] > v2[k]) {
return false;
}
}
return true;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
string s;
cin >> s;
vector<vector<long long> > pre(n, vector<long long>(26, 0));
pre[0][s[0] - 'a'] = 1;
for (long long i = 1; i < n; i++) {
for (long long j = 0; j < 26; j++) {
pre[i][j] = pre[i - 1][j];
}
pre[i][s[i] - 'a']++;
}
long long t;
cin >> t;
for (long long j = 0; j < t; j++) {
string w;
cin >> w;
vector<long long> word(26, 0);
for (long long i = 0; i < w.size(); i++) {
word[w[i] - 'a']++;
}
long long lower = -1;
long long upper = n - 1;
while (upper - lower > 1) {
long long mid = (upper + lower) / 2;
if (check(word, pre[mid])) {
upper = mid;
} else {
lower = mid;
}
}
cout << upper + 1 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
for (int i = 0; i < tc; i++) {
long long x[3];
cin >> x[0] >> x[1] >> x[2];
sort(x, x + 3);
if (x[0] < x[1] && x[1] < x[2]) {
x[0]++;
x[2]--;
} else if (x[0] == x[1] && x[2] > x[1]) {
x[0]++;
x[1]++;
if (x[0] == x[1] && x[2] > x[1]) x[2]--;
} else if (x[0] < x[1] && x[1] == x[2]) {
x[1]--;
x[2]--;
if (x[0] < x[1] && x[1] == x[2]) x[0]++;
} else if (x[0] == x[1] && x[1] == x[2]) {
}
cout << (abs(x[0] - x[1]) + abs(x[1] - x[2]) + abs(x[2] - x[0])) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3;
int i, j, k, n, l, m;
vector<vector<int> > b(500);
int tra(char ch) { return int(ch) - int('a'); }
int main() {
cin >> s1 >> s2;
n = s2.length();
m = s1.length();
l = 1;
i = 1;
for (i = 0; i < m; i++) {
b[tra(s1[i])].push_back(i);
}
int current = -1;
bool okk;
l = 1;
int rr, ll, pp, t;
for (i = 0; i < n; i++) {
okk = false;
if (b[tra(s2[i])].empty()) {
cout << -1;
return 0;
}
t = tra(s2[i]);
rr = b[t].size() - 1;
ll = 0;
if (b[t][rr] > current)
while (true) {
pp = (ll + rr) / 2;
if (b[t][pp] > current)
rr = pp;
else
ll = pp;
if (b[t][rr - 1] <= current || (ll == rr)) {
{
okk = true;
current = b[t][rr];
}
break;
}
}
if (!okk) {
l++;
current = b[tra(s2[i])][0];
}
}
cout << l;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r;
while ((r = a % b) != 0) {
a = b;
b = r;
}
return b;
}
int main() {
int x, y;
int a, b, i;
scanf("%d%d%d%d", &x, &y, &a, &b);
int s = x * y / gcd(x, y);
int t = b / s - (a - 1) / s;
printf("%d\n", t);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int inf = 1e9 + 7;
const double eps = 1e-8;
long long qpow(long long a, long long b, long long m) {
long long r = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) r = r * a % m;
a = a * a % m;
}
return (r + m) % m;
}
const int maxn = 45;
int vis[50][50][50][4][4][4];
int a[4][4];
int ans = 0;
int dfs(int x1, int x2, int x3, int A, int B, int C) {
if (vis[x1][x2][x3][A][B][C]) return 0;
vis[x1][x2][x3][A][B][C] = 1;
int b[4] = {0, x1, x2, x3};
int c[4] = {0, A, B, C};
int g[50] = {0};
for (int i = 1; i <= 3; i++) g[b[i]] = i;
for (int i = 1; i <= 3; i++) {
int t = b[i];
if (t <= maxn) {
ans = max(ans, t);
if (!(c[i] & 1) && !g[maxn + i]) {
for (int j = max(0, t - a[i][2]); j <= t + a[i][2]; j++) {
if (j > 0 && !g[j]) {
b[i] = j;
c[i] ^= 1;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[i] = t;
c[i] ^= 1;
}
}
}
if (!(c[i] & 2) && !g[maxn + i]) {
for (int j = 1; j <= 3; j++) {
int v = b[j];
if (abs(t - v) != 1) continue;
b[j] = maxn + i;
c[i] ^= 2;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[j] = v;
c[i] ^= 2;
}
}
if (g[maxn + i]) {
int k = g[maxn + i];
for (int j = max(0, t - a[i][3]); j <= t + a[i][3]; j++) {
if (j > 0 && !g[j]) {
b[k] = j;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[k] = maxn + i;
}
}
}
}
}
return 0;
}
int main() {
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) cin >> a[i][j];
dfs(a[1][1], a[2][1], a[3][1], 0, 0, 0);
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Add(int &a, int b) { a = (a + b) % 1000000007; }
int Min(int &a, int b) { a = (a + 1000000007 - b) % 1000000007; }
int Mul(int &a, int b) { a = (long long)a * b % 1000000007; }
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long pow(long long a, long long b) {
long long res(1);
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
long long powM(long long a, long long b, long long mod) {
long long res(1);
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
const int infi = 2147483647;
const long long infl = 9223372036854775807;
const long double eps = 1e-12;
struct Point {
long double x, y;
Point() {}
Point(long double _x, long double _y) : x(_x), y(_y) {}
Point operator+(const Point &t) const { return Point(x + t.x, y + t.y); }
Point operator-(const Point &t) const { return Point(x - t.x, y - t.y); }
Point operator*(const long double &t) const { return Point(x * t, y * t); }
Point operator/(const long double &t) const { return Point(x / t, y / t); }
bool operator<(const Point &t) const {
return fabs(x - t.x) < eps ? y < t.y : x < t.x;
}
bool operator==(const Point &t) const {
return fabs(x - t.x) < eps && fabs(y - t.y) < eps;
}
long double len() const { return sqrt(x * x + y * y); }
Point rot90() const { return Point(-y, x); }
};
struct Circle {
Point o;
long double r;
Circle() {}
Circle(Point _o, long double _r) : o(_o), r(_r) {}
friend vector<Point> operator&(const Circle &c1, const Circle &c2) {
long double d = (c1.o - c2.o).len();
if (d > c1.r + c2.r + eps || d < fabs(c1.r - c2.r) - eps)
return vector<Point>();
long double dt = (c1.r * c1.r - c2.r * c2.r) / d, d1 = (d + dt) / 2;
Point dir = (c2.o - c1.o) / d, pcrs = c1.o + dir * d1;
dt = sqrt(max(0.0L, c1.r * c1.r - d1 * d1)), dir = dir.rot90();
return vector<Point>{pcrs + dir * dt, pcrs - dir * dt};
}
} p[5];
struct DSU {
int fa[5];
void init(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
if (x != y) fa[x] = y;
}
} dsu;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= (n); ++i) cin >> p[i].o.x >> p[i].o.y >> p[i].r;
vector<Point> all;
dsu.init(n);
int v, e = 0, c = 0;
for (int i = 1; i <= (n); ++i) {
vector<Point> pat;
for (int j = 1; j <= (n); ++j)
if (i != j) {
vector<Point> tmp = p[i] & p[j];
if (!tmp.empty()) dsu.merge(i, j);
for (int k = 0; k < (tmp.size()); ++k)
all.push_back(tmp.at(k)), pat.push_back(tmp.at(k));
}
sort(pat.begin(), pat.end());
e += unique(pat.begin(), pat.end()) - pat.begin();
}
sort(all.begin(), all.end());
v = unique(all.begin(), all.end()) - all.begin();
for (int i = 1; i <= (n); ++i) c += (dsu.find(i) == i);
cout << e - v + c + 1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
istream &in = cin;
int n, m;
int t[100001], T[100001], x[100001], c[100001];
long long get(int i) {
if (t[i] >= T[i]) return (long long)m * x[i] + c[i];
long long tmp1 = (long long)m * x[i] + c[i];
long long tmp2 =
(long long)m / (T[i] - t[i]) * c[i] + (m % (T[i] - t[i]) == 0 ? 0 : c[i]);
return min(tmp1, tmp2);
}
int main() {
in >> n >> m;
for (int u = 0; u < n; ++u) in >> t[u] >> T[u] >> x[u] >> c[u];
long long ret = 0;
for (int i = 0; i < n; ++i) ret += get(i);
cout << ret << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
const int mod = 100007;
const int inf = 1e9 + 10;
int MAIN() {
int v1, v2, t, d;
cin >> v1 >> v2 >> t >> d;
if (d == 0) {
cout << v1 * t << endl;
return 0;
}
int mx = -1, mv = v1 + (t - 1) * d;
for (int mid = v1; mid <= mv; ++mid) {
int dist = 0, speed, t1, t2;
t1 = t2 = 0;
for (speed = v1; speed < mid; speed += d) {
dist += speed;
++t1;
}
dist += mid;
++t1;
for (speed = v2; speed < mid; speed += d) {
dist += speed;
++t2;
}
if (t1 + t2 <= t) {
dist += (t - t2 - t1) * mid;
mx = max(mx, dist);
}
}
cout << mx << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxe = 2e5 + 5;
int main() {
int n;
cin >> n;
int arr[maxe];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ptr1 = 0;
int ptr2 = n - 1;
int alice = 0;
int bob = 0;
int lastflag = 3;
while (ptr1 < ptr2) {
if (arr[ptr1] < arr[ptr2]) {
lastflag = 1;
arr[ptr2] -= arr[ptr1];
arr[ptr1] = 0;
alice++;
ptr1++;
} else if (arr[ptr1] > arr[ptr2]) {
lastflag = 2;
arr[ptr1] -= arr[ptr2];
arr[ptr2] = 0;
bob++;
ptr2--;
} else {
lastflag = 3;
alice++;
bob++;
ptr1++;
ptr2--;
}
}
if (lastflag == 1 && ptr1 == ptr2)
bob++;
else if (lastflag == 2 && ptr1 == ptr2)
alice++;
else if (lastflag == 3 && ptr1 == ptr2)
alice++;
cout << alice << " " << bob;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
int N;
string T;
int Q;
pair<string, vector<int>> solt(string T) {
int N = T.length();
vector<int> v{-1};
string ret;
int suc = 0;
for (int i = (0), i_end_ = (N); i < i_end_; i++) {
if (T[i] == '0') {
if (suc % 2) ret += '1';
suc = 0;
ret += '0';
v.push_back(i);
} else
suc++;
}
if (suc % 2) ret += '1';
v.push_back(N);
return make_pair(ret, v);
}
struct rand_int_ {
using lint = long long;
mt19937 mt;
rand_int_() : mt(chrono::steady_clock::now().time_since_epoch().count()) {}
lint operator()(lint x) { return this->operator()(0, x); }
lint operator()(lint l, lint r) {
uniform_int_distribution<lint> d(l, r - 1);
return d(mt);
}
} rnd;
template <typename V>
struct rolling_hash {
V B;
vector<V> hash;
vector<V> power;
rolling_hash() {}
rolling_hash(const string &s, V b) : B(b) {
int N = s.length();
hash.resize(N + 1), power.resize(N + 1, 1);
for (int i = 0; i < N; i++) {
power[i + 1] = power[i] * B;
hash[i + 1] = hash[i] * B + s[i];
}
}
V get_hash(int l, int r) { return hash[r] - hash[l] * power[r - l]; }
};
using lint = long long;
using plint = pair<lint, lint>;
struct DoubleHash : public plint {
static plint MODs;
DoubleHash(plint x) : plint(x) {}
DoubleHash(lint x, lint y) : plint(x, y) {}
DoubleHash(lint x) : DoubleHash(x, x) {}
DoubleHash() : DoubleHash(0) {}
static inline DoubleHash mod_subtract(plint x) {
if (x.first >= MODs.first) x.first -= MODs.first;
if (x.second >= MODs.second) x.second -= MODs.second;
return x;
}
DoubleHash operator+(const DoubleHash &x) const {
return mod_subtract(plint(this->first + x.first, this->second + x.second));
}
DoubleHash operator+(lint x) const {
return mod_subtract(plint(this->first + x, this->second + x));
}
DoubleHash operator-(const DoubleHash &x) const {
return mod_subtract(plint(this->first - x.first + MODs.first,
this->second - x.second + MODs.second));
}
DoubleHash operator*(const DoubleHash &x) const {
return make_pair(this->first * x.first % MODs.first,
this->second * x.second % MODs.second);
}
DoubleHash operator*(lint x) const {
return make_pair(this->first * x % MODs.first,
this->second * x % MODs.second);
}
};
plint DoubleHash::MODs = plint(1000000007, 998244353);
rolling_hash<DoubleHash> rh;
vector<int> nxtz, prvz;
vector<int> zaatsu;
pair<DoubleHash, pint> solve(int l, int r) {
int lz = nxtz[l];
int rz = prvz[r - 1];
if (lz > rz) {
return make_pair(DoubleHash(-1, -1), pint(r - l - 10000000, -1));
}
pint rp = make_pair((lz - l) % 2, (r - rz) % 2);
return make_pair(rh.get_hash(zaatsu[lz], zaatsu[rz]), rp);
}
int main() {
cin >> N >> T;
N = T.length();
nxtz.resize(N);
prvz.resize(N);
string Ttrunc;
vector<int> zeropos;
tie(Ttrunc, zeropos) = solt(T);
{
int t = 0;
for (int i = (0), i_end_ = (N); i < i_end_; i++) {
while (zeropos[t] < i) t++;
nxtz[i] = zeropos[t];
}
t = zeropos.size() - 1;
for (int i = (N)-1, i_begin_ = (0); i >= i_begin_; i--) {
while (zeropos[t] > i) t--;
prvz[i] = zeropos[t];
}
}
zaatsu.resize(N);
{
int j = 0;
for (int i = (0), i_end_ = (N); i < i_end_; i++)
if (T[i] == '0') {
while (Ttrunc[j] != '0') j++;
zaatsu[i] = j;
j++;
}
}
DoubleHash b(rnd(1, 100000), rnd(1, 1000000));
rh = rolling_hash<DoubleHash>(Ttrunc, b);
vector<int> ret;
cin >> Q;
while (Q--) {
int l1, l2, len;
cin >> l1 >> l2 >> len;
l1--, l2--;
auto h1 = solve(l1, l1 + len);
auto h2 = solve(l2, l2 + len);
ret.push_back(h1 == h2);
}
for (auto v : ret) {
if (v)
puts("Yes");
else
puts("No");
}
}
| 8 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 5;
using namespace std;
int a[maxn * 2];
int main() {
int n;
cin >> n;
int flag = 0;
for (int t = 0; t < n; t++) {
scanf("%d", &a[t]);
if (a[t] == 1) {
flag = 1;
}
}
for (int t = n; t < 2 * n; t++) {
a[t] = a[t - n];
}
int s = 1;
int maxnn = -1;
for (int t = 1; t < 2 * n; t++) {
if (a[t] == a[t - 1] && a[t] == 1) {
s++;
} else {
s = 1;
}
if (s > maxnn) {
maxnn = s;
}
}
if (maxnn > n) {
maxnn = n;
}
if (flag == 1)
cout << maxnn << endl;
else {
cout << "0" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<long long int> record;
long long int t;
long long int sum = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> t;
sum = sum + t - 1;
if (sum % 2 == 0)
cout << 2 << endl;
else
cout << 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10, MN = 1e6 + 10, MOD = 1e9 + 7;
int fact[MN], lfact[MN], n, k, ps[MN], dp[MN];
void ok(int &x) {
if (x >= MOD) x -= MOD;
}
int bpw(int a, int b) {
int ret = 1, cur = a;
while (b) {
if (b & 1) ret = 1ll * ret * cur % MOD;
cur = 1ll * cur * cur % MOD;
b >>= 1;
}
return ret;
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
fact[0] = 1;
for (int i = 1; i < MN; ++i) fact[i] = 1ll * i * fact[i - 1] % MOD;
for (int i = 0; i < MN; ++i) lfact[i] = bpw(fact[i], MOD - 2);
cin >> n >> k;
dp[0] = ps[0] = 1;
for (int i = 1; i <= n; ++i) {
dp[i] = 1ll * ((ps[i - 1] - (i - k <= 0 ? 0 : ps[i - k - 1]) + MOD) % MOD) *
fact[i - 1] % MOD;
ps[i] = ps[i - 1] + 1ll * dp[i] * lfact[i] % MOD;
ok(ps[i]);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans += 1ll * dp[i] * fact[n - 1] % MOD * lfact[i] % MOD;
ok(ans);
}
cout << (1ll * fact[n] - ans + MOD) % MOD << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int len, vis[100010];
int check1() {
int i;
for (i = 0; i < len; i++)
if (s[i] != '1') return 0;
return 1;
}
int main() {
int i;
scanf("%s", s);
len = strlen(s);
if (check1()) {
for (i = 0; i < len - 1; i++) printf("1");
printf("\n");
} else {
for (i = 1; i < len; i++)
if (s[i] != '1') break;
vis[i] = 1;
for (i = 0; i < len; i++)
if (!vis[i]) printf("%c", s[i]);
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100][100];
int n;
int p = -1;
int main() {
memset(a, -1, sizeof(a));
cin >> n;
for (int j = n; j < 2 * n + 1; j++) {
int k = 0;
p++;
for (int i = p; i < n + 1; i++) {
a[i][j] = k;
a[2 * n - i][j] = k;
a[i][2 * n - j] = k;
a[j][i] = k;
k++;
}
}
for (int i = 0; i < 2 * n + 1; i++) {
for (int j = 0; j < 2 * n + 1; j++)
if (a[i][j] == -1 && j < n + 1)
cout << " ";
else if (a[i][j] != -1 && a[i][j + 1] != -1)
cout << a[i][j] << " ";
else if (a[i][j] != -1)
cout << a[i][j];
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using ll = long long;
int main() {
int a, b, n;
cin >> a >> b >> n;
int cnt = 0;
vi vis(n + 1, 0);
for (int i = a; i <= n; i += a) vis[i] = 1;
for (int i = b; i <= n; i += b)
if (vis[i]) cnt++;
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
int main() {
fast();
long long t, i;
cin >> t;
while (t--) {
int n;
cin >> n;
if ((n - 1) / 2 == 2)
cout << 2 << " " << (n - 1) / 2 * 2 << endl;
else
cout << 2 << " " << (n - 1) / 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int L = 10005;
const int N = 55;
const int INF = 0x7f7f7f7f;
int n, d, a[N], mind[N * L];
bool vst[N * L];
int main() {
scanf("%d%d", &n, &d);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
vst[0] = true;
int top = 0;
for (int i = 0; i < n; ++i) {
for (int j = top; j >= 0; --j)
if (vst[j]) {
vst[j + a[i]] = true;
}
top += a[i];
}
memset(mind, 0x7f, sizeof(mind));
mind[0] = 0;
priority_queue<pair<int, int> > q;
q.push(pair<int, int>(-mind[0], 0));
int ans = 0;
for (int i = 1; i <= top; ++i)
if (vst[i]) {
while (!q.empty() && q.top().second + d < i) q.pop();
if (q.empty()) break;
mind[i] = mind[q.top().second] + 1;
q.push(pair<int, int>(-mind[i], i));
ans = i;
}
printf("%d %d\n", ans, mind[ans]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
cin >> m;
int mult = 1;
for (int i = 0; i < n; i++) {
mult *= 2;
if (mult > m) {
cout << m;
return 0;
}
}
cout << m % mult;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int INF = 1e9 + 7;
const long long INFLL = 1e16;
const double EPS = 1e-6;
using namespace std;
const int maxn = 505;
int grid[maxn][maxn];
int bit[maxn][maxn];
int par[maxn * maxn], size[maxn * maxn];
int root(int a) {
if (par[a] == a) return a;
return par[a] = root(par[a]);
}
int root(int a, int b) {
int x = a * maxn + b;
return root(x);
}
void join(int a, int b, int c, int d) {
int x = root(a, b);
int y = root(c, d);
if (x == y) return;
size[y] += size[x];
par[x] = y;
}
int sz(int a, int b) { return size[root(a, b)]; }
int n, m;
char s[maxn][maxn];
int step[2][4] = {{1, 0, -1, 0}, {0, 1, 0, -1}};
int dp(int a, int b) {
a++, b++;
if (a >= n) a = n;
if (b >= n) b = n;
return bit[a][b];
}
int dp(int a, int b, int c, int d) {
a--, b--;
return dp(c, d) - dp(a, d) - dp(c, b) + dp(a, b);
}
void init() {
for (int k = (int)0; k < (int)maxn * maxn; k++) par[k] = k, size[k] = 1;
scanf("%d%d", &n, &m);
for (int k = (int)0; k < (int)n; k++) scanf("%s", s[k]);
for (int k = (int)0; k < (int)n; k++)
for (int i = (int)0; i < (int)n; i++)
if (s[k][i] != '.') size[root(k, i)] = 0;
for (int k = (int)0; k < (int)n; k++)
for (int i = (int)0; i < (int)n; i++) {
if (s[k][i] == '.') {
for (int j = (int)0; j < (int)4; j++) {
int kk = k + step[0][j];
int ii = i + step[1][j];
if (kk >= 0 && kk < n && ii >= 0 && ii < n && s[kk][ii] == '.') {
join(k, i, kk, ii);
}
}
} else {
bit[k + 1][i + 1]++;
}
bit[k + 1][i + 1] += bit[k][i + 1] + bit[k + 1][i] - bit[k][i];
}
}
char S(int a, int b) {
if (a < 0 || b < 0 || a >= n || b >= n) return 'X';
return s[a][b];
}
int cnt[maxn * maxn], now;
void add(int a, int b) {
int x = root(a, b);
if (S(a, b) == '.') {
if (cnt[x] == 0) now += size[x];
cnt[x]++;
} else {
for (int j = (int)0; j < (int)4; j++) {
int aa = a + step[0][j];
int bb = b + step[1][j];
if (S(aa, bb) == '.') {
x = root(aa, bb);
if (cnt[x] == 0) now += size[x];
cnt[x]++;
}
}
}
}
void del(int a, int b) {
int x = root(a, b);
if (S(a, b) == '.') {
cnt[x]--;
if (cnt[x] == 0) now -= size[x];
} else {
for (int j = (int)0; j < (int)4; j++) {
int aa = a + step[0][j];
int bb = b + step[1][j];
if (S(aa, bb) == '.') {
x = root(aa, bb);
cnt[x]--;
if (cnt[x] == 0) now -= size[x];
}
}
}
}
void hit(int x) {
int a = x, b = 0;
int aa = a + m, bb = b + m;
now = 0;
memset(cnt, 0, sizeof(cnt));
for (int k = (int)a; k < (int)aa + 1; k++)
for (int i = (int)b; i < (int)bb + 1; i++) {
add(k, i);
}
}
void solve() {
int ret = 0;
m--;
for (int k = (int)0; k < (int)n; k++) {
for (int i = (int)0; i < (int)n; i++) {
int kk = k + m;
int ii = i + m;
if (kk >= n || ii >= n) break;
if (i == 0)
hit(k);
else {
for (int j = (int)k; j < (int)kk + 1; j++) add(j, ii);
}
ret = max(ret, now + dp(k, i, kk, ii));
for (int j = (int)k; j < (int)kk + 1; j++) del(j, i);
}
}
printf("%d\n", ret);
}
void debug() {
for (int k = (int)0; k < (int)n; k++) {
for (int i = (int)0; i < (int)n; i++) printf("%d ", sz(k, i));
printf("\n");
}
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, x;
cin >> s >> x;
long long t = s - x, k, bc = 0, l = x;
if (s < x) {
cout << 0 << endl;
return 0;
}
if (t % 2 == 1) {
cout << 0 << endl;
return 0;
}
t = t / 2;
k = x & t;
if (k != 0) {
cout << 0 << endl;
return 0;
}
while (x != 0) {
if (x % 2 == 1) bc++;
x /= 2;
}
t = 1;
while (bc != 0) {
t *= 2;
bc--;
}
if (s == l)
cout << t - 2 << endl;
else
cout << t << endl;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333)
if (c >= '0' && c <= '9') break;
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return n;
}
}
long long dp[6][1000010], val[6];
void ywymain() {
int k = get(), f0 = get(), f1 = get(), f2 = get(), f3 = get(), f4 = get(),
f5 = get();
val[0] = f0;
val[1] = f1;
val[2] = f2;
val[3] = f3;
val[4] = f4;
val[5] = f5;
int q = get();
while (q) {
q--;
int n = get(), dk = 100000;
memset(dp, 128, sizeof(dp));
for (int i = 0; i <= 9 * k && i <= n / 100000; i++) {
int bits = i / 9, rem = i % 9;
if (k - bits <= 1)
dp[5][i] = bits * (long long)f5 * 3ll + (rem == 3) * f5 +
(rem == 6) * 2ll * f5;
else
dp[5][i] =
bits * (long long)f5 * 3ll + f5 * (long long)min(k - bits, rem / 3);
}
for (int i = 4; i >= 2; i--) {
for (int a = 0; a <= 9 * k && a <= n / (dk / 10); a++) {
int bits = a / 9, rem = a % 9;
long long ans;
if (k - bits <= 1)
ans = bits * (long long)val[i] * 3ll + (rem == 3) * val[i] +
(rem == 6) * 2ll * val[i];
else
ans = bits * (long long)val[i] * 3ll +
val[i] * (long long)min(k - bits, rem / 3);
for (int b = 0; b <= n / dk; b++)
if (dp[i + 1][b] >= 0)
dp[i][a + b * 10] = max(dp[i][a + b * 10], dp[i + 1][b] + ans);
}
dk /= 10;
}
long long ans = 0;
for (int x = 0; x <= 99 * k && x <= n; x++) {
if ((n - x) % 100 || dp[2][(n - x) / 100] < 0) continue;
for (int a = 0; a < 9; a++) {
for (int b = 0; b < 9; b++) {
if (a * 10 + b > x || (x - a * 10 - b) % 9) continue;
int rem = x - a * 10 - b;
for (int i = (a != 0); i <= 2 && i <= k; i++) {
for (int j = (b != 0); j <= 2 && j <= k; j++) {
if (90 * (k - i) + 9 * (k - j) < rem) continue;
long long rest = 0;
if (i <= 1)
rest += (a == 6) * 2ll * f1 + (a == 3) * f1;
else
rest += (a / 3ll) * (long long)f1;
if (j <= 1)
rest += (b == 6) * 2ll * f0 + (b == 3) * f0;
else
rest += (b / 3ll) * (long long)f0;
if (f1 >= 10ll * f0) {
int cnt9 = max(rem % 90, rem - 90 * (k - i)) / 9,
cnt90 = min(k - i, rem / 90);
if (cnt9 > k - j) continue;
ans =
max(ans, dp[2][(n - x) / 100] + cnt9 * (long long)f0 * 3ll +
cnt90 * (long long)f1 * 3ll + rest);
} else {
if (k - j < (rem % 90) / 9) continue;
int cnt9 =
(rem % 90) / 9 + ((k - j - (rem % 90) / 9) / 10) * 10;
cnt9 = min(cnt9, rem / 9);
int cnt90 = (rem - 9 * cnt9) / 90;
if (cnt9 > k - j || cnt90 > k - i) continue;
ans =
max(ans, dp[2][(n - x) / 100] + cnt9 * (long long)f0 * 3ll +
cnt90 * (long long)f1 * 3ll + rest);
}
}
}
}
}
}
cout << ans << endl;
}
}
} // namespace ywy
int main() {
ywy::ywymain();
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int MAXN = 4001;
int r, c, n, k, a[MAXN], p[MAXN], L[MAXN], R[MAXN], sA[MAXN], sB[MAXN],
pA[MAXN], pB[MAXN];
std::pair<int, int> z[MAXN];
std::vector<int> d[MAXN];
long long answer;
bool cmp(const std::pair<int, int> &a, const std::pair<int, int> &b) {
return a.second < b.second;
}
void del(int now, long long &answer) {
int tA = 0, tB = 0, zL = now, zR = now;
if (!--a[now]) {
R[L[now]] = R[now];
L[R[now]] = L[now];
}
for (int i = 1; i <= k + 1 && zL != 0; i++, zL = L[zL]) {
sA[++tA] = a[zL];
pA[tA] = zL;
}
for (int i = 1; i <= k + 1 && zR != c + 1; i++, zR = R[zR]) {
sB[++tB] = a[zR];
pB[tB] = zR;
}
for (int i = 1; i <= tA; i++) sA[i] += sA[i - 1];
for (int i = 1; i <= tB; i++) sB[i] += sB[i - 1];
for (int i = tA, j = 1; i >= 1; i--) {
while (j <= tB && sA[i] + sB[j] - a[now] + 1 < k) j++;
if (j <= tB && sA[i] + sB[j] - a[now] + 1 == k) {
int pred = (i == tA) ? 0 : pA[i + 1];
int succ = (j == tB) ? c + 1 : pB[j + 1];
answer += 1ll * (pA[i] - pred) * (succ - pB[j]);
assert(pA[i] >= pred);
}
}
}
int main() {
std::cin >> r >> c >> n >> k;
for (int i = 1; i <= n; i++) {
std::cin >> z[i].first >> z[i].second;
}
std::sort(z + 1, z + n + 1, cmp);
for (int i = 1; i <= n; i++) {
d[z[i].first].push_back(i);
}
long long base = 0;
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++) base += 1ll * i * j;
for (int i = 1; i <= r; i++) {
int tot = 0;
R[0] = c + 1;
L[c + 1] = 0;
static int tmp[MAXN], cnt[MAXN];
std::fill(tmp, tmp + c + 1, 0);
std::fill(a, a + c + 1, 0);
std::fill(cnt, cnt + n + 1, 0);
for (int j = n; j >= 1; j--) {
if (z[j].first < i) continue;
if (a[z[j].second] == 0) {
p[j] = z[j].second;
L[z[j].second] = 0;
R[z[j].second] = R[0];
L[R[0]] = z[j].second;
R[0] = z[j].second;
}
a[z[j].second]++;
tmp[z[j].second]++;
}
long long counter = 0;
for (int j = 1; j <= c; j++) {
tmp[j] += tmp[j - 1];
}
for (int j = 1; j <= c; j++) {
cnt[tmp[j - 1]]++;
for (int h = 0; h < k && h <= tmp[j]; h++) {
counter += cnt[tmp[j] - h];
}
}
for (int j = r; j >= i; j--) {
answer -= counter;
for (auto v : d[j]) {
del(z[v].second, counter);
}
}
}
std::cout << base + answer << std::endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
bool ckmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
const int N = 200005;
int n;
struct node {
int a, b;
} a[N];
inline bool cmp(const node &a, const node &b) {
return a.a != b.a ? a.a > b.a : a.b > b.b;
}
void Main() {
priority_queue<int, vector<int>, greater<int> > pq;
long long ans = 0, now = 0, mxv = 0;
n = read();
for (int i = 1, iend = n; i <= iend; ++i)
a[i].a = read(), a[i].b = read(), ans += a[i].b;
sort(a + 1, a + n + 1, cmp);
for (int i = 1, iend = n; i <= iend; ++i) {
now += a[i].b, pq.push(a[i].b);
if ((int)(pq).size() > n - a[i].a) now -= pq.top(), pq.pop();
ckmax(mxv, now);
}
printf("%lld\n", ans -= mxv);
}
signed main() {
for (int T = read(); T; --T) Main();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q, ma[104], usin[104], x;
int main() {
cin >> n >> q;
for (int i = 0; i < q; i++) {
int t, k, d;
cin >> t >> k >> d;
x = 0;
for (int i = 0; i < n; i++)
if (ma[i] <= t) usin[x++] = i;
if (x < k)
cout << -1 << endl;
else {
int sum = 0;
for (int i = 0; i < k; i++) ma[usin[i]] = t + d, sum += usin[i] + 1;
cout << sum << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, m;
int main() {
std ::ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (; t--;) {
cin >> n;
string src, trg;
cin >> src >> trg;
vector<int> st, en;
for (int i = 0; i < n; ++i) {
if (src[i] != trg[i]) {
st.emplace_back(src[i]);
en.emplace_back(trg[i]);
}
}
if (st.size() == 2 and st[0] == st[1] and en[0] == en[1]) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, cnt1 = 0;
cin >> n1;
int a[n1], i, j;
for (i = 0; i < n1; ++i) cin >> a[i];
if (n1 == 1) {
cout << "1";
} else {
for (i = 0; i < n1; ++i) {
if (a[i] == i + 1) {
for (j = i - 1; j >= 0; --j) {
if (a[j] > a[i]) break;
}
if (j < 0) cnt1++;
}
}
cout << cnt1;
}
return 0;
}
| 1 |
#include<iostream>
#include<unordered_set>
#include<set>
#include<list>
#include<map>
#include<stack>
#include<string>
#include<iterator>
#include<math.h>
#include<limits.h>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
#define ll long long
#define ull unsigned long long
#define pb push_back
#define MOD 1000000007
#define MAX 1000001
int main(){
fast;
ll t, n, ai;
cin>>t;
while(t--){
cin>>n;
vector< pair<int, int> > nums;
for(int i = 0;i<n;i++){
cin>>ai;
nums.pb(make_pair(ai,i));
}
sort(nums.begin(), nums.end());
// for(ll i = 0;i<n;i++){
// cout<<nums[i].first<<' '<<nums[i].second<<'\n';
// }
ll count = 0;
for(int i = 0;i<n;i++){
for(int j=i+1;j<n;j++){
ll v = (ll)nums[i].first*(ll)nums[j].first;
ll ind = nums[i].second + nums[j].second;
if(v==(ind+2))
count++;
if(v > 2*n)
break;
}
}
cout<<count<<'\n';
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 100007;
struct wT {
bool operator<(const wT &a) const {
return ((age ^ a.age) ? (age < a.age) : (id > a.id));
}
int id, age;
} wal[MAXN];
class sbtT {
public:
sbtT() : kc(0), rt(0) {
memset(val, 0, sizeof(val));
memset(size, 0, sizeof(size));
memset(lc, 0, sizeof(lc));
memset(rc, 0, sizeof(rc));
}
void insert(int nv) { insert(nv, rt); }
void del(int nv) { del(nv, rt, false); }
int minval() { return getmin(rt); }
void print() { print(rt); }
private:
void leftrot(int &now) {
int nl = lc[now];
lc[now] = rc[nl];
rc[nl] = now;
size[now] = size[lc[now]] + size[rc[now]] + 1;
size[nl] = size[lc[nl]] + size[rc[nl]] + 1;
now = nl;
}
void rightrot(int &now) {
int nl = rc[now];
rc[now] = lc[nl];
lc[nl] = now;
size[now] = size[lc[now]] + size[rc[now]] + 1;
size[nl] = size[lc[nl]] + size[rc[nl]] + 1;
now = nl;
}
void insert(int nv, int &now) {
if (!now) {
now = ++kc;
val[now] = nv;
size[now] = 1;
} else {
if (nv < val[now])
insert(nv, lc[now]), maintain(now, true);
else if (nv > val[now])
insert(nv, rc[now]), maintain(now, false);
}
}
int del(int nv, int &now, bool flag) {
if (!now) return -1;
if (flag ? (val[now] == nv || (!lc[now] && nv < val[now]) ||
(!rc[now] && nv > val[now]))
: (val[now] == nv)) {
int ret = val[now];
if (!lc[now] || !rc[now])
now = lc[now] ^ rc[now];
else
val[now] = del(nv, lc[now], true);
return ret;
} else {
if (nv < val[now])
return del(nv, lc[now], flag);
else
return del(nv, rc[now], flag);
}
}
void maintain(int &now, bool flag) {
if (flag) {
if (size[lc[lc[now]]] > size[rc[now]])
leftrot(now);
else if (size[rc[lc[now]]] > size[rc[now]])
rightrot(lc[now]), leftrot(now);
else
return;
} else {
if (size[rc[rc[now]]] > size[lc[now]])
rightrot(now);
else if (size[lc[rc[now]]] > size[lc[now]])
leftrot(rc[now]), rightrot(now);
return;
}
maintain(lc[now], true);
maintain(rc[now], false);
maintain(now, true);
maintain(now, false);
}
void print(int now) {
if (!now) return;
print(lc[now]);
printf("%d ", val[now]);
print(rc[now]);
}
int getmin(int now) {
if (!lc[now])
return val[now];
else
return getmin(lc[now]);
}
static const int SBTMAXN = 100007;
int kc, rt;
int val[SBTMAXN], size[SBTMAXN], lc[SBTMAXN], rc[SBTMAXN];
} s;
int n;
int ans[MAXN];
void init();
void input();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &wal[i].age), wal[i].id = n - i;
}
void work() {
sort(wal, wal + n);
s.insert(INF);
int mini;
for (int i = 0; i < n; ++i) {
mini = s.minval();
if (mini < wal[i].id)
ans[wal[i].id] = wal[i].id - mini - 1;
else
ans[wal[i].id] = -1;
s.insert(wal[i].id);
}
for (int i = n; i > 0; --i) printf("%d ", ans[i]);
putchar('\n');
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int N = 1e5 + 5;
int n, m, a[N], v[N], ve[N];
int res[2][N];
void go(int id) {
memset(ve, INF, sizeof ve);
for (int i = 1; i <= m; i++) {
int j = lower_bound(ve, ve + N, v[i] + 1) - ve;
ve[j] = v[i];
res[id][i] = j;
}
}
int main(void) {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
a[l]++;
a[r + 1]--;
}
int at = 0;
for (int i = 1; i <= m; i++) {
at += a[i];
v[i] = at;
}
go(0);
reverse(v + 1, v + m + 1);
go(1);
reverse(res[1] + 1, res[1] + m + 1);
int ans = 0;
for (int i = 1; i <= m; i++) ans = max(ans, res[0][i] + res[1][i] + 1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2 * 1e5 + 5;
vector<int> adj[N];
bool visited[N];
stack<int> rec;
void dfs(int cur_node) {
visited[cur_node] = true;
for (int i = 0; i < (int)adj[cur_node].size(); ++i) {
int next_node = adj[cur_node][i];
if (!visited[next_node]) dfs(next_node);
}
rec.push(cur_node);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
ll arr[n + 1], b[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
for (int i = 1; i <= n; ++i) {
cin >> b[i];
}
for (int i = 1; i <= n; ++i) {
int u = i;
int v = b[i];
if (v != -1) {
adj[u].push_back(v);
}
}
memset(visited, false, sizeof(visited));
for (int i = 1; i <= n; ++i) {
if (!visited[i]) dfs(i);
}
ll ans = 0;
stack<int> temp;
vector<int> pos;
while (!rec.empty()) {
int node = rec.top();
rec.pop();
if (arr[node] < 0) {
temp.push(node);
continue;
}
ans += arr[node];
pos.push_back(node);
if (b[node] != -1) {
arr[b[node]] += arr[node];
}
}
while (!temp.empty()) {
int node = temp.top();
temp.pop();
pos.push_back(node);
ans += arr[node];
}
cout << ans << "\n";
for (auto x : pos) cout << x << " ";
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100005];
int n, i, ans = -1;
cin >> str;
n = strlen(str);
int m = str[n - 1] - '0';
for (i = 0; i < n; i++) {
if ((str[i] - '0') % 2 == 0) {
if (str[i] - '0' <= m) {
char c = str[i];
str[i] = str[n - 1];
str[n - 1] = c;
break;
} else
ans = i;
}
}
if (i == n) {
if (ans == -1)
cout << ans;
else {
char c = str[ans];
str[ans] = str[n - 1];
str[n - 1] = c;
cout << str;
}
} else
cout << str;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int d, m, y, bd, bm, by, D, M, Y, age, mage;
int mm[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
scanf("%d.%d.%d", &d, &m, &y);
scanf("%d.%d.%d", &bd, &bm, &by);
D = bd;
M = bm;
Y = by;
age = 0;
while (D != d || m != M || y >= Y) {
if (Y % 4 == 0)
mm[2] = 29;
else
mm[2] = 28;
D++;
if (D == mm[M] + 1) D = 1, M++;
if (M == 13) M = 1, Y++;
if ((M == bm && D == bd) ||
(bm == 2 && bd == 29 && Y % 4 && D == 1 && M == 3))
age++;
if (d == D && M == m && y == Y) break;
}
mage = age;
age = 0;
swap(bm, by);
D = bd;
M = bm;
Y = by;
while (D != d || m != M || y >= Y) {
if (D > 31 || M > 12) break;
if (Y % 4 == 0)
mm[2] = 29;
else
mm[2] = 28;
D++;
if (D == mm[M] + 1) D = 1, M++;
if (M == 13) M = 1, Y++;
if ((M == bm && D == bd) ||
(bm == 2 && bd == 29 && Y % 4 && D == 1 && M == 3))
age++;
if (d == D && M == m && y == Y) break;
}
mage = max(mage, age);
age = 0;
swap(bd, bm);
D = bd;
M = bm;
Y = by;
while (D != d || m != M || y >= Y) {
if (D > 31 || M > 12) break;
if (Y % 4 == 0)
mm[2] = 29;
else
mm[2] = 28;
D++;
if (D == mm[M] + 1) D = 1, M++;
if (M == 13) M = 1, Y++;
if ((M == bm && D == bd) ||
(bm == 2 && bd == 29 && Y % 4 && D == 1 && M == 3))
age++;
if (d == D && M == m && y == Y) break;
}
mage = max(mage, age);
age = 0;
swap(by, bm);
D = bd;
M = bm;
Y = by;
while (D != d || m != M || y >= Y) {
if (D > 31 || M > 12) break;
if (Y % 4 == 0)
mm[2] = 29;
else
mm[2] = 28;
D++;
if (D == mm[M] + 1) D = 1, M++;
if (M == 13) M = 1, Y++;
if ((M == bm && D == bd) ||
(bm == 2 && bd == 29 && Y % 4 && D == 1 && M == 3))
age++;
if (d == D && M == m && y == Y) break;
}
mage = max(mage, age);
age = 0;
swap(bd, bm);
D = bd;
M = bm;
Y = by;
while (D != d || m != M || y >= Y) {
if (D > 31 || M > 12) break;
if (Y % 4 == 0)
mm[2] = 29;
else
mm[2] = 28;
D++;
if (D == mm[M] + 1) D = 1, M++;
if (M == 13) M = 1, Y++;
if ((M == bm && D == bd) ||
(bm == 2 && bd == 29 && Y % 4 && D == 1 && M == 3))
age++;
if (d == D && M == m && y == Y) break;
}
mage = max(mage, age);
age = 0;
swap(by, bm);
D = bd;
M = bm;
Y = by;
while (D != d || m != M || y >= Y) {
if (D > 31 || M > 12) break;
if (Y % 4 == 0)
mm[2] = 29;
else
mm[2] = 28;
D++;
if (D == mm[M] + 1) D = 1, M++;
if (M == 13) M = 1, Y++;
if ((M == bm && D == bd) ||
(bm == 2 && bd == 29 && Y % 4 && D == 1 && M == 3))
age++;
if (d == D && M == m && y == Y) break;
}
mage = max(mage, age);
if (mage >= 18)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = int(0); i < int(n); ++i) cin >> a[i];
sort(a.begin(), a.end());
long long ans = 0;
for (int i = int(0); i < int(n - 1); ++i) ans += a[i + 1] - a[i] - 1;
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, z[11], a[200005];
int getp(int idx) {
int val = 0;
for (int i = 0; i < 11; i++) {
int t;
if (idx == z[i]) continue;
printf("? %d %d\n", idx, z[i]);
fflush(stdout);
scanf("%d", &t);
if (t & (1 << i)) val += 1 << i;
}
return val;
}
void solve() {
srand(time(0));
scanf("%d", &n);
int cnt = 0;
memset(z, 0, sizeof(z));
while (cnt < 11) {
int x = rand() % (n - 1) + 2;
int y = rand() % (x - 1) + 1;
int t;
printf("? %d %d\n", x, y);
fflush(stdout);
scanf("%d", &t);
for (int i = 0; i < 11; i++) {
if (!z[i] && !(t & (1 << i))) {
z[i] = x;
cnt++;
}
}
}
int idx = 1, val = getp(idx);
for (int i = 2; i <= n && val; i++) {
int t;
printf("? %d %d\n", idx, i);
fflush(stdout);
scanf("%d", &t);
if (t == val) {
idx = i;
val = getp(idx);
}
}
for (int i = 1; i <= n; i++) {
if (idx == i)
a[i] = val;
else {
int t;
printf("? %d %d\n", idx, i);
fflush(stdout);
scanf("%d", &t);
a[i] = t;
}
}
printf("! ");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
int main() {
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
long long int i, j, n, k, val, tmp, suma, tam;
int main() {
scanf("%I64d %I64d", &n, &k);
tam = n;
for (j = 1, i = 1; j <= tam; j++) {
scanf("%I64d", &val);
tmp = suma - ((i - 1LL) * ((n - i) * val));
if (tmp < k) {
printf("%I64d\n", j);
n--;
} else {
suma += val * (i - 1LL);
i++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % MOD;
while (b > 0) {
if (b & 1) {
res = (res * a) % MOD;
b--;
}
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
long long int fermat_inv(long long int y) { return power(y, MOD - 2); }
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
long long int min(long long int a, long long int b) { return (a > b) ? b : a; }
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
bool prime[1000001];
vector<int> primes;
void SieveOfEratosthenes(int n) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = 0;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p < 1000001; p++)
if (prime[p]) primes.push_back(p);
}
long long int fact[100010];
long long int finv[100010];
void factorial(int n) {
fact[0] = 1;
finv[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i, fact[i] %= MOD, finv[i] = fermat_inv(fact[i]);
}
long long int ncr(long long int n, long long int r) {
if (n < r)
return 0;
else {
long long int x = finv[r] * finv[n - r] % MOD;
return fact[n] * x % MOD;
}
}
void dfs(int a, vector<int> adj[], int vis[], stack<int>& st) {
vis[a] = 1;
for (int i : adj[a]) {
if (vis[i]) continue;
dfs(i, adj, vis, st);
}
st.push(a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int te = 1;
while (te--) {
int n;
cin >> n;
string a[n];
set<int> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (char j : a[i]) s.insert(j - 'a');
}
vector<int> adj[26];
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].size() - 1; j++)
adj[a[i][j] - 'a'].push_back(a[i][j + 1] - 'a');
}
stack<int> st;
int vis[26] = {0};
for (int i : s) {
if (vis[i]) continue;
dfs(i, adj, vis, st);
}
memset(vis, 0, sizeof(vis));
while (!st.empty()) {
if (!vis[st.top()]) {
int x = st.top();
vis[x] = 1;
while (!adj[x].empty()) {
cout << (char)(x + 'a');
x = adj[x][0];
vis[x] = 1;
}
cout << (char)(x + 'a');
}
st.pop();
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
int n, m, k;
int ans[1000001];
int main() {
cin >> n >> m >> k;
int f = 1 + n + m;
int im = 0;
for (int i = 0; i < k; i++) {
ans[im++] = 1;
}
bool ff = false;
if (k == 1) {
int l = 1000000;
for (int i = 1; i < l; i++) {
ans[im++] = i * n - (i - 1);
if (ans[im - 1] + n > f) break;
}
} else {
int l = 1000000;
for (int i = 1; i < l; i++) {
int last = im;
ans[im] = ans[im - 1] + n - 1;
im++;
if (ans[im - 2] + n >= f) break;
for (int j = 1; j < k; j++) ans[im++] = ans[last] + 1;
if (ans[im - 1] + n > f) break;
}
}
cout << im << "\n";
for (int i = 0; i < im; i++) cout << ans[i] << " ";
in.close();
out.close();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const double EPS = 0.000000001;
const double INFD32 = 1000000000;
const long long INF64 = 1000000000000000000;
const long long INF32 = 1000000000;
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
char ch;
cin >> ch;
long long x = (ch - '0');
if (x % 2 == 0) ans += i;
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d", &a);
for (b = 0; b < a; b++) {
int c, d, e = 0, f, g, h;
char s1[200], s2[200], s3[200];
scanf("%s%s%s", &s1, &s2, &s3);
c = strlen(s1);
for (d = 0; d < c; d++) {
e = 0;
if (s1[d] == s3[d] || s2[d] == s3[d]) {
e = 1;
}
if (e == 0) {
break;
}
}
if (e == 0) {
printf("NO\n");
} else {
printf("YES\n");
}
}
}
| 0 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
char s[1000010], l[1000010], r[1000010];
long long f[1000010], sum[1000010];
int n, sl, sr, pl[1000010], pr[1000010], hshs[1000010], hshl[1000010],
hshr[1000010], fpow[1000010];
bool ok1(int x) {
if (x + sl - 1 > n) return false;
if (sl == pl[x]) return true;
return l[pl[x] + 1] < s[x + pl[x]];
}
bool ok2(int x) {
if (x + sr - 1 > n) return false;
if (pr[x] == sr) return true;
return r[pr[x] + 1] > s[x + pr[x]];
}
int get_hsh(int *hsh, int l, int r) {
return (hsh[r] -
((long long)(hsh[l - 1]) * (long long)(fpow[r - l + 1]) % 998244353) +
998244353) %
998244353;
}
void solve(int *s, int *hsh, int len) {
for (int i = 1; i <= n - len + 1; i++) {
int l = 0;
int r = len;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (get_hsh(hshs, i, i + mid - 1) == get_hsh(hsh, 1, mid))
l = mid;
else
r = mid - 1;
}
s[i] = l;
}
}
void gethash(char *str, int *hsh, int len) {
for (int i = 1; i <= len; i++)
hsh[i] = ((long long)(hsh[i - 1]) * (long long)(11) + str[i] - '0' + 1) %
998244353;
}
int main() {
fpow[0] = 1;
for (int i = 1; i <= 1000000; i++)
fpow[i] = ((long long)(fpow[i - 1]) * (long long)(11) % 998244353);
scanf("%s", s + 1);
scanf("%s", l + 1);
scanf("%s", r + 1);
n = strlen(s + 1);
sl = strlen(l + 1);
sr = strlen(r + 1);
gethash(l, hshl, sl);
gethash(r, hshr, sr);
gethash(s, hshs, n);
f[0] = 1;
solve(pl, hshl, sl);
solve(pr, hshr, sr);
for (int i = 0; i <= n; i++) {
if (i) {
sum[i] += sum[i - 1];
f[i] += sum[i];
f[i] %= 998244353;
}
if (s[i + 1] == '0') {
if (sl == 1 && l[1] == '0') {
f[i + 1] += f[i];
f[i + 1] %= 998244353;
}
continue;
}
if (sl < sr) {
sum[sl + i + 1] += f[i];
sum[sl + i + 1] %= 998244353;
sum[sr + i] += 998244353 - f[i];
sum[sr + i] %= 998244353;
}
if (sl == sr) {
if (ok1(i + 1) && ok2(i + 1)) {
f[i + sl] += f[i];
f[i + sl] %= 998244353;
}
} else {
if (ok1(i + 1)) {
f[i + sl] += f[i];
f[i + sl] %= 998244353;
}
if (ok2(i + 1)) {
f[i + sr] += f[i];
f[i + sr] %= 998244353;
}
}
}
std::cout << f[n] << std::endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? -x : x;
}
const int N = 1e6 + 10;
int n, a[N], ans[N];
char s[N], t[N];
char re(char c) {
if (c == 'L') return 'R';
return 'L';
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
scanf("%s", s + 1);
sort(a + 1, a + n + 1);
int l = 1, r = n;
for (int i = n; i > 1; i--) {
if (s[i - 1] == s[i]) {
t[i] = ((r - l + 1) & 1) ? s[i] : re(s[i]);
ans[i] = a[l++];
} else {
ans[i] = a[r--];
t[i] = s[i];
}
}
ans[1] = a[l];
t[1] = s[1];
for (int i = 1; i <= n; i++) printf("%d %c\n", ans[i], t[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int n;
std::cin >> n;
bool check = true;
bool check2 = true;
int tp = INT_MAX;
for (int i = 0, a, b; i < n; ++i) {
std::cin >> a >> b;
if (a != b) check = false;
if (a > tp) check2 = false;
tp = a;
}
if (!check)
std::cout << "rated";
else if (!check2)
std::cout << "unrated";
else
std::cout << "maybe";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[100005];
long long b[100005];
long long f[100005];
vector<long long> tam[100005];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> f[i];
tam[f[i]].push_back(i);
}
for (long long i = 1; i <= m; i++) {
cin >> b[i];
}
for (long long i = 1; i <= m; i++) {
if (tam[b[i]].size() == 0) {
cout << "Impossible";
return 0;
}
}
for (long long i = 1; i <= m; i++) {
if (tam[b[i]].size() > 1) {
cout << "Ambiguity";
return 0;
}
}
cout << "Possible" << endl;
for (long long i = 1; i <= m; i++) {
cout << tam[b[i]][0] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
string s, ans;
bool is_valid(int i, string &s, int c) {
return (i - 2 < 0 || s[i - 2] - 'a' != c) &&
(i - 1 < 0 || s[i - 1] - 'a' != c);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> p >> s;
for (int i = n - 1; i >= 0; --i) {
for (int c1 = 0; c1 < p; ++c1) {
if (s[i] - 'a' < c1 && is_valid(i, s, c1)) {
ans = s.substr(0, i) + string(1, c1 + 'a');
for (int j = i + 1; j < n; ++j) {
for (int c2 = 0; c2 < p; ++c2) {
if (is_valid(j, ans, c2)) {
ans.push_back(c2 + 'a');
break;
}
}
}
cout << ans << "\n";
return 0;
}
}
}
cout << "NO\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = (int)1e9 + 7;
const int N = (int)1e6 + 7;
int n, k, s, t;
int c[N], v[N], g[N];
bool check(int M) {
int tim = 0;
for (int i = (1); i < (k + 2); ++i) {
int d = g[i] - g[i - 1];
if (M < d)
return false;
else if (2 * d < M)
tim += d;
else
tim += 3 * d - M;
}
return tim <= t;
}
void Init() {
g[0] = 0;
g[k + 1] = s;
for (int i = (1); i < (n + 1); ++i) scanf("%d%d", c + i, v + i);
for (int i = (1); i < (k + 1); ++i) scanf("%d", g + i);
sort(g + 1, g + k + 1);
}
int Solve() {
int L = 2, R = 2e9;
while (L < R) {
int M = L + ((R - L) >> 1);
if (check(M))
R = M;
else
L = M + 1;
}
if (!check(L)) return puts("-1");
int ans = INF;
for (int i = (1); i < (n + 1); ++i)
if (v[i] >= L) ans = min(ans, c[i]);
return printf("%d\n", ans == INF ? -1 : ans);
}
int main() {
while (~scanf("%d%d%d%d", &n, &k, &s, &t)) {
Init();
Solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long pa(long long a1, long long r, long long n) {
long long an = a1 + (n - 1) * r;
return ((a1 + an) * n) / 2;
}
int main() {
long long m, b, x, y, horizontal, vertical, ans;
scanf("%lld%lld", &m, &b);
ans = 0;
for (x = 0; x <= m * b; x++) {
if (x % m) {
y = max(0ll, (-x / m) + b - 1);
} else {
y = (-x / m) + b;
}
horizontal = pa(0, 1, x + 1);
vertical = pa(horizontal, x + 1, y + 1);
ans = max(ans, vertical);
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long tpp = 9e18;
int tp = 1e9;
long long n, a;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
;
if (n == 1) {
cout << 1 << endl;
;
return 0;
;
}
if (n == 2) {
cout << 2 << endl;
;
return 0;
;
}
if (n == 3) {
cout << 6 << endl;
;
return 0;
;
}
if (n & 1) {
cout << n * (n - 1) * (n - 2) << endl;
;
return 0;
;
} else {
if (n % 3 == 0) {
cout << (n - 1) * (n - 2) * (n - 3) << endl;
;
return 0;
;
} else {
cout << n * (n - 1) * (n - 3) << endl;
;
return 0;
;
}
}
return 0;
;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int main() {
int n, k;
cin >> n >> k;
vector<int> v;
int j = n;
while (k--) {
v.push_back(j--);
}
if (v.size() != n)
for (int i = 1; i <= j; i++) {
v.push_back(i);
}
for (int i = 0; i < n; i++) cout << v[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int pre[400005], to[400005], las[400005], inc;
int fa[400005][21], jmp[400005][21], dep[400005], dfn[400005], out[400005], dft;
int n, m, q, ans[400005];
void ins(int a, int b) {
pre[++inc] = las[a];
las[a] = inc, to[inc] = b;
}
void dfs(int x, int par) {
fa[x][0] = par, dfn[x] = ++dft, dep[x] = dep[par] + 1;
for (int i = 1; i <= 20; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = las[x]; i; i = pre[i])
if (to[i] != par) dfs(to[i], x);
out[x] = dft;
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20, delta = dep[x] - dep[y]; i >= 0; i--)
if (delta >> i & 1) x = fa[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
void GetJmp1(int x) {
for (int i = las[x]; i; i = pre[i]) {
int y = to[i];
GetJmp1(y);
if (!jmp[x][0] || (dep[jmp[x][0]] > dep[jmp[y][0]] && jmp[y][0]))
jmp[x][0] = jmp[y][0];
}
}
void GetJmp2(int x) {
for (int i = 1; i <= 20; i++) jmp[x][i] = jmp[jmp[x][i - 1]][i - 1];
for (int i = las[x]; i; i = pre[i]) GetJmp2(to[i]);
}
int C[400005];
void Add(int x, int v) {
for (int i = x; i < 400005; i += (i & -i)) C[i] += v;
}
int Query(int x) {
int ret = 0;
for (int i = x; i; i ^= (i & -i)) ret += C[i];
return ret;
}
struct node {
int x, l, r, ty, id;
} op[400005 * 4];
int tot, sm[400005 * 4];
int cmp(node a, node b) { return a.x == b.x ? a.ty < b.ty : a.x < b.x; }
int main() {
scanf("%d", &n);
for (int i = 2, x; i <= n; i++) scanf("%d", &x), ins(x, i);
dfs(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y, anc;
scanf("%d%d", &x, &y), anc = LCA(x, y);
if (!jmp[x][0] || dep[jmp[x][0]] > dep[anc]) jmp[x][0] = anc;
if (!jmp[y][0] || dep[jmp[y][0]] > dep[anc]) jmp[y][0] = anc;
op[++tot] = (node){dfn[x], dfn[y], 0, 0, 0};
op[++tot] = (node){dfn[y], dfn[x], 0, 0, 0};
}
GetJmp1(1), GetJmp2(1);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int x, y, anc;
scanf("%d%d", &x, &y), anc = LCA(x, y);
if (anc == x || anc == y) {
int p = (anc == x ? y : x);
for (int j = 20; j >= 0; j--)
if (jmp[p][j] && dep[jmp[p][j]] > dep[anc])
p = jmp[p][j], ans[i] += (1 << j);
if (!jmp[p][0] || dep[jmp[p][0]] > dep[anc]) ans[i] = -1;
} else {
for (int j = 20; j >= 0; j--)
if (jmp[x][j] && dep[jmp[x][j]] > dep[anc])
x = jmp[x][j], ans[i] += (1 << j);
for (int j = 20; j >= 0; j--)
if (jmp[y][j] && dep[jmp[y][j]] > dep[anc])
y = jmp[y][j], ans[i] += (1 << j);
ans[i]++;
if (!jmp[x][0] || !jmp[y][0] || dep[jmp[x][0]] > dep[anc] ||
dep[jmp[y][0]] > dep[anc])
ans[i] = -1;
op[++tot] = (node){dfn[x], dfn[y], out[y], -1, i},
op[++tot] = (node){out[x], dfn[y], out[y], 1, i};
}
}
sort(op + 1, op + tot + 1, cmp);
for (int i = 1; i <= tot; i++) {
if (op[i].ty == -1) sm[op[i].id] = Query(op[i].r) - Query(op[i].l - 1);
if (op[i].ty == 0) Add(op[i].l, 1);
if (op[i].ty == 1)
sm[op[i].id] = Query(op[i].r) - Query(op[i].l - 1) - sm[op[i].id];
}
for (int i = 1; i <= q; i++) {
if (ans[i] == -1)
printf("-1\n");
else
printf("%d\n", ans[i] - (sm[i] > 0) + 1);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int pow_mod(long long int a, long long int b) {
long long int res = 1;
while (b != 0) {
if (b & 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
long long int inv_mod(long long int x) { return pow_mod(x, 1000000007 - 2); }
const long long int N = (long long int)3e5;
long long int inv[N];
long long int fac[N];
void init() {
fac[0] = 1;
for (long long int i = 1; i < N; i++) fac[i] = (i * fac[i - 1]) % 1000000007;
for (long long int i = 0; i < N; i++) inv[i] = inv_mod(fac[i]);
}
long long int ncr(long long int n, long long int r) {
if (n < r) return 0;
if (n == r || r == 0) return 1LL;
long long int x = fac[n];
long long int y = inv[n - r];
long long int z = inv[r];
return ((x * y) % 1000000007 * z) % 1000000007;
}
bool test_cases = 0;
void solve() {
long long int n;
cin >> n;
long long int b[n];
long long int c[n];
for (long long int i = 0; i < n - 1; i++) {
cin >> b[i];
}
for (long long int i = 0; i < n - 1; i++) cin >> c[i];
for (long long int i = 0; i < n - 1; i++) {
if (b[i] > c[i]) {
cout << "-1\n";
return;
}
}
long long int a[n];
map<long long int, long long int> mp;
vector<long long int> v;
for (long long int i = 0; i < n - 1; i++) {
mp[b[i]]++;
mp[c[i]]++;
}
for (auto each : mp) v.push_back(each.first);
mp.clear();
for (long long int i = 0; i < v.size(); i++) {
mp[v[i]] = i + 1;
}
long long int sz = (long long int)v.size();
multiset<long long int> adj[sz + 3];
map<pair<long long int, long long int>, long long int> edge;
for (long long int i = 0; i < n - 1; i++) {
long long int x = b[i];
long long int y = c[i];
x = mp[x];
y = mp[y];
adj[x].insert(y);
adj[y].insert(x);
edge[{x, y}]++;
edge[{y, x}]++;
}
bool mark[sz + 3];
memset(mark, false, sizeof(mark));
function<void(long long int, long long int)> dfs = [&](long long int s,
long long int p) {
mark[s] = true;
for (auto each : adj[s])
if (!mark[each]) dfs(each, s);
};
dfs(1, -1);
bool flag = true;
for (long long int i = 1; i <= sz; i++) {
if (!mark[i]) {
flag = false;
break;
}
}
long long int cnt = 0;
for (long long int i = 1; i <= sz; i++) {
if (adj[i].size() % 2) ++cnt;
}
if (cnt > 2) {
flag = false;
}
long long int start = 1;
for (long long int i = 1; i <= sz; i++) {
if (adj[i].size() % 2) start = i;
}
if (!flag) {
cout << "-1\n";
return;
}
vector<long long int> ans;
function<void(long long int, long long int)> dfss = [&](long long int s,
long long int p) {
long long int edge_cnt = 0;
while (!adj[s].empty()) {
long long int fst = *adj[s].begin();
adj[s].erase(adj[s].find(fst));
adj[fst].erase(adj[fst].find(s));
dfss(fst, s);
}
ans.push_back(s);
};
dfss(start, -1);
for (auto each : ans) cout << v[each - 1] << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
if (test_cases) cin >> t;
while (t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 7;
int n, dp[N][N];
int main(void) {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 1, x; i <= n; ++i) {
cin >> x;
dp[i][i] = x;
}
for (int k = 2; k <= n; ++k) {
for (int i = 1, j; (j = i + k - 1) <= n; ++i) {
dp[i][j] = dp[i][j - 1] ^ dp[i + 1][j];
}
}
for (int k = 2; k <= n; ++k) {
for (int i = 1, j; (j = i + k - 1) <= n; ++i) {
dp[i][j] = max(dp[i][j], max(dp[i][j - 1], dp[i + 1][j]));
}
}
int m;
cin >> m;
for (int i = 1; i <= m; ++i) {
int l, r;
cin >> l >> r;
cout << dp[l][r] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
set<char> s;
int main() {
int n;
cin >> n;
string ss;
ss = ss + "0";
string str;
cin >> str;
ss = ss + str;
int len = ss.size();
for (int i = 1; i < len; i++) {
if (ss[i] < 'a') q.push(i);
}
q.push(len);
int maxx = 0;
int st = 0;
while (!q.empty()) {
s.clear();
int sum = 0;
int en = q.front();
q.pop();
for (int i = st + 1; i < en; i++) {
if (s.find(ss[i]) == s.end()) {
sum++;
s.insert(ss[i]);
}
}
st = en;
maxx = max(maxx, sum);
}
printf("%d", maxx);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<int> se;
int a[100009];
int main() {
int n, s = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
se.insert(a[i]);
}
for (int i = 1; i <= n; ++i) {
int s = a[i], t = 0;
for (int j = i + 1; j <= n; ++j) {
s |= a[j];
t |= a[j];
se.insert(s);
if (s == t) {
break;
}
}
}
printf("%d\n", se.size());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 4301000;
pair<int, int> a[mn], b[mn], c[mn];
vector<pair<int, int> > ans;
int n, m, i, j, k, l2, l1;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
pair<int, int> res;
res.first = a.first + b.first, res.second = a.second + b.second;
return res;
}
int main() {
scanf("%d%d", &n, &m);
if (n <= m) {
puts("-1");
return 0;
}
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + 1 + n);
l2 = 0;
for (k = 0; k <= m; ++k) {
l1 = l2;
for (i = 1; i <= n; ++i) {
j = n - i + 1 - k;
if (j >= 1) b[++l2] = a[i] + a[j];
if (!k) continue;
j = n - i + 1 + k;
if (j <= n) b[++l2] = a[i] + a[j];
}
sort(b + 1 + l1, b + 1 + l2);
merge(b + 1, b + 1 + l1, b + 1 + l1, b + 1 + l2, c + 1);
l1 = l2;
memcpy(b + 1, c + 1, l1 * sizeof(pair<int, int>));
for (i = 1; i <= l2; i = j) {
for (j = i; b[i] == b[j] && j <= l2; ++j)
;
if (j - i >= n - k) ans.push_back(b[i]);
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); ++i)
printf("%.2lf %.2lf\n", (double)ans[i].first * 0.5,
(double)ans[i].second * 0.5);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int calc(int n, int X, int x) {
if (!n) return X == 1 && !x ? 0 : 1000111222;
if (x == 1) return X == n ? max(0, n - 2) : 1000111222;
if (!x) return 1000111222;
return calc(n - X / x, x, X % x) + X / x - 1;
}
void trace(int n, int X, int x, int &z) {
if (!n) return;
if (x == 1) {
z = 0;
printf("T");
if (n > 1) {
z = 1;
for (int i = 0; i < n - 1; i++) printf("B");
}
} else {
int zz;
trace(n - X / x, x, X % x, zz);
z = 1 - zz;
for (int i = 0; i < X / x; i++) printf((z ? "B" : "T"));
}
}
int main() {
int n, r, ans = 1000111222, y;
cin >> n >> r;
if (n == 1 && r == 1) {
cout << 0 << endl << "T" << endl;
return 0;
}
for (int i = 1; i <= r - 1; i++) {
int x = calc(n, r, i);
if (x < ans) ans = x, y = i;
}
if (ans == 1000111222)
puts("IMPOSSIBLE");
else {
cout << ans << endl;
int z;
trace(n, r, y, z);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1 << 11];
int main() {
int i, n, l;
scanf("%d", &n);
l = (1 << (n + 1)) - 1;
for (i = 2; i <= l; ++i) scanf("%d", &a[i]);
int ans = 0;
for (i = (l >> 1); i >= 1; --i) {
a[i] += max(a[i << 1], a[i << 1 | 1]);
ans += abs(a[i << 1] - a[i << 1 | 1]);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926536;
template <typename T>
void print(T t) {
for (auto &it : t) cout << it << " ";
cout << endl;
}
double find_sqr(double x) { return x * x; }
void solve() {
long long n, h;
cin >> n >> h;
for (long long i = 1; i < n; i++) {
cout << fixed << setprecision(12)
<< (long double)h * sqrt((long double)i / (long double)n);
cout << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
;
solve();
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 1000010;
using namespace std;
vector<int> s[MAXN];
int L(int x, int p) {
int ans = 0;
for (int i = 0; i < s[p].size(); i++) {
ans += x / s[p][i];
}
return x - ans;
}
int main() {
for (int p = 2; p < MAXN; ++p) {
if (s[p].size() == 0) {
for (int n = p; n < MAXN; n += p) {
int l = s[n].size();
for (int i = 0; i < l; ++i) s[n].push_back(-s[n][i] * p);
s[n].push_back(p);
}
}
}
int t, x, p, k;
cin >> t;
while (t > 0) {
t--;
cin >> x >> p >> k;
int b = L(x, p);
int l = x, r = 1e9, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (L(mid, p) - b >= k)
r = mid;
else
l = mid;
}
cout << r << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int H, W;
string A[2020];
int SV[2020][2020];
int SH[2020][2020];
signed long long ret;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> H >> W;
for (y = 0; y < H; y++) cin >> A[y];
A[0][0] = A[H - 1][W - 1] = A[H - 1][0] = A[0][W - 1] = '#';
for (y = 0; y < H; y++)
for (x = 0; x < W; x++) {
SV[y + 1][x + 1] = SV[y][x + 1] + (A[y][x] == '#');
SH[y + 1][x + 1] = SH[y + 1][x] + (A[y][x] == '#');
}
for (y = 1; y < H - 1; y++)
if (SH[y + 1][W] - SH[y + 1][0] == 0) ret++;
for (x = 1; x < W - 1; x++)
if (SV[H][x + 1] - SV[0][x + 1] == 0) ret++;
for (y = 1; y < H - 1; y++)
for (x = 1; x < W - 1; x++) {
if (SH[y + 1][x + 1] - SH[y + 1][0] == 0 &&
SV[y + 1][x + 1] - SV[0][x + 1] == 0)
ret++;
if (SH[y + 1][x + 1] - SH[y + 1][0] == 0 &&
SV[H][x + 1] - SV[y][x + 1] == 0)
ret++;
if (SH[y + 1][W] - SH[y + 1][x] == 0 &&
SV[y + 1][x + 1] - SV[0][x + 1] == 0)
ret++;
if (SH[y + 1][W] - SH[y + 1][x] == 0 && SV[H][x + 1] - SV[y][x + 1] == 0)
ret++;
}
for (y = 1; y < H - 1; y++) {
int s[2][2020] = {};
int su[2][2020] = {};
for (x = 1; x < W - 1; x++) {
if (SV[y + 1][x + 1] - SV[0][x + 1] == 0) s[0][x] = 1;
if (SV[H][x + 1] - SV[y][x + 1] == 0) s[1][x] = 1;
if (A[y][x] == '.') {
if (A[y][x - 1] == '.') {
if (s[0][x]) ret += su[1][x - 1];
if (s[0][x] && x >= 2) ret += su[0][x - 2];
if (s[1][x]) ret += su[0][x - 1];
if (s[1][x] && x >= 2) ret += su[1][x - 2];
}
su[0][x] = su[0][x - 1] + s[0][x];
su[1][x] = su[1][x - 1] + s[1][x];
}
}
}
for (x = 1; x < W - 1; x++) {
int s[2][2020] = {};
int su[2][2020] = {};
for (y = 1; y < H - 1; y++) {
if (SH[y + 1][x + 1] - SH[y + 1][0] == 0) s[0][y] = 1;
if (SH[y + 1][W] - SH[y + 1][x] == 0) s[1][y] = 1;
if (A[y][x] == '.') {
if (A[y - 1][x] == '.') {
if (s[0][y]) ret += su[1][y - 1];
if (s[0][y] && y >= 2) ret += su[0][y - 2];
if (s[1][y]) ret += su[0][y - 1];
if (s[1][y] && y >= 2) ret += su[1][y - 2];
}
su[0][y] = su[0][y - 1] + s[0][y];
su[1][y] = su[1][y - 1] + s[1][y];
}
}
}
cout << ret << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int hentai[1000005];
int cnt[1000005];
int main() {
int N;
scanf("%d", &N);
int s = 999999999, e = 0;
long long sum = 0;
for (int i = 0; i < N; i++) {
scanf("%d", &hentai[i]);
sum += hentai[i];
cnt[hentai[i]]++;
s = min(s, hentai[i]);
e = max(e, hentai[i]);
}
bool ok = 0, sm = 0;
vector<int> ans;
int av = sum / N;
for (int i = s; i <= e; i++) {
if (cnt[i] == N - 2) ok = 1;
if (cnt[i] == 1 && i != av) ans.push_back(i);
if (cnt[i] == N) sm = 1;
}
if (sm) {
printf("%s", "Exemplary pages.");
return 0;
} else if ((!ok && N > 2) || sum % N != 0 || ans.size() != 2) {
printf("%s", "Unrecoverable configuration.");
return 0;
} else {
vector<int> ind;
for (int i = 0; i < N; i++)
if (ans[0] == hentai[i]) ind.push_back(i);
for (int i = 0; i < N; i++)
if (ans[1] == hentai[i]) ind.push_back(i);
if (ans[0] > ans[1]) {
swap(ans[0], ans[1]);
swap(ind[0], ind[1]);
}
printf("%d ml. from cup #%d to cup #%d.", ans[1] - av, ind[0] + 1,
ind[1] + 1);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1100000];
int perm[1100000], v[1100000];
int prox[1100000];
int n, m;
int diff(int x, int y) {
if (x == -1 || y == -1) return -10 * 1100000;
if (x <= y) return y - x;
return diff(0, y) + diff(x, m - 1) + 1;
}
int diff2(int x, int y) {
if (x <= y) return y - x;
return diff2(0, y) + diff2(x, n - 1) + 1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) prox[i] = i + 1;
prox[n - 1] = 0;
memset(perm, -1, sizeof perm);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
perm[x] = i;
}
for (int i = 0; i < n; i++) v[i] = perm[a[i]];
int ini, fim, andou, ans;
fim = ini = fim = ans = andou = 0;
int vezes = 3 * (max(n, m));
while (vezes--) {
if (v[fim] == -1) {
fim = prox[fim], ini = fim;
andou = 0;
continue;
}
if (andou == 0) {
ans = max(ans, 1);
andou += diff(v[fim], v[prox[fim]]);
fim = prox[fim];
continue;
}
if (andou >= m) {
andou -= diff(v[ini], v[prox[ini]]);
ini = prox[ini];
} else {
ans = max(ans, diff2(ini, fim) + 1);
andou += diff(v[fim], v[prox[fim]]);
fim = prox[fim];
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rnd(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100;
const int MOD = 998244353;
struct P {
int x, y;
P() {}
P(int x, int y) : x(x), y(y) {}
};
P operator-(const P& a, const P& b) { return P(a.x - b.x, a.y - b.y); }
long long operator^(const P& a, const P& b) {
return (long long)a.x * b.y - (long long)a.y * b.x;
}
int side(const P& a, const P& b, const P& c) {
long long res = (b - a) ^ (c - a);
return res < 0 ? -1 : res > 0 ? +1 : 0;
}
bool operator<(const P& a, const P& b) {
bool apos = a.y > 0 || a.y == 0 && a.x > 0,
bpos = b.y > 0 || b.y == 0 && b.x > 0;
if (apos != bpos) return apos;
long long res = a ^ b;
return res > 0;
}
void inc(int& a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
void dec(int& a, int b) {
if ((a -= b) < 0) a += MOD;
}
void incprod(int& a, int b, int c) { a = (a + (long long)b * c) % MOD; }
int n;
P p[MAXN];
vector<int> adj[MAXN];
int par[MAXN];
vector<int> path[MAXN][MAXN];
void dfsinit(int at) {
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
par[to] = at;
dfsinit(to);
}
}
void dfspath(int at, int prv, int root) {
path[root][at] = prv == -1 ? vector<int>() : path[root][prv];
path[root][at].push_back(at);
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == prv) continue;
dfspath(to, at, root);
}
}
int dp[MAXN];
int dpprod[MAXN];
int dpedge[MAXN][MAXN];
bool hasroot[MAXN][MAXN];
void ensuredpedge(int s, int t, int skip) {
if (dpedge[s][t] != -1) return;
const vector<int>& curpath = path[s][t];
for (int i = (0); i < (((int)(curpath).size())); ++i) {
int at = curpath[i];
if (at != s && at != t && side(p[s], p[t], p[at]) <= 0)
return void(dpedge[s][t] = 0);
}
dpedge[s][t] = 1;
for (int i = (0); i < (((int)(curpath).size())); ++i) {
int at = curpath[i];
for (int j = (0); j < (((int)(adj[at]).size())); ++j) {
int to = adj[at][j];
if (to == skip) continue;
if (i - 1 < 0) {
if (side(p[at], p[curpath[i + 1]], p[to]) >= 0) continue;
} else if (i + 1 >= ((int)(curpath).size())) {
if (side(p[curpath[i - 1]], p[at], p[to]) >= 0) continue;
} else {
int prv = curpath[i - 1], nxt = curpath[i + 1];
if (side(p[prv], p[at], p[nxt]) <= 0 &&
(side(p[prv], p[at], p[to]) >= 0 ||
side(p[at], p[nxt], p[to]) >= 0))
continue;
if (side(p[prv], p[at], p[nxt]) >= 0 &&
(side(p[prv], p[at], p[to]) >= 0 &&
side(p[at], p[nxt], p[to]) >= 0))
continue;
}
assert(dp[to] != -1);
dpedge[s][t] = (long long)dpedge[s][t] * dp[to] % MOD;
}
}
}
void dfsnodes(int at, vector<int>& nodes) {
nodes.push_back(at);
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
dfsnodes(to, nodes);
}
}
void dfscalc(int at) {
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
dfscalc(to);
}
dpprod[at] = 1;
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
dpprod[at] = (long long)dpprod[at] * dp[to] % MOD;
}
dp[at] = dpprod[at];
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
int cur = dpprod[to];
for (int j = (0); j < (((int)(adj[at]).size())); ++j)
if (j != i) {
int to2 = adj[at][j];
if (to2 == par[at]) continue;
cur = (long long)cur * dp[to2] % MOD;
}
inc(dp[at], cur);
}
vector<int> nodes;
vector<pair<int, int>> leafedges;
vector<pair<int, int>> hulledges;
dfsnodes(at, nodes);
for (int i = (0); i < (((int)(nodes).size())); ++i) {
int to = nodes[i];
if (to == at) continue;
leafedges.push_back(make_pair(to, par[to]));
if (par[to] == at) leafedges.push_back(make_pair(par[to], to));
}
for (int a = (0); a < (((int)(leafedges).size())); ++a)
for (int b = (0); b < (((int)(leafedges).size())); ++b) {
int aa = leafedges[a].first, bb = leafedges[b].first;
if (side(p[aa], p[bb], p[at]) < 0) continue;
const vector<int>& curpath = path[aa][bb];
if (((int)(curpath).size()) < 3 || curpath[1] != leafedges[a].second ||
curpath[((int)(curpath).size()) - 2] != leafedges[b].second)
continue;
ensuredpedge(aa, bb, par[at]);
if (dpedge[aa][bb] != 0) {
hulledges.push_back(make_pair(a, b));
hasroot[aa][bb] = false;
for (int i = (0); i < (((int)(curpath).size())); ++i)
if (curpath[i] == at) hasroot[aa][bb] = true;
}
}
sort(hulledges.begin(), hulledges.end(),
[&](const pair<int, int>& u, const pair<int, int>& v) {
P udir = p[leafedges[u.second].first] - p[leafedges[u.first].first];
P vdir = p[leafedges[v.second].first] - p[leafedges[v.first].first];
return udir < vdir;
});
for (int i = (0); i < (((int)(leafedges).size())); ++i) {
for (int rep = (0); rep < (2); ++rep) {
vector<int> ways(((int)(leafedges).size()), 0);
inc(ways[i], 1);
for (int j = (0); j < (((int)(hulledges).size())); ++j) {
int a = hulledges[j].first, b = hulledges[j].second;
int aa = leafedges[a].first, bb = leafedges[b].first;
if (rep == 1 && hasroot[aa][bb]) continue;
incprod(ways[b], ways[a], dpedge[aa][bb]);
}
dec(ways[i], 1);
if (rep == 0)
inc(dp[at], ways[i]);
else
dec(dp[at], ways[i]);
}
}
}
int solve() {
for (int i = (0); i < (n); ++i) dp[i] = -1;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) dpedge[i][j] = -1;
par[0] = -1;
dfsinit(0);
for (int i = (0); i < (n); ++i) dfspath(i, -1, i);
dfscalc(0);
return dp[0];
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d%d", &p[i].x, &p[i].y);
for (int i = (0); i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
printf("%d\n", solve());
}
int solvestupid() {
vector<bool> ok(1 << n, false);
for (int mask = (1); mask < (1 << n); ++mask) {
vector<int> cur;
for (int i = (0); i < (n); ++i)
if (mask & (1 << i)) cur.push_back(i);
if (((int)(cur).size()) == 1) {
ok[mask] = true;
continue;
}
sort(cur.begin(), cur.end(), [](const int& a, const int& b) {
if (p[a].x != p[b].x) return p[a].x < p[b].x;
return p[a].y < p[b].y;
});
vector<int> hull;
for (int i = (0); i < (((int)(cur).size())); ++i) {
while (((int)(hull).size()) >= 2 &&
side(p[hull[((int)(hull).size()) - 2]],
p[hull[((int)(hull).size()) - 1]], p[cur[i]]) < 0)
hull.pop_back();
hull.push_back(cur[i]);
}
int fixed = ((int)(hull).size());
for (int i = ((int)(cur).size()) - 2; i >= 0; --i) {
while (((int)(hull).size()) >= fixed + 1 &&
side(p[hull[((int)(hull).size()) - 2]],
p[hull[((int)(hull).size()) - 1]], p[cur[i]]) < 0)
hull.pop_back();
hull.push_back(cur[i]);
}
hull.pop_back();
vector<int> deg(n, 0);
queue<int> q;
q.push(cur[0]);
while (!q.empty()) {
int at = q.front();
q.pop();
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (deg[to] != 0) continue;
if ((mask & (1 << to)) == 0) continue;
++deg[at], ++deg[to], q.push(to);
}
}
vector<bool> onhull(n, false);
for (int i = (0); i < (((int)(hull).size())); ++i) onhull[hull[i]] = true;
bool valid = true;
for (int i = (0); i < (((int)(cur).size())); ++i) {
int at = cur[i];
if (deg[at] == 0) valid = false;
if ((deg[at] == 1) != onhull[at]) valid = false;
}
ok[mask] = valid;
}
vector<int> ways(1 << n, 0);
inc(ways[0], 1);
for (int mask = (1); mask < (1 << n); ++mask) {
int fixed = 0;
while ((mask & (1 << fixed)) == 0) ++fixed;
for (int pmask = 0; pmask < mask;
pmask = (pmask + (1 << n) - 1 - mask + 1) & mask)
if ((pmask & (1 << fixed)) == 0 && ok[mask ^ pmask])
inc(ways[mask], ways[pmask]);
}
return ways[(1 << n) - 1];
}
void stress() {
for (int rep = (0); rep < (100000); ++rep) {
n = rnd() % 15 + 1;
for (int i = (0); i < (n); ++i)
while (true) {
p[i].x = rnd() % 100 + 1, p[i].y = rnd() % 100 + 1;
bool ok = true;
for (int j = (0); j < (i); ++j)
if (p[j].x == p[i].x && p[j].y == p[i].y) ok = false;
for (int j = (0); j < (i); ++j)
for (int k = (j + 1); k < (i); ++k)
if (side(p[j], p[k], p[i]) == 0) ok = false;
if (ok) break;
}
vector<pair<int, int>> e;
vector<int> col(n);
for (int i = (0); i < (n); ++i) col[i] = i;
for (int i = (0); i < (n - 1); ++i)
while (true) {
int a = rnd() % n, b = rnd() % n;
if (col[a] == col[b]) continue;
bool ok = true;
for (int j = (0); j < (((int)(e).size())); ++j) {
P A = p[a], B = p[b], C = p[e[j].first], D = p[e[j].second];
if (side(A, B, C) * side(A, B, D) == -1 &&
side(C, D, A) * side(C, D, B) == -1)
ok = false;
}
if (!ok) continue;
e.push_back(make_pair(a, b));
int ocol = col[b];
for (int j = (0); j < (n); ++j)
if (col[j] == ocol) col[j] = col[a];
break;
}
for (int i = (0); i < (n); ++i) adj[i].clear();
for (int i = (0); i < (((int)(e).size())); ++i) {
int a = e[i].first, b = e[i].second;
adj[a].push_back(b), adj[b].push_back(a);
}
int have = solve();
int want = solvestupid();
if (have == want) {
if ((rep + 1) % 1000 == 0) printf(".");
continue;
}
printf("have=%d want=%d\n", have, want);
printf("%d\n", n);
for (int i = (0); i < (n); ++i) printf("%d %d\n", p[i].x, p[i].y);
for (int i = (0); i < (((int)(e).size())); ++i)
printf("%d %d\n", e[i].first + 1, e[i].second + 1);
break;
}
}
int main() {
run();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
void PA(const T (&a)[N], int n = -1) {
if (!n) n = N;
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << '\n';
}
template <typename T, size_t N, size_t M>
void PA(const T (&a)[N][M], int n, int m) {
for (int i = 0; i < n; i++) PA(a[i], m);
cout << '\n';
}
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
struct cmp {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) const {
if (a.first != b.first)
return a.first > b.first;
else
return a.second < b.second;
}
};
template <typename T>
T power(T x, int y) {
T r = 1;
while (y > 0) {
if (y & 1) r *= x;
x *= x;
y /= 2;
}
return r;
}
void print_no() { cout << "nO" << '\n'; }
void print_yes() { cout << "yEs" << '\n'; }
unordered_map<char, int> mp;
string s;
bool flag;
void solve() {
cin >> s;
for (auto it : s) mp[it]++;
if (mp.size() > 4) return print_no();
if (mp.size() == 4) return print_yes();
if (mp.size() == 3) {
flag = false;
for (auto it : mp) flag |= it.second > 1;
if (flag)
return print_yes();
else
return print_no();
}
if (mp.size() == 2) {
flag = true;
for (auto it : mp) flag &= it.second > 1;
if (flag)
return print_yes();
else
return print_no();
}
return print_no();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
namespace in {
inline int getc() { return getchar(); }
template <typename T>
inline void read(T &t) {
t = 0;
int f = 0;
char ch = getc();
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getc();
}
while (isdigit(ch)) {
t = t * 10 + ch - 48;
ch = getc();
}
if (f) t = -t;
}
template <typename T, typename... Args>
inline void read(T &t, Args &...args) {
read(t);
read(args...);
}
} // namespace in
namespace out {
char buffer[1 << 21];
int p1 = -1;
const int p2 = (1 << 21) - 1;
inline void flush() { fwrite(buffer, 1, p1 + 1, stdout), p1 = -1; }
inline void putc(const char &x) {
if (p1 == p2) flush();
buffer[++p1] = x;
}
template <typename T>
void write(T x) {
static char buf[15];
static int len = -1;
if (x >= 0) {
do {
buf[++len] = x % 10 + 48, x /= 10;
} while (x);
} else {
putc('-');
do {
buf[++len] = -(x % 10) + 48, x /= 10;
} while (x);
}
while (len >= 0) putc(buf[len]), --len;
}
} // namespace out
using namespace std;
template <const int mod>
struct modint {
int x;
modint<mod>(int o = 0) { x = o; }
modint<mod> &operator=(int o) { return x = o, *this; }
modint<mod> &operator+=(modint<mod> o) {
return x = x + o.x >= mod ? x + o.x - mod : x + o.x, *this;
}
modint<mod> &operator-=(modint<mod> o) {
return x = x - o.x < 0 ? x - o.x + mod : x - o.x, *this;
}
modint<mod> &operator*=(modint<mod> o) {
return x = 1ll * x * o.x % mod, *this;
}
modint<mod> &operator^=(int b) {
modint<mod> a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint<mod> &operator/=(modint<mod> o) { return *this *= o ^= mod - 2; }
modint<mod> &operator+=(int o) {
return x = x + o >= mod ? x + o - mod : x + o, *this;
}
modint<mod> &operator-=(int o) {
return x = x - o < 0 ? x - o + mod : x - o, *this;
}
modint<mod> &operator*=(int o) { return x = 1ll * x * o % mod, *this; }
modint<mod> &operator/=(int o) {
return *this *= ((modint<mod>(o)) ^= mod - 2);
}
template <class I>
friend modint<mod> operator+(modint<mod> a, I b) {
return a += b;
}
template <class I>
friend modint<mod> operator-(modint<mod> a, I b) {
return a -= b;
}
template <class I>
friend modint<mod> operator*(modint<mod> a, I b) {
return a *= b;
}
template <class I>
friend modint<mod> operator/(modint<mod> a, I b) {
return a /= b;
}
friend modint<mod> operator^(modint<mod> a, int b) { return a ^= b; }
friend bool operator==(modint<mod> a, int b) { return a.x == b; }
friend bool operator!=(modint<mod> a, int b) { return a.x != b; }
bool operator!() { return !x; }
modint<mod> operator-() { return x ? mod - x : 0; }
modint<mod> &operator++(int) { return *this += 1; }
};
const int N = 4e6 + 5;
const int mod = 998244353;
const modint<mod> GG = 3, Ginv = modint<mod>(1) / 3;
struct poly {
vector<modint<mod>> a;
modint<mod> &operator[](int i) { return a[i]; }
int size() { return a.size(); }
void resize(int n) { a.resize(n); }
void reverse() { std::reverse(a.begin(), a.end()); }
void print() {
for (auto x : a) printf("%d ", x);
puts("");
}
};
int rev[N];
inline poly one() {
poly a;
a.a.push_back(1);
return a;
}
inline int ext(int n) {
int k = 0;
while ((1 << k) < n) k++;
return k;
}
inline void init(int k) {
int n = 1 << k;
for (int i = 0; i < n; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (k - 1));
}
inline void ntt(poly &a, int k, int typ) {
int n = 1 << k;
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int mid = 1; mid < n; mid <<= 1) {
modint<mod> wn = (typ > 0 ? GG : Ginv) ^ ((mod - 1) / (mid << 1));
for (int r = mid << 1, j = 0; j < n; j += r) {
modint<mod> w = 1;
for (int k = 0; k < mid; k++, w = w * wn) {
modint<mod> x = a[j + k], y = w * a[j + k + mid];
a[j + k] = x + y, a[j + k + mid] = x - y;
}
}
}
if (typ < 0) {
modint<mod> inv = modint<mod>(1) / n;
for (int i = 0; i < n; i++) a[i] *= inv;
}
}
poly operator+(poly a, poly b) {
int n = max(a.size(), b.size());
a.resize(n), b.resize(n);
for (int i = 0; i < n; i++) a[i] += b[i];
return a;
}
poly operator-(poly a, poly b) {
int n = max(a.size(), b.size());
a.resize(n), b.resize(n);
for (int i = 0; i < n; i++) a[i] -= b[i];
return a;
}
inline poly operator*(poly a, poly b) {
int n = a.size() + b.size() - 1, k = ext(n);
a.resize(1 << k), b.resize(1 << k), init(k);
ntt(a, k, 1);
ntt(b, k, 1);
for (int i = 0; i < (1 << k); i++) a[i] *= b[i];
ntt(a, k, -1), a.resize(n);
return a;
}
inline poly operator*(poly a, modint<mod> b) {
for (int i = 0; i < a.size(); i++) a[i] *= b;
return a;
}
inline poly operator/(poly a, modint<mod> b) {
for (int i = 0; i < a.size(); i++) a[i] /= b;
return a;
}
inline poly operator-(poly a) {
for (int i = 0; i < a.size(); i++) a[i] = -a[i];
return a;
}
modint<mod> fac[N], ifac[N];
poly next(poly f, modint<mod> c) {
poly g;
g.resize(f.size());
for (int i = 0; i < f.size(); i++) f[i] *= fac[i];
f.reverse();
for (int i = 0; i < f.size(); i++) g[i] = (c ^ i) * ifac[i];
g = g * f;
g.resize(f.size());
g.reverse();
for (int i = 0; i < f.size(); i++) g[i] *= ifac[i];
return g;
}
poly solve(int n) {
if (n == 0) {
return one();
}
int m = n / 2;
poly F = solve(m);
F.resize(m + 1);
F = F * next(F, modint<mod>(m));
F.resize(n + 1);
if (n & 1) {
for (int i = n; i; i--) F[i] = F[i] * (n - 1) + F[i - 1];
F[0] *= (n - 1);
}
return F;
}
modint<mod> C(int n, int m) {
if (m > n) return 0;
return fac[n] * ifac[m] * ifac[n - m];
}
signed main() {
int n = 3, a, b;
in::read(n, a, b);
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i;
ifac[n] = modint<mod>(1) / fac[n];
for (int i = n; i; i--) ifac[i - 1] = ifac[i] * i;
poly F = solve(n - 1);
F.resize(a + b);
modint<mod> ans = F[a + b - 2] * C(a + b - 2, a - 1);
out::write(ans.x);
out::flush();
return 0;
}
| 10 |
#include <bits/stdc++.h>
double PI = 3.1415926535;
const int N = (int)(1 * 1e6 + 10);
using namespace std;
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % 1000000007;
}
b >>= 1;
a = (a * a) % 1000000007;
}
return ans;
}
int main() {
long long int n, x, i, sum = 0, mx = INT_MIN;
cin >> n >> x;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
mx = max(mx, a[i]);
}
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
a[i] = mx - a[i];
m[a[i]]++;
}
long long int sol = sum - mx;
i = 0;
while (m[i] % x == 0) {
m[i + 1] += m[i] / x;
i++;
}
sol += min(i, mx);
cout << power(x, sol) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 1e9;
int n, m, ans = inf;
vector<int> v, v1;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int z;
cin >> z;
v.push_back(z);
}
for (int i = 0; i < m; i++) {
int x1, x2, y;
cin >> x1 >> x2 >> y;
if (x1 == 1) v1.push_back(x2);
}
sort(v.begin(), v.end());
sort(v1.begin(), v1.end());
v.push_back(inf);
for (int i = 0; i < v.size(); i++) {
int x = lower_bound(v1.begin(), v1.end(), v[i]) - v1.begin();
ans = min(ans, i + ((int)v1.size() - x));
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, k, i, j;
cin >> n >> k;
vector<long long int> v;
unordered_map<long long int, long long int> mp;
for (i = 0; i < n; i++) {
long long int x;
cin >> x;
if (mp[x] == 0) {
v.push_back(x);
mp[x] = 1;
}
}
if (v.size() > k) {
cout << -1 << "\n";
} else {
for (i = 1; i <= n; i++) {
if (v.size() == k) {
break;
}
if (mp[i] == 0) {
v.push_back(i);
}
}
cout << n * v.size() << "\n";
for (i = 0; i < n; i++) {
for (j = 0; j < v.size(); j++) {
cout << v[j] << " ";
}
}
cout << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline void read(t &res) {
char ch;
while (ch = getchar(), !isdigit(ch))
;
res = ch ^ 48;
while (ch = getchar(), isdigit(ch)) res = res * 10 + (ch ^ 48);
}
const int e = 915;
int f[e][e], ans, L[e], R[e], b[e], n, m, Left[e][e];
struct point {
int x, l;
} a[e];
inline bool cmp(const point &a, const point &b) { return a.x < b.x; }
int main() {
read(n);
int i, j, k;
for (i = 1; i <= n; i++) {
read(a[i].x), read(a[i].l);
b[++m] = a[i].x;
b[++m] = a[i].x - a[i].l;
b[++m] = a[i].x + a[i].l;
}
sort(a + 1, a + n + 1, cmp);
sort(b + 1, b + m + 1);
m = unique(b + 1, b + m + 1) - b - 1;
for (i = 1; i <= n; i++) {
L[i] = lower_bound(b + 1, b + m + 1, a[i].x - a[i].l) - b;
R[i] = lower_bound(b + 1, b + m + 1, a[i].x + a[i].l) - b;
a[i].x = lower_bound(b + 1, b + m + 1, a[i].x) - b;
}
for (i = 1; i <= n; i++) {
Left[i][i] = L[i];
Left[i + 1][i] = a[i].x;
for (j = i + 1; j <= n; j++) Left[i][j] = min(Left[i][j - 1], L[j]);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
f[i][j] = max(f[i][j - 1], f[i - 1][j]);
if (L[i] <= j && j <= a[i].x)
f[i][j] = max(f[i][j], f[i - 1][L[i]] + b[j] - b[L[i]]);
else if (j < L[i])
f[i][j] = max(f[i][j], f[i - 1][j]);
else {
for (k = 1; k <= i; k++)
if (R[k] >= j)
f[i][j] = max(f[i][j],
f[k - 1][Left[k + 1][i]] + b[j] - b[Left[k + 1][i]]);
}
ans = max(ans, f[i][j]);
}
cout << ans << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100007;
int n, m, q;
unordered_map<int, int> fa[maxn], ans[maxn];
int find_set(int v, int c) {
if (fa[v][c] == v) return v;
return fa[v][c] = find_set(fa[v][c], c);
}
void union_set(int x, int y, int c) {
if (fa[x].find(c) == fa[x].end()) fa[x][c] = x;
if (fa[y].find(c) == fa[y].end()) fa[y][c] = y;
int fx = find_set(x, c), fy = find_set(y, c);
if (fx != fy) fa[fx][c] = fy;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
union_set(x, y, c);
}
scanf("%d", &q);
while (q--) {
int x, y, Ans = 0;
scanf("%d%d", &x, &y);
if (ans[x].find(y) != ans[x].end()) {
printf("%d\n", ans[x][y]);
continue;
}
int s1 = fa[x].size(), s2 = fa[y].size();
if (s1 > s2) swap(x, y);
for (auto u : fa[x]) {
if (fa[y].find(u.first) != fa[y].end() &&
find_set(x, u.first) == find_set(y, u.first))
Ans++;
}
ans[x][y] = ans[y][x] = Ans;
printf("%d\n", Ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, maxi = 0;
cin >> t;
string a, b, c;
map<string, long long> mp;
mp["polycarp"] = 1;
while (t--) {
cin >> a >> b >> c;
transform(a.begin(), a.end(), a.begin(), ::tolower);
transform(c.begin(), c.end(), c.begin(), ::tolower);
mp[a] = mp[c] + 1;
}
for (auto i : mp) maxi = max(i.second, maxi);
cout << maxi;
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int fact(int n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double m, n;
cin >> m >> n;
double exp = 0;
for (double i = 1; i <= m; i++) {
exp += (i * (pow(i / m, n) - pow((i - 1) / m, n)));
}
cout << fixed << setprecision(10) << exp;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int kd, x, y, z;
node() {}
node(int _kd, int _x, int _y, int _z) { kd = _kd, x = _x, y = _y, z = _z; }
} r[150];
int n, m, q;
long long f[13][1 << 13];
bool ok(int m1, int rt, int m2, int ch) {
for (int i = 1; i <= m + q; i++) {
int x = r[i].x, y = r[i].y;
if (!((m1 >> x) & 1) || !((m1 >> y) & 1)) continue;
if (((m2 >> x) & 1) == ((m2 >> y) & 1)) continue;
if (i <= m) {
if (y == rt) swap(x, y);
if (x != rt || y != ch) return 0;
} else if (r[i].z != rt)
return 0;
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
r[i] = node(0, --x, --y, 0);
}
for (int i = 1; i <= q; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (x == y && z != x) return puts("0"), 0;
r[i + m] = node(1, --x, --y, --z);
}
for (int i = 0; i <= n - 1; i++) f[i][1 << i] = 1;
for (int i = 0; i <= (1 << n) - 1; i++)
for (int rt = 0; rt <= n - 1; rt++)
if ((i >> rt) & 1) {
int ch = -1;
for (int j = 0; j <= n - 1; j++)
if (((i >> j) & 1) && (j ^ rt)) {
ch = j;
break;
}
if (ch == -1) continue;
for (int msk = i; msk; --msk, msk &= i)
if (!((msk >> rt) & 1) && ((msk >> ch) & 1)) {
for (int CH = 0; CH <= n - 1; CH++)
if (((msk >> CH) & 1) and (ok(i, rt, msk, CH)))
f[rt][i] += f[rt][i ^ msk] * f[CH][msk];
}
}
printf("%I64d\n", f[0][(1 << n) - 1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void quickSort(int arr[], int b[], int left, int right) {
int i = left, j = right;
int tmp;
int t;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot) i++;
while (arr[j] > pivot) j--;
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
t = b[i];
b[i] = b[j];
b[j] = t;
i++;
j--;
}
};
if (left < j) quickSort(arr, b, left, j);
if (i < right) quickSort(arr, b, i, right);
}
int main() {
int n, a[1005], b[1005], i, m, min, max, f;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
b[i] = i;
}
quickSort(a, b, 0, n - 1);
min = a[0];
max = a[n - 1];
if (min == max) {
cout << "Exemplary pages.";
return 0;
} else {
m = (max - min) / 2;
max = max - m;
min = min + m;
a[0] = max;
a[n - 1] = min;
f = 0;
for (i = 0; i < n; i++) {
if (max != a[i]) {
f = 1;
break;
}
}
if (f == 1)
cout << "Unrecoverable configuration.";
else
cout << m << " ml. from cup #" << b[0] + 1 << " to cup #" << b[n - 1] + 1
<< ".";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, m, x, y, xx, yy, z, p, X, Y, s, M, N, i, j;
scanf("%d%d%d%d%d%d", &n, &m, &xx, &yy, &z, &p);
xx = xx % 4;
z = z % 4;
yy = yy % 2;
for (i = 1; i <= p; i++) {
N = n;
M = m;
scanf("%d%d", &x, &y);
for (j = 1; j <= xx; j++) {
X = y;
Y = N + 1 - x;
x = X;
y = Y;
s = N;
N = M;
M = s;
}
for (j = 1; j <= yy; j++) {
y = M + 1 - y;
}
for (j = 1; j <= 4 - z; j++) {
X = y;
Y = N + 1 - x;
x = X;
y = Y;
s = N;
N = M;
M = s;
}
printf("%d %d\n", x, y);
}
scanf(" ");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int mod = 1000000007;
const int inf = 1000000000;
const double eps = 0.0000001;
int memo[30];
void calc_memo() {
fill(begin(memo), end(memo), 1);
for (int i = 0b11; i <= (1 << 25) - 1; i = (i << 1) | 1) {
int m = (int)log2(i + 1);
for (int b = 2; b * b < i; b++) {
if (i % b == 0) {
memo[m] = i / b;
break;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
calc_memo();
for (int i = 0; i < q; i++) {
int a;
cin >> a;
if ((a & (a + 1)) != 0) {
int mask = 1;
int res = 0;
while (mask <= a) {
res |= mask;
mask <<= 1;
}
cout << res << "\n";
} else {
int z = (int)log2(a + 1);
cout << memo[z] << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int calc(int x) {
long long det = 8ll * x + 1;
int t = (int)(sqrt(det) + 0.5);
if (1ll * t * t != det) return -1;
return (t + 1) / 2;
}
void print(char ch, int k) {
for (int i = 1; i <= k; i++) putchar(ch);
}
int main() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int p = calc(a), q = calc(d);
if (p == -1 || q == -1) {
puts("Impossible");
return 0;
}
if ((!a || !d) && b + c == 0) {
if (!a && !d)
putchar('0');
else if (a)
print('0', p);
else
print('1', q);
putchar('\n');
} else if (1ll * p * q != b + c)
puts("Impossible");
else {
print('0', b / q);
print('1', q - b % q);
if (b / q < p) putchar('0');
print('1', b % q);
print('0', p - b / q - 1);
putchar('\n');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 130000;
const double pi = acos(-1);
struct E {
double x, y;
E() {}
E(const double _x, const double _y) {
x = _x;
y = _y;
}
} w[maxn], t0[maxn], t1[maxn];
int id[maxn];
inline E operator+(const E &x, const E &y) { return E(x.x + y.x, x.y + y.y); }
inline E operator-(const E &x, const E &y) { return E(x.x - y.x, x.y - y.y); }
inline E operator*(const E &x, const E &y) {
return E(x.x * y.x - x.y * y.y, x.y * y.x + x.x * y.y);
}
long long Mod;
int b;
int N, ln, n;
long long re = 0;
long long f0[maxn], f1[maxn], temp[maxn];
long long nf0[maxn], nf1[maxn];
void DFT(E s[], const int sig) {
for (int i = 0; i < N; i++)
if (i < id[i]) swap(s[i], s[id[i]]);
for (int m = 2; m <= N; m <<= 1) {
int t = m >> 1, tt = N / m;
for (int j = 0; j < N; j += m) {
for (int i = 0; i < t; i++) {
E wn = sig == 1 ? w[i * tt] : w[N - i * tt];
E tx = s[j + i], ty = s[j + i + t] * wn;
s[j + i] = tx + ty;
s[j + i + t] = tx - ty;
}
}
}
if (sig == -1)
for (int i = 0; i < N; i++) s[i].x /= (double)N;
}
void solve() {
f0[0] = 1;
int now = 0;
for (int i = 30; i >= 1; i--) {
if (now & 1) {
for (int j = 0; j <= n; j++) t0[j] = E((f0[j] + f1[j]) % Mod, 0);
for (int j = 0; j <= n; j++) t1[j] = E(f1[j], 0);
for (int j = n + 1; j < N; j++) t0[j] = t1[j] = E(0, 0);
DFT(t0, 1);
DFT(t1, 1);
for (int j = 0; j < N; j++) t0[j] = t0[j] * t1[j];
DFT(t0, -1);
for (int j = 0; j <= n; j++)
nf0[j] = (f0[j] + ((long long)(t0[j].x + 0.5))) % Mod;
for (int j = 0; j <= n; j++) t0[j] = E((f0[j] + f1[j]) % Mod, 0);
for (int j = 0; j <= n; j++) t1[j] = E(f0[j], 0);
for (int j = n + 1; j < N; j++) t0[j] = t1[j] = E(0, 0);
DFT(t0, 1);
DFT(t1, 1);
for (int j = 0; j < N; j++) t0[j] = t0[j] * t1[j];
DFT(t0, -1);
for (int j = 0; j <= n; j++)
nf1[j] = (((long long)(t0[j].x + 0.5)) % Mod - f0[j] + Mod) % Mod;
} else {
for (int j = 0; j <= n; j++) t0[j] = E((f0[j] + f1[j]) % Mod, 0);
for (int j = 0; j <= n; j++) t1[j] = E(f0[j], 0);
for (int j = n + 1; j < N; j++) t0[j] = t1[j] = E(0, 0);
DFT(t0, 1);
DFT(t1, 1);
for (int j = 0; j < N; j++) t0[j] = t0[j] * t1[j];
DFT(t0, -1);
for (int j = 0; j <= n; j++)
nf0[j] = (((long long)(t0[j].x + 0.5)) % Mod - f1[j] + Mod) % Mod;
for (int j = 0; j <= n; j++) t0[j] = E((f0[j] + f1[j]) % Mod, 0);
for (int j = 0; j <= n; j++) t1[j] = E(f1[j], 0);
for (int j = n + 1; j < N; j++) t0[j] = t1[j] = E(0, 0);
DFT(t0, 1);
DFT(t1, 1);
for (int j = 0; j < N; j++) t0[j] = t0[j] * t1[j];
DFT(t0, -1);
for (int j = 0; j <= n; j++)
nf1[j] = (f1[j] + ((long long)(t0[j].x + 0.5)) % Mod) % Mod;
}
for (int j = 0; j <= n; j++) f0[j] = nf0[j], f1[j] = nf1[j];
now <<= 1;
if ((b & (1 << i)) > 0) {
for (int j = n; j >= 1; j--)
f1[j] = (f1[j] + f0[j - 1] + f1[j - 1]) % Mod;
now |= 1;
}
for (int j = 1; j <= n; j += 2) re += f1[j];
re %= Mod;
}
}
int main() {
scanf("%d%d%I64d", &n, &b, &Mod);
N = 1, ln = 0;
while (N <= 2 * n) N <<= 1, ln++;
for (int i = 1; i < N; i++) id[i] = (id[i >> 1] >> 1) | ((i & 1) << ln - 1);
for (int m = 2; m <= N; m <<= 1) {
int t = m >> 1, tt = N / m;
for (int i = 0; i < t; i++) {
w[i * tt] = E(cos(2 * pi * i / m), sin(2 * pi * i / m));
w[N - i * tt] = E(cos(2 * pi * i / m), sin(-2 * pi * i / m));
}
}
solve();
printf("%I64d\n", re);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e3 + 5;
long long n, m, x, y, val[MAXN][MAXN], p[MAXN][MAXN], mn[MAXN][MAXN],
mn2[MAXN][MAXN];
vector<pair<pair<long long, long long>, long long>> ans;
pair<long long, long long> q[MAXN];
long long sz;
pair<long long, pair<long long, long long>> sec[MAXN * MAXN];
bool mark[MAXN][MAXN];
int main() {
scanf("%lld %lld %lld %lld", &n, &m, &x, &y);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) scanf("%lld", &val[i][j]);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
p[i + 1][j + 1] = p[i][j + 1] + p[i + 1][j] - p[i][j] + val[i][j];
for (long long i = 0; i < n; i++) {
long long h = 0, t = 0;
for (long long j = m - 1; ~j; j--) {
while (t - h && q[t - 1].second >= val[i][j]) t--;
q[t++] = {j, val[i][j]};
if (q[h].first >= j + y) h++;
mn[i][j] = q[h].second;
}
}
for (long long j = 0; j < m; j++) {
long long h = 0, t = 0;
for (long long i = n - 1; ~i; i--) {
while (t - h && q[t - 1].second >= mn[i][j]) t--;
q[t++] = {i, mn[i][j]};
if (q[h].first >= i + x) h++;
mn2[i][j] = q[h].second;
}
}
for (long long i = 0; i + x <= n; i++)
for (long long j = 0; j + y <= m; j++)
sec[sz++] = {p[i + x][j + y] - p[i][j + y] - p[i + x][j] + p[i][j] -
mn2[i][j] * x * y,
{i, j}};
sort(sec, sec + sz);
for (long long i = 0; i < sz; i++) {
long long a = sec[i].second.first, b = sec[i].second.second;
if (!mark[a][b]) {
ans.push_back({{a, b}, sec[i].first});
for (long long c = max(0ll, a - x + 1); c < min(a + x, n); c++)
for (long long d = max(0ll, b - y + 1); d < min(b + y, m); d++)
mark[c][d] = 1;
}
}
printf("%lld\n", (long long)ans.size());
for (auto z : ans)
printf("%lld %lld %lld\n", z.first.first + 1, z.first.second + 1, z.second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
long long l, r, ans;
inline void prebuild(const long long &x) {
if (x > (1ll << 37)) {
return;
}
a.push_back(x);
prebuild(x * 10 + 4);
prebuild(x * 10 + 7);
}
int32_t main() {
ios_base ::sync_with_stdio(false);
cin >> l >> r;
prebuild(4);
prebuild(7);
sort(a.begin(), a.end());
int ind = 0;
for (; ind < a.size(); ++ind) {
if (a[ind] >= l) {
break;
}
}
for (; ind < a.size(); ++ind) {
if (a[ind] >= r) {
ans += (r - l + 1) * a[ind];
break;
} else {
ans += (a[ind] - l + 1) * a[ind];
l = a[ind] + 1;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[200100];
priority_queue<long long> S;
int main() {
long long n, k, b, c;
cin >> n >> k >> b >> c;
for (int i = 0; i < n; i++) cin >> a[i];
if (b > 5 * c) b = 5 * c;
sort(a, a + n);
long long ans = (1LL << 62);
for (int r = 0; r < 5; r++) {
while (!S.empty()) S.pop();
long long sum = 0, offset = 0, last = 0;
for (int i = 0; i < n; i++) {
long long x = a[i];
while ((x - r) % 5 != 0) x++;
sum += (x - last) / 5 * b * S.size();
offset += (x - last) / 5;
last = x;
int cost = (x - a[i]) * c;
sum += cost;
S.push(cost - offset * b);
if (S.size() > k) {
long long f = S.top();
S.pop();
sum -= f + offset * b;
}
if (S.size() == k) ans = min(ans, sum);
}
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 2e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t, tc = 0;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<int, int> > a(n + n - 1);
for (auto &qq : a) cin >> qq.first >> qq.second;
vector<int> v(n + n - 1);
iota((v).begin(), (v).end(), 0);
sort((v).begin(), (v).end(), [&](int &p, int &q) { return a[p] < a[q]; });
long long tf = 0, ts = 0;
for (auto &qq : a) tf += qq.first, ts += qq.second;
long long oddf = 0, odds = 0;
for (int i = 0; i < (int)v.size(); i += 2) {
oddf += a[v[i]].first;
odds += a[v[i]].second;
}
if (oddf + oddf >= tf and odds + odds >= ts) {
cout << "YES\n";
for (int i = 0; i < (int)v.size(); i += 2) {
if (i) cout << " ";
cout << v[i] + 1;
}
cout << "\n";
} else {
long long evef = tf - oddf + a[v.back()].first,
eves = ts - odds + a[v.back()].second;
if (evef * 2 >= tf and eves * 2 >= ts) {
cout << "YES\n";
for (int i = 1; i < (int)v.size(); i += 2) {
if (i > 1) cout << " ";
cout << v[i] + 1;
}
cout << " " << v.back() + 1 << "\n";
} else
cout << "NO\n\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], y[n], i, j, a, b, count = 0;
bool v[2001][2001];
memset(v, 0, sizeof(v));
for (i = 0; i < n; i++) {
cin >> a >> b;
x[i] = a;
y[i] = b;
v[1000 + a][1000 + b] = true;
}
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
a = x[i] + x[j];
b = y[i] + y[j];
if (a % 2 == 0 and b % 2 == 0) {
a /= 2;
b /= 2;
if (v[1000 + a][1000 + b] == true) count++;
}
}
}
cout << count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const bool ready = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
return true;
}();
const double PI = acos(-1);
using ll = long long;
using pii = pair<ll, ll>;
using pdd = pair<double, double>;
using vd = vector<double>;
using vb = vector<bool>;
using vi = vector<ll>;
using vvi = vector<vi>;
using vs = vector<string>;
void solve() {
ll n;
cin >> n;
;
vi hbit(n);
for (ll i = 0; i < n; i++) {
ll aux;
cin >> aux;
;
for (ll j = 31; j >= 0; j--) {
if (aux & (1LL << j)) {
hbit[i] = j + 1;
break;
}
}
}
vvi pre(32, vi(n + 1));
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 32; j++) pre[j][i + 1] = pre[j][i];
pre[hbit[i]][i + 1]++;
}
ll ans = 0;
for (ll i = 0; i < n; i++) {
ans += pre[hbit[i]][n] - pre[hbit[i]][i + 1];
}
cout << ans << "\n";
}
signed main() {
ll t;
cin >> t;
;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, cnt = 1;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cout << a[n - k];
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long fib[200111];
long long the[2][(1 << 20)], t[(1 << 20)];
int T;
int n, q, i, j, k;
long long query(int l, int r, int id, int b) {
if (l == 1 && r == t[id]) return the[1][id];
if (l || r != t[id]) {
if (r <= t[(id << 1)]) return query(l, r, (id << 1), b);
if (l >= t[(id << 1)])
return query(l - t[(id << 1)], r - t[(id << 1)], (id << 1 ^ 1), b);
return (query(l, t[(id << 1)], (id << 1), b) +
query(0, r - t[(id << 1)], (id << 1 ^ 1), b + t[(id << 1)] - l)) %
1000000000ll;
}
return (the[0][id] * fib[b] + the[1][id] * (b ? fib[b - 1] : 0)) %
1000000000ll;
}
int main() {
fib[0] = fib[1] = 1ll;
for (i = 2; i < 200111; ++i)
fib[i] = (fib[i - 1] + fib[i - 2]) % 1000000000ll;
scanf("%d %d", &n, &q);
for (T = 1; T < n; T <<= 1)
;
for (i = 0; i < n; ++i) scanf("%I64d", the[0] + i + T);
for (i = 0; i < T; ++i) t[i + T] = 1;
for (i = T - 1; i >= 0; --i) {
t[i] = t[i << 1] << 1;
the[0][i] = (query(0, t[i << 1], i << 1, 0) +
query(0, t[i << 1], i << 1 ^ 1, t[i << 1])) %
1000000000ll;
the[1][i] = (query(1, t[i << 1], i << 1, 0) +
query(0, t[i << 1], i << 1 ^ 1, t[i << 1] - 1)) %
1000000000ll;
}
while (q--) {
scanf("%d", &i);
if (i == 1) {
scanf("%d %d", &i, &j);
i += T - 1;
the[0][i] = j;
while (i >>= 1) {
the[0][i] = (query(0, t[i << 1], i << 1, 0) +
query(0, t[i << 1], i << 1 ^ 1, t[i << 1])) %
1000000000ll;
the[1][i] = (query(1, t[i << 1], i << 1, 0) +
query(0, t[i << 1], i << 1 ^ 1, t[i << 1] - 1)) %
1000000000ll;
}
} else {
scanf("%d %d", &i, &j);
printf("%I64d\n", query(--i, j, 1, 0));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const max_s = 1 << 19;
int sg_mem[max_s];
int const max_m = 3 * (6 + 6 + 10 + 10 + 15);
int mask[max_m], ml = 0;
int const r[][19] = {
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
{2, 6, 11, 1, 5, 10, 15, 0, 4, 9, 14, 18, 3, 8, 13, 17, 7, 12, 16},
{11, 15, 18, 6, 10, 14, 17, 2, 5, 9, 13, 16, 1, 4, 8, 12, 0, 3, 7}};
void gen_masks(int const *a, int const *b) {
int n = b - a;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
mask[ml] = 0;
for (int k = i; k <= j; k++) mask[ml] |= (1 << a[k]);
ml++;
}
}
}
void gen_ints(int const *a) {
gen_masks(a, a + 3);
gen_masks(a + 3, a + 7);
gen_masks(a + 7, a + 12);
gen_masks(a + 12, a + 16);
gen_masks(a + 16, a + 19);
}
void gen_all() {
gen_ints(r[0]);
gen_ints(r[1]);
gen_ints(r[2]);
}
void print(int n) {
printf(" ");
for (int i = 0; i < 3; i++) printf("%c ", (n & (1 << i)) ? 'O' : '.');
printf("\n ");
for (int i = 3; i < 7; i++) printf("%c ", (n & (1 << i)) ? 'O' : '.');
printf("\n");
for (int i = 7; i < 12; i++) printf("%c ", (n & (1 << i)) ? 'O' : '.');
printf("\n ");
for (int i = 12; i < 16; i++) printf("%c ", (n & (1 << i)) ? 'O' : '.');
printf("\n ");
for (int i = 16; i < 19; i++) printf("%c ", (n & (1 << i)) ? 'O' : '.');
printf("\n");
getchar();
}
int const max_sg = 32;
int sg(int st) {
if (sg_mem[st] != -1) return sg_mem[st];
char *is = new char[max_sg];
memset(is, 0, max_sg * sizeof(char));
for (int i = 0; i < max_m; i++)
if ((st & mask[i]) == mask[i]) is[sg(st & ~mask[i])] = 1;
int mex = 0;
while (is[mex]) mex++;
delete[] is;
return sg_mem[st] = mex;
}
int main() {
memset(sg_mem, -1, sizeof(sg_mem));
sg_mem[0] = 0;
gen_all();
int st = 0;
for (int i = 0; i < 19; i++) {
char c;
cin >> c;
if (c == 'O') st |= (1 << i);
}
int st_sg = sg(st);
if (st_sg)
cout << "Karlsson" << endl;
else
cout << "Lillebror" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void minimize(T &A, T B) {
A = min(A, B);
}
template <class T>
void maximize(T &A, T B) {
A = max(A, B);
}
const long long maxsize = 100000;
const long long mod = 1e9 + 9;
const long long base = 311;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void inti() {
freopen(
"c"
".inp",
"r", stdin);
freopen(
"c"
".out",
"w", stdout);
}
int t;
long long l, r;
void nhap() {
cin >> t;
while (t--) {
cin >> l >> r;
long long m = r / 2 + 1;
if (m < l) {
cout << r % l << endl;
} else {
cout << r % m << endl;
}
}
}
int main() {
fastio();
nhap();
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.