solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, c;
cin >> n >> m >> a >> b >> c;
vector<vector<int> > field(n, vector<int>(m, 0));
int rem = n * m;
if (n * m % 2 == 1) goto IMPOSSIBLE;
if (n * m > 2 * a + 2 * b + 4 * c) goto IMPOSSIBLE;
if (n % 2 == 1) {
for (int i = 0; i < m; i += 2) {
if (a == 0) goto IMPOSSIBLE;
--a;
field[n - 1][i] = field[n - 1][i + 1] = (i % 4) + 10;
}
--n;
rem -= m;
} else if (m % 2 == 1) {
for (int i = 0; i < n; i += 2) {
if (b == 0) goto IMPOSSIBLE;
--b;
field[i][m - 1] = field[i + 1][m - 1] = (i % 4) + 10;
}
--m;
rem -= n;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (field[i][j] != 0) continue;
vector<bool> used(10, false);
if (i > 0) used[field[i - 1][j]] = true;
if (i > 0 && j < m - 1) used[field[i - 1][j + 1]] = true;
if (j > 0) used[field[i][j - 1]] = true;
if (i < n - 1 && j > 0) used[field[i + 1][j - 1]] = true;
int pos = 1;
int num1, num2;
while (used[pos]) ++pos;
num1 = pos++;
while (used[pos]) ++pos;
num2 = pos;
if (b >= 2) {
field[i][j] = field[i + 1][j] = num1;
field[i][j + 1] = field[i + 1][j + 1] = num2;
b -= 2;
} else if (a >= 2) {
field[i][j] = field[i][j + 1] = num1;
field[i + 1][j] = field[i + 1][j + 1] = num2;
a -= 2;
} else if (c >= 1) {
field[i][j] = field[i][j + 1] = field[i + 1][j] = field[i + 1][j + 1] =
num1;
c -= 1;
} else
goto IMPOSSIBLE;
}
}
for (int i = 0; i < field.size(); ++i) {
for (int j = 0; j < field[i].size(); ++j) {
cout << char('a' + field[i][j]);
}
cout << endl;
}
goto END;
IMPOSSIBLE:
cout << "IMPOSSIBLE" << endl;
END:
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], sum[1000005], dp[1000005], pw[1000005], w[1000005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
sum[a[i]]++;
}
for (int i = 2; i < 1000005; ++i)
for (int j = i + i; j < 1000005; j += i) sum[i] += sum[j];
pw[0] = 1;
for (int i = 1; i < 1000005; ++i) pw[i] = pw[i - 1] * 2 % 1000000007;
for (int i = 1; i < 1000005; ++i)
dp[i] = (dp[i - 1] * 2 % 1000000007 + pw[i - 1]) % 1000000007;
int ans = 0;
for (int i = 1000005 - 1; i > 1; --i) {
w[i] = dp[sum[i]];
for (int j = i + i; j < 1000005; j += i) w[i] = (w[i] - w[j]) % 1000000007;
ans = (ans + 1ll * i * w[i]) % 1000000007;
}
printf("%d", (ans + 1000000007) % 1000000007);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, string> mp;
mp['2'] = "2";
mp['3'] = "3";
mp['4'] = "223";
mp['5'] = "5";
mp['6'] = "35";
mp['7'] = "7";
mp['8'] = "2227";
mp['9'] = "2337";
int n;
cin >> n;
string s;
cin >> s;
string s2 = "";
for (int i = 0; i < s.size(); i++) {
s2 += mp[s[i]];
}
sort(s2.rbegin(), s2.rend());
cout << s2 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 23;
int N, P;
bool rp(int& a, int b) { return a == -1 or b < a ? a = b, true : false; }
using i4 = array<int, 4>;
i4 a[MN];
int d[1 << MN], o[MN], b[1 << MN];
using i2 = array<int, 2>;
i2 f[MN];
bool F;
void dodp() {
d[0] = 1;
for (int i = 0, k, l, m; i < (1 << N); i++) {
if (d[i] == -1) continue;
for (k = 0; k < N and a[k][0] <= d[i]; k++)
;
if (k == N) continue;
m = max(d[i], k ? a[k - 1][0] + a[k - 1][1] : -1), l = a[k][0] - m - 1;
for (int j = 0; j < N; j++) {
if (i & 1 << o[j]) continue;
for (; k <= o[j] and l < a[o[j]][2]; k++)
if (i & 1 << k or m == a[k][0])
m = a[k][0] + a[k][1], l = a[k + 1][0] - m - 1;
else
l += a[k + 1][0] - a[k][0];
if (k > o[j]) continue;
if (rp(d[i | 1 << o[j]], a[o[j]][2] + m)) b[i | 1 << o[j]] = o[j];
}
}
}
void fin(int p, int m) {
for (; m;) {
f[a[b[m]][3]] = {p, d[m] - a[b[m]][2]};
m ^= 1 << b[m];
}
}
int solve1() {
if (d[(1 << N) - 1] == -1) return F = false, 0;
fin(1, (1 << N) - 1);
return F = true, 0;
}
int solve2() {
for (int i = 0, q = (1 << N) - 1; i < 1 << N; i++)
if (d[i] != -1 and d[i ^ q] != -1)
return F = true, fin(1, i), fin(2, i ^ q), 0;
return F = false, 0;
}
int main() {
scanf("%d%d", &N, &P);
for (int i = 0; i < N; i++)
scanf("%d%d%d", &a[i][0], &a[i][1], &a[i][2]), a[i][3] = i;
sort(a, a + N, [](i4 x, i4 y) { return x[0] < y[0]; });
for (int i = 0; i < N; i++) o[i] = i;
sort(o, o + N, [](int x, int y) { return a[x][2] < a[y][2]; });
for (int i = 0; i < 1 << N; i++) d[i] = -1;
a[N] = {-1, -1, -1, -1};
dodp();
F = true;
if (P == 1) solve1();
if (P == 2) solve2();
if (F) {
printf("YES\n");
for (int i = 0; i < N; i++) printf("%d %d\n", f[i][0], f[i][1]);
} else
printf("NO\n");
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int N, M;
int A[MAXN];
bool chng[MAXN];
vector<int> pos[2];
bool comp(int x, int y) { return A[x] > A[y]; }
int main() {
scanf("%d %d", &N, &M);
int num[2] = {0, 0};
set<int> sai;
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
if (sai.insert(A[i]).second) {
num[A[i] % 2]++;
pos[A[i] % 2].push_back(i);
} else {
chng[i] = true;
}
}
for (int i = 0; i < 2; i++) {
sort(pos[i].begin(), pos[i].end(), comp);
}
for (int i = 0; i < 2; i++) {
if (num[i] > N / 2) {
for (int j = 0; j < num[i] - N / 2; j++) {
chng[pos[i].back()] = true;
pos[i].pop_back();
}
num[i] = N / 2;
}
}
set<int> st[2];
for (int i = 1; i <= M && i <= 4 * N; i++) {
st[i % 2].insert(i);
}
for (int i = 0; i < N; i++) {
if (!chng[i]) {
st[A[i] % 2].erase(A[i]);
}
}
for (int i = 0; i < N; i++) {
if (!chng[i]) {
continue;
}
int par = (num[0] == N / 2);
if (st[par].empty()) {
puts("-1");
return 0;
}
A[i] = *st[par].begin();
st[par].erase(st[par].begin());
num[par]++;
}
printf("%ld\n", count(chng, chng + N, true));
for (int i = 0; i < N; i++) {
printf("%d ", A[i]);
}
puts("");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 110;
char A[NMax][NMax];
int N, M;
int main() {
scanf("%d%d", &N, &M);
if (N == 5) {
printf(">...v\nv.<..\n..^..\n>....\n..^.<\n1 1\n");
return 0;
}
if (N == 3) {
printf(">vv\n^<.\n^.<\n1 3\n");
return 0;
}
for (int i = 100; i >= 2; i -= 2) {
int a = i - 2, b = i - 1;
A[0][b] = '<';
A[99][a] = '>';
for (int j = 0; j < 49; j++) A[j][a] = 'v', A[99 - j][b] = '^';
for (int j = 49; j < 99; j += 2)
A[j][a] = '.', A[j + 1][a] = 'v', A[99 - j][b] = '.',
A[99 - j - 1][b] = '^';
}
for (int i = 0; i < 100; i++) printf("%s\n", A[i]);
printf("1 100\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long vec[100100];
scanf("%d", &n);
long long suma = 0;
long long m = -1;
for (int i = 0; i < n; i++) {
scanf("%lld", &vec[i]);
suma += vec[i];
if (vec[i] > m) m = vec[i];
}
sort(vec, vec + n);
long long menor = 0;
long long mayor = 1000000000000;
long long mid;
while (menor < mayor) {
mid = menor + (mayor - menor) / 2;
suma = 0;
for (int i = 0; i < n; i++) {
suma += mid - vec[i];
}
if (suma >= mid && mid >= m) {
mayor = mid;
} else {
menor = mid + 1;
mid += 1;
}
}
printf("%lld", mid);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
v.push_back(1);
if (n >> 1) {
v.push_back(n);
}
for (long long d = 2; d * d <= n; d++) {
if (n % d == 0) {
if (n / d == d) {
v.push_back(d);
} else {
v.push_back(d);
v.push_back(n / d);
}
}
}
string s = to_string(n);
map<char, bool> m;
for (auto c : s) {
m[c] = true;
}
int res = 0;
for (auto a : v) {
string t = to_string(a);
for (auto c : t) {
if (m[c]) {
res++;
break;
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1001;
char l[MAX][10][10];
int g[MAX][MAX];
bool c[MAX];
struct edge {
int w;
int p;
int n;
edge(int w, int p, int n) {
this->w = w;
this->p = p;
this->n = n;
}
edge(int p, int n) {
this->p = p;
this->n = n;
this->w = g[p][n];
}
bool operator<(edge const& x) const { return this->w > x.w; }
};
priority_queue<edge> q;
set<int> notCheck;
vector<edge> ans;
int main() {
ios::sync_with_stdio(false);
memset(g, 0, sizeof(g));
memset(c, false, sizeof(c));
int n, m, k, w;
cin >> n >> m >> k >> w;
int base = n * m;
for (int i = 0; i < k; i++) {
g[MAX - 1][i] = base;
g[i][MAX - 1] = base;
char tmp;
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
cin >> tmp;
l[i][x][y] = tmp;
}
}
notCheck.insert(i);
}
for (int i = 0; i < k - 1; i++) {
g[i][i] = 0;
for (int j = i + 1; j < k; j++) {
int count = 0;
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
if (l[i][x][y] != l[j][x][y]) count++;
}
}
count *= w;
g[i][j] = count;
g[j][i] = count;
}
}
int r = 0;
for (int i = 0; i < k; i++) {
q.push(edge(MAX - 1, i));
}
while (!notCheck.empty()) {
edge tmp = q.top();
q.pop();
if (notCheck.count(tmp.n) > 0) {
ans.push_back(tmp);
r += tmp.w;
notCheck.erase(tmp.n);
c[tmp.n] = true;
for (int i = 0; i < k; i++) {
if (!c[i]) q.push(edge(tmp.n, i));
}
} else if (notCheck.count(tmp.p) > 0) {
ans.push_back(tmp);
r += tmp.w;
notCheck.erase(tmp.n);
c[tmp.p] = true;
for (int i = 0; i < k; i++) {
if (!c[i]) q.push(edge(tmp.p, i));
}
}
}
cout << r << endl;
for (edge e : ans) {
if (e.n == MAX - 1) {
cout << e.p + 1 << ' ' << 0 << endl;
} else if (e.p == MAX - 1) {
cout << e.n + 1 << ' ' << 0 << endl;
} else {
cout << e.n + 1 << ' ' << e.p + 1 << endl;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
queue<pair<int, int> > que;
map<pair<int, int>, int> mm;
int x[8] = {1, -1, 0, 0, -1, -1, 1, 1};
int y[8] = {0, 0, 1, -1, 1, -1, 1, -1};
int main() {
int x0, y0, x1, y1, n, i;
while (scanf("%d%d%d%d", &y0, &x0, &y1, &x1) != EOF) {
scanf("%d", &n);
mm.clear();
while (n--) {
int r, a, b;
scanf("%d%d%d", &r, &a, &b);
for (i = a; i <= b; i++) mm[make_pair(i, r)] = -1;
}
mm[make_pair(x0, y0)] = 0;
mm[make_pair(x1, y1)] = -1;
que.push(make_pair(x0, y0));
while (!que.empty()) {
int tx = que.front().first;
int ty = que.front().second;
que.pop();
for (i = 0; i < 8; i++)
if (mm[make_pair(tx + x[i], ty + y[i])] < 0) {
mm[make_pair(tx + x[i], ty + y[i])] = mm[make_pair(tx, ty)] + 1;
que.push(make_pair(tx + x[i], ty + y[i]));
}
}
printf("%d\n", mm[make_pair(x1, y1)]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300002];
int main() {
cin >> n;
putchar('1');
for (int i = 1, p = n + 1, x; i <= n; i++) {
scanf("%d", &x);
a[x] = 1;
for (; p > 1 && a[p - 1]; --p)
;
printf(" %d", p + i - n);
}
return cout << endl, 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double sum = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int j = 0; j < n; j++) {
sum += arr[j];
}
cout << sum / n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int> > less(n, vector<int>(m));
vector<vector<int> > great(n, vector<int>(m));
vector<vector<int> > field(n, vector<int>(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> field[i][j];
for (int i = 0; i < n; ++i) {
vector<int> temp = field[i];
sort(temp.begin(), temp.end());
temp.resize(unique(temp.begin(), temp.end()) - temp.begin());
for (int j = 0; j < m; ++j) {
auto it = lower_bound(temp.begin(), temp.end(), field[i][j]);
less[i][j] = it - temp.begin();
great[i][j] = (int)temp.size() - less[i][j];
}
}
for (int i = 0; i < m; ++i) {
vector<int> temp;
for (int j = 0; j < n; ++j) temp.push_back(field[j][i]);
sort(temp.begin(), temp.end());
temp.resize(unique(temp.begin(), temp.end()) - temp.begin());
for (int j = 0; j < n; ++j) {
auto it = lower_bound(temp.begin(), temp.end(), field[j][i]);
less[j][i] = max(less[j][i], (int)(it - temp.begin()));
great[j][i] = max(great[j][i], (int)(temp.size() - (it - temp.begin())));
}
}
for (int i = 0; i < n; ++i, cout << '\n')
for (int j = 0; j < m; ++j) cout << less[i][j] + great[i][j] << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
pair<unsigned long long, unsigned long long> b[1000000];
int main() {
unsigned long long k1, k2, k3, t1, t2, t3, n, x;
cin >> k1 >> k2 >> k3 >> t1 >> t2 >> t3 >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i].first = a[i];
b[i].second = i;
}
int i;
for (i = 0; i < k1 && i < n; i++) b[i].first = b[i].first + t1;
for (; i < n; i++) {
b[i].first =
(b[i].first > b[i - k1].first ? b[i].first : b[i - k1].first) + t1;
}
sort(b, b + n);
for (i = 0; i < k2 && i < n; i++) b[i].first = b[i].first + t2;
for (; i < n; i++) {
b[i].first =
(b[i].first > b[i - k2].first ? b[i].first : b[i - k2].first) + t2;
}
sort(b, b + n);
for (i = 0; i < k3 && i < n; i++) b[i].first = b[i].first + t3;
for (; i < n; i++) {
b[i].first =
(b[i].first > b[i - k3].first ? b[i].first : b[i - k3].first) + t3;
}
unsigned long long m = b[0].first - a[b[0].second];
for (int i = 1; i < n; i++)
m = (m > b[i].first - a[b[i].second] ? m : b[i].first - a[b[i].second]);
cout << m << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans, m, M;
cin >> n;
ans = n / 7;
ans <<= 1;
m = n % 7 == 6 ? ans + 1 : ans;
if (n % 7 > 1)
M = ans + 2;
else if (n % 7 == 1)
M = ans + 1;
else
M = ans;
cout << m << " " << M << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int sum[500005];
vector<long long int> v;
double fun(long long int i, long long int maxn) {
return ((double)sum[i] + (double)maxn) / (double)(i + 2);
}
double tern(long long int low, long long int high, long long int maxn) {
while (low < high) {
long long int f = (2 * low + high) / 3;
long long int g = (2 * high + low + 2) / 3;
if (fun(f, maxn) < fun(g, maxn))
high = g - 1;
else if (fun(f, maxn) > fun(g, maxn))
low = f + 1;
else if (fun(f, maxn) == fun(g, maxn)) {
low = f + 1;
high = g - 1;
}
}
if (low >= high) return maxn - fun(low, maxn);
}
int main() {
int t;
cin >> t;
while (t--) {
long long int ch, x;
double ans;
cin >> ch;
if (ch == 1) {
cin >> x;
v.push_back(x);
if (v.size() == 1)
sum[0] = x;
else
sum[v.size() - 1] = sum[v.size() - 2] + x;
}
if (ch == 2) {
if (v.size() == 1)
ans = 0;
else if (v.size() == 2)
ans = ((double)v[1] - (double)(v[1] + v[0]) / (double)2);
else {
ans = tern(0, v.size() - 2, v[v.size() - 1]);
}
cout << setprecision(15) << ans << "\n";
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
cin >> n >> x;
int distressed = 0;
while (n--) {
char c;
int i;
cin >> c >> i;
if (c == '-') {
if (i > x)
distressed++;
else
x -= i;
} else
x += i;
}
cout << x << " " << distressed;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int64_t> fact_table(int n, int64_t m) {
vector<int64_t> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % m;
return fact;
}
uint64_t fast_exp(uint64_t a, uint64_t b, uint64_t m) {
uint64_t ans = 1;
while (b >= 1) {
if (b % 2) ans = ans * a % m;
b /= 2;
a = a * a % m;
}
return ans;
}
int64_t inv(int64_t x, int64_t m) { return fast_exp(x, m - 2, m); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
const int64_t MOD = 1e9 + 7;
vector<int64_t> fact = fact_table(2 * 1e5 + 1, MOD);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (fact[n * 2] * inv(2, MOD) % MOD) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> adj[300005];
set<pair<int, int> > val, tr_val;
bool vis[300005];
int ent[300005], low[300005], t = 0;
int bcc_num = 0;
vector<int> art;
vector<pair<int, int> > bri;
vector<int> bcc[300005];
void dfs(int n, int p = -1) {
vis[n] = true;
ent[n] = low[n] = t++;
int a, b;
for (int c : adj[n]) {
if (c == p) continue;
if (!vis[c]) {
dfs(c, n);
low[n] = min(low[n], low[c]);
if (low[c] >= ent[n]) {
if (low[c] > ent[n]) bri.push_back({n, c});
bcc_num++;
}
} else if (ent[c] < low[n]) {
low[n] = min(low[n], ent[c]);
}
}
}
void tarjan_bcc() {
fill(vis, vis + 300005, false);
fill(ent, ent + 300005, -1);
fill(low, low + 300005, -1);
for (int i = 1; i <= N; i++)
if (!vis[i]) dfs(i);
}
int A, B, AN, BN;
set<pair<int, int> > b_set;
int cmp = 0, cmp_lbl[300005], has_one[300005];
vector<int> tr_adj[300005];
void dfs2(int n) {
if (n == A) AN = cmp;
if (n == B) BN = cmp;
vis[n] = true;
cmp_lbl[n] = cmp;
for (int c : adj[n])
if (b_set.find({n, c}) == b_set.end() &&
b_set.find({c, n}) == b_set.end()) {
if (!vis[c]) dfs2(c);
if (val.count({n, c}) > 0) has_one[cmp] = true;
}
}
bool dfs3(int n, bool found, int p = -1) {
vis[n] = true;
bool any = false;
found |= has_one[n];
if (n == BN && found) {
return true;
}
for (int c : tr_adj[n])
if (c != p)
any |= dfs3(c, found | (tr_val.find({n, c}) != tr_val.end()), n);
return any;
}
int main() {
scanf("%d %d", &N, &M);
int a, b, c;
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &a, &b, &c);
if (c) {
val.insert({a, b});
val.insert({b, a});
}
adj[a].push_back(b);
adj[b].push_back(a);
}
tarjan_bcc();
fill(vis, vis + 300005, false);
cin >> A >> B;
b_set = set<pair<int, int> >(bri.begin(), bri.end());
for (int i = 1; i <= N; i++)
if (!vis[i]) {
dfs2(i);
cmp++;
}
for (pair<int, int> e : bri) {
int n1 = cmp_lbl[e.first], n2 = cmp_lbl[e.second];
if (val.count(e) > 0) {
tr_val.insert({n1, n2});
tr_val.insert({n2, n1});
}
tr_adj[n1].push_back(n2);
tr_adj[n2].push_back(n1);
}
fill(vis, vis + 300005, false);
if (dfs3(AN, false))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
if (b > a) {
swap(a, b);
}
unsigned long long int n = a / b;
if (n * b != a) {
cout << "-1" << endl;
continue;
}
unsigned long long int cnt = 0;
while (n % 8 == 0) {
if (n == 0) break;
n = n / 8;
++cnt;
}
while (n % 4 == 0) {
if (n == 0) break;
n = n / 4;
++cnt;
}
while (n % 2 == 0) {
if (n == 0) break;
n = n / 2;
++cnt;
}
if (n == 0 || n == 1) {
cout << cnt << endl;
} else {
cout << "-1" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dX[] = {0, 0, 1, -1};
int dY[] = {1, -1, 0, 0};
string alpha = "abcdefghijklmnopqrstuvwxyz";
int MOD = 1000000007;
const int N = 200100;
string s;
int m, arr[20], n;
long long dp[(1 << 18) + 5][100];
long long solve(int mask, int rem, bool f) {
if (mask == (1 << n) - 1) return (rem == 0);
long long& ret = dp[mask][rem];
if (~ret) return ret;
ret = 0;
bool taken[10] = {0};
for (int i = 0; i < n; ++i) {
if (arr[i] == 0 && !f) continue;
if (taken[arr[i]]) continue;
if ((1 << i) & mask) continue;
ret += solve(mask | (1 << i), (rem * 10 + arr[i]) % m, f || (arr[i] > 0));
taken[arr[i]] = 1;
}
return ret;
}
int main() {
cin >> s;
scanf("%d", &m);
n = (s.size());
for (int i = 0; i < n; ++i) arr[i] = s[i] - '0';
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, 0) << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (b & 1) {
for (int i = 1; i <= a; i++) {
printf("0");
}
for (int i = 1; i <= b; i++) {
if (i & 1)
printf("0");
else
printf("1");
}
printf("1");
for (int i = 1; i <= c; i++) {
printf("1");
}
} else if (b == 0) {
if (a > 0)
for (int i = 1; i <= a + 1; i++) {
printf("0");
}
if (c > 0)
for (int i = 1; i <= c + 1; i++) {
printf("1");
}
} else {
for (int i = 1; i <= a; i++) {
printf("0");
}
for (int i = 1; i <= b; i++) {
if (i & 1)
printf("0");
else {
printf("1");
while (c > 0) {
printf("1");
c--;
}
}
}
printf("0");
}
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 5;
void solve() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int z = 0, o = 0;
for (long long int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
if (s[i] == '1')
o++;
else
z++;
}
}
cout << max(z, o) << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, r;
cin >> n >> s;
r = s / n;
if (s % n != 0) r++;
cout << r << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
namespace convex_hull {
const double eps = 1e-8;
const double PI = acos(-1.0);
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
struct Point {
double x, y;
Point(double _x = 0.0, double _y = 0.0) : x(_x), y(_y) {}
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
double operator^(const Point &b) const { return x * b.y - y * b.x; }
double operator*(const Point &b) const { return x * b.x + y * b.y; }
};
Point p[MAXN];
int Stack[MAXN], top;
double dist(Point a, Point b) { return sqrt((a - b) * (a - b)); }
bool _cmp(Point p1, Point p2) {
double tmp = (p1 - p[0]) ^ (p2 - p[0]);
if (sgn(tmp) > 0)
return true;
else if (sgn(tmp) == 0 && sgn(dist(p1, p[0]) - dist(p2, p[0])) <= 0)
return true;
else
return false;
}
void Graham(int n) {
Point p0;
int k = 0;
p0 = p[0];
for (int i = 1; i < n; i++) {
if ((p0.y > p[i].y) || (sgn(p0.y - p[i].y) == 0 && p0.x > p[i].x)) {
p0 = p[i];
k = i;
}
}
swap(p[k], p[0]);
sort(p + 1, p + n, _cmp);
if (n == 1) {
top = 1;
Stack[0] = 0;
return;
}
if (n == 2) {
top = 2;
Stack[0] = 0;
Stack[1] = 1;
return;
}
Stack[0] = 0;
Stack[1] = 1;
top = 2;
for (int i = 2; i < n; i++) {
while (top > 1 && sgn((p[Stack[top - 1]] - p[Stack[top - 2]]) ^
(p[i] - p[Stack[top - 2]])) <= 0)
top--;
Stack[top++] = i;
}
}
} // namespace convex_hull
using namespace convex_hull;
pair<int, int> sv[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &sv[i].first, &sv[i].second);
for (int i = 0; i < n; i++) {
p[i].x = sv[i].first;
p[i].y = sv[i].second - 1LL * sv[i].first * sv[i].first;
}
Graham(n);
int ans = 0;
for (int i = 0; i < top; i++) {
int j = (i + 1) % top;
int u = Stack[i], v = Stack[j];
if (p[v].x < p[u].x) ans++;
}
printf("%d\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline void inp(int &n) {
n = 0;
int ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
long long gcd(long long A, long long B) {
return A > B ? gcd(B, A) : A ? gcd(B % A, A) : B;
}
long long lcm(long long A, long long B) { return A / gcd(A, B) * B; }
long long pow(long long A, long long B, long long P) {
if (!B) return 1 % P;
long long h = pow(A, B / 2, P);
h *= h;
h %= P;
if (B % 2) h *= A;
return h % P;
}
vector<int> z_function(string s) {
int n = (int)s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int tst;
void get_ready() { tst = 1; }
string ild(int o) {
string ret;
for (int j = 0; j < o; j++) ret += "9";
return ret;
}
string bill(int n, int x) {
string s;
for (int i = 0; i < n; i++) s += char(min(9, x) + '0'), x -= min(x, 9);
return s;
}
string sub(string s, int l) {
string ret;
for (int i = l; i < s.size(); i++) ret += s[i];
return ret;
}
string s[500], q;
int XX, is;
void build(int l, int x) {
if (x < 0) {
s[XX] += '#';
return;
}
if (l >= q.size()) return;
if (is) {
for (int i = 0; i <= 9; i++)
if (i + 9 * (q.size() - 1 - l) >= x) {
s[XX] += char(i + '0');
build(l + 1, x - i);
return;
}
}
int st = q[l] + 1 - '0';
if (q[l] - '0' + 9 * (q.size() - 1 - l) >= x) {
if (bill(q.size() - 1 - l, x - q[l] + '0') > sub(q, l + 1)) {
s[XX] += q[l];
build(l + 1, x - q[l] + '0');
return;
}
}
for (int i = st; i <= 9; i++)
if (i + 9 * (q.size() - 1 - l) >= x) {
s[XX] += char(i + '0');
is = 1;
build(l + 1, x - i);
return;
}
s[XX] += '#';
}
int x, i, n, j;
int X[500];
bool READ() {
cin >> n;
s[0] = "0";
for (i = 1; i <= n; i++) {
cin >> X[i];
x = X[i];
while (x > 0) {
s[i] = char(min(9, x) + '0') + s[i];
x -= min(x, 9);
}
if ((s[i].size() < s[i - 1].size()) ||
(s[i].size() == s[i - 1].size() && s[i] <= s[i - 1])) {
if (9 * s[i - 1].size() - 1 < X[i] || ild(s[i - 1].size()) == s[i - 1]) {
s[i] = "1";
for (j = 0; j < s[i - 1].size(); j++) s[i] += "0";
x = X[i] - 1;
int l = s[i].size() - 1;
while (x) {
s[i][l] = char(min(9, x) + '0');
l--;
x -= min(9, x);
}
continue;
}
q = s[i - 1];
XX = i;
s[i] = "";
is = 0;
build(0, X[i]);
for (j = 0; j < s[i].size(); j++)
if (s[i][j] == '#') break;
if (j != s[i].size()) {
s[i] = bill(s[i - 1].size(), X[i] - 1);
reverse(s[i].begin(), s[i].end());
s[i] = "1" + s[i];
}
}
}
for (i = 1; i <= n; i++) cout << s[i] << endl;
return 1;
}
bool SOLVE() { return 1; }
bool PRINT() { return 1; }
bool CLEAR() { return 1; }
int main() {
get_ready();
while (tst--) {
if (!READ()) {
return 0;
}
if (!SOLVE()) {
return 0;
}
if (!PRINT()) {
return 0;
}
if (!CLEAR()) {
return 0;
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
string s, q = "", p = "";
cin >> s;
int hr = (s[0] - '0') * 10 + (s[1] - '0');
int min = (s[3] - '0') * 10 + (s[4] - '0');
if (!(min >= 0 && min <= 59)) min = 2 * 10 + (s[4] - '0');
if (min >= 0 && min <= 9) {
q = to_string(min);
q = "0" + q;
} else
q = to_string(min);
if (hr >= 0 && hr <= 9 && t == 24) {
p = to_string(hr);
p = "0" + p;
cout << p << ":" << q << endl;
return 0;
}
if (t == 24) {
if (hr >= 10 && hr <= 23)
cout << hr << ":" << q << endl;
else {
hr = 10 + (s[1] - '0');
cout << hr << ":" << q << endl;
}
return 0;
} else {
if (hr == 0)
cout << "10"
<< ":" << q << endl;
else if (hr >= 1 && hr <= 9) {
cout << "0" << hr << ":" << q << endl;
} else if (hr >= 10 && hr <= 12)
cout << hr << ":" << q << endl;
else {
if (s[1] == '0') {
cout << "1" << s[1] << ":" << q << endl;
} else
cout << "0" << s[1] << ":" << q << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, s, t, sol;
int p[100005], used_col[300], used_sum[300];
void back(int niv) {
if (niv == n + 1) {
++sol;
return;
}
for (int i = 1; i <= n; ++i) {
if (!used_col[i]) {
int sum = (niv - 1 + i - 1) % n + 1;
if (!used_sum[sum]) {
used_col[i] = 1;
used_sum[sum] = 1;
back(niv + 1);
used_col[i] = 0;
used_sum[sum] = 0;
}
}
}
}
int main() {
scanf("%d", &n);
if (n == 15) sol = 150347555;
if (n == 13) sol = 695720788;
if (n == 11) sol = 890786230;
if (n == 9) sol = 734832000;
if (n == 7) sol = 670320;
if (n == 5) sol = 1800;
if (n == 3) sol = 18;
if (n == 1) sol = 1;
printf("%d\n", sol);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum1 = 0;
int sum2 = 0;
for (int i = 0; i < n; i++) {
int ai;
cin >> ai;
sum1 += ai;
}
for (int i = 0; i < n; i++) {
int bi;
cin >> bi;
sum2 += bi;
}
cout << (sum2 <= sum1 ? "Yes" : "No") << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx4[4] = {0, -1, 0, 1};
int dy4[4] = {1, 0, -1, 0};
int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int Power(int base, int exp) {
int ans = 1;
while (exp > 0) {
if (exp & 1) ans = (1LL * ans * base) % 1000000007;
exp = exp >> 1;
base = (1LL * base * base) % 1000000007;
}
return ans;
}
vector<int> prime;
void sieve() {
vector<bool> mark(1000000, 1);
for (int i = 2; i < 1000000; i += 2) mark[i] = 0;
mark[2] = 1;
for (int p = 3; 1LL * p * p < 1000000; p++)
if (mark[p])
for (int j = p * p; j < 1000000; j += p) mark[j] = 0;
for (int p = 2; p < 1000000; p += 1)
if (mark[p]) prime.push_back(p);
}
void input() {
sieve();
int n, m;
cin >> n >> m;
int a[n], b[m];
set<int> is_bad;
for (int i = 0; i < n; i += 1) cin >> a[i];
for (int i = 0; i < m; i += 1) {
cin >> b[i];
is_bad.insert(b[i]);
}
vector<vector<int> > p(n);
vector<vector<int> > x(n);
for (int i = 0; i < n; i += 1) {
int y = a[i];
for (int j = 0; y > 1 && 1LL * prime[j] * prime[j] <= a[i]; j++) {
if (y % prime[j] == 0) {
p[i].push_back(prime[j]);
int cnt = 0;
while (y % prime[j] == 0) cnt++, y = y / prime[j];
x[i].push_back(cnt);
}
}
if (y > 1) {
p[i].push_back(y);
x[i].push_back(1);
}
}
vector<bool> flag(p[0].size(), 0);
for (int i = 0; i < (int)p[0].size(); i += 1)
if (is_bad.find(p[0][i]) != is_bad.end()) flag[i] = 1;
int i = n - 1;
while (i >= 0) {
vector<int> g, pg;
int alive = 0;
for (int k = 0; k < (int)p[0].size(); k += 1) {
g.push_back(p[0][k]);
pg.push_back(x[0][k]);
if (flag[k] && pg[k]) alive++;
}
if (!alive) break;
for (int j = 0; j < i + 1; j += 1) {
for (int k = 0; k < (int)g.size(); k += 1) {
if (pg[k] == 0) continue;
int idx = (lower_bound(p[j].begin(), p[j].end(), g[k]) - p[j].begin());
if (idx < p[j].size() && p[j][idx] == g[k])
pg[k] = min(pg[k], x[j][idx]);
else
pg[k] = 0;
if (flag[k] && pg[k] == 0) alive--;
if (alive == 0) break;
}
if (alive == 0) break;
}
if (alive == 0) {
i--;
continue;
}
int tmp = 0;
for (int k = 0; k < (int)p[0].size(); k += 1) {
if (flag[k])
tmp += pg[k] * (i + 1);
else
tmp -= pg[k] * (i + 1);
}
if (tmp < 0) {
i--;
continue;
}
for (int j = 0; j < i + 1; j += 1) {
for (int k = 0; k < (int)g.size(); k += 1) {
if (pg[k] == 0) continue;
int idx = (lower_bound(p[j].begin(), p[j].end(), g[k]) - p[j].begin());
if (idx < p[j].size() && p[j][idx] == g[k]) x[j][idx] -= pg[k];
}
}
i--;
}
int ans = 0;
for (int i = 0; i < n; i += 1)
for (int j = 0; j < (int)p[i].size(); j += 1) {
if (is_bad.find(p[i][j]) != is_bad.end())
ans -= x[i][j];
else
ans += x[i][j];
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int q = 1;
while (q--) input();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x_end, stop, max_l, k;
int l, ans = 0, end, dist, f = 2;
scanf("%d %d %d %d", &x_end, &max_l, &stop, &k);
l = max_l;
for (int i = 1; i <= k; i++) {
if (i & 1)
end = 0;
else
end = x_end;
dist = abs(end - stop);
l -= dist;
if (l < 0) {
ans = -1;
break;
}
if (k == i) f = 1;
if (l < f * (x_end - dist)) {
ans++;
l = max_l;
if (l < f * (x_end - dist)) {
ans = -1;
break;
}
}
l -= x_end - dist;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const long long maxn = 5e5 + 5;
const double eps = 1e-7;
const double PI = acos(-1);
int sum[maxn], cot[maxn];
int main() {
int m, k, n, s;
cin >> m >> k >> n >> s;
vector<int> res(m + 1);
for (int i = 1; i <= m; i++) {
cin >> res[i];
}
for (int i = 0; i < s; i++) {
int x;
cin >> x;
cot[x]++;
}
int cnt = 0;
for (int i = 1; i <= 5e5; i++) {
if (cot[i] == 0) cnt++;
}
int r = m;
for (int i = m; i >= 1; i--) {
sum[res[i]]++;
if (sum[res[i]] == cot[res[i]]) cnt++;
while (r - i + 1 >= k && cnt >= 5e5) {
if (sum[res[r]] == cot[res[r]]) cnt--;
sum[res[r]]--;
r--;
}
if (r < m) {
r++;
sum[res[r]]++;
if (sum[res[r]] == cot[res[r]]) cnt++;
}
if (cnt == 5e5 && r - i + 1 >= k && (i - 1) / k + 1 + (m - r) / k >= n) {
cout << r - i + 1 - k + (i - 1) % k << endl;
for (int j = 1; j <= (i - 1) % k; j++) {
cout << j << " ";
}
int tot = (r - i + 1 - k);
for (int j = i; j <= r; j++) {
if (sum[res[j]] > cot[res[j]] && tot > 0) {
cout << j << " ";
tot--;
}
sum[res[j]]--;
}
return 0;
}
}
cout << -1;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p, a[150010];
struct node {
vector<pair<int, int> > Num;
node operator+(const node &P) const {
node ans = P;
for (int i = 0; i < Num.size(); i++) {
bool pd = 0;
for (int j = 0; j < ans.Num.size(); j++) {
if (Num[i].first == ans.Num[j].first) {
ans.Num[j].second += Num[i].second;
pd = 1;
break;
}
}
if (pd) continue;
if (ans.Num.size() < p) {
ans.Num.push_back(Num[i]);
continue;
}
int minx = 0;
for (int j = 0; j < ans.Num.size(); j++) {
if (ans.Num[j].second < ans.Num[minx].second) {
minx = j;
}
}
if (ans.Num[minx].second < Num[i].second) {
int x = ans.Num[minx].second;
ans.Num[minx] = Num[i];
for (int j = 0; j < ans.Num.size(); j++) {
ans.Num[j].second -= x;
}
} else {
for (int j = 0; j < ans.Num.size(); j++) {
ans.Num[j].second -= Num[i].second;
}
}
}
return ans;
}
} nd[600010];
int tag[600010];
void add(int k, int l, int r, int x) {
tag[k] = x;
nd[k].Num.resize(1);
nd[k].Num[0] = make_pair(x, r - l + 1);
}
void push_down(int k, int l, int r) {
if (!tag[k]) return;
int mid = (l + r) >> 1;
add(k << 1, l, mid, tag[k]);
add(k << 1 | 1, mid + 1, r, tag[k]);
tag[k] = 0;
}
void build(int k, int l, int r) {
if (l == r) {
add(k, l, r, a[l]);
return;
}
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
nd[k] = nd[k << 1] + nd[k << 1 | 1];
}
void modify(int k, int l, int r, int x, int y, int ad) {
if (x <= l && r <= y) {
add(k, l, r, ad);
return;
}
int mid = (l + r) >> 1;
push_down(k, l, r);
if (x <= mid) modify(k << 1, l, mid, x, y, ad);
if (mid < y) modify(k << 1 | 1, mid + 1, r, x, y, ad);
nd[k] = nd[k << 1] + nd[k << 1 | 1];
}
node query(int k, int l, int r, int x, int y) {
if (x <= l && r <= y) return nd[k];
int mid = (l + r) >> 1;
push_down(k, l, r);
if (x <= mid && mid < y)
return query(k << 1, l, mid, x, y) + query(k << 1 | 1, mid + 1, r, x, y);
if (x <= mid)
return query(k << 1, l, mid, x, y);
else
return query(k << 1 | 1, mid + 1, r, x, y);
}
int main() {
scanf("%d %d %d", &n, &m, &p);
p = 100 / p;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
for (int i = 1, opt, x, y, z; i <= m; i++) {
scanf("%d %d %d", &opt, &x, &y);
if (opt == 1) {
scanf("%d", &z);
modify(1, 1, n, x, y, z);
} else {
node ans = query(1, 1, n, x, y);
printf("%d ", ans.Num.size());
for (int i = 0; i < ans.Num.size(); i++) {
printf("%d ", ans.Num[i].first);
}
printf("\n");
}
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 15 + 1e5;
const int INF = 1e9;
pair<int, string> p[N];
long long res[12];
long long si[12];
bool emp[12];
long long POW(long long a, long long b) {
if (b == 0) return 1;
long long x = POW(a, b / 2) % mod;
x = (x * x) % mod;
if (b & 1) return (x * a) % mod;
return x;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long ans = 0, q;
string s;
cin >> s >> q;
for (int i = 0; i < q; ++i) {
string x;
cin >> p[i].first >> x;
x.erase(x.begin());
x.erase(x.begin());
p[i].second = x;
}
for (int i = 0; i < 10; ++i) {
res[i] = i;
si[i] = 10;
emp[i] = 0;
}
for (int i = q - 1; i >= 0; --i) {
long long xans = 0, po = 1, qs = 1;
int m = (p[i].second).size();
if (m)
for (int j = m - 1; j >= 0; --j) {
int t = (p[i].second)[j] - '0';
if (emp[t]) continue;
xans = (xans + (po * res[t]) % mod) % mod;
po = (po * si[t]) % mod;
qs = (qs * si[t]) % mod;
}
else {
res[p[i].first] = 0;
si[p[i].first] = 1;
emp[p[i].first] = 1;
continue;
}
if (qs == 1) {
res[p[i].first] = 0;
emp[p[i].first] = 1;
si[p[i].first] = 1;
continue;
}
res[p[i].first] = xans;
si[p[i].first] = qs;
emp[p[i].first] = 0;
}
int n = s.size();
long long po = 1;
for (int i = n - 1; i >= 0; --i) {
int t = s[i] - '0';
if (emp[t]) continue;
ans = (ans + (po * res[t]) % mod) % mod;
po = (po * si[t]) % mod;
}
cout << ans;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0 || b == 0) return 0;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
int main() {
int n, m, z;
cin >> n >> m >> z;
int lcm = n * m / gcd(n, m);
cout << z / lcm;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, n;
cin >> s >> n;
vector<pair<int, int> > d;
for (int i = 0; i < n; i++) {
int x;
int y;
cin >> x >> y;
d.push_back(make_pair(x, y));
}
sort(d.begin(), d.end());
int win = 1;
for (int i = 0; i < n; i++) {
if (s > d[i].first)
s += d[i].second;
else {
win = 0;
break;
}
}
if (win)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int mod = 998244353;
const int MXN = (int)1e6 + 7;
pair<int, int> a[MXN], b[MXN];
pair<int, int> st[MXN];
int ck[MXN];
map<pair<int, int>, int> mp;
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i < n + 1; ++i) scanf("%d %d", &a[i].first, &a[i].second);
for (int i = 1; i < n + 1; ++i) scanf("%d %d", &b[i].first, &b[i].second);
for (int i = 1; i < n + 1; ++i) mp[b[i]] = 1;
int cntp = 0;
for (int i = 1; i < n + 1; ++i)
for (int j = 1; j < n + 1; ++j) {
int x = a[i].first + b[j].first;
int y = a[i].second + b[j].second;
st[++cntp] = make_pair(x, y);
}
sort(st + 1, st + cntp + 1);
for (int i = 1; i < cntp + 1; ++i) {
int r = i;
while (r + 1 <= cntp && st[r + 1] == st[i]) r++;
if (r - i + 1 < n) {
i = r;
continue;
}
bool gg = 0;
for (int j = 1; j < n + 1; ++j) {
int x = st[i].first - a[j].first;
int y = st[i].second - a[j].second;
if (mp.find(make_pair(x, y)) == mp.end()) {
gg = 1;
break;
}
}
if (!gg) {
printf("%d %d\n", st[i].first, st[i].second);
return 0;
}
i = r;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const int mod = (int)1e9 + 7;
const int N = (int)2e5;
const int K = 18;
vector<pair<int, int> > g[N];
int up[N], down[N], anc[K][N];
int n, m, in[N], out[N], T;
long long ans;
long long binpow(long long x, long long pw) {
long long res = 1;
while (pw) {
if (pw & 1) res = res * x % mod;
x = x * x % mod;
pw >>= 1;
}
return res;
}
void dfs(int v, int pr = 0, int t = 0) {
for (pair<int, int> u : g[v])
if (u.first != pr) dfs(u.first, v, u.second);
up[pr] += up[v];
down[pr] += down[v];
if (t == 1 && up[v] > 0) ans += binpow(2, up[v]) - 1;
if (t == -1 && down[v] > 0) ans += binpow(2, down[v]) - 1;
ans %= mod;
}
void precalc(int v, int pr = 0) {
anc[0][v] = pr;
for (int i = 1; i < K; i++) anc[i][v] = anc[i - 1][anc[i - 1][v]];
in[v] = ++T;
for (pair<int, int> u : g[v])
if (u.first != pr) precalc(u.first, v);
out[v] = T;
}
bool isAnc(int a, int b) { return in[a] <= in[b] && out[a] >= out[b]; }
int get_lca(int a, int b) {
if (isAnc(a, b)) return a;
for (int i = K - 1; i >= 0; i--)
if (!isAnc(anc[i][a], b)) a = anc[i][a];
return anc[0][a];
}
int main() {
out[0] = inf;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, x;
scanf("%d %d %d", &a, &b, &x);
g[a].push_back(make_pair(b, x));
g[b].push_back(make_pair(a, -x));
}
precalc(1);
int q, a = 1, b, c;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &b);
int c = get_lca(a, b);
up[c]--;
up[a]++;
down[c]--;
down[b]++;
a = b;
}
dfs(1);
cout << ans << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
const int inf = 1000005;
using namespace std;
int dx[] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[] = {1, 0, -1, 1, -1, -1, 0, 1};
vector<int> arr[10];
void compute() {
int temp[] = {2, 3, 5, 7};
for (int i = 1; i < 10; ++i) {
int num = i;
for (int j = 0; j < 4; ++j) {
while (num % temp[j] == 0) {
arr[i].push_back(temp[j]);
num /= temp[j];
}
}
}
}
int cnt[10];
void add(int n) {
for (int i = 2; i <= n; ++i) {
for (int x : arr[i]) cnt[x]++;
}
}
void rmv(int n) {
for (int i = 2; i <= n; ++i) {
for (int x : arr[i]) cnt[x]--;
}
}
string func(string &str, int n) {
string ans;
for (char c : str) {
if (c == '0' || c == '1') continue;
add(c - '0');
}
int i = 9;
while (i >= 2) {
if (!cnt[i]) {
i--;
continue;
}
ans.push_back(i + '0');
rmv(i);
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
compute();
int n;
cin >> n;
string str;
cin >> str;
cout << func(str, n) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, t1, t2, t3, t4, x1, y1, x2, y2, a, b, c;
double buf1, buf2, buf3, buf4, buf5, ans, tempans;
scanf("%lld %lld %lld %lld %lld %lld %lld", &a, &b, &c, &x1, &y1, &x2, &y2);
ans = abs(x1 - x2) + abs(y1 - y2);
if (a == 0) {
buf1 = -c / (1.0 * a);
tempans = abs(y1 - y2) + abs(x1 - buf1) + abs(x2 - buf1);
ans = min(ans, tempans);
} else if (b == 0) {
buf1 = -c / (1.0 * b);
tempans = abs(x1 - x2) + abs(y1 - buf1) + abs(y2 - buf1);
ans = min(ans, tempans);
} else {
buf1 = x1;
buf2 = (-a * x1) - c;
buf2 /= (1.0 * b);
tempans = abs(y1 - buf2);
buf3 = x2;
buf4 = (-a * x2) - c;
buf4 /= (1.0 * b);
tempans += abs(y2 - buf4);
buf5 = (buf1 - buf3) * (buf1 - buf3) + (buf2 - buf4) * (buf2 - buf4);
tempans += sqrtl(buf5);
ans = min(ans, tempans);
buf1 = x1;
buf2 = (-a * x1) - c;
buf2 /= (1.0 * b);
tempans = abs(y1 - buf2);
buf4 = y2;
buf3 = (-b * y2) - c;
buf3 /= (1.0 * a);
tempans += abs(x2 - buf3);
buf5 = (buf1 - buf3) * (buf1 - buf3) + (buf2 - buf4) * (buf2 - buf4);
tempans += sqrtl(buf5);
ans = min(ans, tempans);
buf2 = y1;
buf1 = (-b * y1) - c;
buf1 /= (1.0 * a);
tempans = abs(x1 - buf1);
buf3 = x2;
buf4 = (-a * x2) - c;
buf4 /= (1.0 * b);
tempans += abs(y2 - buf4);
buf5 = (buf1 - buf3) * (buf1 - buf3) + (buf2 - buf4) * (buf2 - buf4);
tempans += sqrtl(buf5);
ans = min(ans, tempans);
buf2 = y1;
buf1 = (-b * y1) - c;
buf1 /= (1.0 * a);
tempans = abs(x1 - buf1);
buf4 = y2;
buf3 = (-b * y2) - c;
buf3 /= (1.0 * a);
tempans += abs(x2 - buf3);
buf5 = (buf1 - buf3) * (buf1 - buf3) + (buf2 - buf4) * (buf2 - buf4);
tempans += sqrtl(buf5);
ans = min(ans, tempans);
}
printf("%.15lf\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 40;
int n, k;
vector<int> num;
void input() {
cin >> n >> k;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
num.push_back(a);
}
}
void output() {
sort(num.begin(), num.end());
if (k <= n)
cout << num[n - k] << " " << num[n - k] << endl;
else
cout << "-1" << endl;
}
int main() {
input();
output();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, X = 15;
int n, m, p, x;
long long f[N][X][3], g[N][X][3], ans = 0;
vector<int> e[N];
void dfs(int u, int fa) {
f[u][0][0] = p - 1;
f[u][1][1] = 1;
f[u][0][2] = m - p;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == fa) continue;
dfs(v, u);
memset(g[u], 0, sizeof(g[u]));
for (int i = 0; i <= x; i++)
for (int j = 0; i + j <= x; j++)
for (int k = 0; k < 3; k++) {
if (k == 0)
g[u][i + j][k] =
(f[u][i][k] * (f[v][j][0] + f[v][j][1] + f[v][j][2]) +
g[u][i + j][k]) %
1000000007;
if (k == 1)
g[u][i + j][k] =
(f[u][i][k] * f[v][j][0] + g[u][i + j][k]) % 1000000007;
if (k == 2)
g[u][i + j][k] =
(f[u][i][k] * (f[v][j][0] + f[v][j][2]) + g[u][i + j][k]) %
1000000007;
}
memcpy(f[u], g[u], sizeof(f[u]));
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
cin >> p >> x;
dfs(1, 0);
for (int i = 0; i <= x; i++)
for (int j = 0; j < 3; j++) ans = (f[1][i][j] + ans) % 1000000007;
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
int n, k;
vector<int> g[200100];
vector<pair<int, int> > es;
int depth[200100];
long long chnum[200100];
long long dp[200100][5];
long long ans = 0ll;
void dfs(int v, int p, int d) {
depth[v] = d;
chnum[v] = 1ll;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) continue;
dfs(g[v][i], v, d + 1);
chnum[v] += chnum[g[v][i]];
}
}
void rec(int v, int p) {
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) continue;
rec(g[v][i], v);
dp[g[v][i]][0]++;
for (int j = 0; j < k; j++) {
for (int l = 0; l < k; l++) {
ans += (dp[v][j] * dp[g[v][i]][l]) *
(long long)((k * 2 - (j + l + 1)) % k);
}
}
for (int j = 0; j < k; j++) {
dp[v][(j + 1) % k] += dp[g[v][i]][j];
}
}
for (int i = 1; i < k; i++) ans += dp[v][i] * (long long)(k - i);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
es.push_back(pair<int, int>(a, b));
}
dfs(0, -1, 0);
for (int i = 0; i < es.size(); i++) {
int u = es[i].first, v = es[i].second;
if (depth[u] > depth[v]) swap(u, v);
ans += chnum[v] * (((long long)n) - chnum[v]);
}
rec(0, -1);
assert(ans % (long long)k == 0ll);
cout << ans / (long long)k << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int main() {
long long n, k;
while (scanf("%lld%lld", &n, &k) > 0) {
int a, b;
scanf("%d%d", &a, &b);
long long x = (1ll << 60), y = -(1ll << 60);
for (int i = 0, s = k - a; i < 2; i++, s += 2 * a) {
for (int j = 0, s1 = k - b; j < 2; j++, s1 += 2 * b) {
long long start_l = (s1 - s + n * k) % (n * k);
if (s1 == s) {
start_l = n * k;
}
long long l = start_l;
while (true) {
long long stops = (n * k) / gcd(n * k, l);
x = min(x, stops);
y = max(y, stops);
l += k;
if (l % (n * k) == start_l % (n * k)) break;
}
}
}
printf("%lld %lld\n", x, y);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
queue<int> q[N];
int a[N], b[N], c[N], vis[N];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
c[a[i]]++;
c[b[i]]++;
q[a[i]].push(b[i]);
q[b[i]].push(a[i]);
}
int u = 0, v = 1;
for (int i = 1; i <= n; i++) {
if (c[i] > u) {
u = c[i];
v = i;
}
}
for (int i = 1; i <= m; i++) {
if (a[i] == v || b[i] == v) {
cout << a[i] << " " << b[i] << endl;
vis[a[i]] = 1;
vis[b[i]] = 1;
}
}
while (!q[v].empty()) {
int t = q[v].front();
q[v].pop();
while (!q[t].empty()) {
if (!vis[q[t].empty()]) {
if (!vis[q[t].front()]) {
cout << t << " " << q[t].front() << endl;
vis[q[t].front()] = 1;
q[v].push(q[t].front());
}
q[t].pop();
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long ans;
int digit(long long x) {
long long ret = 0;
while (x) {
ret += x % 10;
x /= 10;
}
return ret;
}
int main() {
scanf("%I64d", &n);
ans = -1;
for (int i = 1; i <= 81; ++i) {
long long d = i * i + 4 * n;
long long a = sqrt(d);
if (a * a != d) continue;
long long x = a - i;
if (x <= 0 || x & 1) continue;
x /= 2;
if (digit(x) == i && (ans == -1 || x < ans)) ans = x;
}
printf("%I64d", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000005;
long long INFF = 1000000000000000005LL;
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
double pi = 3.1415926536;
int MOD = 1e9 + 7;
long long power(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x;
x = (x * x);
n /= 2;
}
return res;
}
const int N = 2e5 + 10;
int n;
long long a[N], b[N];
long long ans;
vector<vector<int>> G;
vector<int> l1, l2;
int mark[N];
void dfs(int v) {
mark[v] = 1;
for (auto u : G[v]) {
if (!mark[u]) {
dfs(u);
}
}
ans += a[v];
if (b[v] != -1 && a[v] > 0) {
a[b[v]] += a[v];
}
if (a[v] > 0)
l1.push_back(v);
else
l2.push_back(v);
}
void topsort() {
ans = 0;
for (int i = 1; i <= n; i++) {
if (!mark[i]) dfs(i);
}
cout << ans << '\n';
for (auto l : l1) cout << l << ' ';
reverse(l2.begin(), l2.end());
for (auto l : l2) cout << l << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
l1.clear();
l2.clear();
ans = 0;
cin >> n;
G.resize(n + 5);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] != -1) G[b[i]].push_back(i);
}
topsort();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int ans;
if (n == 1 || m == 1)
ans = max(m, n);
else if (m == 2 && n == 2)
ans = 4;
else if (n == 2) {
if (m & 1)
ans = m + 1;
else if (m % 4 == 2)
ans = m + 2;
else
ans = m;
} else if (m == 2) {
if (n & 1)
ans = n + 1;
else if (n % 4 == 2)
ans = n + 2;
else
ans = n;
} else
ans = ((n * m) % 2 == 0 ? (n * m) / 2 : (n * m) / 2 + 1);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, l, r, t;
cin >> s;
int c = s.find('|');
l = s.substr(0, c);
r = s.substr(c + 1);
cin >> t;
for (auto pointer : t)
if (l.size() <= r.size())
l += pointer;
else
r += pointer;
cout << (l.size() == r.size() ? l + '|' + r : "Impossible") << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> G[1 << 20], ans;
int vis[1 << 20];
set<pair<int, int> > E;
void dfs(int u, int p) {
if (((int)ans.size()) == n) return;
ans.push_back(u);
vis[u] = 1;
for (int v : G[u])
for (int t : G[p])
if (v == t && !vis[t]) return dfs(t, u);
}
bool DO(int a, int b) {
int x = min(a, b), y = max(a, b);
if (E.find(make_pair(x, y)) == E.end()) {
return 0;
}
E.erase(make_pair(x, y));
return 1;
}
bool valid() {
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (2); j++) {
if (i + j + 1 >= n) break;
int x = min(ans[i], ans[i + j + 1]), y = max(ans[i], ans[i + j + 1]);
if (!DO(x, y)) return 0;
}
}
if (!DO(ans[n - 2], ans[0])) return 0;
if (!DO(ans[n - 1], ans[0])) return 0;
if (!DO(ans[n - 1], ans[1])) return 0;
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (2 * n); i++) {
int a, b;
scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
E.insert(make_pair(min(a, b), max(a, b)));
}
for (int i = (1); i <= (n); i++)
if (((int)G[i].size()) > 4) {
puts("-1");
return 0;
}
for (int i = 0; i < (((int)G[1].size())); i++) {
for (int j = 0; j < (((int)G[1].size())); j++) {
if (i == j) continue;
memset(vis, 0, sizeof vis);
ans.push_back(1);
vis[1] = 1;
vis[G[1][j]] = 1;
dfs(G[1][i], 1);
bool c = 0;
for (int v : G[ans.back()]) c |= v == G[1][j];
if (c) ans.push_back(G[1][j]);
if (ans.size() == n) break;
ans.clear();
}
if (!ans.empty()) break;
}
if (ans.empty() || !valid()) {
puts("-1");
return 0;
}
for (int u : ans) printf("%d ", u);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = INT_MAX, df = 3e5 + 7;
long long i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a[df], pos[df],
b[df], id[df], cnt, ans[df];
char st[5];
bool cmp(long long st, long long ch) { return a[st] < a[ch]; }
inline long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch > '9' || ch < '0') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * y;
}
int main() {
scanf("%lld%lld%lld", &n, &m, &t);
for (long long i = (0); i <= (n - 1); ++i) {
scanf("%lld", &a[i]), scanf("%s", st);
a[i]--;
id[i] = i, b[i] = (st[0] == 'R') ? 1 : -1;
pos[i] = ((b[i] * t + a[i]) % m + m) % m;
cnt = ((cnt + (b[i] * t + a[i] - pos[i]) / m + n) % n + n) % n;
}
sort(id, id + n, cmp), sort(pos, pos + n);
for (long long i = (0); i <= (n - 1); ++i) ans[id[i]] = pos[(i + cnt) % n];
for (long long i = (0); i <= (n - 1); ++i) printf("%lld ", ans[i] + 1);
return puts(""), 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
set<string> S;
int main() {
int n;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
if (S.count(s))
cout << "YES\n";
else
cout << "NO\n";
S.insert(s);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, k;
int main() {
cin >> t;
for (int w = 0; w < t; w++) {
cin >> n >> m >> k;
if (m <= n / k) {
cout << m << endl;
continue;
}
if ((m - n / k) % (k - 1) == 0) {
cout << n / k - (m - n / k) / (k - 1) << endl;
continue;
}
cout << n / k - (m - n / k) / (k - 1) - 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> fact(1001);
long long power(long long a, long long b) {
if (b == 0) return 1;
long long ans = power(a, b / 2);
ans = (ans % 998244353 * ans % 998244353) % 998244353;
if (b % 2 == 1) return (ans * a) % 998244353;
return ans;
}
long long inverse(long long a, long long p) { return power(a, p - 2); }
long long ncr(long long n, long long r) {
long long ans = fact[n];
ans = (ans * inverse(fact[r], 998244353)) % 998244353;
ans = (ans * inverse(fact[n - r], 998244353)) % 998244353;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
fact[0] = 1;
for (long long i = 1; i < 1001; i++) fact[i] = (fact[i - 1] * i) % 998244353;
long long t = 1;
while (t--) {
long long n, ans = 0;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> dp(n + 1, 0);
for (long long i = n - 1; i >= 0; i--) {
if (a[i] <= 0) {
dp[i] = ans;
continue;
}
for (long long j = i + a[i]; j < n; j++) {
long long x = ncr(j - i - 1, a[i] - 1);
ans = (ans + x) % 998244353;
ans = (ans + (x * dp[j + 1]) % 998244353) % 998244353;
}
dp[i] = ans;
}
cout << ans << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 1;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
int n, h, ans[N], a[N], b[N];
struct pos {
int ix, a;
};
pos p[N];
bool cmp(const pos &a, const pos &b) { return a.a < b.a; }
int main() {
scanf("%d%d", &n, &h);
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i].a);
p[i].ix = i;
}
sort(p, p + n, cmp);
for (int i = 0; i < n; ++i) ans[i] = 1;
if (n < 6) {
int cur = INF;
for (int i = 0; i < (1 << n); ++i) {
int ca = 0, cb = 0;
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == (1 << j))
a[ca++] = p[j].a;
else
b[cb++] = p[j].a;
}
int maxn = -1, minn = INF;
if (ca && cb) {
minn = min(minn, a[0] + b[0] + h);
maxn = max(maxn, a[ca - 1] + b[cb - 1] + h);
}
if (ca > 1) {
minn = min(minn, a[0] + a[1]);
maxn = max(maxn, a[ca - 1] + a[ca - 2]);
}
if (cb > 1) {
minn = min(minn, b[0] + b[1]);
maxn = max(maxn, b[cb - 1] + b[cb - 2]);
}
if (maxn - minn < cur) {
cur = maxn - minn;
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == (1 << j))
ans[p[j].ix] = 1;
else
ans[p[j].ix] = 2;
}
}
}
printf("%d\n", cur);
} else {
int cur = p[n - 1].a + p[n - 2].a - p[1].a - p[0].a;
int maxn = -1, minn = p[0].a + p[1].a + h;
maxn = max(maxn, p[n - 1].a + p[n - 2].a);
maxn = max(maxn, p[n - 1].a + p[0].a + h);
minn = min(minn, p[1].a + p[2].a);
if (maxn - minn < cur) {
cur = maxn - minn;
ans[p[0].ix] = 2;
}
if (1) {
int ed = -1;
for (int i = 1; i < n - 2; ++i) {
int maxn = p[n - 1].a + p[n - 2].a, minn = p[0].a + p[1].a + h;
maxn = max(maxn, p[n - 1].a + p[i].a + h);
minn = min(minn, p[i + 1].a + p[0].a);
if (i > 1) minn = min(minn, p[1].a + p[2].a);
if (maxn - minn < cur) {
cur = maxn - minn;
ans[p[0].ix] = 1;
ed = i;
}
}
if (~ed)
for (int i = 1; i <= ed; ++i) ans[p[i].ix] = 2;
}
printf("%d\n", cur);
}
for (int i = 0; i < n; ++i) {
printf("%d", ans[i]);
printf(i == n - 1 ? "\n" : " ");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 100;
long long n;
vector<long long> pos;
long long cou(long long k) {
long long ans = 0;
for (long long i = 1; i <= n; i += k) {
long long mid = (i + i + k - 1) / 2;
for (long long j = i; j <= i + k - 1; j++) {
ans += abs(pos[mid] - pos[j]);
}
}
return ans;
}
signed main() {
cin >> n;
pos.push_back(0);
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
if (x) pos.push_back(i);
}
n = pos.size() - 1;
long long k = -1, sum = 1e18;
for (long long i = 2; i <= n; i++) {
if (n % i == 0) {
sum = min(sum, cou(i));
k = i;
}
}
if (k == -1) {
cout << "-1\n";
return 0;
}
cout << sum << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2017;
int qu[N], re[N], n, mi[N], x;
int main() {
memset(mi, 0x3f, sizeof(mi));
scanf("%d", &n);
int k;
for (int i = 0; i <= 9; i++)
for (int t = 0; t <= 1; t++) {
k = 0;
for (int j = 0; j <= n - 1; j++)
if (((j >> i) & 1) == t) k++;
if (k) {
printf("%d\n", k);
fflush(stdout);
for (int j = 0; j <= n - 1; j++)
if (((j >> i) & 1) == t) printf("%d ", j + 1), fflush(stdout);
fflush(stdout);
for (int j = 0; j <= n - 1; j++) {
scanf("%d", &x);
if (((j >> i) & 1) == 1 - t) mi[j] = min(mi[j], x);
}
}
}
printf("%d\n", -1);
fflush(stdout);
for (int i = 0; i <= n - 1; i++) {
printf("%d ", mi[i]);
fflush(stdout);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200000], d[200000];
int process() {
int MAX = -1;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
d[a[i]]++;
MAX = max(MAX, a[i]);
}
int res = 0;
if (n > 0) res = 1;
for (int i = 2; i <= MAX; i++) {
int cnt = 0;
int j = 0;
while (j <= MAX) {
cnt += d[j];
j += i;
}
res = max(res, cnt);
}
cout << res;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
process();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k, count1 = INT_MIN;
cin >> n >> k;
int ram[k];
for (int i = 0; i < k; i++) cin >> ram[i];
int l = ram[0];
int r;
for (int i = 0; i < k; i++) {
if (i + 1 < k) {
r = ram[i + 1] - ram[i] - 1;
r = (r % 2) + (r / 2) + 1;
int maxi = max(r, l);
count1 = max(count1, maxi);
l = r;
} else {
r = n - ram[i] + 1;
int maxi = max(r, l);
count1 = max(count1, maxi);
l = r;
}
}
cout << count1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long tt;
cin >> tt;
getchar();
while (tt--) {
long long n, x, y, z, i;
string a, b, c;
cin >> a;
getchar();
cin >> b;
getchar();
cin >> c;
getchar();
n = a.size();
for (i = 0; i < n; i++) {
x = a[i] - 97;
y = b[i] - 97;
z = c[i] - 97;
if (z == x || z == y)
continue;
else
break;
}
if (i == n)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 10;
int n, a[N];
int b[N];
int par[N], sz[N];
long long sum[N];
int root(int v) {
if (par[v] == v) return v;
return root(par[v]);
}
void merge(int x, int y) {
x = root(x), y = root(y);
if (x == y) return;
if (sz[y] > sz[x]) swap(x, y);
par[y] = x;
sz[x] += sz[y];
sum[x] += sum[y];
}
long long maior, ans[N];
bool mrk[N];
void solve() {
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = i;
sum[i] = a[i];
}
for (int i = n; i >= 1; i--) {
ans[i] = maior;
int pos = b[i];
mrk[pos] = true;
if (pos + 1 <= n && mrk[pos + 1]) merge(pos, pos + 1);
if (pos - 1 >= 1 && mrk[pos - 1]) merge(pos, pos - 1);
maior = max(maior, sum[root(pos)]);
}
for (int i = 1; i <= n; i++) printf("%lld\n", ans[i]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000;
const long long mod = 1000000007;
template <class T>
void read_vector(vector<T>& __cur) {
for (T& _cnt : __cur) {
cin >> _cnt;
}
}
template <class T>
T lcm(T a, T b) {
return abs(a * b) / __gcd(a, b);
}
struct msg {
long long will_read, l, r, prev;
};
long long count_intersection(msg a, msg b) {
return max((long long)0, a.r - b.l + 1);
}
long long get_read_msg(msg a) {
if (a.l == 1) {
return a.r;
}
return a.r - a.l + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<msg> h(n + 1);
for (long long i = 1; i <= n; i++) {
h[i].l = max((long long)1, i - k);
h[i].r = min(n, i + k);
cin >> h[i].prev;
}
h[1].will_read = get_read_msg(h[1]);
cout << h[1].will_read << " ";
for (long long i = 2; i <= n; i++) {
if (h[i].prev != 0)
h[i].will_read = h[h[i].prev].will_read + get_read_msg(h[i]) -
count_intersection(h[h[i].prev], h[i]);
else
h[i].will_read = get_read_msg(h[i]);
cout << h[i].will_read << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int id[100010], pre[100010], t[100010];
int stk[100010];
int top;
int max(int x, int y) { return x > y ? x : y; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &id[i]);
top = 0;
stk[++top] = 0;
t[0] = 1000000000;
for (int i = 1; i < n; i++) {
t[i] = 1;
while (top > 0 && id[i] > id[stk[top]]) {
t[i] = max(t[i], t[stk[top]] + 1);
top--;
}
stk[++top] = i;
}
int ans = 0;
for (int i = 0; i < n; i++)
if (t[i] < 1000000000) ans = max(ans, t[i]);
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int visited[200001][2];
long long arr[200001];
long long dp[200001][2];
int n;
long long solve(int index, int turn) {
if (index == n) return 0;
if (visited[index][turn]) return dp[index][turn];
visited[index][turn] = 1;
if (turn == 0) {
dp[index][turn] = max(dp[index][turn],
(long long)solve(index + 1, 1 - turn) + arr[index]);
if (index + 1 != n)
dp[index][turn] = max(dp[index][turn], solve(index + 1, turn));
} else {
dp[index][turn] = INT_MAX;
dp[index][turn] = min(dp[index][turn],
(long long)solve(index + 1, 1 - turn) - arr[index]);
if (index + 1 != n)
dp[index][turn] = min(dp[index][turn], solve(index + 1, turn));
}
return dp[index][turn];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 200001; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INT_MIN;
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
}
for (int i = 1; i < n; i++) arr[i] += arr[i - 1];
printf("%lld\n", solve(1, 0));
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int size = 200000000;
map<int, int> mp;
int main() {
int n, k, x, q, res;
while (cin >> n >> k) {
mp.clear();
for (int i = 0; i < n; ++i) {
cin >> x;
for (int j = 1; j * x <= size && j <= k; ++j) {
if (mp.find(j * x) == mp.end()) {
mp[j * x] = j;
} else {
mp[j * x] = min(j, mp[j * x]);
}
}
}
cin >> q;
while (q--) {
cin >> x;
res = (mp.find(x) == mp.end() ? 33 : mp[x]);
for (auto it : mp) {
if (mp.find(x - it.first) != mp.end()) {
res = min(res, it.second + mp[x - it.first]);
}
}
cout << (res > k ? -1 : res) << endl;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int x, n, r, ress, resf, sub, fil;
string a, b, last;
vector<string> start;
map<string, bool> k, file;
map<string, vector<string> > v;
void dfs(string s) {
k[s] = true;
sub++;
if (file[s]) {
fil++;
sub--;
}
for (int i = 0; i < v[s].size(); i++) {
if (!k[v[s][i]]) dfs(v[s][i]);
}
}
int main() {
while (getline(cin, a)) {
b = "";
n = a.size();
if (n) {
x = 0;
r = 0;
while (x < n) {
b += a[x];
if (b[x] == '\\') {
r++;
if (r == 2) start.push_back(b);
if (r > 2) v[last].push_back(b);
last = b;
}
x++;
}
v[last].push_back(b);
file[b] = true;
}
}
for (int i = 0; i < start.size(); i++) {
if (!k[start[i]]) {
fil = 0;
sub = -1;
dfs(start[i]);
ress = max(ress, sub);
resf = max(resf, fil);
}
}
cout << ress << ' ' << resf << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(unsigned long long &x) { scanf("%llu", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.F);
putchar(' ');
_W(x.S);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int MOD = 1e9 + 7, mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
const int MAXN = 3e5 + 10, MAXM = 2e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int inv2 = 5e8 + 4;
const int Lim = 1 << 20;
struct ACautomaton {
int ch[MAXN][26], fail[MAXN], ans[MAXN], cnt, rt[MAXN], top, sz[MAXN],
son[MAXN][26], val[MAXN];
void insert(char *s) {
int n = strlen(s);
int u = rt[++top] = ++cnt;
for (int i = 0; i < n; i++) {
if (!ch[u][s[i] - 'a']) ch[u][s[i] - 'a'] = ++cnt;
u = ch[u][s[i] - 'a'];
}
val[u]++;
}
int merge(int u, int v) {
if (!u || !v) return u + v;
val[u] += val[v];
for (int i = 0; i < 26; i++) ch[u][i] = merge(ch[u][i], ch[v][i]);
return u;
}
void getfail(int rt) {
queue<int> q;
for (int i = 0; i < 26; i++)
if (ch[rt][i])
q.push(son[rt][i] = ch[rt][i]), fail[ch[rt][i]] = rt;
else
son[rt][i] = rt;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
if (ch[u][i]) {
son[u][i] = ch[u][i];
fail[son[u][i]] = son[fail[u]][i];
q.push(son[u][i]);
} else
son[u][i] = son[fail[u]][i];
}
ans[u] = val[u] + ans[fail[u]];
}
}
void build(char *s) {
insert(s);
sz[top] = 1;
while (sz[top] == sz[top - 1])
rt[top - 1] = merge(rt[top - 1], rt[top]), sz[top - 1] += sz[top], top--;
getfail(rt[top]);
}
long long query(char *s) {
long long n = strlen(s), res = 0;
for (int i = 1; i <= top; i++) {
int u = rt[i];
for (int j = 0; j < n; j++) u = son[u][s[j] - 'a'], res += ans[u];
}
return res;
}
} A, B;
char s[MAXN];
void solve() {
int n;
R(n);
for (int i = 1; i <= n; i++) {
int p;
R(p, s);
if (p == 1)
A.build(s);
else if (p == 2)
B.build(s);
else
W(A.query(s) - B.query(s));
fflush(stdout);
}
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int n, t, p, k;
cin >> n >> t;
if (n == 1 && t == 10) {
cout << -1 << endl;
return 0;
}
if (t == 10) {
for (int i = 1; i <= n; i++) {
if (i == 1)
cout << 1;
else
cout << 0;
}
cout << endl;
return 0;
} else if (t != 10) {
for (int i = 1; i <= n; i++) cout << t;
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, s, d, m, n;
deque<int> f;
scanf("%d%d%d", &a, &s, &d);
for (int i = 0; i < a; i++) {
scanf("%d", &n);
f.push_back(n);
}
for (int i = 0; i < s; i++) {
m = *max_element(f.begin(), f.end());
for (int u = 0; u < a; u++) {
if (f[u] == m) {
f.erase(f.begin() + u);
break;
}
}
}
n = *max_element(f.begin(), f.end());
printf("%d", m - n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> A(m);
vector<vector<bool>> B(n);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) B[i].push_back(s[j] == '1');
}
for (auto& v : B)
for (int j = 0; j < m; j++)
if (v[j]) A[j]++;
bool found{};
for (auto& v : B) {
found = true;
for (int j = 0; j < m; j++) {
if (v[j] and A[j] < 2) {
found = false;
break;
}
}
if (found) break;
}
cout << (found ? "YES" : "NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h[227], cnt = 1, dis[227], vis[227];
int pre[227], px[227], ans = 0;
struct Edge {
int to, next, s, c;
} e[100127];
inline void AddEdge(int x, int y, int s, int c) {
e[++cnt] = (Edge){y, h[x], s, c};
h[x] = cnt;
e[++cnt] = (Edge){x, h[y], 0, -c};
h[y] = cnt;
}
bool SPFA(int S, int T) {
int i, x, y;
for (i = S; i <= T; i++) dis[i] = 0x3f3f3f3f, vis[i] = 0;
dis[S] = 0;
vis[S] = 1;
px[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
x = q.front();
q.pop();
vis[x] = 0;
for (i = h[x]; i; i = e[i].next) {
y = e[i].to;
if (e[i].s > 0 && dis[x] + e[i].c < dis[y]) {
dis[y] = dis[x] + e[i].c;
pre[y] = i;
px[y] = x;
if (!vis[y]) {
vis[y] = 1;
q.push(y);
}
}
}
}
if (dis[T] < 0x3f3f3f3f) return true;
return false;
}
inline void update(int T) {
int y = T, dlt = 0x3f3f3f3f;
while (px[y]) {
dlt = min(dlt, e[pre[y]].s);
y = px[y];
}
ans += dlt * dis[T];
y = T;
while (px[y]) {
e[pre[y]].s -= dlt;
e[pre[y] ^ 1].s += dlt;
y = px[y];
}
}
int a[127], c[127], last[127];
int main() {
scanf("%d%d", &n, &m);
int i, S, T;
S = 1;
T = (n + 1) << 1;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
for (i = 1; i <= n; i++) {
AddEdge(S, i << 1, 1, c[a[i]]);
AddEdge(i << 1, i << 1 | 1, 1, 0);
AddEdge(i << 1 | 1, T, 1, 0);
}
last[a[1]] = 1;
for (i = 2; i <= n; i++) {
AddEdge((i - 1) << 1, i << 1, m - 1, 0);
if (last[a[i]]) AddEdge((i - 1) << 1, last[a[i]] << 1 | 1, 1, -c[a[i]]);
last[a[i]] = i;
}
while (SPFA(S, T)) update(T);
printf("%d", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAX = 5e5 + 5;
const long long MAX2 = 11;
const long long MOD = 1000000007;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 450;
int n, k, x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
x = n - k >> 1;
while (n) {
for (long long i = 1; i <= x; ++i)
if (n) cout << 0, n--;
if (n) cout << 1, n--;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2.5e5 + 5;
const int MAXM = 5e5 + 5;
namespace LCT {
struct Node {
Node *fa;
union {
Node *son[2];
struct {
Node *ls, *rs;
};
};
bool rev_tag;
int vtag, val, mx;
Node(void) {}
Node(Node *emp, int _val)
: fa(emp), ls(emp), rs(emp), rev_tag(0), vtag(-1), val(_val), mx(_val) {}
} *emp = new Node(emp, -1), *hd = 0;
inline Node *new_Node(int val) {
if (!hd) {
static const int SIZ = MAXN + MAXM;
hd = new Node[SIZ + 1];
for (int i = 0; i < SIZ; ++i) (hd + i)->rs = hd + i + 1;
(hd + SIZ)->rs = 0;
}
Node *res = hd;
hd = hd->rs;
*res = Node(emp, val);
return res;
}
inline bool is_root(Node *u) {
return u->fa == emp || (u->fa->ls != u && u->fa->rs != u);
}
inline int get_ch(Node *u) { return u->fa->rs == u; }
inline void upd_rev(Node *u) {
u->rev_tag ^= 1;
swap(u->ls, u->rs);
}
inline void upd_v(Node *u, int k) {
if (u->mx != -1) {
if (u->val != -1) u->val = k;
u->vtag = u->mx = k;
}
}
inline void push_up(Node *u) { u->mx = max(max(u->ls->mx, u->rs->mx), u->val); }
inline void push_down(Node *u) {
if (u->rev_tag) {
upd_rev(u->ls);
upd_rev(u->rs);
u->rev_tag = 0;
}
if (u->vtag != -1) {
upd_v(u->ls, u->vtag);
upd_v(u->rs, u->vtag);
u->vtag = -1;
}
}
inline void rotate(Node *u) {
Node *v = u->fa, *w = v->fa;
int k = get_ch(u);
if (!is_root(v)) w->son[get_ch(v)] = u;
v->son[k] = u->son[!k];
u->son[!k]->fa = v;
u->son[!k] = v;
v->fa = u;
u->fa = w;
push_up(v);
push_up(u);
}
inline void push_down_all(Node *u) {
if (!is_root(u)) push_down_all(u->fa);
push_down(u);
}
inline void splay(Node *u) {
push_down_all(u);
for (Node *v; v = u->fa, !is_root(u); rotate(u))
if (!is_root(v)) rotate(get_ch(v) == get_ch(u) ? v : u);
}
inline Node *access(Node *u) {
Node *pre = emp;
for (; u != emp; pre = u, u = u->fa) splay(u), u->rs = pre, push_up(u);
return pre;
}
inline void make_root(Node *u) { upd_rev(access(u)); }
inline Node *find(Node *u) {
access(u);
splay(u);
push_down(u);
while (u->ls != emp) u = u->ls, push_down(u);
splay(u);
return u;
}
inline void link(Node *u, Node *v) {
make_root(u);
splay(u);
u->fa = v;
push_up(v);
}
inline void cut(Node *u, Node *v) {
make_root(u);
access(v);
splay(v);
v->ls = u->fa = emp;
push_up(v);
}
inline int query_mx(Node *u, Node *v) {
make_root(u);
access(v);
splay(v);
return v->mx;
}
inline void update_val(Node *u, Node *v, int k) {
make_root(u);
access(v);
splay(v);
upd_v(v, k);
}
} // namespace LCT
using namespace LCT;
int a[MAXM], b[MAXM];
Node *pn[MAXN], *pe[MAXM];
bool del[MAXM];
inline void adde(int id) {
int u = a[id], v = b[id];
if (find(pn[u]) != find(pn[v])) {
link(pe[id], pn[u]);
link(pe[id], pn[v]);
del[id] = 0;
} else {
update_val(pn[u], pn[v], id);
del[id] = 1;
}
}
inline void dele(int id) {
int u = a[id], v = b[id];
if (del[id]) {
assert(query_mx(pn[u], pn[v]) == id);
update_val(pn[u], pn[v], 0);
} else {
int oth = query_mx(pn[u], pn[v]);
if (oth > 0) {
cut(pn[u], pe[id]);
cut(pn[v], pe[id]);
int uu = a[oth], vv = b[oth];
link(pn[uu], pe[oth]);
link(pn[vv], pe[oth]);
del[oth] = 0;
update_val(pn[u], pn[v], 0);
} else {
cut(pn[u], pe[id]);
cut(pn[v], pe[id]);
}
}
}
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= n; ++i) pn[i] = new_Node(-1);
for (int i = 1; i <= m; ++i) pe[i] = new_Node(0);
long long ans = 0;
for (int r = 1, l = 1; r <= m; ++r) {
int u = a[r], v = b[r];
while (l < r && find(pn[u]) == find(pn[v]) && query_mx(pn[u], pn[v]) > 0)
dele(l++);
adde(r);
ans += r - l + 1;
}
printf("%lld", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T mod_v(T num) {
if (num >= 0)
return num % 1000000007;
else
return (num % 1000000007 + 1000000007) % 1000000007;
}
template <class T>
inline T gcd(T a, T b) {
a = abs(a);
b = abs(b);
while (b) b ^= a ^= b ^= a %= b;
return a;
}
template <class T>
T fast_pow(T n, T p) {
if (p == 0) return 1;
if (p % 2) {
T g = mod_v(mod_v(n) * mod_v(fast_pow(n, p - 1)));
return g;
} else {
T g = fast_pow(n, p / 2);
g = mod_v(mod_v(g) * mod_v(g));
return g;
}
}
template <class T>
inline T modInverse(T n) {
return fast_pow(n, 1000000007 - 2);
}
template <class T>
inline void debug(string S1, T S2, string S3) {
cout << S1 << S2 << S3;
}
bool equalTo(double a, double b) {
if (fabs(a - b) <= 1e-9)
return true;
else
return false;
}
bool notEqual(double a, double b) {
if (fabs(a - b) > 1e-9)
return true;
else
return false;
}
bool lessThan(double a, double b) {
if (a + 1e-9 < b)
return true;
else
return false;
}
bool lessThanEqual(double a, double b) {
if (a < b + 1e-9)
return true;
else
return false;
}
bool greaterThan(double a, double b) {
if (a > b + 1e-9)
return true;
else
return false;
}
bool greaterThanEqual(double a, double b) {
if (a + 1e-9 > b)
return true;
else
return false;
}
template <class T>
inline int in(register T& num) {
register char c = 0;
num = 0;
bool n = false;
while (c < 33) c = getchar();
while (c > 33) {
if (c == '-')
n = true;
else
num = num * 10 + c - '0';
c = getchar();
}
num = n ? -num : num;
return 1;
}
int main() {
int n;
int kp[100005];
in(n);
for (int i = 1; i <= n; i++) {
in(kp[i]);
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
printf("%d %d\n", abs(kp[i + 1] - kp[i]), abs(kp[n] - kp[i]));
} else if (i == n) {
printf("%d %d\n", abs(kp[i] - kp[i - 1]), abs(kp[i] - kp[1]));
} else {
printf("%d %d\n", min(abs(kp[i] - kp[i - 1]), abs(kp[i + 1] - kp[i])),
max(abs(kp[n] - kp[i]), abs(kp[i] - kp[1])));
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long nax = 3e5 + 5;
long long cnt[nax];
long long f[nax];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long mx = 0;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long clr;
cin >> clr;
cnt[f[clr]]--;
f[clr]++;
cnt[f[clr]]++;
mx = max(mx, f[clr]);
if (cnt[1] == i) {
ans = i;
} else if (cnt[i] == 1) {
ans = i;
} else if (cnt[1] == 1 && cnt[mx] * mx == i - 1) {
ans = i;
} else if (cnt[mx - 1] * (mx - 1) == i - mx && cnt[mx] == 1) {
ans = i;
}
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e5 + 10;
int a[mn], b[mn];
int gr(int x) {
if (x == 1) return 1;
if (x == 2) return 0;
if (x == 3) return 1;
if (x == 4) return 2;
if (x & 1) return 0;
int y = gr(x / 2);
if (y == 1) return 2;
return 1;
}
int main() {
int n, k, i;
scanf("%d%d", &n, &k);
if (k & 1) {
int sum = 0;
for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
sum ^= gr(x);
}
printf("%s", sum ? "Kevin" : "Nicky");
} else {
int sum = 0;
for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x == 2)
sum ^= 2;
else if (x == 1)
sum ^= 1;
else
sum ^= !(x & 1);
}
printf("%s", sum ? "Kevin" : "Nicky");
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 100010;
map<string, int> mp;
int pi[110], ct[110];
int main() {
int ptr, n, m, i, ma, mi, cc;
string na;
while (~scanf("%d%d", &n, &m)) {
memset(ct, 0, sizeof ct);
mp.clear(), ptr = 1;
ma = mi = 0;
for (i = 0; i < n; i++) scanf("%d", &pi[i]);
sort(pi, pi + n);
for (i = 0; i < m; i++) {
cin >> na;
if (!mp[na]) mp[na] = ptr++;
ct[mp[na]]++;
}
sort(ct + 1, ct + ptr);
for (i = ptr - 1, cc = 0; i >= 1; i--) mi += ct[i] * pi[cc++];
for (i = ptr - 1, cc = n - 1; i >= 1; i--) ma += ct[i] * pi[cc--];
printf("%d %d\n", mi, ma);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
int main() {
int n, m, k, c;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + m);
int l = 0, r = min(n, m);
while (l < r - 1) {
int mid = (l + r) / 2;
int co = mid - 1;
long long zz = k;
for (int i = n - 1; i >= 0 && co >= 0; --i) zz += min(a[i] - b[co--], 0);
if (zz >= 0)
l = mid;
else
r = mid - 1;
}
long long su = 0;
for (int i = 0; i < r; ++i) su += b[i];
int co = r - 1;
long long zz = k;
for (int i = n - 1; i >= 0 && co >= 0; --i) zz += min(a[i] - b[co--], 0);
if (zz >= 0) {
cout << r << ' ' << max(0LL, su - (long long)k);
} else {
cout << l << ' ' << max(0LL, su - (long long)b[l] - (long long)k);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void useFileInput() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void setMyPrecision(int n) { cout << fixed << setprecision(n); }
bool test = 0;
bool fileInput = 0;
bool found(string flw) {
return (flw == "ABC" || flw == "ACB" || flw == "BAC" || flw == "BCA" ||
flw == "CAB" || flw == "CBA");
}
void solve() {
string landscaape;
cin >> landscaape;
if (landscaape.length() < 3) {
cout << "No";
return;
}
string tmp = "";
tmp += landscaape[0];
tmp += landscaape[1];
tmp += landscaape[2];
if (landscaape.length() == 3) {
if (found(tmp)) {
cout << "Yes";
return;
}
}
for (int i = 1; i <= landscaape.length() - 3; i++) {
if (found(tmp)) {
cout << "Yes";
return;
}
tmp = tmp.substr(1);
tmp += landscaape[i + 2];
}
if (found(tmp))
cout << "Yes";
else
cout << "No";
}
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
if (fileInput) useFileInput();
if (test) {
int t;
cin >> t;
while (t--) solve();
} else
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m;
int b[N][N];
bool row[N], col[N];
int ans[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) row[i] = 1;
for (int i = 1; i <= m; ++i) col[i] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &b[i][j]);
if (!b[i][j]) {
row[i] = 0;
col[j] = 0;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (b[i][j]) {
if (!row[i] && !col[j]) {
puts("NO");
return 0;
}
}
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) ans[i][j] = (row[i] && col[j] ? 1 : 0);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (!b[i][j]) {
for (int k = 1; k <= n; ++k)
if (ans[k][j] == 1) {
puts("NO");
return 0;
}
for (int k = 1; k <= m; ++k)
if (ans[i][k] == 1) {
puts("NO");
return 0;
}
} else {
bool have = 0;
for (int k = 1; k <= n; ++k)
if (ans[k][j] == 1) have = 1;
for (int k = 1; k <= m; ++k)
if (ans[i][k] == 1) have = 1;
if (!have) {
puts("NO");
return 0;
}
}
}
}
puts("YES");
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%d ", ans[i][j]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long mod = 998244353ll;
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(2 * n);
for (long long i = 0; i < (2 * n); i++) cin >> a[i];
sort((a).begin(), (a).end());
long long LIM = 150005;
long long* inv = new long long[LIM] - 1;
inv[1] = 1;
for (long long i = (2); i <= (LIM - 1); i++)
inv[i] = mod - (mod / i) * inv[mod % i] % mod;
long long binCoef = 1;
for (long long i = 2 * n; i >= (n + 1); i--) {
binCoef *= i;
binCoef %= mod;
}
for (long long i = n; i >= (1); i--) {
binCoef *= inv[i];
binCoef %= mod;
}
long long s1 = 0;
long long s2 = 0;
for (long long i = 0; i < (n); i++) s1 += a[i];
for (long long i = (n); i <= (2 * n - 1); i++) s2 += a[i];
long long res = binCoef * ((s2 - s1) % mod);
res %= mod;
cout << res << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int md = int(1e9) + 7;
const int inf = 0x3f3f3f3f;
const long long infl = 0x3f3f3f3f3f3f3f3f;
const int mx = 1 << 19;
int tree[2 * mx], flag[2 * mx];
void update(int i) {
while (i /= 2) tree[i] = tree[i << 1] + tree[i << 1 | 1];
}
int query(int i, int l, int r, int u, int v) {
if (u <= l && r <= v) return tree[i];
int mid = (l + r) / 2;
int lans = 0, rans = 0;
if (u < mid) lans = query(i << 1, l, mid, u, v);
if (mid < v) rans = query(i << 1 | 1, mid, r, u, v);
return lans + rans;
}
int lower_bound_rtol(int pos, long long sm) {
int i = mx + pos, l = pos, len = 1;
long long tot = 0;
while (l >= 0) {
if (i & 1 && tree[i >> 1] + tot < sm)
i >>= 1, l -= len, len <<= 1;
else if (tree[i] + tot < sm)
tot += tree[i--], l -= len;
else if (len > 1)
i = i << 1 | 1, len >>= 1, l += len;
else
break;
}
return l;
}
int lower_bound_rtol(long long sm) {
int l = mx;
long long tot = 0;
for (int i = 1, len = mx; i && len; i = i << 1 | 1, len >>= 1) {
if (tot + tree[i] < sm) {
tot += tree[i];
l -= len;
i--;
}
}
return l - 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
vector<tuple<int, int, int>> vq;
for (int i = 0; i < (q); i++) {
int l, r;
cin >> l >> r;
vq.push_back(make_tuple(n - r, l, i));
}
sort((vq).begin(), (vq).end());
vector<int> vans(q);
int it = 0;
for (int i = 0; i < (n); i++) {
int d = i + 1 - a[i];
if (d >= 0) {
int l = -1;
l = lower_bound_rtol(d);
l = min(l, i);
if (l >= 0) {
tree[mx + l]++;
update(mx + l);
}
}
while (it < q && get<0>(vq[it]) == i + 1) {
int curr, curl, curi;
tie(curr, curl, curi) = vq[it];
int ans = 0;
ans = query(1, 0, mx, curl, curr);
vans[curi] = ans;
it++;
}
}
for (int i = 0; i < (q); i++) {
cout << vans[i] << "\n";
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long lb = 1, rb = 3 * k, mb;
while (lb < rb) {
mb = (lb + rb) / 2;
if ((mb - mb / n) == k && mb % n) break;
if (mb - mb / n >= k)
rb = mb;
else
lb = mb + 1;
}
cout << mb << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, ans;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long SG[61] = {0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5,
5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7,
7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10};
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a;
ans ^= SG[a];
}
if (ans)
cout << "NO\n";
else
cout << "YES\n";
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << '\n';
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
const int N = 1e5 + 7;
int n, m, a, b, y[N], y2[N], l[N], idx1, idx2;
double ans = 1e18;
double sq(double x) { return x * x; }
double dist(double x1, double y1, double x2, double y2) {
return sqrt(sq(x1 - x2) + sq(y1 - y2));
}
double d(int i, int j) {
double ya = y[i], yb = y2[j];
double dd = dist(0.0, 0.0, a, ya) + dist(a, ya, b, yb) + l[j];
if (dd < ans) {
ans = dd;
idx1 = i, idx2 = j;
}
return dd;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m >> a >> b;
for (int i = 1; i <= n; i++) cin >> y[i];
for (int i = 1; i <= m; i++) cin >> y2[i];
for (int i = 1; i <= m; i++) cin >> l[i];
for (int i = 1; i <= m; i++) {
int lo = 1, hi = n;
while (hi - lo > 3) {
int m1 = lo + (hi - lo) / 3, m2 = hi - (hi - lo) / 3;
if (d(m1, i) > d(m2, i))
lo = m1;
else
hi = m2;
}
for (int j = lo; j <= hi; j++) d(j, i);
}
cout << idx1 << " " << idx2 << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
const long long MOD = 1e9 + 7;
const long long INF = 3e18 + 19763;
long long pw(long long a, long long b) {
return b == 0 ? 1LL : (pw(a * a, b / 2) % MOD * (b % 2 == 0 ? 1LL : a));
}
long long p[MAXN], ans[MAXN];
vector<pair<long long, long long> > on, zr;
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
on.clear();
zr.clear();
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> p[i];
};
string s;
cin >> s;
for (long long i = 0; i < n; i++) {
if (s[i] == '1')
on.push_back({p[i], i});
else
zr.push_back({p[i], i});
}
sort(on.begin(), on.end());
sort(zr.begin(), zr.end());
for (long long i = 0; i < zr.size(); i++) ans[zr[i].second] = i + 1;
for (long long i = 0; i < on.size(); i++)
ans[on[i].second] = i + 1 + zr.size();
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
};
cout << '\n';
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, n;
int main() {
int i, j;
cin >> T;
while (T--) {
scanf("%d", &n);
for (i = 0; i <= n / 3; i++) {
for (j = 0; j * 5 + i * 3 <= n; j++) {
if ((n - i * 3 - j * 5) % 7 == 0) {
printf("%d %d %d\n", i, j, (n - i * 3 - j * 5) / 7);
break;
}
}
if (j * 5 + i * 3 <= n) break;
}
if (i > n / 3) puts("-1");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class TT>
bool pal(T a, TT n) {
int k = 0;
for (int i = 0; i <= n / 2; i++) {
if (a[i] != a[n - i - 1]) {
k = 1;
break;
}
}
return k ? 0 : 1;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int x = 0, y = 0;
for (auto it : s)
if (it == '1')
x++;
else
y++;
int mn = min(x, y);
x -= mn;
y -= mn;
cout << max(x, y);
getchar();
getchar();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, long long> p;
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
p[x]++;
}
map<int, long long>::iterator it;
long long ans = 0;
for (it = p.begin(); it != p.end(); it++) {
if (it->first > 0) break;
if (it->first == 0)
ans += (it->second - 1) * it->second / 2;
else
ans += it->second * p[-it->first];
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod;
inline long long add(long long x, long long y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline long long sub(long long x, long long y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline long long mul(long long x, long long y) { return (x * 1LL * y) % mod; }
inline long long binpow(long long a, long long b) {
long long x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline long long inv(long long a) { return binpow(a, mod - 2); }
const long long N = 50;
long long p[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long d;
cin >> d >> mod;
p[0] = 1;
long long cur = 1;
for (long long i = 1; i < N; i++) {
p[i] = mul(p[i - 1], add(binpow(2, i - 1), 1));
}
long long where = 1, group = 0;
while (where <= d + 1) {
where *= 2;
group++;
}
group--;
vector<long long> S(N);
S[0] = 1;
for (long long i = 1; i < N; i++) {
S[i] = add(S[i - 1], mul(sub(binpow(2, i - 1), 1), p[i - 1]));
S[i] = add(S[i], p[i]);
}
long long extra_terms = sub(d, binpow(2, group));
cout << add(S[group], mul(extra_terms, p[group])) << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
long long n, k, jad[4][2005], jad1[4][2005], mit;
long long c = 998244353;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k;
jad[0][1] = 1;
jad[1][2] = 1;
jad[2][2] = 1;
jad[3][1] = 1;
long long sum = 0;
for (int(i) = (0); ((i)) < ((n - 1)); ((i))++) {
for (int j = 1; j <= k; j++) {
jad1[0][j] = jad[0][j] + jad[1][j] + jad[2][j] + jad[3][j - 1];
jad1[0][j] %= c;
jad1[1][j] = jad[1][j] + jad[0][j - 1] + jad[3][j - 1];
if (j > 3) jad1[1][j] += jad[2][j - 2];
jad1[1][j] %= c;
jad1[2][j] = jad[2][j] + jad[0][j - 1] + jad[3][j - 1];
if (j > 3) jad1[2][j] += jad[1][j - 2];
jad1[2][j] %= c;
jad1[3][j] = jad[3][j] + jad[0][j - 1] + jad[1][j] + jad[2][j];
jad1[3][j] %= c;
}
for (int(i) = (0); ((i)) < ((k + 1)); ((i))++)
for (int(j) = (0); ((j)) < ((4)); ((j))++) jad[j][i] = jad1[j][i];
for (int(i) = (0); ((i)) < ((4)); ((i))++) memset(jad1[i], 0, k + 1);
}
for (int(i) = (0); ((i)) < ((4)); ((i))++) {
sum += jad[i][k];
sum %= c;
}
cout << sum << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long M[20];
long long R[20];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
cout.precision(10);
int n;
cin >> n;
long long mx = 1;
for (int i = 1; i <= n; ++i) {
cin >> M[i];
mx = mx * M[i] / gcd(mx, M[i]);
}
for (int i = 1; i <= n; ++i) {
cin >> R[i];
}
long long db = 0;
for (int i = 0; i < mx; ++i) {
for (int j = 1; j <= n; ++j) {
if (i % M[j] == R[j]) {
++db;
break;
}
}
}
cout << (long double)(db) / mx;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int x[1010], y[1010], t[1010];
void update(int idx, int val, int n) {
while (idx <= n) {
t[idx] = (t[idx] + val) % 1000000007;
idx += idx & (-idx);
}
}
int sum(int idx) {
int s = 0;
while (idx > 0) {
s = (s + t[idx]) % 1000000007;
idx -= idx & (-idx);
}
return s;
}
int main() {
int n, res = 0;
cin >> n;
for (int i = (1); i < (n + 1); i++) cin >> x[i];
for (int i = (1); i < (n + 1); i++) {
int val = (2 + sum(i - 1) - sum(x[i] - 1) + 1000000007) % 1000000007;
res = (res + val) % 1000000007;
update(i, val, n + 1);
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char w[1000050];
int ch[1000050][26], fa[1000050], len[1000050], lst = 1, cnt = 1, pos[1000050];
int head[1000050], to[1000050], nxt[1000050], tot;
int f[22][1000050], Lg[1000050], dp[1000050], ans, dfn[1000050], enp[1000050];
int mx[1000050 << 2], n;
inline void add(int u, int v) {
to[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
}
void update(int l, int r, int x, int v, int p) {
mx[p] = max(mx[p], v);
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid)
update(l, mid, x, v, p << 1);
else
update(mid + 1, r, x, v, p << 1 | 1);
}
int query(int l, int r, int x, int y, int p) {
if (x <= l && y >= r) return mx[p];
int mid = (l + r) >> 1, re = 0;
if (x <= mid) re = max(re, query(l, mid, x, y, p << 1));
if (y > mid) re = max(re, query(mid + 1, r, x, y, p << 1 | 1));
return re;
}
void insert(int x, int id) {
int p = lst, np = ++cnt, q, nq;
lst = np;
len[np] = len[p] + 1;
for (; p && !ch[p][x]; p = fa[p]) ch[p][x] = np;
if (!p)
fa[np] = 1;
else {
q = ch[p][x];
if (len[q] == len[p] + 1)
fa[np] = q;
else {
nq = ++cnt;
fa[nq] = fa[q];
memcpy(ch[nq], ch[q], sizeof(ch[q]));
fa[q] = fa[np] = nq;
len[nq] = len[p] + 1;
for (; p && ch[p][x] == q; p = fa[p]) ch[p][x] = nq;
}
}
pos[id] = lst;
}
void dfs(int x) {
int i;
dfn[x] = ++dfn[0];
f[0][x] = fa[x];
for (i = 1; (1 << i) <= cnt; i++) f[i][x] = f[i - 1][f[i - 1][x]];
for (i = head[x]; i; i = nxt[i]) {
dfs(to[i]);
}
enp[x] = dfn[0];
}
int LEN;
int getp(int x, int d) {
x = pos[x];
int i;
for (i = 20; i >= 0; i--) {
if (f[i][x] && len[f[i][x]] >= d) x = f[i][x];
}
return x;
}
bool check(int x, int d) {
if (d == 1) return 1;
if (x - d + 1 < 1) return 0;
int p = getp(x, d - 1);
if (query(1, cnt, dfn[p], enp[p], 1) >= d - 1) return 1;
p = getp(x - 1, d - 1);
if (query(1, cnt, dfn[p], enp[p], 1) >= d - 1) return 1;
return 0;
}
int main() {
scanf("%d%s", &n, w + 1);
reverse(w + 1, w + n + 1);
int i, j = n;
for (i = 1; i <= n; i++) insert(w[i] - 'a', i);
for (i = 2; i <= cnt; i++) add(fa[i], i);
dfs(1);
LEN = 0;
while ((1 << LEN) <= cnt) LEN++;
for (i = 1, j = 0; i <= n; i++) {
dp[i] = dp[i - 1] + 1;
while (!check(i, dp[i])) {
dp[i]--;
j++;
update(1, cnt, dfn[getp(j, dp[j])], dp[j], 1);
}
ans = max(ans, dp[i]);
}
printf("%d\n", ans);
return 0;
}
| 25 |
#include <bits/stdc++.h>
int main() {
int n, i, sum = 0;
scanf("%d", &n);
for (i = 1; i < n; i++) {
sum = sum + i;
if (sum == n) {
printf("YES");
return 0;
} else if (sum > n) {
printf("NO");
return 0;
}
}
if (n == 1 || n == 0) printf("YES");
if (n == 2) printf("NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[5][101];
int main() {
int n, k;
cin >> n >> k;
printf("YES\n");
if (k % 2) {
if (k <= n - 2) {
str[1][n / 2] = '#';
for (int i = 1; i <= k / 2; i++) {
str[1][n / 2 - i] = str[1][n / 2 + i] = '#';
}
} else {
for (int i = 1; i < n - 1; i++) str[1][i] = '#';
for (int i = 1; i <= (k - n + 2) / 2; i++)
str[2][n / 2 - i] = str[2][n / 2 + i] = '#';
}
} else {
for (int i = 1; i <= k / 2; i++) {
str[1][i] = str[2][i] = '#';
}
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < n; j++) {
printf("%c", str[i][j] == '#' ? '#' : '.');
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n, l, t, m, rmx;
long long int ans, bite;
void reset();
void b_search(int low, int top);
long long int cal(int mid);
int main() {
int i, j, k;
while (scanf("%d %d %d", &a, &b, &n) == 3) {
for (i = 0; i < n; i++) {
scanf("%d %d %d", &l, &t, &m);
rmx = t - a + b;
rmx /= b;
if (rmx < l) {
printf("-1\n");
continue;
}
bite = (long long int)t * m;
b_search(l, rmx);
printf("%lld\n", ans);
}
}
return 0;
}
void b_search(int low, int top) {
if (low > top) {
return;
}
int mid;
long long int sum;
mid = (low + top) / 2;
sum = cal(mid);
if (sum <= bite) {
ans = mid;
b_search(mid + 1, top);
return;
}
b_search(low, mid - 1);
return;
}
long long int cal(int mid) {
long long int e, s, s2;
e = (mid - l) + 1;
s = (2 * l) + e - 1;
s *= e;
s *= b;
s /= 2;
s2 = (a - b);
s2 *= e;
s += s2;
return s;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100101;
const double PI = acos(-1);
const double eps = 1e-9;
int f[N], g[N], tmp[N], n, m;
double L[N], ang[N];
pair<double, double> a[N], b[N * 2];
bool chk(double lim) {
int cnt = 0;
for (int i = 1; i <= n; ++i) {
double t = acos(lim / L[i]);
double l = ang[i] - t, r = ang[i] + t;
if (r > 2 * PI) l -= 2 * PI, r -= 2 * PI;
b[cnt++] = make_pair(r, l);
b[cnt++] = make_pair(r + 2 * PI, l + 2 * PI);
}
sort(b, b + cnt);
for (int i = 0, j = 0; i < n; ++i) {
for (; j < cnt && b[j].second <= b[i].first; ++j)
;
f[i] = j;
g[i] = i;
}
for (int i = 0; (1 << i) <= m; ++i) {
if (m >> i & 1) {
for (int j = 0; j < n; ++j) {
tmp[j] = g[f[j] % n] + f[j] - f[j] % n;
if (tmp[j] >= n + j) return 1;
}
memcpy(g, tmp, sizeof g);
}
for (int j = 0; j < n; ++j) tmp[j] = f[f[j] % n] + f[j] - f[j] % n;
memcpy(f, tmp, sizeof f);
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i)
cin >> a[i].first >> a[i].second,
L[i] = sqrt(a[i].first * a[i].first + a[i].second * a[i].second),
ang[i] = atan2(a[i].second, a[i].first);
double l = 0, r = *min_element(L + 1, L + n + 1);
while (r - l > eps) {
double mid = l + (r - l) / 2;
if (chk(mid))
l = mid;
else
r = mid;
}
cout << fixed << setprecision(8) << (l + r) / 2 << '\n';
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N |= (1LL << pos); }
int Reset(int N, int pos) { return N &= ~(1LL << pos); }
bool Check(int N, int pos) { return N & (1LL << pos); }
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
inline void cn(long &n) {
n = 0;
long ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
template <class T>
void cmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void cmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
int len(const T &c) {
return (int)c.size();
}
template <class T>
int len(char c[]) {
return (int)strlen(c);
}
string itos(long n) {
string s;
while (n) {
s += (n % 10 + 48);
n /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long stoi(string s) {
long n = 0;
for (int i(0), _n(len(s)); i < _n; ++i) n = n * 10 + (s[i] - 48);
return n;
}
long long n, a, b, i, j, k, res[20000006];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b;
for (i = 1, j = 1, k = 1; i <= a || j <= b; k++) {
if (i * b < j * a) {
res[k] = 1;
i++;
} else if (i * b > j * a) {
res[k] = 2;
j++;
} else {
res[k] = 3;
res[k++] = 3;
i++;
j++;
}
}
k--;
for (int i(0), _n(n); i < _n; ++i) {
cin >> a;
if (a % k == 0)
b = res[k];
else
b = res[a % k];
if (b == 1)
cout << "Vanya\n";
else if (b == 2)
cout << "Vova\n";
else
cout << "Both\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, w, a[N], b[N];
int cur[N];
long long ans;
struct node {
long long val;
int pos;
node(int P, long long V) { pos = P, val = V; }
bool operator<(const node &C) const { return val > C.val; }
};
priority_queue<node> q[6];
const int limit[] = {0, 0, 1, 1, 2};
const int p[] = {0, 1, 4, 3, 5};
const int limit2[] = {0, 0, 0, 1, 1, 2};
int ch;
const long long INF = 1LL << 60;
long long calc(int x) {
if (x == 1) return q[1].size() ? q[1].top().val : INF;
if (x == 2) return q[4].size() ? q[4].top().val : INF;
if (x == 3)
return q[3].size() && q[2].size() ? q[3].top().val + q[2].top().val : INF;
return q[5].size() && q[2].size() ? q[5].top().val + q[2].top().val : INF;
}
void work(int x) {
if (x == 1) {
int pos = q[1].top().pos;
cur[pos] = 1;
q[3].push(node(pos, -a[pos]));
q[4].push(node(pos, b[pos] - a[pos]));
return;
}
if (x == 2) {
int pos = q[4].top().pos;
cur[pos] = 2;
q[5].push(node(pos, a[pos] - b[pos]));
return;
}
if (x == 3) {
int pos1 = q[3].top().pos, pos2 = q[2].top().pos;
cur[pos1] = 0;
q[1].push(node(pos1, a[pos1]));
q[2].push(node(pos1, b[pos1]));
cur[pos2] = 2;
q[5].push(node(pos2, a[pos2] - b[pos2]));
return;
}
if (x == 4) {
int pos1 = q[5].top().pos, pos2 = q[2].top().pos;
cur[pos1] = 1;
q[3].push(node(pos1, -a[pos1]));
q[4].push(node(pos1, b[pos1] - a[pos1]));
cur[pos2] = 2;
q[5].push(node(pos2, a[pos2] - b[pos2]));
return;
}
}
int main() {
cin >> n >> w;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= n; i++) {
q[1].push(node(i, a[i]));
q[2].push(node(i, b[i]));
}
for (int c = 1; c <= w; c++) {
ch = -1;
for (int i = 1; i <= 5; i++)
while (q[i].size() && cur[q[i].top().pos] != limit2[i]) q[i].pop();
for (int i = 1; i <= 4; i++) {
if (q[p[i]].size() && cur[q[p[i]].top().pos] == limit[i])
if (ch == -1 || calc(i) < calc(ch)) ch = i;
}
ans += calc(ch);
work(ch);
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) printf("%d", cur[i]);
return 0;
}
| 18 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.