solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void qmax(int &x, int y) {
if (x < y) x = y;
}
void qmin(int &x, int y) {
if (x > y) x = y;
}
inline int read() {
char s;
int k = 0, base = 1;
while ((s = getchar()) != '-' && s != EOF && !(isdigit(s)))
;
if (s == EOF) exit(0);
if (s == '-') base = -1, s = getchar();
while (isdigit(s)) k = k * 10 + (s ^ '0'), s = getchar();
return k * base;
}
inline void write(long long x) {
static char cnt, num[20];
cnt = 0;
if (!x) {
putchar('0');
return;
}
for (; x; x /= 10) num[++cnt] = x % 10;
for (; cnt; putchar(num[cnt--] + 48))
;
}
const int N = 85;
int n, m, k;
int a[N], c1[N];
int L[N], R[N], cnt[N];
int p[N];
namespace Min_Cost {
const int maxn = 500;
const int maxm = 5e3 + 100;
int po[maxn], to[maxm << 1], ne[maxm << 1], w[maxm << 1], id;
int c[maxn << 1];
int MaxF, S, T;
int vis[maxn], pre[maxn];
int MinC, dis[maxn];
void add(int x, int y, int z, int C) {
id++;
to[id] = y, w[id] = z, c[id] = C, ne[id] = po[x], po[x] = id;
swap(x, y);
z = 0, C = -C;
id++;
to[id] = y, w[id] = z, c[id] = C, ne[id] = po[x], po[x] = id;
}
bool spfa() {
queue<int> q;
memset(pre, 0, sizeof(pre));
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= T; i++) dis[i] = 1e6 * n;
q.push(S), vis[S] = 1;
dis[S] = 0;
int u, v;
while (!q.empty()) {
u = q.front();
q.pop();
vis[u] = 0;
for (int i = po[u]; i; i = ne[i])
if (w[i]) {
v = to[i];
if (dis[u] + c[i] < dis[v]) {
pre[v] = i;
dis[v] = dis[u] + c[i];
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
return dis[T] != dis[0];
}
void get_ans() {
int W = w[pre[T]];
for (int i = T; pre[i]; i = to[pre[i] ^ 1]) {
qmin(W, w[pre[i]]);
}
MaxF += W;
for (int i = T; pre[i]; i = to[pre[i] ^ 1]) {
MinC += c[pre[i]] * W;
w[pre[i]] -= W;
w[pre[i] ^ 1] += W;
}
}
void work() {
id = 1;
for (int i = 1; i <= n; i++) {
add(S, i, 1, c1[a[i]]);
add(i, i + n, 1, 0);
add(i + n, T, 1, 0);
if (i < n) add(i, i + 1, k - 1, 0);
if (pre[a[i]]) add(i - 1, pre[a[i]] + n, 1, -c1[a[i]]);
pre[a[i]] = i;
}
memset(pre, 0, sizeof(pre));
while (spfa()) get_ans();
printf("%d\n", MinC);
}
} // namespace Min_Cost
int main() {
n = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) c1[i] = read();
Min_Cost::S = n + n + 1;
Min_Cost::T = n + n + 2;
Min_Cost::work();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x;
vector<pair<int, int> > vec;
void binser(int x1, int y1, int x2, int y2) {
if (x1 == x2) {
int kir = 1, kan = n;
while (kir < kan) {
int mid = (kir + kan) / 2;
printf("? %d %d %d %d\n", x1, 1, x2, mid);
fflush(stdout);
scanf("%d", &x);
if (x & 1)
kan = mid;
else
kir = mid + 1;
}
vec.push_back({x1, kir});
} else {
int kir = 1, kan = n;
while (kir < kan) {
int mid = (kir + kan) / 2;
printf("? %d %d %d %d\n", 1, y1, mid, y2);
fflush(stdout);
scanf("%d", &x);
if (x & 1)
kan = mid;
else
kir = mid + 1;
}
vec.push_back({kir, y1});
}
}
void print() {
printf("! %d %d %d %d\n", vec[0].first, vec[0].second, vec[1].first,
vec[1].second);
fflush(stdout);
}
int main() {
scanf("%d", &n);
int hit = 0;
for (int i = 1; i <= n; i++) {
printf("? %d 1 %d %d\n", i, i, n);
fflush(stdout);
scanf("%d", &x);
if (x & 1) {
binser(i, 1, i, n);
hit++;
}
if (hit == 2) {
print();
return 0;
}
}
for (int i = 1; i < n; i++) {
printf("? 1 %d %d %d\n", i, n, i);
fflush(stdout);
scanf("%d", &x);
if (x & 1) {
binser(1, i, n, i);
hit++;
}
if (hit == 2) {
print();
return 0;
}
}
binser(1, n, n, n);
print();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char tem1[] = "AbdHIMOopqTUVvWwXxY";
char tem2[] = "AdbHIMOoqpTUVvWwXxY";
int main() {
char s[1010];
scanf("%s", &s);
int len = strlen(s);
int i = 0, j = len - 1;
bool flag = 1;
while (i <= j) {
int k;
for (k = 0; k < strlen(tem1); k++) {
if (tem1[k] == s[i]) break;
}
if (k == strlen(tem1)) {
flag = 0;
break;
}
if (tem1[k] == s[i] && tem2[k] == s[j]) {
i++;
j--;
continue;
} else {
flag = 0;
break;
}
}
if (flag)
printf("TAK\n");
else
printf("NIE\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
map<int, int> l;
map<int, int> mp;
map<int, int> visited;
vector<int> adj[N];
long long power(long long a, long long b) {
long long ret = 1;
for (long long i = 0; i < b; i++) ret = (ret * a) % 998244353;
return ret;
}
int cur = 1;
void DFS(int s, int p, int c) {
if (visited[s]) {
if (l[s] != c) cur = 0;
return;
}
visited[s] = 1;
l[s] = c, mp[c]++;
for (auto x : adj[s])
if (x != p) DFS(x, s, !c);
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
long long res = 1;
if (n == 1) {
cout << 3 << endl;
continue;
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
cur = 1;
mp.clear();
DFS(i, -1, 0);
res =
1LL * cur *
(res * (power(2, mp[0]) % 998244353 + power(2, mp[1]) % 998244353) %
998244353) %
998244353;
}
}
cout << res << endl;
mp.clear();
l.clear();
visited.clear();
for (int i = 1; i <= n; i++) adj[i].clear();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, y;
cin >> n;
vector<int> a(n);
cin >> a[0];
y = a[0];
for (int i = 1; i < n; i++) {
cin >> a[i];
y = y & a[i];
}
cout << y << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[505][505];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
int top = 1000, right = -1, buttom = -1, left = 1000;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == '.') continue;
if (i <= top) top = i;
if (left >= j) left = j;
if (i >= buttom) buttom = i;
if (j >= right) right = j;
{}
}
}
int flag = 1;
for (int i = top; i <= buttom; i++) {
for (int j = left; j <= right; j++) {
if (s[i][j] != 'X') {
flag = 0;
cout << "NO" << endl;
return 0;
}
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int t, i, j, k, l, num1[11], a[20], num2[11], res[11], cc, ans;
char sub[10], s[300];
while (~scanf("%d", &t)) {
k = 0, cc = 0;
memset(sub, 0, sizeof(sub));
memset(a, 0, sizeof(a));
memset(num1, 0, sizeof(num1));
memset(num2, 0, sizeof(num2));
memset(res, 0, sizeof(res));
while (t > 0) {
sub[k] = t % 10 + '0';
a[k++] = t % 10;
num1[t % 10]++;
t = t / 10;
}
sub[k] = '\0';
getchar();
scanf("%s", s);
l = strlen(s);
for (i = 0; i < l; i++) {
num2[s[i] - '0']++;
}
num1[2] += num1[5], num1[6] += num1[9];
num2[2] += num2[5], num2[6] += num2[9];
for (i = 0; i < k; i++) {
if (a[i] == 5)
res[cc++] = num2[2] / num1[2];
else if (a[i] == 9)
res[cc++] = num2[6] / num1[6];
else
res[cc++] = num2[a[i]] / num1[a[i]];
}
ans = res[0];
for (i = 0; i < cc; i++)
if (ans > res[i]) ans = res[i];
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int even(int n) { return n % 2; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int e1 = 0, e2 = 0, o1 = 0, o2 = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (even(x))
o1++;
else
e1++;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (even(x))
o2++;
else
e2++;
}
cout << min(o1, e2) + min(o2, e1) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n1, i, l, j, k, n, m, ss1[100100], ss2[100030], ss3[100030];
char cc(char c1, char c2) {
char c = 'c';
if (c1 != 'a' && c2 != 'a')
c = 'a';
else if (c1 != 'b' && c2 != 'b')
c = 'b';
return c;
}
int main() {
string s1, s2, s3 = "";
cin >> l >> m;
cin >> s1 >> s2;
int match = 0;
for (i = 0; i < l; i++) {
if (s1.at(i) == s2.at(i)) match++;
}
bool tr = true;
m = l - m;
if (m <= match) {
match = m;
m = 0;
j = 0;
} else {
for (i = 0; i <= match; i++) {
j = m - i;
k = l - i - 2 * j;
if (k >= 0 && k + i >= match) {
tr = true;
break;
} else
tr = false;
}
if (k < 0) tr = false;
match = i;
}
if (tr == false) {
cout << -1 << endl;
return 0;
}
int l1 = j, l2 = j;
m = l - 2 * j - match;
for (i = 0; i < l; i++) {
if (s1.at(i) == s2.at(i)) {
if (match) {
match--;
s3.insert(i, 1, s1.at(i));
} else
s3.insert(i, 1, cc(s1.at(i), s2.at(i)));
} else if (l1) {
l1--;
s3.insert(i, 1, s1.at(i));
} else if (l2) {
l2--;
s3.insert(i, 1, s2.at(i));
} else {
s3.insert(i, 1, cc(s1.at(i), s2.at(i)));
}
}
cout << s3 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
unsigned long long n, m, k;
cin >> n >> m >> k;
int* a = new int[n];
int p = (n + 1) / 2;
unsigned long long t = 1000000;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
if (!(i % 2) && a[i] < t) t = a[i];
}
if (n % 2 && m >= p) {
unsigned long long q = m / p;
cout << min(k * q, t) << endl;
} else
cout << 0 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v;
long long mx = -1, mn = -1;
for (long long i = 1; i * i <= n; i++)
if (n % i == 0) {
v.push_back(i);
v.push_back(n / i);
}
sort((v).begin(), (v).end());
for (int i = 0; i < (int)(v).size(); i++) {
long long rest = n / v[i];
for (int j = 0; j < (int)(v).size(); j++)
if (rest % v[j] == 0) {
long long a = v[i] + 1;
long long b = v[j] + 2;
long long c = rest / v[j] + 2;
mx = max(mx, a * b * c - (a - 1) * (b - 2) * (c - 2));
if (mn == -1) mn = a * b * c - (a - 1) * (b - 2) * (c - 2);
mn = min(mn, a * b * c - (a - 1) * (b - 2) * (c - 2));
}
}
cout << mn << " " << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long power(long long B, long long P) {
if (P == 0) return 1;
long long X = power(B, P / 2);
if (P % 2 == 0)
return X * X;
else
return B * X * X;
}
long long fx[] = {1, -1, 0, 0};
long long fy[] = {0, 0, 1, -1};
long long A[3000005], B[3000005], C[3000005], visited[3000005], level[3000005];
char CH[1000][1000];
vector<long long> V, G;
int main() {
long long T, N, E, u, Q, v, i, j, k, sum = 0, ck = 0, x, y, cs = 0;
string S, S1;
double d1, d2, d3;
cin >> N;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) cin >> CH[i][j];
}
long long ar1[] = {-1, -1, 1, 1};
long long ar2[] = {-1, 1, -1, 1};
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
if (i == j) {
if (CH[i][j] != CH[0][0]) {
cout << "NO" << endl;
return 0;
}
} else if (i + j == N - 1) {
if (CH[i][j] != CH[0][0] || CH[i][j] != CH[0][N - 1]) {
cout << "NO" << endl;
return 0;
}
} else if (CH[i][j] == CH[0][0] || CH[i][j] != CH[0][1]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> adia[1100];
int costsg;
int n, m;
int S, T, l;
int dist[1100];
vector<pair<pair<int, int>, pair<int, int>>> alone;
int cbin();
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> l >> S >> T;
int a, b, c;
while (m--) {
cin >> a >> b >> c;
if (c == 0) alone.push_back({{a, adia[a].size()}, {b, adia[b].size()}});
adia[a].push_back({b, c});
adia[b].push_back({a, c});
}
costsg = 100;
int p(0), q(1 << 30);
while (q) {
if (p + q <= 1000 * 1000 * 1100) {
costsg = p + q;
int x(cbin());
if (x <= l) p += q;
}
q >>= 1;
}
costsg = p;
if (cbin() > l || p == 0) {
cout << "NO";
return 0;
}
costsg = p + 1;
if (cbin() < l) {
cout << "NO";
return 0;
}
for (auto i : alone) {
adia[i.first.first][i.first.second].second =
adia[i.second.first][i.second.second].second = p;
}
int punere(p);
p = 0, q = 1 << 20;
while (q) {
if (p + q <= alone.size()) {
for (int i(0); i < p + q; i++)
adia[alone[i].first.first][alone[i].first.second].second++,
adia[alone[i].second.first][alone[i].second.second].second++;
int x(cbin());
for (int i(0); i < p + q; i++)
adia[alone[i].first.first][alone[i].first.second].second--,
adia[alone[i].second.first][alone[i].second.second].second--;
if (x <= l) p += q;
}
q >>= 1;
}
for (int i(0); i < p; i++)
adia[alone[i].first.first][alone[i].first.second].second++,
adia[alone[i].second.first][alone[i].second.second].second++;
cout << "YES\n";
for (int i(0); i < n; i++) {
for (auto j : adia[i]) {
if (j.first > i) cout << i << ' ' << j.first << ' ' << j.second << '\n';
}
}
return 0;
}
int cbin() {
for (int i(0); i <= n; i++) dist[i] = 1e9 + 100;
priority_queue<pair<int, int>> q;
q.push({0, S});
while (!q.empty()) {
int t(q.top().first), x(q.top().second);
t *= -1;
q.pop();
if (dist[x] < t) continue;
if (x == T) return dist[x];
for (auto i : adia[x]) {
if (!i.second) i.second = costsg;
if (dist[i.first] > t + i.second) {
dist[i.first] = t + i.second;
q.push({-dist[i.first], i.first});
}
}
}
return 2 * 1000 * 1000 * 1000;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxjp = 18 + 1;
vector<complex<int> > A;
complex<int> m, p;
int n;
long long j;
int sum[maxjp];
void sym(const int l) { m = 2 * A[l] - m; }
int main() {
scanf("%d", &n);
cin >> j;
j %= (2 * n);
int x, y;
scanf("%d %d", &x, &y);
m = complex<int>(x, y);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
p = complex<int>(x, y);
A.push_back(p);
}
for (int i = 0; i < j; i++) sym(i % n);
cout << m.real() << " " << m.imag() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000 + 5], b[1000 + 5];
pair<int, int> tmp[1000 + 5];
vector<pair<int, int> > ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tmp[i] = make_pair(a[i], i);
}
sort(tmp + 1, tmp + 1 + n);
for (int i = 1; i <= n; i++) a[tmp[i].second] = i;
for (int i = 1; i <= n; i++) b[a[i]] = i;
for (int i = n; i >= 1; i--) {
for (int j = i; j < n; j++) {
if (b[j] > b[j + 1]) {
ans.push_back(make_pair(b[j + 1], b[j]));
swap(b[j], b[j + 1]);
}
}
}
printf("%d\n", (int)ans.size());
for (auto p : ans) printf("%d %d\n", p.first, p.second);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long l, r, m;
cin >> l >> r >> m;
if (m < l) {
cout << l << " " << l << " " << 2 * l - m << "\n";
} else {
for (long long i = l; i <= r; i++) {
long long x = m % i;
long long j = i - x;
if (j <= r - l) {
cout << i << " " << l << " " << l + j << "\n";
break;
}
if (x <= r - l) {
cout << i << " " << l + x << " " << l << "\n";
break;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 9223372036854775807;
long long fastPow(long long b, long long e) {
long long r = 1;
while (e) {
if (e % 2 == 1) {
r *= b;
r %= mod;
}
b *= b;
b %= mod;
e /= 2;
}
return r;
}
long long pgcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return pgcd(b, a % b);
}
long long sign(long long a) {
if (a < 0) {
return -1;
}
if (a == 0) {
return 0;
}
return 1;
}
bool isPrime(long long a) {
if (a == 1) {
return false;
}
long long f = sqrt(a);
for (long long i = 2; i <= f; i++) {
if (a % i == 0) {
return false;
}
}
return true;
}
long long toInt(string s) {
long long tot = 0;
for (long long i = s.size() - 1; i >= 0; i--) {
tot += ((s[i] - '0') % mod) * fastPow(10, i);
tot %= mod;
}
return tot;
}
string toString(long long a) {
string s = "";
while (a) {
s = (char)('0' + a % 10) + s;
a /= 10;
}
return s;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long m;
cin >> m;
string s;
cin >> s;
set<long long> used;
vector<char> ans;
for (long long i = 0; i < s.size(); i++) {
char c = 'z';
long long a = -9223372036854775807;
for (long long j = i; j < i + m; j++) {
if (c >= s[j]) {
c = s[j];
a = j;
}
}
if (used.count(a)) break;
ans.push_back(c);
used.insert(a);
if (a + m >= s.size()) break;
i = a;
}
sort(ans.begin(), ans.end());
char last = ans.back();
for (long long i = 0; i < s.size(); i++) {
if (used.count(i)) continue;
if (s[i] < last) ans.push_back(s[i]);
}
sort(ans.begin(), ans.end());
for (auto a : ans) {
cout << a;
}
cout << endl;
}
| 5 |
#include<bits/stdc++.h>
#define FOR(i,a,b) for(register int i=(a);i<=(b);i++)
#define REP(i,a,b) for(register int i=(a);i>=(b);i--)
#define pb push_back
#define fi first
#define se second
#define hvie '\n'
using namespace std;
typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
int yh(){
int ret=0;bool f=0;char c=getchar();
while(!isdigit(c)){if(c==EOF)return -1;if(c=='-')f=1;c=getchar();}
while(isdigit(c))ret=(ret<<3)+(ret<<1)+(c^48),c=getchar();
return f?-ret:ret;
}
const int maxn=1e5+5;
int n;
int a[maxn];
int f[maxn];
int mj[maxn];
int main(){
n=yh();
FOR(i,1,n){
a[i]=yh();
}
n=unique(a+1,a+1+n)-a-1;
// FOR(i,1,n) cout<<a[i]<<" ";cout<<endl;
memset(mj,-1,sizeof(mj));
f[0]=0,f[1]=1;
int ans=n;
mj[a[1]]=1;
FOR(i,2,n){
f[i]=f[i-1]+(a[i]!=a[i-2]);
if(mj[a[i]]!=-1){
int j=mj[a[i]]+1;
// cout<<i<<": "<<j<<hvie;
f[i]=min(f[i],f[j]+(i-j-1)+(a[j-1]!=a[i]));
}
mj[a[i]]=i;
// cout<<"dp"<<i<<" : "<<f[i]<<hvie;
ans=min(ans,f[i]+n-i);
}
cout<<ans<<hvie;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1000000;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
long long x1[1000000];
long long t[4300000];
long long g[4300000];
set<pair<long long, long long> > st;
set<pair<long long, long long> >::iterator it;
void push(long long v) {
t[v * 2] += g[v];
t[v * 2 + 1] += g[v];
g[v * 2 + 1] += g[v];
g[v * 2] += g[v];
g[v] = 0;
}
void modify(long long v, long long tl, long long tr, long long l, long long r,
long long val) {
if (l > r) return;
if (tl == l and tr == r) {
t[v] += val;
g[v] += val;
} else {
long long tm = (tl + tr) / 2;
push(v);
modify(v * 2, tl, tm, l, min(r, tm), val);
modify(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
}
long long get(long long v, long long tl, long long tr, long long pos) {
if (tl == tr) return t[v];
long long tm = (tl + tr) / 2;
push(v);
if (pos <= tm)
return get(v * 2, tl, tm, pos);
else
return get(v * 2 + 1, tm + 1, tr, pos);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
long long n, k, d, kol, now, pos;
long long l, r;
cin >> n >> k >> d;
for (int i = 1; i <= n; i++) {
cin >> x1[i];
}
sort(x1 + 1, x1 + 1 + n);
for (int i = 1; i <= n; i++) {
st.insert({x1[i], i});
}
n++;
modify(1, 1, n, 1, 1, 1);
for (int i = 1; i < n; i++)
if (get(1, 1, n, i)) {
now = x1[i];
it = st.lower_bound({x1[i] + d + 1, 0});
if (it != st.end())
pos = it->second;
else
pos = n;
l = i + k;
r = pos;
if (l <= r) modify(1, 1, n, l, r, 1);
}
if (get(1, 1, n, n))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-6;
int cnt[200005];
int dist[200005];
int tmp[200005];
int n, m;
long long Run(int start, bool isRight) {
memmove(tmp, cnt, sizeof(tmp));
int now = start;
long long res = 0LL;
for (int k = 0; k < m; k++) {
if (tmp[now] > 0)
tmp[now]--;
else
return -1;
if (k == m - 1) return res;
if (now == n) isRight = false;
if (now == 1) isRight = true;
if (isRight) {
now++;
res += dist[now];
} else {
res += dist[now];
now--;
}
}
return res;
}
bool Check(long long newRes, long long &res) {
if (res == -1) {
res = newRes;
return true;
}
if (newRes != -1 && newRes != res) return false;
return true;
}
long long Solve() {
long long res = -1;
if (!Check(Run(1, true), res)) return -1;
if (!Check(Run(2, false), res)) return -1;
if (!Check(Run(n, false), res)) return -1;
if (!Check(Run(n - 1, true), res)) return -1;
for (int i = 2; i <= n - 1; i++) {
if (cnt[i] > cnt[i - 1])
if (!Check(Run(i, true), res)) return -1;
if (cnt[i] > cnt[i + 1])
if (!Check(Run(i, false), res)) return -1;
}
return res;
}
int main() {
{ ; };
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", dist + i);
scanf("%d", &m);
for (int j = 0; j < m; j++) {
int b;
scanf("%d", &b);
cnt[b]++;
}
for (int i = n; i >= 1; i--) dist[i] -= dist[i - 1];
dist[1] = 0;
cout << Solve() << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[5555], n, k;
int cnt[1111111];
int seen[1111111];
int main() {
int i, j;
cin >> n >> k;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 1; i <= n; ++i) {
for (j = i + 1; j <= n; ++j) {
int dd = a[i] - a[j];
if (dd < 0) dd = -dd;
cnt[dd]++;
}
}
int m;
for (m = n - k;; ++m) {
int bad = 0;
for (j = m; j <= 1000000; j += m) bad += cnt[j];
if (bad > (k * (k + 1)) / 2) continue;
int need = 0;
for (j = 1; j <= n; ++j) {
int md = a[j] % m;
if (seen[md] == m)
need++;
else
seen[md] = m;
}
if (need <= k) break;
}
cout << m;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - '0';
while (isdigit(ch = getchar())) v = v * 10 + ch - '0';
if (f)
return -v;
else
return v;
}
const int maxn = 1003;
long long a[maxn][maxn], b[maxn][maxn], c[maxn][maxn];
int n, m, k;
int main() {
n = get(), m = get();
k = get();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
a[i][j] = a[i - 1][j] + a[i][j - 1] + get() - a[i - 1][j - 1],
b[i][j] = b[i - 1][j + 1] + a[i][j] -
(i > k && j + k <= m ? a[i - k][j + k] : 0),
c[i][j] =
c[i - 1][j - 1] + a[i][j] - (i > k && j > k ? a[i - k][j - k] : 0);
b[i][0] = b[i - 1][1] - (i > k ? a[i - k][k] : 0);
}
long long v = -1, t;
int x, y;
for (int i = k; i <= n - k + 1; i++)
for (int j = k; j <= m - k + 1; j++)
if ((t = b[i + k - 1][j] + b[i - 1][j - k] - c[i + k - 1][j - 1] -
c[i - 1][j + k - 1]) > v)
v = t, x = i, y = j;
printf("%d %d\n", x, y);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
const long long inf64 = 1ll * inf * inf;
const int mod = 1000 * 1000 + 3;
int sum(int a, int b) { return (a + b) % mod; }
int mul(int a, int b) { return (1ll * a * b) % mod; }
int binpow(int n, int p) {
if (p == 0) return 1;
int q = binpow(n, p / 2);
q = mul(q, q);
if (p % 2) q = mul(q, n);
return q;
}
const int N = 1000100;
int fact[N], rfact[N];
int C(int n, int k) {
return (n < k ? 0 : mul(fact[n], mul(rfact[n - k], rfact[k])));
}
bool solve() {
fact[0] = 1;
rfact[0] = binpow(fact[0], mod - 2);
for (int i = 1; i < N; i++) {
fact[i] = mul(fact[i - 1], i);
rfact[i] = binpow(fact[i], mod - 2);
}
int n, c;
cin >> n >> c;
int res = 0;
for (int i = 1; i <= n; i++) {
res = sum(res, C(c + i - 1, i));
}
cout << res << '\n';
return true;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long par[N];
long long vis[N];
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int parent(int x) {
while (par[x] != x) {
x = par[x];
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int cnt = 0, x, y, i;
memset(vis, -1, sizeof(vis));
for (long long i = 0; i < 100; i++) {
par[i] = i;
}
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x = parent(x);
y = parent(y);
par[x] = y;
}
for (long long i = 1; i < n + 1; i++) {
if (vis[parent(i)] == -1) {
cnt++;
vis[parent(i)] = 1;
}
}
cout << binpow(2, n - cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool p[501][5001];
struct state {
int d, sum;
string s;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int i, j, k, m, n, d0, nd, mod, d, sum, nsum, sum0;
string s;
cin >> mod >> sum0;
queue<state> q;
q.push({0, 0, ""});
p[0][0] = 1;
while (!q.empty()) {
d = q.front().d;
sum = q.front().sum;
s = q.front().s + ' ';
q.pop();
if (d == 0 && sum == sum0) {
cout << s;
return 0;
}
for (i = 0; i <= 9; i++) {
nd = (d * 10 + i) % mod;
nsum = sum + i;
if (p[nd][nsum] == 0 && nsum <= sum0) {
p[nd][nsum] = 1;
s[s.size() - 1] = '0' + i;
q.push({nd, nsum, s});
}
}
}
cout << -1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, m, t;
int Last[100002], Next[100002], End[100002];
long long w[100002];
int dp[3002][3002], s[100002];
long long v[3002][3002];
inline int Min(int p, int q) { return p < q ? p : q; }
void dfs0(int p, int f) {
s[p] = 1;
for (int i = Last[p]; i; i = Next[i])
if (End[i] != f) dfs0(End[i], p), w[p] += w[End[i]], s[p] += s[End[i]];
}
void dfs(int p, int f) {
int cnt = 1;
for (int i = 0; i <= m && i <= s[p]; i++) dp[p][i] = 0, v[p][i] = 1e18;
v[p][0] = 0;
for (int i = Last[p]; i; i = Next[i])
if (End[i] != f) {
dfs(End[i], p);
for (int j = Min(m, cnt + s[End[i]]); j >= 1; j--)
for (int k = Min(j, cnt); k >= 0 && k >= j - s[End[i]]; k--) {
if (dp[p][j] < dp[p][k] + dp[End[i]][j - k] ||
(dp[p][j] == dp[p][k] + dp[End[i]][j - k] &&
v[p][j] > v[p][k] + v[End[i]][j - k]))
dp[p][j] = dp[p][k] + dp[End[i]][j - k],
v[p][j] = v[p][k] + v[End[i]][j - k];
}
cnt += s[End[i]];
}
for (int j = Min(m, cnt); j >= 1; j--)
if (dp[p][j] < dp[p][j - 1] + (w[p] - v[p][j - 1] > 0) ||
(dp[p][j] == dp[p][j - 1] + (w[p] - v[p][j - 1] > 0) && v[p][j] > w[p]))
dp[p][j] = dp[p][j - 1] + (w[p] - v[p][j - 1] > 0), v[p][j] = w[p];
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) Last[i] = 0;
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
w[i] = -p;
}
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
w[i] += p;
}
for (int i = 1; i < n + n - 2; i += 2) {
scanf("%d%d", &End[i + 1], &End[i]);
Next[i] = Last[End[i + 1]];
Last[End[i + 1]] = i;
Next[i + 1] = Last[End[i]];
Last[End[i]] = i + 1;
}
dfs0(1, 0);
dfs(1, 0);
printf("%d\n", dp[1][m - 1] + (w[1] > v[1][m - 1]));
}
}
| 8 |
#include <bits/stdc++.h>
char s1[52], s2[52];
int fr[26], ne[52], v[52], w[52], bs = 0;
bool f1[26][52][52], f2[26][52][52];
int z1[52][52], z2[52][52], dp[52][52];
int inf = 99999999;
void addb(int a, int b, int c) {
v[bs] = b;
w[bs] = c;
ne[bs] = fr[a];
fr[a] = bs++;
}
int main() {
int n, n1, n2;
scanf("%s%s%d", s1, s2, &n);
n1 = strlen(s1);
n2 = strlen(s2);
for (int i = 0; i < 26; i++) fr[i] = -1;
for (int i = 0; i < n; i++) {
char ch[10];
scanf("%s", ch);
addb(ch[0] - 'a', ch[3] - 'a', ch[4] - 'a');
}
for (int l = 1; l <= n1; l++) {
for (int i = 0; i < n1; i++) {
int j = i + l - 1;
if (j >= n1) break;
for (int c = 0; c < 26; c++) {
if (i == j && c == s1[i] - 'a') {
f1[c][i][j] = true;
continue;
}
f1[c][i][j] = false;
for (int k = i; k < j; k++) {
for (int a = fr[c]; a != -1; a = ne[a]) {
if (f1[v[a]][i][k] && f1[w[a]][k + 1][j]) {
f1[c][i][j] = true;
break;
}
}
if (f1[c][i][j]) break;
}
}
}
}
for (int i = 0; i < n1; i++) {
for (int j = i; j < n1; j++) {
for (int c = 0; c < 26; c++) {
if (f1[c][i][j]) z1[i][j] |= (1 << c);
}
}
}
for (int l = 1; l <= n2; l++) {
for (int i = 0; i < n2; i++) {
int j = i + l - 1;
if (j >= n2) break;
for (int c = 0; c < 26; c++) {
if (i == j && c == s2[i] - 'a') {
f2[c][i][j] = true;
continue;
}
f2[c][i][j] = false;
for (int k = i; k < j; k++) {
for (int a = fr[c]; a != -1; a = ne[a]) {
if (f2[v[a]][i][k] && f2[w[a]][k + 1][j]) {
f2[c][i][j] = true;
break;
}
}
if (f2[c][i][j]) break;
}
}
}
}
for (int i = 0; i < n2; i++) {
for (int j = i; j < n2; j++) {
for (int c = 0; c < 26; c++) {
if (f2[c][i][j]) z2[i][j] |= (1 << c);
}
}
}
for (int i = n1; i >= 0; i--) {
for (int j = n2; j >= 0; j--) {
if (i == n1 && j == n2)
dp[i][j] = 0;
else if (i == n1 || j == n2)
dp[i][j] = inf;
else {
dp[i][j] = inf;
for (int x = i; x < n1; x++) {
for (int y = j; y < n2; y++) {
if ((z1[i][x] & z2[j][y]) && dp[x + 1][y + 1] + 1 < dp[i][j])
dp[i][j] = dp[x + 1][y + 1] + 1;
}
}
}
}
}
if (dp[0][0] == inf)
printf("-1");
else
printf("%d", dp[0][0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:5000000000")
const long long mod = 1000000007;
long long Inf = (long long)2e9;
long long LINF = (long long)1e18 + 1e17;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int b, k;
cin >> b >> k;
vector<int> a(k);
for (int(i) = 0; (i) < k; (i)++) cin >> a[i];
reverse((a).begin(), (a).end());
if (b % 2 == 0) {
if (a[0] % 2 == 0)
cout << "even";
else
cout << "odd";
return 0;
}
int cnt = 0;
for (int(i) = 0; (i) < k; (i)++)
if (a[i] % 2 == 1) cnt++;
if (cnt % 2 == 0)
cout << "even";
else
cout << "odd";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const double sn = 1e-6;
int n;
vector<int> ch[1000006];
int te[1000006];
int to[1000006];
bool v[1000006];
vector<int> res;
int c;
int tot;
int dfs(int i) {
if (v[i]) return to[i];
v[i] = true;
int sz = ch[i].size();
int sum = 0;
for (int j = 0; j < sz; j++) {
int ts = dfs(ch[i][j]);
if (ts == tot / 3)
res.push_back(ch[i][j]);
else
sum += ts;
}
return to[i] = sum + te[i];
}
int main() {
scanf("%d", &n);
int sc = 0;
for (int i = 1; i <= n; i++) {
int t;
scanf("%d%d", &t, &te[i]);
if (t != 0)
ch[t].push_back(i);
else
sc = i;
tot += te[i];
}
if (tot % 3 != 0) {
printf("-1\n");
return 0;
}
dfs(sc);
int sz = res.size();
if (sz >= 2) {
printf("%d %d\n", res[0], res[1]);
} else
printf("-1\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, k;
char s[maxn];
vector<int> reles[maxn];
int fa[maxn], sz[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (y == 0) swap(x, y);
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int calc(int x) {
int y = x > k ? x - k : x + k;
x = find(x);
y = find(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int sz, x;
scanf("%d", &sz);
for (int j = 1; j <= sz; j++) {
scanf("%d", &x);
reles[x].push_back(i);
}
}
for (int i = 1; i <= k + k; i++) fa[i] = i;
for (int i = k + 1; i <= k + k; i++) sz[i] = 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (reles[i].size() == 0) {
} else if (reles[i].size() == 1) {
ans -= calc(reles[i][0]);
if (s[i] == '1') {
fa[find(reles[i][0] + k)] = 0;
} else {
fa[find(reles[i][0])] = 0;
}
ans += calc(reles[i][0]);
} else {
int x = reles[i][0], y = reles[i][1];
if (s[i] == '1') {
if (find(x) != find(y)) {
ans -= calc(reles[i][0]);
ans -= calc(reles[i][1]);
merge(x, y);
merge(x + k, y + k);
ans += calc(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= calc(x);
ans -= calc(y + k);
merge(x, y + k);
merge(x + k, y);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, k;
int a[N];
vector<int> v[N];
int main() {
cin >> n >> k >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
v[a[i] % m].push_back(a[i]);
}
for (int i = 0; i < m; ++i) {
if (v[i].size() >= k) {
cout << "Yes" << endl;
for (int j = 0; j < k; ++j) cout << v[i][j] << ' ';
cout << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt, tot, dfsclk, pos[400005], fst[400005], pnt[400005 << 1],
len[400005 << 1], nxt[400005 << 1], a[400005], b[400005], c[400005],
fa[400005];
long long f[400005], u1[400005], u2[400005], v1[400005], v2[400005], ans;
bool ok[400005];
void add(int x, int y, int z) {
pnt[++tot] = y;
len[tot] = z;
nxt[tot] = fst[x];
fst[x] = tot;
}
void dfs(int x) {
pos[x] = ++dfsclk;
int p;
for (p = fst[x]; p; p = nxt[p]) {
int y = pnt[p];
if (y != fa[x]) {
if (!pos[y]) {
fa[y] = x;
c[y] = len[p];
dfs(y);
} else if (pos[y] > pos[x]) {
for (; y != x; y = fa[y]) {
ok[y] = 0;
a[++cnt] = y;
b[cnt] = c[y];
}
ok[x] = 0;
a[++cnt] = x;
b[cnt] = len[p];
}
}
}
}
void dp(int x, int last) {
int p;
for (p = fst[x]; p; p = nxt[p]) {
int y = pnt[p];
if (ok[y] && y != last) {
dp(y, x);
ans = max(ans, f[x] + f[y] + len[p]);
f[x] = max(f[x], f[y] + len[p]);
}
}
}
int main() {
scanf("%d", &n);
int i, x, y, z;
memset(ok, 1, sizeof(ok));
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
dfs(1);
long long sum = 0, mx = 0;
for (i = 1; i <= cnt; i++) dp(a[i], 0);
for (i = 1; i <= cnt; i++) {
sum += b[i - 1];
u1[i] = max(u1[i - 1], f[a[i]] + sum);
v1[i] = max(v1[i - 1], f[a[i]] + sum + mx);
mx = max(mx, f[a[i]] - sum);
}
long long tmp = b[cnt];
sum = mx = b[cnt] = 0;
for (i = cnt; i; i--) {
sum += b[i];
u2[i] = max(u2[i + 1], f[a[i]] + sum);
v2[i] = max(v2[i + 1], f[a[i]] + sum + mx);
mx = max(mx, f[a[i]] - sum);
}
long long mn = v1[cnt];
for (i = 1; i < cnt; i++)
mn = min(mn, max(max(v1[i], v2[i + 1]), u1[i] + u2[i + 1] + tmp));
ans = max(ans, mn);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c;
cin >> a >> b >> c;
if (a == 0) {
if (b == 0) {
if (c == 0)
cout << -1;
else
cout << 0;
} else
cout << fixed << setprecision(5) << "1\n" << -c / b;
} else {
double denta = b * b - 4 * a * c;
if (denta < 0)
cout << 0;
else if (denta == 0)
cout << "1\n" << fixed << setprecision(5) << -b / 2 / a;
else {
double x1 = (-b - sqrt(denta)) / 2 / a, x2 = (-b + sqrt(denta)) / 2 / a;
if (x1 > x2) {
double temp = x1;
x1 = x2;
x2 = temp;
}
cout << "2\n"
<< fixed << setprecision(5) << x1 << "\n"
<< fixed << setprecision(5) << x2;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10505;
int n, Q, id[55][205], S, T;
int head[N], tot = 1, nd;
int dis[N], q[N], ans;
struct edge {
int to, next, f;
} e[N * 20];
void add(int x, int y, int f) {
e[++tot] = (edge){y, head[x], f};
head[x] = tot;
e[++tot] = (edge){x, head[y], 0};
head[y] = tot;
}
bool bfs() {
for (int i = (int)(1); i <= (int)(nd); i++) dis[i] = -1;
int h = 0, t = 1;
q[1] = S;
dis[S] = 0;
while (h != t) {
int x = q[++h];
for (int i = head[x]; i; i = e[i].next)
if (dis[e[i].to] == -1 && e[i].f) {
dis[e[i].to] = dis[x] + 1;
if (e[i].to == T) return 1;
q[++t] = e[i].to;
}
}
return 0;
}
int dfs(int x, int flow) {
if (x == T) return flow;
int k, rest = flow;
for (int i = head[x]; i && rest; i = e[i].next)
if (dis[e[i].to] == dis[x] + 1 && e[i].f) {
k = dfs(e[i].to, min(rest, e[i].f));
e[i].f -= k;
e[i ^ 1].f += k;
rest -= k;
}
if (rest) dis[x] = -1;
return flow - rest;
}
int main() {
scanf("%d%d", &n, &Q);
S = ++nd;
T = ++nd;
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(0); j <= (int)(201); j++) id[i][j] = ++nd;
for (int i = (int)(1); i <= (int)(n); i++) {
int A, B, C;
scanf("%d%d%d", &A, &B, &C);
for (int j = (int)(-100); j <= (int)(100); j++)
add(id[i][j + 100], id[i][j + 101], 1000000 - A * j * j - B * j - C);
}
for (int i = (int)(1); i <= (int)(n); i++) {
int l, r;
scanf("%d%d", &l, &r);
add(S, id[i][l + 100], 1 << 30);
add(id[i][r + 101], T, 1 << 30);
}
for (int i = (int)(1); i <= (int)(Q); i++) {
int x, y, v;
scanf("%d%d%d", &y, &x, &v);
for (int j = (int)(-100); j <= (int)(100); j++)
add(id[y][j + 100], id[x][max(min(j + 100 - v, 201), 0)], 1 << 30);
}
for (; bfs(); ans += dfs(S, 1 << 30))
;
printf("%d\n", 1000000 * n - ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, a[100008], count, maxi = 0, maxk, si;
cin >> n;
for (i = 0; i < n; i++) a[i] = i + 1;
maxk = 100009;
maxi = 1;
for (i = 1; i <= n; i++) {
si = 0;
if (n % i) si = 1;
k = n / i + i + si;
if (k < maxk) {
maxk = k;
maxi = i;
}
}
for (i = 0; i < n; i++) {
if (i < (n / maxi) * maxi)
cout << a[(i / maxi + 1) * maxi - i % maxi - 1] << " ";
else
cout << a[n - (i + 1) % maxi] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
int na;
long long want;
int a[MAXN];
int b[MAXN], nb;
bool ok(long long x) {
if (x == 0) {
int mx = a[0];
for (int i = (1); i < (na); ++i)
if (a[i] > mx) mx = a[i];
return mx >= want;
}
long long rem = want;
int pd = 0;
long long cur = 1;
for (int i = (0); i < (nb); ++i) {
int d = na - b[i] - 1, times = a[b[i]];
while (pd < d) {
++pd;
long long num = x + pd - 1, den = pd, g = gcd(num, den);
num /= g, den /= g;
assert(cur % den == 0);
cur /= den;
if (cur >= (rem + num - 1) / num) {
return true;
} else
cur *= num;
}
if (cur >= (rem + times - 1) / times) {
return true;
}
rem -= cur * times;
}
return rem <= 0;
}
void run() {
scanf("%d%lld", &na, &want);
for (int i = (0); i < (na); ++i) scanf("%d", &a[i]);
nb = 0;
for (int i = na - 1; i >= 0; --i)
if (a[i] != 0) b[nb++] = i;
long long l = -1, h = want;
while (l + 1 < h) {
long long m = l + (h - l) / 2;
if (ok(m))
h = m;
else
l = m;
}
printf("%lld\n", h);
}
int main() {
run();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int ans1[600005];
long long int ans2[600005];
int minsufa[600005];
int maxprefb[600005];
int res[600005];
int main() {
int(n), (w);
scanf("%d%d", &(n), &(w));
;
vector<pair<int, int> > v1;
vector<pair<pair<int, int>, int> > v2;
for (int i = (0); i < (n); ++i) {
int(a), (b);
scanf("%d%d", &(a), &(b));
;
if (b - a >= a) {
v1.push_back(make_pair(a, -i - 1));
v1.push_back(make_pair(b - a, i + 1));
} else {
v2.push_back(make_pair(make_pair(b, b - a), i));
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (v2.size()) {
maxprefb[0] = v2[0].first.second;
for (int i = (1); i < (v2.size()); ++i) {
maxprefb[i] = max(maxprefb[i - 1], v2[i].first.second);
}
minsufa[v2.size()] = 1e9;
minsufa[v2.size() - 1] =
v2[v2.size() - 1].first.first - v2[v2.size() - 1].first.second;
for (int i = (v2.size() - 2); i >= (0); --i) {
minsufa[i] = min(minsufa[i + 1], v2[i].first.first - v2[i].first.second);
}
}
ans1[0] = 0;
for (int i = (1); i < (v1.size() + 1); ++i) {
ans1[i] = ans1[i - 1] + v1[i - 1].first;
}
ans2[0] = 0;
int j = 0;
long long int pref = 0;
while (j < v2.size()) {
pref += v2[j].first.first;
ans2[2 * j + 1] =
min(pref - maxprefb[j], pref + minsufa[j + 1] - v2[j].first.first);
ans2[2 * j + 2] = pref;
j++;
}
long long int best = 1e9 * 1LL * 1e9;
int dlak = -1;
for (int k = (0); k < (w + 1); ++k) {
int l = w - k;
if (k <= v1.size() && l <= 2 * v2.size()) {
if (ans1[k] + ans2[l] < best) {
best = ans1[k] + ans2[l];
dlak = k;
}
}
}
cout << best << endl;
for (int i = (0); i < (n); ++i) res[i] = 0;
for (int i = (0); i < (dlak); ++i) {
if (v1[i].second < 0)
res[-v1[i].second - 1] = 1;
else
res[v1[i].second - 1] = 2;
}
int l = w - dlak;
if (l % 2 == 0) {
for (int j = (0); j < (l / 2); ++j) res[v2[j].second] = 2;
} else {
if (ans2[l + 1] - ans2[l] == maxprefb[l / 2]) {
bool ok = false;
for (int j = (0); j < (l / 2 + 1); ++j) {
if (!ok && v2[j].first.second == maxprefb[l / 2])
res[v2[j].second] = 1, ok = true;
else
res[v2[j].second] = 2;
}
} else {
for (int j = (0); j < (l / 2); ++j) {
res[v2[j].second] = 2;
}
for (int j = (l / 2); j < (v2.size()); ++j) {
if (v2[j].first.first - v2[j].first.second == minsufa[l / 2 + 1]) {
res[v2[j].second] = 1;
break;
}
}
}
}
for (int i = (0); i < (n); ++i) printf("%d", res[i]);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 200105;
const double PI = acos(-1.0);
const double eps = 1e-6;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
string s[205], tt;
int n, m, ans[205], l, r, len;
int work() {
for (int l = (1); l <= (10); ++l)
for (int t = (0); t <= ((1 << l) - 1); ++t) {
tt = "";
for (int k = (0); k <= (l - 1); ++k) tt += (t >> k & 1 ? "1" : "0");
if (s[n].find(tt) == -1) return l - 1;
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) cin >> s[i];
scanf("%d", &m);
while (m--) {
scanf("%d%d", &l, &r);
s[++n] = s[l] + s[r];
len = s[n].length();
if (len > 1000) s[n] = s[n].substr(0, 500) + s[n].substr(len - 500, 500);
ans[n] = max(work(), max(ans[l], ans[r]));
printf("%d\n", ans[n]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
cin.tie(0);
int n, S;
cin >> n >> S;
vector<ll> item(n);
for (int i = 0; i < n; i++) cin >> item[i];
int lo = 1, hi = n;
while (lo <= hi) {
int mid = (lo + hi) / 2;
vector<ll> cost(n);
for (int i = 0; i < n; i++) cost[i] = item[i] + 1ll * (i + 1) * mid;
sort(cost.begin(), cost.end());
long long sum = 0;
for (int i = 0; i < mid; i++) sum += cost[i];
cerr << "mid: " << mid << endl;
cerr << "sum: " << sum << endl;
if (sum > S)
hi = mid - 1;
else
lo = mid + 1;
}
--lo;
long long res = 0;
for (int i = 0; i < n; i++) item[i] = item[i] + 1ll * (i + 1) * lo;
sort((item).begin(), (item).end());
for (int i = 0; i < lo; i++) res += item[i];
cout << lo << ' ' << res << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
int size[100005];
int parent[100005];
int ans = 0;
int bfs(int node, int p) {
size[node] = 1;
parent[node] = p;
for (int i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != p) {
int curr = bfs(adj[node][i], node);
if (curr % 2 == 0) ans++;
size[node] += curr;
}
}
return size[node];
}
pair<int, int> edge[100005];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
edge[i] = {a, b};
}
if (n % 2) {
cout << -1 << endl;
return;
}
bfs(0, -1);
cout << ans << endl;
}
int main() {
std::ios::sync_with_stdio(false);
;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e9 + 7;
const bool debugger1 = 0;
const bool debugger2 = 0;
const bool debugger3 = 1;
const bool debugger4 = 1;
const bool debugger5 = 1;
int n, ans = 0;
std::vector<int> order;
vector<pair<int, int> > pary;
int tab[205];
int main() {
scanf("%d", &n);
for (int i = 1; i < 2 * n + 1; i++) scanf("%d", &tab[i]);
for (int i = 1; i < 2 * n; i++) {
int szukana = tab[i];
int l = i + 1;
while (tab[l] != szukana) l++;
for (int j = l; j > i + 1; j--) swap(tab[j], tab[j - 1]), ans++;
i++;
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long sum, a[1005];
int n;
while (scanf("%d", &n) != EOF) {
sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i] + (a[i] - 1) * i;
}
cout << sum << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
long double pi = 3.1415926535897932384626433832795;
const int N = 2e5 + 10, lg = 31, MAXN = 1111;
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long _gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long _x1, _y1;
long long d = _gcd(b % a, a, _x1, _y1);
x = _y1 - (b / a) * _x1;
y = _x1;
return d;
}
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
a %= mod;
res %= mod;
}
return res;
}
void term_res(string res) {
cout << res;
exit(0);
}
int n, l = 25;
vector<pair<int, int> > g[N];
int a[N];
int tin[N], tout[N];
long long dist[N];
int timer;
int up[N][22];
int pluss[N], minuss[N];
void dfs(int v, int p = 1) {
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i].first;
long long add = g[v][i].second;
if (to != p) {
dist[to] = dist[v] + add;
dfs(to, v);
}
}
}
multiset<long long> s[N];
int ans[N];
int sid[N];
void dfs0(int v, int p = 0) {
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i].first;
if (to == p) continue;
dfs0(to, v);
if (s[sid[to]].size() > s[sid[v]].size()) {
swap(sid[to], sid[v]);
}
s[sid[v]].insert(s[sid[to]].begin(), s[sid[to]].end());
s[sid[to]].clear();
}
s[sid[v]].erase(s[sid[v]].upper_bound(dist[v]), s[sid[v]].end());
ans[v] = s[sid[v]].size();
s[sid[v]].insert(dist[v] - a[v]);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i + 1], sid[i] = i + 1;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[i + 2].push_back(make_pair(u, v));
g[u].push_back(make_pair(i + 2, v));
}
dfs(1);
dfs0(1);
for (int i = 0; i < n; i++) cout << ans[i + 1] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[10005], dp[10005][2005];
signed main() {
int Test;
scanf("%d", &Test);
while (Test--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int maxX = 0;
for (int i = 1; i <= n; i++) maxX = max(maxX, a[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= 2 * maxX; j++) dp[i][j] = 0x3f3f3f3f;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 2 * maxX; j++) {
if (dp[i - 1][j] == 0x3f3f3f3f) continue;
dp[i][max(0, j - a[i])] =
min(dp[i][max(0, j - a[i])], dp[i - 1][j] + a[i]);
if (j + a[i] <= 2 * maxX)
dp[i][j + a[i]] = min(dp[i][j + a[i]], max(0, dp[i - 1][j] - a[i]));
}
}
int ans = 0x3f3f3f3f;
for (int j = 0; j <= 2 * maxX; j++) ans = min(ans, dp[n][j] + j);
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
using namespace std;
long long ask(long long c, long long d) {
long long ret;
cout << "? " << c << " " << d << endl;
cin >> ret;
return ret;
}
void print(long long a, long long b) {
cout << "! " << a << " " << b << endl;
exit(0);
}
void sol(long long is, long long a, long long b, long long id) {
if (id == -1) print(a, b);
long long cur = 0;
if (is == 1) {
cur = ask(a | (1 << id), b | (1 << id));
if (cur == 1) {
if (ask(a, b | (1 << id)) == 1) {
a |= (1 << id);
b |= (1 << id);
} else {
}
sol(1, a, b, id - 1);
} else {
a |= (1 << id);
sol(ask(a, b), a, b, id - 1);
}
} else if (is == 0) {
for (long long i = id; i >= 0; i--) {
if (ask(a | (1 << i), b) == -1) {
a |= (1 << i);
b |= (1 << i);
}
}
print(a, b);
} else {
cur = ask(a | (1 << id), b | (1 << id));
if (cur == -1) {
if (ask(a | (1 << id), b) == 1) {
} else {
a |= (1 << id);
b |= (1 << id);
}
sol(-1, a, b, id - 1);
} else {
b |= (1 << id);
sol(ask(a, b), a, b, id - 1);
}
}
}
signed main() {
if (ask(0, 0) == 0) {
long long res = 0;
for (long long i = 0; i < 30; i++) {
if (ask(1 << i, 0) == -1) {
res |= (1 << i);
}
}
print(res, res);
} else {
sol(ask(0, 0), 0, 0, 29);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans[1000], b[1000], suma[1000], sumb[1000];
int main() {
int i, n, d;
cin >> n;
for (i = 1; i < n; i++) {
cin >> d;
if (i == 0)
suma[i] = d;
else
suma[i] = suma[i - 1] + d;
}
for (i = 1; i < n; i++) {
cin >> d;
if (i == 0)
sumb[i] = d;
else
sumb[i] = sumb[i - 1] + d;
}
for (i = 0; i < n; i++) cin >> b[i];
for (i = 0; i < n; i++)
ans[i] = suma[i] - suma[0] + sumb[n - 1] - sumb[i] + b[i];
sort(ans, ans + n);
cout << ans[0] + ans[1];
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MOD = 998244353;
const int INF = 1e9 + 7;
int as[1005] = {-INF};
int N, K;
int dp[1005][1005] = {{1}};
int solve(int crit) {
int j = 0;
for (int i = 1; i <= N; i++) {
for (int k = 0; k <= K; k++) {
dp[i][k] = dp[i - 1][k];
}
while (as[j + 1] <= as[i] - crit) j++;
for (int k = 0; k < K; k++) {
dp[i][k + 1] = (dp[i][k + 1] + dp[j][k]) % MOD;
}
}
return dp[N][K];
}
int main() {
scanf("%d %d", &N, &K);
for (int i = 1; i <= N; i++) {
scanf("%d", &as[i]);
}
std::sort(as + 1, as + N + 1);
int ans = 0;
for (int i = 1; i * (K - 1) <= 100000; i++) {
ans = (ans + solve(i)) % MOD;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
int arr[200005];
int cnt[200005];
int c[200005];
int main() {
ios_base::sync_with_stdio(0);
int n;
while (cin >> n) {
memset(cnt, 0, sizeof(cnt));
memset(c, 0, sizeof(c));
for (int i = 0; i < n; ++i) {
cin >> arr[i];
cnt[arr[i]]++;
}
c[0] = n;
for (int i = 1; i < 200001; ++i) {
c[i] = c[i - 1] - cnt[i - 1];
}
long long int mx = 0;
for (int i = 1; i < 200001; ++i) {
if (cnt[i]) {
long long int tmp = 0;
for (int j = i; j < 200001; j += i) {
tmp += c[j];
if (!c[j]) break;
}
mx = max(mx, tmp * i);
}
}
cout << mx << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, w;
scanf("%d", &n);
if (n == 20) {
w = 15;
}
if (n == 11) {
w = 4;
}
if (n == 21) w = 4;
if (n < 20 && n > 10 && n != 11) {
w = 4;
}
if (n <= 10 || n > 21) w = 0;
printf("%d", w);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, q;
cin >> n >> q;
vector<long long int> a(n);
long long int o, m;
o = m = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
o++;
else
m++;
}
m = min(o, m);
for (long long int i = 0; i < q; i++) {
long long int l, r;
cin >> l >> r;
l--;
r--;
long long int len = r - l + 1;
if (len % 2 || len / 2 > m) {
cout << "0"
<< "\n";
} else
cout << "1"
<< "\n";
}
return;
}
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
c_p_c();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n;
int A[N][N], F[N][N][N][N];
int dp(int x, int y, int u, int v) {
if (x > u || y > v || x > n || y > n || u > n || v > n || x < 1 || y < 1 ||
u < 1 || v < 1)
return int(1e8);
if (F[x][y][u][v] > -1) return F[x][y][u][v];
int ans = max(u - x, v - y) + 1;
int H, V;
H = V = int(1e8);
for (int i = y; i < v; i++) {
H = min(H, dp(x, y, u, i) + dp(x, i + 1, u, v));
}
for (int i = x; i < u; i++) {
V = min(V, dp(x, y, i, v) + dp(i + 1, y, u, v));
}
ans = min(ans, min(H, V));
F[x][y][u][v] = ans;
return ans;
}
int main() {
cin >> n;
for (int x = 0; x <= n; x++)
for (int y = 0; y <= n; y++)
for (int u = 0; u <= n; u++)
for (int v = 0; v <= n; v++) F[x][y][u][v] = -1;
string line;
for (int i = 1; i <= n; i++) {
cin >> line;
for (int j = 1; j <= n; j++)
A[i][j] = (line[j - 1] == '.'), F[i][j][i][j] = 1 - A[i][j];
}
cout << dp(1, 1, n, n);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const long long MOD = 998244353;
int n, m;
long long cr[MAXN];
long long a[MAXN], b[MAXN];
void read_input() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> cr[i];
}
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
}
}
long long mul(long long a, long long b) {
a *= b;
a %= MOD;
return a;
}
long long add(long long a, long long b) {
a += b;
a %= MOD;
return a;
}
long long poww(long long a, long long b) {
long long tmp = a % MOD, ans = 1;
while (b) {
if (b & 1) {
ans = mul(ans, tmp);
}
tmp = mul(tmp, tmp);
b >>= 1;
}
return ans;
}
long long inv(long long b) { return poww(b, MOD - 2); }
long long sm[MAXN];
long long get_sum(int l, int r) {
if (l > r) return 0;
if (l == 0) return sm[r];
long long ans = sm[r] - sm[l - 1];
if (ans < 0) ans += MOD;
return ans;
}
void solve() {
sort(cr, cr + n);
sm[0] = cr[0] % MOD;
for (int i = 1; i < n; i++) {
sm[i] = add(cr[i], sm[i - 1]);
}
for (int i = 0; i < m; i++) {
int l = 0, r = n - 1;
int ans = -1;
while (l <= r) {
int middle = (l + r) >> 1;
if (cr[middle] < b[i]) {
ans = middle;
l = middle + 1;
} else {
r = middle - 1;
}
}
int bg = n - ans - 1;
if (a[i] > bg) {
cout << "0\n";
continue;
}
if (ans == -1) bg = n;
long long answer = mul(mul(bg - a[i], get_sum(ans + 1, n - 1)), inv(bg));
long long answer2 = mul(mul(bg - a[i] + 1, get_sum(0, ans)), inv(bg + 1));
cout << add(answer, answer2) << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
read_input();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, q, i;
cin >> q;
while (q--) {
int sum = 0;
cin >> l >> r;
if (r % 2 == 0) {
if (l % 2 == 0)
cout << (l + r) / 2 << endl;
else
cout << (r - l + 1) / 2 << endl;
} else {
if (l % 2 == 0)
cout << "-" << (r - l + 1) / 2 << endl;
else
cout << "-" << (l + r) / 2 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
vector<int> p, rank, setSize;
int numSets;
void build(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
const int N = 5e6;
int a[N];
int n, m;
int mp[N];
int fir[N];
UnionFind uf;
int all;
bool go(int msk, int x) {
if (msk == 0) return 0;
if (fir[msk] == -2) return 0;
if (fir[msk] != -1) {
uf.unionSet(mp[fir[msk]], mp[x]);
return 1;
}
bool f = 0;
for (int i = 0; i < n; i++)
if (((1 << i) & msk) != 0) {
f |= go(msk ^ (1 << i), x);
}
if (mp[msk] != -1) {
f = 1;
uf.unionSet(mp[x], mp[msk]);
}
if (f) {
fir[msk] = x;
} else
fir[msk] = -2;
return f;
}
int main() {
memset(mp, -1, sizeof mp);
scanf("%d %d", &n, &m);
all = (1 << n) - 1;
uf.build(m);
memset(fir, -1, sizeof fir);
for (int i = 0; i < (int)m; i++) {
scanf("%d", a + i);
mp[a[i]] = i;
if (a[i] == 0) {
printf("1\n");
return 0;
}
}
for (int i = 0; i < (int)m; i++) {
go(a[i] ^ all, a[i]);
}
int r = 0;
for (int i = 0; i < (int)m; i++) r += uf.p[i] == i;
printf("%d\n", r);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long c = 220000;
long long x, y, n, a[c];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> x >> y;
for (int i = 1; i < n; i++) a[i] = 1;
a[n] = y - n + 1;
long long sum = n - 1 + a[n] * a[n];
if (a[n] > 0 && sum >= x)
for (int i = 1; i <= n; i++) cout << a[i] << " ";
else
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1;
inline char getc() {
return (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class T>
inline void read(T &x) {
char ch;
int f = 1;
x = 0;
while (isspace(ch = getc()))
;
if (ch == '-') ch = getc(), f = -1;
do x = x * 10 + ch - '0';
while (isdigit(ch = getc()));
x *= f;
}
template <class T, class... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <class T>
inline void write(T x) {
static char stk[128];
int top = 0;
if (x == 0) {
putc('0');
return;
}
if (x < 0) putc('-'), x = -x;
while (x) stk[top++] = x % 10, x /= 10;
while (top) putc(stk[--top] + '0');
}
template <class T, class... Args>
inline void write(T x, Args... args) {
write(x);
putc(' ');
write(args...);
}
inline void space() { putc(' '); }
inline void endl() { putc('\n'); }
struct _flush {
~_flush() { flush(); }
} __flush;
}; // namespace io
using io::endl;
using io::flush;
using io::getc;
using io::putc;
using io::read;
using io::space;
using io::write;
const int N = 500005;
struct edge {
int v, t;
edge(int _v, int _t) : v(_v), t(_t) {}
};
vector<edge> R[N];
int col[N], dis[N];
int main() {
int n, m;
read(n, m);
for (int i = 1; i <= m; ++i) {
int u, v, t;
read(u, v, t);
R[v].emplace_back(u, t);
}
fill(col + 1, col + 1 + n, -1);
queue<int> q;
q.push(n);
dis[n] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
if (x == 1) {
write(dis[1] - 1), endl();
for (int i = 1; i <= n; ++i) write(int(col[i] > 0));
endl();
return 0;
}
for (edge e : R[x]) {
if (dis[e.v] != 0) continue;
if (col[e.v] == -1) {
if (e.t == 2) {
col[e.v] = 0;
dis[e.v] = dis[x] + 1;
q.push(e.v);
} else
col[e.v] = e.t ^ 1;
} else if (col[e.v] == e.t || e.t == 2) {
dis[e.v] = dis[x] + 1;
q.push(e.v);
}
}
}
write(-1), endl();
for (int i = 1; i <= n; ++i) write(int(col[i] > 0));
endl();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cost_white, cost_black, total_cost = 0;
cin >> n >> cost_white >> cost_black;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n / 2.0; i++) {
if (arr[i] == 2 && arr[n - i - 1] == 2) {
total_cost += (i == n - i - 1 ? 1 : 2) * min(cost_white, cost_black);
} else if (arr[i] == 2 || arr[n - i - 1] == 2) {
if (arr[i] != 2) {
total_cost += arr[i] == 0 ? cost_white : cost_black;
} else {
total_cost += arr[n - i - 1] == 0 ? cost_white : cost_black;
}
} else if (arr[i] != arr[n - i - 1]) {
cout << -1 << endl;
exit(0);
}
}
cout << total_cost << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long get(long long n, long long k) {
if (k == 1) return 0;
if (k == 2) {
return n * (n - 1) / 2;
}
if (k == 3) {
return n * (n - 1) * (n - 2) / 6 * 2;
}
if (k == 4) {
return (long long)n * (n - 1) * (n - 2) * (n - 3) / 24 * (6 + 3);
}
return 0;
}
void solve(long long tz) {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
a[i] = i + 1;
}
long long cnt = 0;
long long A[1001] = {0};
long long last = 1;
long long num = 0;
for (long long i = 0; i < 1001; i++) {
A[i] = last + num;
last = A[i];
num++;
}
long long B[1001] = {0};
last = 1;
num = 1;
for (long long i = 0; i < 1001; i++) {
B[i] = last + (num - 1) * (num - 1);
last = B[i];
num++;
}
if (k == 1) {
cout << 1 << endl;
return;
} else if (k == 2) {
cout << A[n - 1] << endl;
return;
} else if (k == 3) {
cout << B[n - 1] << endl;
return;
} else if (k == 4) {
long long ans = 1;
for (int i = 1; i <= k; i++) {
ans += get(n, i);
}
cout << ans << endl;
return;
}
}
int main() {
long long t;
t = 1;
long long z = 0;
while (t--) {
z++;
solve(z);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<vector<pair<int, int> > > adj;
int dp[105][105][27][3];
int dfs(int v, int u, int last, int turn) {
if (dp[v][u][last][turn]) return dp[v][u][last][turn];
int cur = ((turn == 1) ? v : u);
dp[v][u][last][turn] = 3 - turn;
for (pair<int, int> nei : adj[cur]) {
if (nei.second >= last) {
int a = v, b = u;
if (turn == 1)
a = nei.first;
else
b = nei.first;
int tmp = dfs(a, b, nei.second, 3 - turn);
if (tmp == turn) {
dp[v][u][last][turn] = tmp;
break;
}
}
}
return dp[v][u][last][turn];
}
int main() {
ios::sync_with_stdio(0);
cin >> N >> M;
adj.resize(N + 1);
for (int i = 0; i < M; ++i) {
int a, b;
char c;
cin >> a >> b >> c;
c = c - 'a' + 1;
adj[a].push_back(make_pair(b, c));
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) {
if (i == j)
cout << 'B';
else {
int ans = dfs(i, j, 0, 1);
cout << (ans == 1 ? 'A' : 'B');
}
}
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1010010;
long long sum[M];
set<pair<int, int> > S;
vector<pair<int, pair<int, int> > > ev;
int n, w;
void inc(int l, int r, int val) {
l = max(l, 0);
r = min(r, w - 1);
sum[l] += val;
sum[r + 1] -= val;
}
int main() {
scanf("%d%d", &n, &w);
while (n--) {
int m;
scanf("%d", &m);
S.clear();
ev.clear();
int lefty, righty;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
int l = i;
int r = w - (m - i);
ev.push_back(make_pair(l, make_pair(r, x)));
ev.push_back(make_pair(r, make_pair(w + 1000, x)));
if (i == 0) lefty = r - 1;
if (i == m - 1) righty = l + 1;
}
ev.push_back(make_pair(-1, make_pair(lefty, 0)));
ev.push_back(make_pair(lefty, make_pair(w + 1000, 0)));
ev.push_back(make_pair(righty, make_pair(w - 1, 0)));
ev.push_back(make_pair(w, make_pair(w + 1000, 0)));
sort(ev.begin(), ev.end());
for (int i = 0; i < ev.size(); i++) {
if (ev[i].second.first != w + 1000) {
S.insert(make_pair(ev[i].second.second, ev[i].second.first));
}
if (i > 0 && S.size() > 0 && ev[i - 1].first < ev[i].first) {
inc(ev[i - 1].first + 1, ev[i].first, S.rbegin()->first);
}
if (ev[i].second.first == w + 1000) {
S.erase(make_pair(ev[i].second.second, ev[i].first));
}
}
}
for (int i = 1; i < w; i++) sum[i] += sum[i - 1];
for (int i = 0; i < w; i++) printf("%I64d ", sum[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct recta {
int x1, x2;
int y1, y2;
} a[6];
int n;
int main() {
scanf("%d", &n);
for (int p = (0); p <= (n - 1); p += (1))
scanf("%d%d%d%d", &a[p].x1, &a[p].y1, &a[p].x2, &a[p].y2);
int lwx = 1e6, lwy = 1e6;
int gtx = -1, gty = -1, s = 0;
for (int p = (0); p <= (n - 1); p += (1)) {
s += (a[p].x2 - a[p].x1) * (a[p].y2 - a[p].y1);
if (a[p].x1 < lwx) lwx = a[p].x1;
if (a[p].x2 > gtx) gtx = a[p].x2;
if (a[p].y1 < lwy) lwy = a[p].y1;
if (a[p].y2 > gty) gty = a[p].y2;
}
if ((gtx - lwx) == (gty - lwy) && s == (gtx - lwx) * (gty - lwy)) {
printf("YES");
return 0;
}
printf("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
long long n;
long long k;
long long gsum;
long long mod = 1000000000 + 7;
int col[1000500];
long long cc[1000500];
long long tt[1000500];
long long fact[200500];
long long obr[200500];
vector<int> del[1000500];
int was[1000500];
long long st(long long x, long long p) {
long long ans = 1;
while (p) {
if (p & 1) ans = ans * x % mod;
x = x * x % mod;
p /= 2;
}
return ans;
}
long long cnk(int n, int k) {
if (k > n) return 0;
return (((fact[n] * obr[k]) % mod) * obr[n - k]) % mod;
}
vector<int> gv;
int bu[1000500];
void calc() {
int n = 1000300;
for (int i = 2; i <= n; i++)
if (bu[i] == 0)
for (int j = i; j <= n; j += i) bu[j] = i;
}
vector<int> getd(int x) {
if (was[x]) return del[x];
vector<int> v;
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) {
v.push_back(i);
if (i * i != x) v.push_back(x / i);
}
}
sort((v).begin(), (v).end());
was[x] = 1;
del[x] = v;
return v;
}
void recalc(int x) {
col[x]++;
long long d = (cnk(col[x], k) - cnk(col[x] - 1, k) - tt[x] + mod + mod) % mod;
gsum += d * x % mod;
gsum %= mod;
cc[x] = (cc[x] + d) % mod;
for (int i = 0; i < (((int)(del[x]).size()) - 1); i++) {
int u = del[x][i];
{
tt[u] += d;
if (tt[u] >= mod) tt[u] -= mod;
}
}
}
void add(int x) {
gv = getd(x);
for (int i = 0; i < (((int)(gv).size())); i++) {
int x = gv[i];
tt[x] = 0;
if (!was[x]) {
was[x] = 1;
for (int j = 0; j < (i); j++)
if (x % gv[j] == 0) del[x].push_back(gv[j]);
del[x].push_back(x);
}
}
for (int i = (((int)(gv).size())) - 1; i >= 0; i--) {
int o = gv[i];
recalc(o);
}
}
int main() {
int q;
cin >> n >> k >> q;
fact[0] = obr[0] = 1;
for (int i = 1; i <= n + q + 1; i++) {
fact[i] = fact[i - 1] * i % mod;
obr[i] = st(fact[i], mod - 2);
}
for (int i = 0; i < (n); i++) {
int x;
scanf("%d", &x);
add(x);
}
for (int i = 0; i < (q); i++) {
int x;
scanf("%d", &x);
add(x);
printf("%d\n", (int)gsum);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
void solve(long long tc) {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(n), x(n, 0), y(n, 0), c(n);
long long d = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = m;
d += a[i];
d -= b[i];
if (c[i] > a[i]) {
y[i] = c[i] - a[i];
b[i] -= y[i];
c[i] -= y[i];
d += y[i];
}
if (c[i] > b[i]) {
x[i] = c[i] - b[i];
a[i] -= x[i];
c[i] -= x[i];
d -= x[i];
}
}
for (long long i = 0; i < n; i++) {
if (d == 0) {
long long mid = c[i] / 2;
x[i] += mid;
y[i] += c[i] - mid;
d -= mid;
d += c[i] - mid;
} else if (d > 0) {
if (d >= c[i]) {
x[i] += c[i];
d -= c[i];
} else {
x[i] += d;
c[i] -= d;
d = 0;
long long mid = c[i] / 2;
x[i] += mid;
y[i] += c[i] - mid;
d -= mid;
d += c[i] - mid;
}
} else {
d = -1ll * d;
if (d >= c[i]) {
y[i] += c[i];
d -= c[i];
d = -1ll * d;
} else {
y[i] += d;
c[i] -= d;
d = 0;
long long mid = c[i] / 2;
x[i] += mid;
y[i] += c[i] - mid;
d -= mid;
d += c[i] - mid;
}
}
}
cout << (d >= 0 ? d : -1ll * d);
cout << "\n";
;
for (long long i = 0; i < n; i++) {
cout << x[i] << " " << y[i];
cout << "\n";
;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
for (long long tc = 1; tc <= t; tc++) {
solve(tc);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c, d, i, j, h, len, x, y, xi[105], resp;
bool ok;
int main() {
scanf("%d %d", &n, &m);
ok = true;
for ((i) = 0; (i) < (m); (i)++) {
scanf("%d %d", &a, &b);
for (j = a; j <= b; j++) {
xi[j]++;
}
}
for (i = 1; i <= n; i++) {
if (xi[i] != 1) {
ok = false;
c = i;
d = xi[i];
break;
}
}
if (ok)
printf("OK");
else
printf("%d %d", c, d);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 100111;
int sum[2][MN], a[MN], n;
int get(int t) {
int i = 0;
int win[2], lastwin = -1;
win[0] = win[1] = 0;
while (i < n) {
if (sum[0][n] - sum[0][i] < t && sum[1][n] - sum[1][i] < t) return -1;
int l = i + 1, r = n, res = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (sum[0][mid] - sum[0][i] >= t || sum[1][mid] - sum[1][i] >= t) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (sum[0][res] - sum[0][i] == t)
++win[0], lastwin = 0;
else
++win[1], lastwin = 1;
i = res;
}
if (win[0] == win[1]) return -1;
if (win[lastwin] != max(win[0], win[1]))
return -1;
else
return max(win[0], win[1]);
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(NULL);
cout << (fixed) << setprecision(6);
while (cin >> n) {
for (int i = (1), _b = (n); i <= _b; i++) {
cin >> a[i];
--a[i];
sum[0][i] = sum[0][i - 1];
sum[1][i] = sum[1][i - 1];
sum[a[i]][i] += 1;
}
vector<pair<int, int> > res;
for (int t = (1), _b = (n); t <= _b; t++) {
int s = get(t);
if (s > 0) res.push_back(make_pair(s, t));
}
cout << res.size() << endl;
sort(res.begin(), res.end());
for (auto e : res) cout << e.first << ' ' << e.second << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const long long INF = 1e9 + 9;
const long long MOD = 1000000007;
int main() {
string s;
int t;
cin >> t;
vector<string> ans;
int n;
string r;
while (t--) {
ans.clear();
cin >> s;
if (s == "::") {
cout << "0000:0000:0000:0000:0000:0000:0000:0000" << endl;
continue;
}
s += ":";
n = s.size();
r = "";
for (int i = 0; i < n; i++) {
if (s[i] == ':') {
if (i == 0) continue;
ans.push_back(r);
r = "";
continue;
}
r += s[i];
}
int w = 8 - ans.size();
int id = 0;
for (int i = 0; i < 8; i++, id++) {
if (i) cout << ":";
if (ans[id] == "") {
cout << string(4, '0');
if (w > 0) id--;
w--;
continue;
}
if (ans[id].size() < 4) cout << string(4 - ans[id].size(), '0');
cout << ans[id];
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> gifts(n);
map<int, int> counter;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
gifts[i] = a;
counter[a % k]++;
}
int gift, alter, res = 0;
for (int i = 0; i < n; i++) {
gift = gifts[i] % k;
if (!counter[gift]) continue;
alter = (k - (gift % k)) % k;
if (counter[alter]) {
if (alter == gift && counter[gift] < 2) continue;
counter[alter]--;
counter[gift]--;
res += 2;
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
int a[200000];
int n;
bool check(double x) {
double bound = a[0] + x;
for (int i = 1, num = 1; i < n; i++)
if (a[i] > bound) {
bound = a[i] + x;
num++;
if (num > 3) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
double l = 0, r = 1e10;
while (r - l > eps) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.6f\n%.6f", l / 2, a[0] + l / 2);
double bound = a[0] + l;
int num = 1;
for (int i = 1; i < n; i++)
if (a[i] > bound + eps) {
num++;
printf(" %.6f", a[i] + l / 2);
bound = a[i] + l;
}
for (; num < 3; num++) printf(" %.6f", 0.0);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return lower_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return upper_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
} // namespace __algorithm
using namespace __algorithm;
struct __monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) __monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) __monostate& ms) {
return os;
}
} ms;
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N;
re(N);
vvll grid(N, vll(N));
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (N); j++) {
if ((j & 1)) grid[i][j] = 1ll << (i + j);
}
}
for (auto& row : grid) pc(row);
cout << flush;
int Q;
re(Q);
for (int q = 0; q < (Q); q++) {
ll sum;
re(sum);
vpii path = {{0, 0}};
for (int i = 0; i < (2 * N - 2); i++) {
auto [r, c] = path.back();
bool has_next = (sum >> (r + c + 1)) & 1;
if (has_next != (c & 1))
c++;
else
r++;
path.emplace_back(r, c);
}
for (auto& e : path) ps(e.first + 1, e.second + 1);
cout << flush;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int d[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int a[240];
int main(void) {
int n;
int i, j, k;
bool f, g;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < 12; i++) {
for (j = 0, f = true, g = false; j < n && f; j++) {
k = (i + j) % 12;
if (k == 1)
if (a[j] != 28 && a[j] != 29)
f = false;
else {
if (a[j] == 29) {
if (g) f = false;
g = true;
}
}
else if (a[j] != d[k])
f = false;
}
if (f) {
puts("Yes");
return 0;
}
}
puts("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 100 * 1000 + 24, INF = (1 << 30);
long long n;
int sz[MAX_N], ans[MAX_N];
bool mark[MAX_N];
vector<int> G[MAX_N];
void prep(int v, int par = -1) {
sz[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (u != par and mark[u] == false) {
prep(u, v);
sz[v] += sz[u];
}
}
}
int centroid(int v, int cst) {
bool bl = false;
int par = 0;
while (bl == false) {
bl = true;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (u != par and mark[u] == false and sz[u] > cst / 2) {
par = v;
v = u;
bl = false;
break;
}
}
}
return v;
}
void cnd_dec(int v, int c = 0) {
prep(v);
int cent = centroid(v, sz[v]);
mark[cent] = true;
ans[cent] = c;
for (int i = 0; i < G[cent].size(); i++) {
int u = G[cent][i];
if (mark[u] == false) cnd_dec(u, c + 1);
}
}
int main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
cin >> n;
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
cnd_dec(1);
for (int i = 1; i <= n; i++) {
cout << char(ans[i] + 'A') << " ";
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ar[2000000 + 9], pr[2000000 + 9], par[2][2000000 + 9];
int main() {
int i, j = 0, k, l, n, m = 0, tot = 0, temp, siz, flag = 0, ans = 0, test,
curr, ind, x, q, now_xor, f, s, val, prev1, prev2, pos;
char ch;
cin >> n;
for (i = 0; i <= n; i++) {
cin >> ar[i];
m += ar[i];
}
for (i = n; i > 0; i--) {
if (ar[i] > 1 && ar[i - 1] > 1) ans = 1;
}
if (ans == 0) {
cout << "perfect\n";
} else {
cout << "ambiguous\n";
prev1 = 0;
prev2 = 0;
pos = 0;
for (i = 0; i <= n; i++) {
for (j = 1; j <= ar[i]; j++) {
pos++;
par[0][pos] = prev1;
if (j == ar[i]) {
par[1][pos] = prev2;
} else
par[1][pos] = prev1;
}
prev1 = prev2 + 1;
prev2 = pos;
}
for (i = 1; i <= m; i++) cout << par[0][i] << " ";
cout << endl;
for (i = 1; i <= m; i++) cout << par[1][i] << " ";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0), cout.precision(15);
int q;
cin >> q;
while (q--) {
long long n, m;
cin >> n >> m;
long long ar[10];
ar[0] = 0;
for (int i = 1; i < 10; ++i) {
ar[i] = m * i % 10;
ar[i] += ar[i - 1];
}
long long ans = n / 10 / m * ar[9];
ans += ar[(n - (n / 10 / m) * 10 * m) / m];
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string p = "AEIOUY";
bool isv(char ch) {
for (int i = 0; i < 6; ++i)
if (p[i] == ch) return true;
return false;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
int k = -1;
int ans;
for (int i = 0; i < s.size(); ++i) {
if (isv(s[i])) {
ans = max(ans, i - k);
k = i;
}
}
ans = max(ans, n - k);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool alpa[30];
int main() {
unsigned int a, b, l, r;
cin >> a >> b >> l >> r;
vector<char> arr;
unsigned int lmod = (l - 1) % (a + b);
unsigned int len = r - l + 1;
l = (l - 1) % (a + b);
if (a <= b) {
for (int i = 0; i < a; i++) {
arr.push_back('a' + i);
}
for (int i = 0; i < b; i++) {
arr.push_back(arr[a - 1]);
}
for (int i = 0; i < a - 1; i++) {
arr.push_back('a' + i);
}
arr.push_back('a' + a);
for (int i = 0; i < b; i++) {
arr.push_back(arr[2 * a + b - 1]);
}
for (int i = 0; i < a; i++) {
arr.push_back('a' + i);
}
} else {
for (int i = 0; i < a; i++) arr.push_back('a' + i);
unsigned int tmpb = (l > b) ? l : b;
if (tmpb >= a) tmpb = b;
for (int i = 0; i < b; i++) arr.push_back(arr[tmpb]);
for (int i = 0; i < b; i++) {
arr.push_back('a' + i);
}
for (int i = 0; i < a - b; i++) {
arr.push_back('a' + a + i);
}
for (int i = 0; i < b; i++) arr.push_back(arr[a + 2 * b]);
for (int i = 0; i < a; i++) arr.push_back('a' + i);
}
while (len != 0 && l < 3 * a + 2 * b) {
alpa[arr[l++] - 'a'] = 1;
len--;
}
unsigned int cnt = 0;
for (int i = 0; i < 30; i++) {
if (alpa[i] == 1) cnt++;
}
cout << cnt << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, l, r, t = 1e12;
cin >> n;
long long a[n], m = 1e12;
vector<long long> A;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < m) m = a[i];
}
for (long long i = 0; i < n; i++) {
if (a[i] == m) A.push_back(i);
}
for (long long i = 0; i < A.size() - 1; i++) {
if (A[i + 1] - A[i] < t) t = A[i + 1] - A[i];
}
cout << t;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
list<int> vec1;
list<int> vec2;
int n;
cin >> n;
int auxn = n;
int num;
for (int i = 0; i < n; i++) {
cin >> num;
vec1.push_back(num);
}
vec2 = vec1;
vec2.sort();
list<int> aux;
int auxnum;
int cont = 0;
int tam;
for (int j = 0; j < n; j++) {
if (vec1 != vec2) {
aux.push_back(vec1.back());
auxnum = vec1.back();
vec1.pop_back();
while (auxnum == vec1.back()) {
aux.push_back(vec1.back());
vec1.pop_back();
n--;
}
tam = aux.size();
for (int s = 0; s < tam; s++) {
vec1.push_front(auxnum);
aux.pop_back();
cont++;
}
} else
break;
}
if (cont == auxn)
cout << -1 << endl;
else
cout << cont << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
const long long N = 1e6 + 10;
long long a[N], fen[N];
void add(long long i, long long val) {
while (i < N) {
fen[i] += val;
i += (i & (-i));
}
}
long long sum(long long i) {
long long s = 0;
while (i > 0) {
s += fen[i];
i -= (i & (-i));
}
return s;
}
long long g(long long m, long long n) {
memset(fen, 0, sizeof(fen));
long long curr = n + 1, ans = 0;
add(curr, 1);
for (long long i = 0; i < n; i++) {
if (a[i] < m)
curr--;
else
curr++;
ans += sum(curr - 1);
add(curr, 1);
}
return ans;
}
void go() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> a[i];
cout << g(m, n) - g(m + 1, n) << endl;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long t = 1;
cout << fixed << setprecision(12);
while (t--) {
go();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int af[310];
int main() {
int m, n;
cin >> m >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
int tt = t % m;
af[tt]++;
if (af[tt] > 1) {
cout << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[3005][2];
int cst[3][3005];
int main() {
int n;
scanf("%d", &n);
for (int j = 0; j < 3; j++)
for (int i = 0; i < n; i++) scanf("%d", &cst[j][i]);
dp[0][0] = -1e8;
dp[0][1] = 0;
for (int i = 1; i <= n; i++) {
dp[i][0] = max(dp[i - 1][0] + cst[1][i - 1], dp[i - 1][1] + cst[0][i - 1]);
dp[i][1] = max(dp[i - 1][0] + cst[2][i - 1], dp[i - 1][1] + cst[1][i - 1]);
}
printf("%d\n", dp[n][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const long long MAXN = 2e5 + 10;
const long long INF = 0x3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double eps = 1e-9;
const long double PI = acos(-1.0);
long long n, maxV = 0;
long long arr[MAXN], cnt[MAXN], vis[MAXN], mp[MAXN * 2];
struct Node {
long long idx, frequency;
bool operator<(const Node &other) const {
return frequency > other.frequency;
}
} nodes[MAXN];
long long solve(long long x) {
memset(mp, 0x3f, sizeof(mp));
mp[n] = -1;
long long sum = 0;
long long res = 0;
for (long long i = 0; i < n; i++) {
if (arr[i] == maxV)
sum++;
else if (arr[i] == x)
sum--;
if (mp[n + sum] >= INF) {
mp[n + sum] = i;
} else {
res = max(res, i - mp[n + sum]);
}
}
return res;
}
signed main() {
n = read();
for (long long i = 0; i < n; i++) {
arr[i] = read();
cnt[arr[i]]++;
}
long long idx = 0;
for (long long i = 0; i < n; i++) {
if (vis[arr[i]]) continue;
vis[arr[i]] = 1;
nodes[idx++] = {i, cnt[arr[i]]};
}
sort(nodes, nodes + idx);
maxV = arr[nodes[0].idx];
if (nodes[0].frequency == nodes[1].frequency) {
cout << n << endl;
return 0;
}
long long ans = 0;
for (long long i = 0; i < min(800ll, idx); i++) {
long long val = arr[nodes[i].idx];
if (!cnt[val] || val == maxV) continue;
ans = max(ans, solve(val));
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
void solve() {
cin >> s;
int lowest = 1e9;
for (int i = 0; i < s.size(); i++) {
lowest = min(lowest, (int)s[i]);
if (s[i] > lowest)
cout << "Ann\n";
else
cout << "Mike\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<string, int> name;
int get_id(string s) { return name[s] ? name[s] : name[s] = name.size(); }
const int N = 45;
bitset<100100> bs[N];
bool cmp(int a, int b) { return bs[a].count() < bs[b].count(); }
int main() {
name.clear();
cin >> n >> m;
int op;
int gp = 0;
for (int i = 0; i < n; i++) {
cin >> op;
if (op == 1) {
gp++;
} else {
string s;
cin >> s;
int k = get_id(s);
bs[k][gp] = 1;
}
}
vector<vector<int>> g(m + 1, vector<int>(m + 1, 1));
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++)
if ((bs[i] & bs[j]).count()) {
g[i][j] = 0;
g[j][i] = 0;
}
int df = 1e5;
int ans = 0;
while (df--) {
vector<int> p(m + 1);
for (int i = 1; i <= m; i++) p[i] = i;
random_shuffle(p.begin() + 1, p.end());
vector<int> vis(m + 1, 0);
int z = 0;
for (int i = 1; i <= m; i++) {
int gg = 0;
int x = p[i];
for (int j = 1; j <= m; j++)
if (vis[j] && !g[x][j]) gg = 1;
if (!gg) {
vis[x] = 1;
z++;
}
}
ans = max(ans, z);
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int amount = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j and v[i] - v[j] <= d and v[j] - v[i] <= d) amount++;
}
}
cout << amount << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const int M = 1000000007;
long long k, a[N];
long long mpow(long long a, long long b) {
if (b == 0) {
return 1;
} else if (b % 2 == 0) {
long long q = mpow(a, b / 2);
return q * q % M;
} else {
return a * mpow(a, b - 1) % M;
}
}
int main() {
if (fopen("C.in", "r")) freopen("C.in", "r", stdin);
cin >> k;
bool odd = 1;
bool mo = 1;
for (int i = 0; i < k; i++) {
scanf("%I64d", a + i);
if (a[i] % 2 == 0) {
odd = 0;
}
}
long long inv2 = mpow(2, M - 2);
long long inv3 = mpow(3, M - 2);
if (odd) {
long long num = 2;
for (int i = 0; i < k; i++) {
num = mpow(num, a[i]);
}
long long den = num;
num = (num - 2 + M) % M;
num = num * inv3 % M;
num = num * inv2 % M;
den = den * inv2 % M;
cout << num << "/" << den;
} else {
long long num = 2;
for (int i = 0; i < k; i++) {
num = mpow(num, a[i]);
}
long long den = num;
num = (num + 2 + M) % M;
num = num * inv3 % M;
num = (num * inv2) % M;
den = (den * inv2) % M;
cout << num << "/" << den;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
int a, b, c, d;
int dp[102][102][202];
int val(int nr) { return nr + 100; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b >> c >> d;
dp[0][0][val(0)] = 1;
for (int i = 0; i <= a; ++i)
for (int j = 0; j <= b; ++j)
for (int k = -d; k <= c; ++k) {
if (!dp[i][j][val(k)]) continue;
if (k < 0) {
dp[i][j + 1][val(k - 1)] =
(dp[i][j + 1][val(k - 1)] + dp[i][j][val(k)]) % 100000000;
dp[i + 1][j][val(1)] =
(dp[i + 1][j][val(1)] + dp[i][j][val(k)]) % 100000000;
} else if (k == 0) {
dp[i][j + 1][val(-1)] =
(dp[i][j + 1][val(-1)] + dp[i][j][val(k)]) % 100000000;
dp[i + 1][j][val(1)] =
(dp[i + 1][j][val(1)] + dp[i][j][val(k)]) % 100000000;
} else {
dp[i][j + 1][val(-1)] =
(dp[i][j + 1][val(-1)] + dp[i][j][val(k)]) % 100000000;
dp[i + 1][j][val(k + 1)] =
(dp[i + 1][j][val(k + 1)] + dp[i][j][val(k)]) % 100000000;
}
}
int sol = 0;
for (int k = val(-d); k <= val(c); ++k) sol = (sol + dp[a][b][k]) % 100000000;
cout << sol;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void program();
int main(){ program(); ios_base::sync_with_stdio(false); cin.tie(NULL);}
#define int long long
#define endl "\n"
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
for (int i = 0; i < v.size(); ++i) {
if (i == 0) {
out << '[';
}
out << v[i];
if (i < v.size() - 1) {
out << ", ";
} else {
out << ']';
}
}
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const deque<T>& d) {
if (d.size() == 0) {
return out << "[]";
}
out << '[' << d[0];
for (int i = 1; i < d.size(); ++i) {
out << ' ' << d[i];
}
return out << ']';
}
template <typename T>
ostream& operator<<(ostream& out, const set<T>& s) {
if (s.size() == 0) {
return out << "{}";
}
out << '{' << *s.begin();
for (auto it = ++s.begin(); it != s.end(); ++it) {
out << ' ' << *it;
}
return out << '}';
}
template <typename T>
ostream& operator<<(ostream& out, const multiset<T>& s) {
return out << vector<T>(s.begin(), s.end());
}
template <typename T>
ostream& operator<<(ostream& out, const unordered_set<T>& s) {
if (s.size() == 0) {
return out << "{}";
}
vector<T> v(s.begin(), s.end());
sort(v.begin(), v.end());
out << '{' << v[0];
for (int i = 1; i < v.size(); ++i) {
out << ' ' << v[i];
}
return out << '}';
}
template <typename K, typename V>
ostream& operator<<(ostream& out, const map<K, V>& m) {
if (m.size() == 0) {
return out << "{}";
}
out << "{\n";
for (const auto& p : m) {
const K& key = p.first;
out << " " << key << ": " << m.at(key) << '\n';
}
return out << '}';
}
template <typename K, typename V>
ostream& operator<<(ostream& out, const unordered_map<K, V>& m) {
if (m.size() == 0) {
return out << "{}";
}
vector<K> keys;
for (const auto& p : m) {
keys.push_back(p.first);
}
sort(keys.begin(), keys.end());
out << "{\n";
for (const auto& key : keys) {
out << " " << key << ": " << m.at(key) << '\n';
}
return out << '}';
}
template <typename F, typename S>
ostream& operator<<(ostream& out, const pair<F, S>& p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template<typename T, typename U>
struct hash<pair<T, U>> {
size_t operator()(const pair<T, U>& p) const noexcept {
return hash<T>{}(p.first) ^ (hash<U>{}(p.second) << 1);
}
};
int binpow(int a, int b, int m) {
a %= m;
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int invmod(int a, int m){
return binpow(a, m-2, m);
}
vector<vector<int>> g;
vector<int> cycle;
set<int> cycle_vals;
set<int> stk;
int score;
bool fc(int x, int p) {
if(stk.find(x) != stk.end()) {
reverse(cycle.begin(), cycle.end());
while(cycle.back() != x) cycle.pop_back();
return true;
}
cycle.push_back(x);
stk.insert(x);
for(int w: g[x]) if(w != p) {
if(fc(w,x)) return true;
}
stk.erase(x);
cycle.pop_back();
return false;
}
int dfs(int x, int p){
int sm = 1;
for(int w: g[x]) if(w != p && cycle_vals.find(w) == cycle_vals.end()) {
sm += dfs(w,x);
}
return sm;
}
void program(){
int T;
cin>>T;
while(T--){
int n;
cin>>n;
g = vector<vector<int>>(n+1);
for(int i=0;i<n;i++){
int u,v;
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
cycle.clear();
cycle_vals.clear();
stk.clear();
score = 0;
assert(fc(1,-1));
for(int r: cycle) { cycle_vals.insert(r); }
for(int root : cycle){
int tsz = dfs(root,-1);
score += tsz*(tsz-1)/2 + tsz*(n-tsz);
}
cout<<score<<endl;
}
} | 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(const T &a) {
return a * a;
}
const long double EPS = 1e-9;
const long double PI = 2 * acos(0.0);
const int N = 5100;
vector<int> g[N];
inline void SetInVector(vector<int> &v, int pos, int val) {
while ((int)v.size() <= pos) v.push_back(1e9);
v[pos] = min(v[pos], val);
}
vector<int> Dfs(int v, int prev) {
if (g[v].size() == 1) return {1, 0};
vector<int> result[2];
int cur = 0, next = 1;
result[cur] = {0};
for (int to : g[v]) {
if (to == prev) continue;
auto ch = Dfs(to, v);
fill(result[next].begin(), result[next].end(), 1e9);
for (int i = int(ch.size()) - 1; i >= 0; --i) {
int n = int(result[cur].size());
for (int j = n - 1; j >= 0; --j) {
int t = result[cur][j] + ch[i];
SetInVector(result[next], i + j, t);
}
}
swap(cur, next);
}
int m = int(result[cur].size());
int half = m / 2;
for (int i = 0; i <= half; ++i) {
int &lf = result[cur][i];
int &rg = result[cur][m - i - 1];
if (lf + 1 < rg) rg = lf + 1;
if (rg + 1 < lf) lf = rg + 1;
}
return result[cur];
}
int Solve(int source) {
auto v = Dfs(source, -1);
return v[v.size() / 2];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
if (n == 2) {
puts("1");
return 0;
}
int root = 0;
while (g[root].size() < 2) ++root;
printf("%d\n", Solve(root));
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, k;
int a[100009];
using namespace std;
int main() {
while (cin >> n >> k) {
int i;
if (k == 0) {
for (i = 1; i < n; i++) cout << i << " ";
cout << n << endl;
} else if (k == n - 1) {
for (i = n; i > 1; i--) cout << i << " ";
cout << 1 << endl;
} else {
for (i = k + 1; i >= 1; i--) {
cout << i << " ";
}
for (i = k + 2; i < n; i++) {
cout << i << " ";
}
cout << n << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isFib(int x, vector<int>& fib) {
for (int i = 0; i < fib.size() - 1; i++) {
if (fib.at(i) == x) return true;
}
return false;
}
int main() {
vector<int> fib;
long long int prev = 1;
for (long long int i = 0; i < 1000000000;) {
fib.push_back(i);
i += prev;
prev = i - prev;
}
int n;
cin >> n;
for (int a = 0; a < fib.size() - 1; a++) {
int b = n - fib.at(a);
if (isFib(b, fib)) {
cout << 0 << " " << fib.at(a) << " " << b;
return 0;
}
}
cout << "I'm too stupid to solve this problem";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int total;
int ps[32];
int N;
int num[32];
int rs[32];
map<int, int> table;
int board[8][8];
const int INF = 1000000000;
void go(int x, int y, int g) {
if (x == N) throw g;
if (x == N - 1) {
int v = 0;
for (int i = 0; i < N - 1; i++) v += board[i][y];
int p = g - v;
map<int, int>::iterator it = table.find(p);
if (it == table.end() || !it->second) return;
if (y == 0) {
v = 0;
for (int i = 0; i < N - 1; i++) v += board[i][N - 1 - i];
if (g - v != p) return;
}
if (y == N - 1) {
v = 0;
for (int i = 0; i < N - 1; i++) v += board[i][i];
if (g - v != p) return;
v = 0;
for (int i = 0; i < N - 1; i++) v += board[N - 1][i];
if (g - v != p) return;
}
it->second--;
board[x][y] = it->first;
go(x + (y == N - 1), (y + 1) % N, g);
it->second++;
} else if (y == N - 1 && (x != 0)) {
int v = 0;
for (int i = 0; i < N - 1; i++) v += board[x][i];
int p = g - v;
map<int, int>::iterator it = table.find(p);
if (it == table.end() || !it->second) return;
it->second--;
board[x][y] = it->first;
go(x + 1, 0, g);
it->second++;
} else {
for (map<int, int>::iterator it = table.begin(); it != table.end(); it++)
if (it->second) {
board[x][y] = it->first;
it->second--;
if (y == N - 1) {
g = 0;
for (int i = 0; i < N; i++) g += board[0][i];
go(x + 1, 0, g);
} else
go(x, y + 1, g);
it->second++;
}
}
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N * N; i++) {
scanf("%d", ps + i);
table[ps[i]]++;
}
if (N == 1) printf("%d\n%d\n", ps[0], ps[0]);
try {
go(0, 0, 0);
} catch (int v) {
printf("%d\n", v);
for (int i = 0; i < N; i++, printf("\n"))
for (int j = 0; j < N; j++) {
if (j) printf(" ");
printf("%d", board[i][j]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 1;
long long n, h, ans;
long long cal(long long x) {
long long need = x * (x + 1) / 2;
long long remain = n - need;
if (remain % x == 0)
return (remain / x + x);
else
return (remain / x + x + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> h;
long long l = 1, r = 2e9;
while (l != r) {
long long m = (l + r + 1) / 2;
if (m > h) {
if ((((m + h) * (m - h + 1) + m * (m + 1)) / 2 - m) > n)
r = m - 1;
else
l = m;
} else {
if (m * (m + 1) > 2 * n)
r = m - 1;
else
l = m;
}
}
if (l > h) {
if (!(n - (((l + h) * (l - h + 1) + l * (l + 1)) / 2 - l)))
cout << l - h + l;
else if ((n - (((l + h) * (l - h + 1) + l * (l + 1)) / 2 - l)) % l == 0)
cout << l - h + l +
(n - (((l + h) * (l - h + 1) + l * (l + 1)) / 2 - l)) / l;
else
cout << l - h + l +
(n - (((l + h) * (l - h + 1) + l * (l + 1)) / 2 - l)) / l + 1;
} else {
cout << cal(l);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long power(int a, int p) {
if (p == 0) return 1 % mod;
if (p % 2 == 1) return (a * power(a, p - 1)) % mod;
long long ret = power(a, p / 2);
return (ret * ret) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int x[n];
for (int i = 0; i < n; ++i) cin >> x[i];
sort(x, x + n);
long long sum[n];
sum[0] = x[0];
for (int i = 1; i < n; ++i) sum[i] = sum[i - 1] + x[i];
long long res = 0;
for (int i = 0; i < n - 1; ++i) {
long long p2i = power(2, i);
long long sub = ((sum[n - 1] - sum[i]) - (sum[n - 2 - i])) % mod;
res += (p2i * sub) % mod;
res %= mod;
}
cout << res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 1; i <= n; i++) cin >> a[i];
vector<int> g[n + 1];
int dis[n + 1];
queue<int> e;
queue<int> o;
int vis[n + 1];
for (int i = 1; i <= n; i++) {
vis[i] = 0;
dis[i] = -1;
if (i - a[i] >= 1) {
g[i - a[i]].push_back(i);
if ((abs)(a[i] - a[i - a[i]]) % 2 == 1) {
if (a[i] % 2 == 0)
e.push(i);
else
o.push(i);
vis[i] = 1;
dis[i] = 1;
}
}
if (i + a[i] <= n) {
g[i + a[i]].push_back(i);
if ((abs)(a[i] - a[i + a[i]]) % 2 == 1 && vis[i] == 0) {
if (a[i] % 2 == 0)
e.push(i);
else
o.push(i);
vis[i] = 1;
dis[i] = 1;
}
}
}
while (!e.empty()) {
int c = e.front();
e.pop();
for (int i = 0; i < g[c].size(); i++) {
int d = g[c][i];
if (a[d] % 2 == 0 && vis[d] == 0) {
dis[d] = 1 + dis[c];
vis[d] = 1;
e.push(d);
}
}
}
while (!o.empty()) {
int c = o.front();
o.pop();
for (int i = 0; i < g[c].size(); i++) {
int d = g[c][i];
if (a[d] % 2 == 1 && vis[d] == 0) {
dis[d] = 1 + dis[c];
vis[d] = 1;
o.push(d);
}
}
}
for (int i = 1; i <= n; i++) cout << dis[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<long long int> a(n);
vector<long long int> mp(n + 1, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
vector<long long int> ans(n + 1);
priority_queue<pair<long long, long long>> pq;
long long cost = 0;
for (int i = 0; i < n + 1; i++) {
ans[i] = mp[i] + cost;
if (mp[i] == 0) {
if (pq.empty()) {
for (int j = i + 1; j < n + 1; j++) ans[j] = -1;
break;
}
auto tp = pq.top();
pq.pop();
cost += (long long)(i - tp.first);
tp.second--;
if (tp.second > 1) pq.push({tp.first, tp.second});
}
if (mp[i] > 1) pq.push({i, mp[i]});
}
for (int i = 0; i < n + 1; i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[3 * 10000];
bool visited[1000001];
long long dp[1000001];
long long arr[1025][1025];
long long cnt = 0;
int n;
void dfs(int sv) {
if ((int)pow(2, n) <= sv && sv <= (int)pow(2, n + 1) - 1) return;
dfs(2 * sv);
dfs(2 * sv + 1);
long long a = dp[2 * sv + 1];
long long b = dp[2 * sv];
long long ans = max(a + arr[sv][2 * sv + 1], b + arr[sv][2 * sv]);
cnt += max(a + arr[sv][2 * sv + 1], b + arr[sv][2 * sv]) -
min(a + arr[sv][2 * sv + 1], b + arr[sv][2 * sv]);
dp[sv] = ans;
}
int main() {
cin >> n;
int temp = (int)pow(2, n + 1) - 1;
for (int i = 2; i < temp + 1; i++) {
int data;
cin >> data;
arr[i / 2][i] = data;
}
dfs(1);
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[110];
int main() {
int count = 0;
while (cin >> n) {
count = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int j = 2; j < n; j++) {
if (a[j] == 0) {
if (a[j - 1] == 1 && a[j + 1] == 1) {
a[j + 1] = 0;
count++;
}
}
}
cout << count << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int judge(char a[]) {
if (strcmp(a, "monday") == 0) return 1;
if (strcmp(a, "tuesday") == 0) return 2;
if (strcmp(a, "wednesday") == 0) return 3;
if (strcmp(a, "thursday") == 0) return 4;
if (strcmp(a, "friday") == 0) return 5;
if (strcmp(a, "saturday") == 0) return 6;
if (strcmp(a, "sunday") == 0) return 7;
}
int main() {
int i;
char s1[20], s2[20], n, m;
while (~scanf("%s%s", s1, s2)) {
int num;
n = judge(s1);
m = judge(s2);
num = (m - n + 7) % 7;
if (num == 3 || num == 0 || num == 2)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int pos[100005];
int main() {
int n;
scanf("%d", &n);
memset(pos, -1, sizeof(pos));
for (int i = 1; i <= n; i++) {
int x, y, ans = 0;
scanf("%d %d", &x, &y);
for (int j = 1; j * j <= x; j++) {
if (x % j == 0) {
if (pos[j] == -1 || pos[j] < i - y) ans++;
if (j != x / j && (pos[x / j] == -1 || pos[x / j] < i - y)) ans++;
pos[j] = pos[x / j] = i;
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int N = 3e5 + 5, K = 30;
int tam[N] = {1}, g[N][K], _g[N][K];
vector<int> v;
int res[N];
pair<int, int> merge(int a, int b) {
if (!a) return pair<int, int>(b, 0);
if (!b) return pair<int, int>(a, 0);
int r = 0;
v.push_back(a);
for (int i = 0; i < K; i++) {
if (g[a][i] and g[b][i]) {
r++;
pair<int, int> p = merge(g[a][i], g[b][i]);
r += p.second;
} else if (g[b][i]) {
g[a][i] = g[b][i];
}
}
return pair<int, int>(a, r);
}
void go(int at, int d) {
int r = 0;
for (int i = 0; i < K; i++) {
int next = g[at][i];
if (next) {
r++;
go(next, d + 1);
tam[at] += tam[next];
}
}
v.clear();
v.push_back(at);
int u = 0;
for (int i = 0; i < K; i++) {
int next = g[at][i];
pair<int, int> p = merge(u, next);
u = p.first;
r += p.second;
}
for (int i = 0; i < (int)v.size(); i++)
for (int j = 0; j < K; j++) g[v[i]][j] = _g[v[i]][j];
res[d] += r;
}
int main(void) {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
char c;
cin >> a >> b >> c;
g[a][c - 'a'] = b;
_g[a][c - 'a'] = b;
}
go(1, 1);
int ans = 0;
for (int i = 0; i < N; i++)
if (res[i] > res[ans]) ans = i;
cout << n - res[ans] << endl;
cout << ans << endl;
return 0;
}
| 8 |