solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, l, m;
int pre[123456 * 3], other[123456 * 3], last[123456 * 3];
int dfn[500005], dep[500005], sign, father[200005][21], tmp[200050], ans1, ans2;
pair<int, int> f[200050];
bool ok[222222];
void add(int u, int v) {
l++;
pre[l] = last[u];
last[u] = l;
other[l] = v;
}
void dfs(int x, int fa) {
dfn[x] = ++sign;
for (int p = last[x]; p != 0; p = pre[p]) {
int q = other[p];
if (q != fa) {
father[q][0] = x;
dep[q] = dep[x] + 1;
dfs(q, x);
}
}
}
bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
int lca(int x, int y) {
if (x == y) return x;
if (dep[x] > dep[y]) swap(x, y);
for (int j = 20; j >= 0; j--) {
if (dep[father[y][j]] >= dep[x]) y = father[y][j];
}
if (x == y) return x;
for (int j = 20; j >= 0; j--) {
if (father[y][j] != father[x][j]) {
y = father[y][j];
x = father[x][j];
}
}
return father[x][0];
}
void dp(int x, int fa) {
int son = 0;
for (int p = last[x]; p != 0; p = pre[p]) {
int q = other[p];
if (q != fa) {
son++;
dp(q, x);
}
}
if (ok[x]) {
f[x] = make_pair(1, -x);
if (f[x].first - 1 > ans1) {
ans1 = f[x].first - 1;
ans2 = -x;
}
} else
f[x] = make_pair(0, 0);
if (son == 0) return;
for (int p = last[x]; p != 0; p = pre[p]) {
int q = other[p];
if (q != fa) {
if (f[q] == make_pair(0, 0)) continue;
if (f[x] != make_pair(0, 0)) {
if (f[x].first + f[q].first - 1 == ans1) {
ans2 = max(ans2, f[x].second);
ans2 = max(ans2, f[q].second);
} else if (f[x].first + f[q].first - 1 > ans1) {
ans1 = f[x].first + f[q].first - 1;
ans2 = max(f[x].second, f[q].second);
}
}
if (make_pair(f[q].first + 1, f[q].second) > f[x]) {
f[x] = f[q];
f[x].first++;
}
}
}
if (ok[x]) {
if (f[x].first - 1 == ans1) {
ans2 = max(ans2, f[x].second);
} else if (f[x].first - 1 >= ans1) {
ans1 = f[x].first - 1;
ans2 = f[x].second;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dep[1] = 1;
father[1][0] = 1;
dfs(1, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) father[i][j] = father[father[i][j - 1]][j - 1];
for (int i = 1; i <= m; i++) {
scanf("%d", &tmp[i]);
ok[tmp[i]] = 1;
}
sort(tmp + 1, tmp + m + 1, cmp);
long long ans = 0;
int mx = 0;
int maxi = 1;
for (int i = 1; i <= m; i++) {
int x = lca(tmp[i], tmp[i % m + 1]);
int p = dep[tmp[i]] + dep[tmp[i % m + 1]] - dep[x] - dep[x];
ans += p;
if (p == mx) {
maxi = min(maxi, tmp[i]);
maxi = min(maxi, tmp[i % m + 1]);
} else if (p > mx) {
mx = p;
maxi = min(tmp[i], tmp[i % m + 1]);
}
}
ans1 = -100;
ans2 = -1;
dp(1, 0);
printf("%d\n", -ans2);
cout << ans - ans1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Data {
int X, Y, V;
};
bool operator<(Data A, Data B) { return A.V < B.V; }
struct Painter {
int X, Y, Type;
};
struct HashType {
int X, Y;
HashType *Next;
};
int Get() {
char c;
while (c = getchar(), (c < '0' || c > '9') && (c != '-'))
;
bool Flag = (c == '-');
if (Flag) c = getchar();
int X = c - 48;
while (c = getchar(), c >= '0' && c <= '9') X = X * 10 + c - 48;
return Flag ? -X : X;
}
const int BigNumber = 99991;
int Ox, Oy;
int Parent[90000];
HashType *Hash[BigNumber];
bool operator<(Painter A, Painter B) {
int L0 = max(abs(A.X - Ox), abs(A.Y - Oy));
int L1 = max(abs(B.X - Ox), abs(B.Y - Oy));
if (L0 < L1) return true;
if (L0 > L1) return false;
int T0, X0, T1, X1;
if (A.Y == Oy - L0) {
T0 = 3;
X0 = -A.X;
} else if (A.X == Ox + L0) {
T0 = 2;
X0 = -A.Y;
} else if (A.Y == Oy + L0) {
T0 = 1;
X0 = A.X;
} else if (A.X == Ox - L0) {
T0 = 0;
X0 = A.Y;
}
if (B.Y == Oy - L1) {
T1 = 3;
X1 = -B.X;
} else if (B.X == Ox + L1) {
T1 = 2;
X1 = -B.Y;
} else if (B.Y == Oy + L1) {
T1 = 1;
X1 = B.X;
} else if (B.X == Ox - L1) {
T1 = 0;
X1 = B.Y;
}
return (T0 == T1) ? (X0 < X1) : (T0 < T1);
}
int Root(int X) { return (Parent[X] == X) ? X : (Parent[X] = Root(Parent[X])); }
int Find(int X) {
HashType *P = Hash[X % BigNumber];
while (P != NULL)
if (P->X == X)
return P->Y;
else
P = P->Next;
return -1;
}
void Add(int X, int Y) {
int V = X % BigNumber;
HashType *P = new HashType;
P->X = X;
P->Y = Y;
P->Next = Hash[V];
Hash[V] = P;
}
void Delete(int X) {
int V = X % BigNumber;
HashType *P = Hash[V], *Pre = NULL;
while (P->X != X) {
Pre = P;
P = P->Next;
}
if (Pre == NULL)
Hash[V] = Hash[V]->Next;
else
Pre->Next = P->Next;
delete P;
}
int main() {
int M = Get(), N = Get();
static Data A[90000];
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++) A[i * N + j] = (Data){i, j, Get()};
sort(A, A + M * N);
int Total = 0;
static int Group[300][300], Size[90000], Color[90000];
memset(Size, 0, sizeof(Size));
for (int i = 0; i < M * N; i++) {
Group[A[i].X][A[i].Y] = Total;
Size[Total]++;
Color[Total] = A[i].V;
if (i + 1 == M * N || A[i].V != A[i + 1].V) Total++;
}
for (int i = 0; i < Total; i++) Parent[i] = i;
for (int i = 0; i < Total; i++) Add(Color[i], i);
vector<Painter> List[90000];
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++) {
int T = Get();
if (T == -1) continue;
List[Group[i][j]].push_back((Painter){i, j, T});
}
static int Qx[90000], Qy[90000], Qt[90000];
int F = 0, R = 1;
Qx[0] = Get() - 1;
Qy[0] = Get() - 1;
int Temp = Group[Qx[0]][Qy[0]];
for (int i = 0; i < List[Temp].size(); i++)
if (List[Temp][i].X == Qx[0] && List[Temp][i].Y == Qy[0])
Qt[0] = List[Temp][i].Type;
static bool Paint[90000];
memset(Paint, 0, sizeof(Paint));
long long Ans = 0;
while (F < R) {
int X = Qx[F], Y = Qy[F], T = Qt[F];
F++;
int W = Root(Group[X][Y]);
if (!Color[W] || Color[W] == T) continue;
Ans += Size[W];
int H = Find(T);
Delete(Color[W]);
if (H == -1)
Add(Color[W] = T, W);
else {
Parent[W] = H;
Size[H] += Size[W];
}
if (Paint[W]) continue;
Paint[W] = true;
Ox = X;
Oy = Y;
sort(List[W].begin(), List[W].end());
for (int i = 0; i < List[W].size(); i++) {
Qx[R] = List[W][i].X;
Qy[R] = List[W][i].Y;
Qt[R] = List[W][i].Type;
if (Qx[R] == Qx[0] && Qy[R] == Qy[0]) continue;
R++;
}
}
cout << Ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<vector<int> > a(3, vector<int>(52, 0));
vector<string> t(3);
cerr << n << endl;
for (int i = 0; i < 3; i++) {
string s;
cin >> s;
t[i] = s;
sort(t[i].begin(), t[i].end());
cerr << t[i].size() << " " << t[i] << endl;
for (int j = 0; j < s.size(); j++) {
if ('a' <= s[j] && s[j] <= 'z')
a[i][s[j] - 'a']++;
else if ('A' <= s[j] && s[j] <= 'Z')
a[i][s[j] - 'A' + 26]++;
}
}
vector<int> b(3, 0);
for (int i = 0; i < 3; i++) {
cerr << b[i] << " -> ";
int mx = *max_element(a[i].begin(), a[i].end());
b[i] = mx + n;
int tmp = b[i] - t[i].size();
if (n == 1 && mx - t[i].size() == 0) {
b[i] = t[i].size() - 1;
} else if (tmp > 0) {
b[i] = t[i].size();
}
cerr << b[i] << endl;
}
if (b[0] > b[1] && b[0] > b[2]) {
cout << "Kuro" << endl;
} else if (b[1] > b[0] && b[1] > b[2]) {
cout << "Shiro" << endl;
} else if (b[2] > b[1] && b[2] > b[0]) {
cout << "Katie" << endl;
} else {
cout << "Draw" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
using namespace std;
int n, a[1 << 17], b[2][1 << 17], tot[2];
vector<int> vec[2];
vector<pair<int, int>> ans;
int cnt[2];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]--;
b[a[i]][i] = 1;
b[0][i] += b[0][i - 1];
b[1][i] += b[1][i - 1];
vec[a[i]].push_back(i);
}
for (int t = 1; t <= n; t++) {
cnt[0] = cnt[1] = 0;
tot[0] = tot[1] = 0;
bool B = 0;
int lstidx = 0;
while (1) {
int val[2];
for (int i = 0; i < 2; i++) {
val[i] = ((int)((vec[i]).size()) >= tot[i] + t ? vec[i][tot[i] + t - 1]
: n + 1);
}
int idx = min(val[0], val[1]);
if (idx == n + 1) break;
if (idx == val[0])
cnt[0]++;
else
cnt[1]++;
if (idx == n) B = 1;
for (int i = 0; i < 2; i++) tot[i] += b[i][idx] - b[i][lstidx];
lstidx = idx;
}
if (!B) continue;
if (cnt[a[n]] > cnt[!a[n]]) ans.push_back(make_pair(cnt[a[n]], t));
}
sort(ans.begin(), ans.end());
cout << (int)((ans).size()) << '\n';
for (auto it : ans) cout << it.first << ' ' << it.second << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000001;
int s[MAXN];
long long int pot[MAXN];
long long int inv[MAXN];
int cont[MAXN];
long long int power(long long int a, int b) {
long long int ans = 1ll;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
long long int solve(int n, int ini, int fin) {
long long int uno = pot[n - 1], dos = 1ll, ans = 0ll;
for (int j = 0; j < 26; j++) dos = (dos * inv[cont[j + 'a']]) % 1000000007;
for (int j = ini; j <= fin; j++)
if (cont[j]) {
long long int aux = (dos * pot[cont[j]]) % 1000000007;
aux = (aux * inv[cont[j] - 1]) % 1000000007;
aux = (uno * aux) % 1000000007;
ans += aux;
ans %= 1000000007;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pot[0] = 1ll;
for (int i = 0; i < MAXN; i++)
if (i) pot[i] = (pot[i - 1] * (long long int)i) % 1000000007;
for (int i = 0; i < MAXN; i++) inv[i] = power(pot[i], 1000000007 - 2);
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++) cont[a[i]]++;
int n = a.size(), f = 1;
long long int ans = 0ll;
for (int i = 0; i < a.size(); i++) {
int ini = a[i] + 1, fin = (f ? b[i] - 1 : 'z');
if (b[i] > a[i]) f = 0;
ans = (ans + solve(n, ini, fin)) % 1000000007;
n--;
cont[a[i]]--;
}
for (int i = 0; i < a.size(); i++) cont[a[i]]++;
n = a.size();
f = 1;
for (int i = 0; i < b.size(); i++) {
if (!cont[b[i]]) break;
cont[b[i]]--;
n--;
if (b[i] > a[i]) f = 0;
if (f || i == a.size() - 1) continue;
int fin = b[i + 1] - 1, ini = 'a';
ans = (ans + solve(n, ini, fin)) % 1000000007;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x1, y, a[3005][3005];
vector<int> v[3005];
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x1 >> y;
a[x1][y] = 1;
v[x1].push_back(y);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) {
int pp = 0;
for (int k = 0; k < v[i].size(); k++) {
if (a[v[i][k]][j]) pp++;
}
ans += (pp * (pp - 1)) / 2;
}
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)(1e9 + 7);
vector<int> read(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
return v;
}
void solve() {
long long int i, j, k, m, n, ans = 0, cnt = 0, sum = 0;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
long long int F = 0, A = 0, c = 0, e = 0;
for (long long int i = 0; i <= n - 2; i++) {
for (long long int j = 0; j <= m - 2; j++) {
if (a[i][j] == 'a' || a[i][j] == 'f' || a[i][j] == 'c' ||
a[i][j] == 'e') {
for (long long int k = i; k <= i + 1; k++) {
for (long long int f = j; f <= j + 1; f++) {
if (a[k][f] == 'f') F++;
if (a[k][f] == 'a') A++;
if (a[k][f] == 'c') c++;
if (a[k][f] == 'e') e++;
}
}
if (F && A && c && e) ans++;
F = 0, A = 0, c = 0, e = 0;
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, answer = INT_MAX;
cin >> n;
n = n * 2;
vector<int> v;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int totalsum = 0;
vector<int> p;
for (int k = 0; k < n; ++k) {
if (i != k && j != k) {
p.push_back(v[k]);
}
}
for (int c = 1; c < n - 1;) {
totalsum = totalsum + (p[c] - p[c - 1]);
c = c + 2;
}
answer = min(answer, totalsum);
}
}
cout << answer;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n(0), input(0);
cin >> n;
vector<int> vect(n, 0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
vect[input - 1] = 1;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
vect[input - 1] = 1;
}
bool full(true);
for (int i = 0; i < vect.size(); i++) {
if (vect[i] == 0) {
full = false;
break;
}
}
if (full) {
cout << "I become the guy." << endl;
} else {
cout << "Oh, my keyboard!" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double win[1005][1005];
double lose[1005][1005];
int main() {
for (int i = 1; i <= 1000; i++) win[i][0] = 1;
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= 1000; j++) {
win[i][j] = i * 1.0 / (i + j) + lose[i][j - 1] * j / (i + j);
lose[i][j] = j * 1.0 / (i + j) *
(win[i - 1][j - 1] * i / (i + j - 1) +
win[i][j - 2] * (j - 1) / (j + i - 1));
}
}
while (scanf("%d %d", &n, &m) != EOF) {
printf("%.9f\n", win[n][m]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, num;
int father[3000];
long long ans;
int f(int x) { return father[x] == x ? x : father[x] = f(father[x]); }
void u(int x, int y) {
x = f(x);
y = f(y);
if (x != y) father[x] = y;
}
int main() {
while (cin >> n >> m >> k) {
num = 0, ans = 1;
for (int i = 1; i <= n; ++i) father[i] = i;
for (int i = 1; i + k - 1 <= n; ++i) {
int x = i, y = i + k - 1;
while (x < y) {
u(x, y);
x++, y--;
}
}
for (int i = 1; i <= n; ++i)
if (father[i] == i) num++;
for (int i = 0; i < num; ++i) ans *= m, ans %= 1000000007;
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fun(long long x, long long y) {
long long tmp;
while (x % y != 0) {
tmp = x % y;
x = y;
y = tmp;
}
return y;
}
int main() {
long long n;
cin >> n;
long long k;
if (n == 1) {
k = 1;
} else if (n == 2) {
k = 2;
} else if (n % 2 != 0) {
k = (n) * (n - 1) * (n - 2);
} else if (n % 2 == 0) {
k = (n - 1) * (n - 2) * (n - 3);
long long i = 3;
while (i <= (5 * n - 6) / n) {
long long hcf;
hcf = fun(n, n - i);
if (hcf == 1) {
k = n * (n - 1) * (n - i);
break;
}
i++;
}
}
cout << k << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
int n;
int a[MAXN];
bool f[MAXN];
bool sf[MAXN];
int ft;
void solve(int i) {
if (i == 0) {
printf("(%d)", a[0]);
} else if (i == 1) {
printf("(%d->%d)", a[1 - 1], a[1]);
} else {
if (a[i - 1] == 1 && a[i] == 0) {
printf("(((");
for (int j = 0; j < i - 2; j++) {
printf("%d->", a[j]);
}
printf("%d", a[i - 2]);
printf(")->%d)->%d)", a[i - 1], a[i]);
} else if (a[i] == 0) {
printf("(((");
solve(ft);
printf(")->(");
printf("%d", a[ft + 1]);
for (int j = ft + 2; j < i; j++) {
printf("->%d", a[j]);
}
printf("))->%d)", a[i]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
if (0 < n) {
f[0] = a[0] == 0;
sf[0] = f[0];
}
if (1 < n) {
f[1] = a[0] == 1 && a[1] == 0;
sf[1] = sf[1 - 1] || f[1];
}
for (int i = 2; i < n; i++) {
if (a[i - 1] == 1 && a[i] == 0) {
f[i] = true;
} else if (a[i] == 0) {
f[i] = sf[i - 2];
}
sf[i] = sf[i - 1] || f[i];
}
for (int i = 0; i < n; i++) {
if (f[i]) {
ft = i;
break;
}
}
if (f[n - 1]) {
puts("YES");
solve(n - 1);
} else {
puts("NO");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<int> ind(n + 1);
for (int i = 0; i < n; ++i) {
cin >> a[i];
ind[a[i]] = i;
}
vector<long long> sums(n + 1);
for (int i = 1; i <= n; ++i) {
sums[i] = sums[i - 1] + i;
}
int l = ind[1];
int r = ind[1] + 1;
int now = 1;
vector<int> ans(n + 1);
long long cur_sum = 0;
while (now <= n) {
if (ind[now] <= l) {
while (l >= ind[now] && l > -1) cur_sum += a[l--];
} else {
while (r <= ind[now] && r < n) cur_sum += a[r++];
}
if (cur_sum == sums[now]) ans[now] = 1;
++now;
}
for (int i = 0; i < n; ++i) cout << ans[i + 1];
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int MOD = 1000000007;
int N, P;
int dp[MAXN][4];
int a[MAXN], b[MAXN];
int cnt[3];
void load() { scanf("%d%d", &N, &P); }
inline int add(int x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
else if (x < 0)
x += MOD;
return x;
}
inline int mul(int x, int y) { return (long long)x * y % MOD; }
void add(int lo, int hi, int val) {
cnt[val] =
add(cnt[val], mul(hi - lo + 1, add(P, -mul(add(lo, hi), (MOD + 1) / 2))));
}
int solve() {
if (P == 1) return 0;
a[0] = 1;
b[0] = 0;
a[1] = 3;
b[1] = 1;
a[2] = 4;
b[2] = 2;
a[3] = 5;
b[3] = 1;
a[4] = 7;
b[4] = 2;
a[5] = 9;
b[5] = 0;
a[6] = 13;
b[6] = 1;
a[7] = 15;
b[7] = 2;
a[8] = 19;
b[8] = 0;
a[9] = 27;
b[9] = 1;
a[10] = 39;
b[10] = 2;
a[11] = 40;
b[11] = 0;
a[12] = 57;
b[12] = 2;
a[13] = 58;
b[13] = 1;
a[14] = 81;
b[14] = 2;
a[15] = 85;
b[15] = 0;
a[16] = 120;
b[16] = 2;
a[17] = 121;
b[17] = 1;
a[18] = 174;
b[18] = 2;
a[19] = 179;
b[19] = 0;
a[20] = 255;
b[20] = 2;
a[21] = 260;
b[21] = 1;
a[22] = 363;
b[22] = 2;
a[23] = 382;
b[23] = 0;
a[24] = 537;
b[24] = 2;
a[25] = 544;
b[25] = 1;
a[26] = 780;
b[26] = 2;
a[27] = 805;
b[27] = 0;
a[28] = 1146;
b[28] = 2;
a[29] = 1169;
b[29] = 1;
a[30] = 1632;
b[30] = 2;
a[31] = 1718;
b[31] = 0;
a[32] = 2415;
b[32] = 2;
a[33] = 2447;
b[33] = 1;
a[34] = 3507;
b[34] = 2;
a[35] = 3622;
b[35] = 0;
a[36] = 5154;
b[36] = 2;
a[37] = 5260;
b[37] = 1;
a[38] = 7341;
b[38] = 2;
a[39] = 7730;
b[39] = 0;
a[40] = 10866;
b[40] = 2;
a[41] = 11011;
b[41] = 1;
a[42] = 15780;
b[42] = 2;
a[43] = 16298;
b[43] = 0;
a[44] = 23190;
b[44] = 2;
a[45] = 23669;
b[45] = 1;
a[46] = 33033;
b[46] = 2;
a[47] = 34784;
b[47] = 0;
a[48] = 48894;
b[48] = 2;
a[49] = 49549;
b[49] = 1;
a[50] = 71007;
b[50] = 2;
a[51] = 73340;
b[51] = 0;
a[52] = 104352;
b[52] = 2;
a[53] = 106510;
b[53] = 1;
a[54] = 148647;
b[54] = 2;
a[55] = 156527;
b[55] = 0;
a[56] = 220020;
b[56] = 2;
a[57] = 222970;
b[57] = 1;
a[58] = 319530;
b[58] = 2;
a[59] = 330029;
b[59] = 0;
a[60] = 469581;
b[60] = 2;
a[61] = 479294;
b[61] = 1;
a[62] = 668910;
b[62] = 2;
a[63] = 704371;
b[63] = 0;
a[64] = 990087;
b[64] = 2;
a[65] = 1003364;
b[65] = 1;
a[66] = 1437882;
b[66] = 2;
a[67] = 1485130;
b[67] = 0;
a[68] = 2113113;
b[68] = 2;
a[69] = 2156822;
b[69] = 1;
a[70] = 3010092;
b[70] = 2;
a[71] = 3169669;
b[71] = 0;
a[72] = 4455390;
b[72] = 2;
a[73] = 4515137;
b[73] = 1;
a[74] = 6470466;
b[74] = 2;
a[75] = 6683084;
b[75] = 0;
a[76] = 9509007;
b[76] = 2;
a[77] = 9705698;
b[77] = 1;
a[78] = 13545411;
b[78] = 2;
a[79] = 14263510;
b[79] = 0;
a[80] = 20049252;
b[80] = 2;
a[81] = 20318116;
b[81] = 1;
a[82] = 29117094;
b[82] = 2;
a[83] = 30073877;
b[83] = 0;
a[84] = 42790530;
b[84] = 2;
a[85] = 43675640;
b[85] = 1;
a[86] = 60954348;
b[86] = 2;
a[87] = 64185794;
b[87] = 0;
a[88] = 90221631;
b[88] = 2;
a[89] = 91431521;
b[89] = 1;
a[90] = 131026920;
b[90] = 2;
a[91] = 135332446;
b[91] = 0;
a[92] = 192557382;
b[92] = 2;
a[93] = 196540379;
b[93] = 1;
a[94] = 274294563;
b[94] = 2;
a[95] = 288836072;
b[95] = 0;
a[96] = 405997338;
b[96] = 2;
a[97] = 411441844;
b[97] = 1;
a[98] = 589621137;
b[98] = 2;
a[99] = 608996006;
b[99] = 0;
a[100] = 866508216;
b[100] = 2;
a[101] = 884431705;
b[101] = 1;
a[102] = 1000000000;
b[102] = 0;
for (int i = 0; i < MAXN; i++) {
if (a[i + 1] >= P) {
add(a[i], P - 1, b[i]);
break;
}
add(a[i], a[i + 1] - 1, b[i]);
}
dp[0][0] = 1;
for (int i = 1; i <= N; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 3; k++)
dp[i][j] = add(dp[i][j], mul(cnt[k], dp[i - 1][j ^ k]));
int sol = 0;
for (int i = 1; i < 4; i++) sol = add(sol, dp[N][i]);
return sol;
}
int main() {
load();
printf("%d\n", solve());
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -f;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
inline void chkmin(int &a, int b) {
if (a > b) a = b;
}
inline void chkmax(int &a, int b) {
if (a < b) a = b;
}
const int N = 2e5 + 7;
const int mod = 998244353;
int n;
long long f[N], d[N];
int main() {
n = read();
f[0] = 1;
for (int i = 1; i < n; i++) f[i] = f[i - 1] * i % mod;
for (int i = 1; i < n; i++) d[read()]++, d[read()]++;
long long res = n;
for (int i = 1; i <= n; i++) res = res * f[d[i]] % mod;
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
const double PI = 3.141592653589793238463;
using namespace std;
inline long long add(long long a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
inline long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
inline long long mul(long long a, long long b) {
return (long long)((long long)a * b % 1000000007);
}
long long fast_power(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 1) {
result = (result * base) % 1000000007;
}
base = (base * base) % 1000000007;
power = power / 2;
}
return result;
}
long long min(long long a, long long b) { return a > b ? b : a; }
long long max(long long a, long long b) { return a > b ? a : b; }
void dfs(long long s, vector<bool> &vis, vector<vector<long long>> &adlist) {
if (vis[s]) return;
vis[s] = true;
for (auto x : adlist[s]) {
if (vis[x] == false) {
dfs(x, vis, adlist);
}
}
return;
}
void bfs(long long x, vector<bool> &vis, vector<vector<long long>> &adlist,
vector<long long> &level, vector<long long> &parent) {
queue<long long> q;
vis[x] = true;
q.push(x);
while (!q.empty()) {
long long s = q.front();
q.pop();
for (auto u : adlist[s]) {
if (vis[u]) continue;
vis[u] = true;
parent[u] = s;
level[u] = level[s] + 1;
q.push(u);
}
}
}
bool bpchk(vector<vector<long long>> &adj, vector<long long> &color) {
color[1] = 1;
queue<long long> q;
q.push(1);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (auto x : adj[u]) {
if (color[x] == -1) {
color[x] = color[u] ^ 1;
q.push(x);
}
}
}
for (long long i = 1; i < adj.size(); i++) {
for (auto x : adj[i]) {
if (color[x] == color[i]) return false;
}
}
return true;
}
void swap(long long *a, long long *b) {
long long tmp = *a;
*a = *b;
*b = tmp;
}
void SieveOfEratosthenes(long long n, set<long long> &s) {
vector<bool> prime(n + 1, true);
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long p = 2; p <= n; p++)
if (prime[p]) s.insert(p);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
vector<int> dp(1 << 22, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[a[i]] = a[i];
}
for (int i = 0; i < (1 << 22); i++) {
for (int j = 0; j < 22; j++) {
if (i & (1 << j) && dp[i - (1 << j)]) {
dp[i] = dp[i - (1 << j)];
}
}
}
for (int i = 0; i < n; i++) {
int x = (1 << 22) - 1 - a[i];
if (dp[x] != 0) {
cout << dp[x] << " ";
} else
cout << -1 << " ";
}
cout << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double d, n, r, count = 0;
cin >> r >> d >> n;
for (long long int j = 0; j < n; j++) {
long double xx, yy, ro, dist, a, b;
cin >> xx >> yy >> ro;
dist = hypot(xx, yy);
a = (dist - ro);
b = (dist + ro);
if (a >= r - d && b <= r && 2 * ro <= d) {
count++;
}
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool let[26];
memset(let, 1, sizeof(let));
int count = 0;
char who = -1;
for (int i = 0; i < n; ++i) {
char type;
cin >> type;
string st;
cin >> st;
if (type == '?') {
if (st[0] != who && who != -1) ++count;
let[st[0] - 'a'] = false;
} else if (type == '.') {
for (int i = 0; i < st.size(); ++i) let[st[i] - 'a'] = false;
} else {
bool arr[26] = {};
for (int i = 0; i < st.size(); ++i) arr[st[i] - 'a'] = true;
for (int i = 0; i < 26; ++i)
if (!arr[i]) let[i] = false;
if (who != -1) ++count;
}
if (who == -1) {
for (int i = 0; i < 26; ++i)
if (let[i]) {
if (who == -1)
who = i + 'a';
else {
who = -1;
break;
}
}
}
}
cout << count << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int l, d, v, g, r, cnt;
int main() {
scanf("%d%d%d%d%d", &l, &d, &v, &g, &r);
double pre = 1. * d / v;
for (; pre > g + r; cnt++) pre -= g + r;
printf("%.12lf\n",
pre < g ? 1. * l / v : 1. * (l - d) / v + (cnt + 1.) * (g + r));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void loop() {
int n;
cin >> n;
int a[n + 1];
long long int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % n) {
cout << "-1\n";
return;
}
vector<pair<long long int, pair<long long int, long long int> > > v;
for (int i = 2; i <= n; i++) {
if (a[i] % i) {
long long int x = i - (a[i] % i);
v.push_back({1, {i, x}});
a[i] += x;
a[1] -= x;
}
v.push_back({i, {1, a[i] / i}});
a[1] += a[i];
a[i] = 0;
}
for (int i = 2; i <= n; i++) v.push_back({1, {i, sum / n}});
cout << v.size() << "\n";
for (auto x : v)
cout << x.first << " " << x.second.first << " " << x.second.second << "\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) loop();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, INF = 1e9 + 7;
int n;
string second;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> second;
int ind = n - 1;
for (int i = 0; i < (n - 1); i++) {
if (second[i] > second[i + 1]) {
ind = i;
break;
}
}
for (int i = 0; i < n; i++) {
if (i != ind) cout << second[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 1005;
int p[maxn], d[maxn], l[maxn][2], nl, ti;
int main() {
int n, h, r, c;
scanf("%d%d%d", &n, &h, &r);
for (int i = 0; i != n; ++i) scanf("%d%d", p + i, d + i);
c = h;
while (true) {
c += r;
if (c > h) c = h;
if (c <= 0) break;
int t = 0, pos = -1;
for (int i = 0; i != n; ++i)
if (c * 100 <= h * p[i] && t < d[i]) t = d[i], pos = i + 1;
if (~pos) {
r -= t;
l[nl][0] = ti;
l[nl++][1] = pos;
d[pos - 1] = -1;
} else if (r >= 0) {
puts("NO");
return 0;
}
ti++;
}
puts("YES");
printf("%d %d\n", ti, nl);
for (int i = 0; i != nl; ++i) printf("%d %d\n", l[i][0], l[i][1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
const int MOD = 1e9 + 7;
const double PI = acos(-1);
int a[N];
int c[N];
vector<int> v[N];
bool usedColor[N];
int main() {
int n, k;
cin >> n >> k;
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
v[a[i]].push_back(i);
}
int colorID = 0;
for (int i = 1; i <= mx; i++) {
if (v[i].size() > k) {
cout << "NO";
return 0;
}
for (int j = 0; j < v[i].size(); j++) {
c[v[i][j]] = colorID++;
usedColor[colorID] = 1;
colorID %= k;
}
}
for (int i = 1; i <= k; i++) {
if (!usedColor[i]) {
cout << "NO";
return 0;
}
}
puts("YES");
for (int i = 0; i < n; i++) {
cout << c[i] + 1 << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int Ask(int i) {
cout << "? " << i + 1 << endl;
int ans;
cin >> ans;
return ans;
}
int B(int i) {
int ret = Ask(i);
int j = (i + n / 2) % n;
ret -= Ask(j);
return ret;
}
void Print(int i) {
cout << "! " << i + 1 << endl;
exit(0);
}
void Err() {
cout << "! -1" << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
if (n % 4) {
Err();
}
int low = 0, high = n / 2;
int Blow = B(low);
int Bhigh = -Blow;
if (Blow == 0) {
Print(low);
}
while (low < high) {
int mid = (low + high) >> 1;
int Bmid = B(mid);
if (Bmid == 0) {
Print(mid);
}
if (Blow * Bmid < 0) {
high = mid;
Bhigh = Bmid;
} else {
assert(Bmid * Bhigh < 0);
low = mid;
Blow = Bmid;
}
}
Blow = B(low);
if (Blow == 0) {
Print(low);
} else {
Err();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[1007];
long long f[1007][1007][3][3], ans, mod;
int s[1007], l, d[1007];
void dfs(int l, int r) {
if (l + 1 == r)
f[l][r][0][1] = f[l][r][0][2] = f[l][r][1][0] = f[l][r][2][0] = 1;
else if (s[l] == r) {
dfs(l + 1, r - 1);
for (int i = 0; i <= 2; i++)
for (int j = 0; j <= 2; j++) {
if (i != 1)
f[l][r][1][0] = (f[l][r][1][0] + f[l + 1][r - 1][i][j]) % mod;
if (j != 1)
f[l][r][0][1] = (f[l][r][0][1] + f[l + 1][r - 1][i][j]) % mod;
if (i != 2)
f[l][r][2][0] = (f[l][r][2][0] + f[l + 1][r - 1][i][j]) % mod;
if (j != 2)
f[l][r][0][2] = (f[l][r][0][2] + f[l + 1][r - 1][i][j]) % mod;
}
} else {
dfs(l, s[l]);
dfs(s[l] + 1, r);
for (int i = 0; i <= 2; i++)
for (int j = 0; j <= 2; j++)
for (int k = 0; k <= 2; k++)
for (int q = 0; q <= 2; q++) {
if (k == q && k != 0) continue;
f[l][r][i][j] = (f[l][r][i][j] +
(f[l][s[l]][i][k] * f[s[l] + 1][r][q][j]) % mod) %
mod;
}
}
}
int main() {
scanf("%s", &a);
mod = 1e9 + 7;
for (int t = 0; a[l] != '\0'; l++)
if (a[l] == '(')
d[++t] = l;
else {
s[l] = d[t];
s[d[t--]] = l;
}
dfs(0, l - 1);
for (int i = 0; i <= 2; i++)
for (int j = 0; j <= 2; j++) ans = (ans + f[0][l - 1][i][j]) % mod;
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
const int N = (int)10;
const int INF = (int)1e9 + 41;
const long long MD = (long long)1e9 + 7;
bool D = false, E = false;
long long sum[N][N];
long long num[N][N];
int minE[N][N];
vector<pair<int, int>> es = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
void solve() {
int m;
scanf("%d", &m);
for (int i = 0; i < 4; i++) {
for (int j = 0; j <= i; j++) {
minE[j][i] = INF;
sum[j][i] = num[j][i] = 0;
}
}
while (m--) {
int v1, v2, val;
scanf("%d%d%d", &v1, &val, &v2);
v1--;
v2--;
if (v1 > v2) swap(v1, v2);
sum[v1][v2] += val;
num[v1][v2]++;
minE[v1][v2] = min(minE[v1][v2], val);
}
long long ans = 0;
for (int maskV = 1; maskV < 16; maskV++) {
int st = -1;
for (int i = 0; st == -1 && i < 4; i++)
if (maskV & (1 << i)) st = i;
for (int maskE = 0; maskE < 64; maskE++) {
long long cur = 0;
bool fail = false;
vector<int> deg(4, 0);
for (int i = 0; i < 6; i++) {
int v1 = es[i].first;
int v2 = es[i].second;
if ((maskV & (1 << v1)) == 0 || (maskV & (1 << v2)) == 0) continue;
if (maskE & (1 << i)) {
deg[v1]++;
deg[v2]++;
if (num[v1][v2] == 0) fail = true;
if (num[v1][v2] % 2)
cur += sum[v1][v2];
else
cur += sum[v1][v2] - minE[v1][v2];
} else {
if (num[v1][v2] % 2)
cur += sum[v1][v2] - minE[v1][v2];
else
cur += sum[v1][v2];
}
}
int numOdd = 0;
for (int i = 0; i < 4; i++)
if (deg[i] % 2) numOdd++;
if (numOdd > 2) fail = true;
for (int i = 0; i < 4; i++) {
if (maskV & (1 << i)) cur += sum[i][i];
}
if (fail) continue;
int msk = (1 << st);
for (int it = 0; it < 10; it++) {
for (int i = 0; i < 6; i++) {
int v1 = es[i].first;
int v2 = es[i].second;
if ((maskV & (1 << v1)) == 0 || (maskV & (1 << v2)) == 0) continue;
if (((maskE & (1 << i)) && num[v1][v2] > 0) || num[v1][v2] > 1) {
if (msk & (1 << v1)) msk |= (1 << v2);
if (msk & (1 << v2)) msk |= (1 << v1);
}
}
}
if (msk != maskV) continue;
ans = max(ans, cur);
}
}
cout << ans << "\n";
}
int main() {
int tst = 1;
while (tst--) solve();
}
| 8 |
#include <bits/stdc++.h>
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
using namespace std;
const int maxn = 1e6 + 5;
char p[maxn], q[maxn];
int P[27], Q[27], V[27], R[27], F[27];
vector<int> v;
int main() {
int ans = 0;
memset(V, 0, sizeof(V));
memset(R, 0, sizeof(R));
memset(F, 0, sizeof(F));
memset(P, 0, sizeof(P));
memset(Q, 0, sizeof(Q));
scanf("%s", p);
scanf("%s", q);
int l1 = strlen(p), l2 = strlen(q);
for (long long i = 0; i < l1; i++) {
if (p[i] == '?') {
ans++;
continue;
}
int k = p[i] - 'a';
P[k]++;
}
for (long long i = 0; i < l2; i++) {
int k = q[i] - 'a';
Q[k]++;
}
int vis = 0x7fffffff;
for (long long i = 0; i < 26; i++) {
if (Q[i] == 0) continue;
V[i] = P[i] / Q[i];
vis = min(vis, V[i]);
R[i] = P[i] % Q[i];
}
while (++vis) {
int v = 0;
for (long long i = 0; i < 26; i++) {
if (V[i] >= vis) continue;
v += ((vis - V[i]) * Q[i] - R[i]);
}
if (v <= ans)
continue;
else
break;
}
vis--;
for (long long i = 0; i < 26; i++) {
if (V[i] >= vis)
F[i] = 0;
else
F[i] = ((vis - V[i]) * Q[i] - R[i]);
}
int a = 0;
for (long long i = 0; i < l1; i++) {
if (p[i] == '?') {
while (a < 26 && F[a] == 0) a++;
if (a == 26)
cout << "a";
else {
cout << (char)('a' + a);
F[a]--;
}
} else
cout << p[i];
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long lINF = 1e18 + 7;
const int INF = 1e9 + 7;
template <class T>
ostream& operator<<(ostream& s, const vector<T>& v) {
for (size_t i = 0; i < v.size(); i++) {
s << v[i] << ' ';
}
return s;
}
template <class T>
istream& operator>>(istream& s, vector<T>& v) {
for (size_t i = 0; i < v.size(); i++) {
s >> v[i];
}
return s;
}
void solve(int CASE = 0) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << "1 ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
cin >> q;
for (int i = 1; i <= q; i++) {
solve(i);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
int deg[200000];
int main() {
int n, m, i, x, y, cn, cn2;
srand(time(NULL));
scanf("%d %d", &n, &m);
vector<int> v;
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
x--;
y--;
mp[make_pair(x, y)] = 1;
mp[make_pair(y, x)] = 1;
}
for (i = 0; i < n; i++) v.push_back(i);
int tries = 1000;
while (tries--) {
random_shuffle(v.begin(), v.end());
for (i = 0; i < m; i++) {
if (mp.count(make_pair(v[i], v[(i + 1) % n])) != 0) {
break;
}
}
if (i == m) break;
}
if (tries == -1)
cout << -1 << endl;
else {
for (i = 0; i < m; i++) {
cout << v[i] + 1 << " " << v[(i + 1) % n] + 1 << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 45;
void solve() {
int n;
cin >> n;
vector<int> a(2 * n);
vector<int> p(n);
vector<int> s(n);
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
p[0] = (a[0] == 1 ? 1 : -1);
for (int i = 1; i < n; i++) {
p[i] = p[i - 1] + (a[i] == 1 ? 1 : -1);
}
s[n - 1] = (a[2 * n - 1] == 1 ? 1 : -1);
for (int i = n - 2; i >= 0; i--) {
s[i] = s[i + 1] + (a[i + n] == 1 ? 1 : -1);
}
int ans = 1e9;
map<int, int> mp;
for (int i = 0; i < n; i++) {
if (mp.find(s[i]) == mp.end()) {
mp[s[i]] = i;
}
}
for (int i = 0; i < n; i++) {
if (mp.find(-p[i]) != mp.end()) {
ans = min(ans, n - i + mp[(-p[i])] - 1);
}
}
for (int i = 0; i < n; i++) {
if (p[i] == 0) {
ans = min(ans, n + n - i - 1);
}
}
for (int i = 0; i < n; i++) {
if (s[i] == 0) {
ans = min(ans, n + i);
}
}
cout << min(2 * n, ans) << endl;
}
int main() {
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int L = 8005;
const int mo = 1e9 + 7;
int n, m;
long long k;
int d[15];
int c[L];
int Mo[L], Mxr;
long long f0[L], sum[L], a[L], ans[L];
long long tmp[L * 2];
long long add(long long x, long long y) {
return x + y >= mo ? x + y - mo : x + y;
}
long long dec(long long x, long long y) { return x >= y ? x - y : x + mo - y; }
void multi(long long *a, long long *b, long long *c) {
for (int i = 0; i <= Mxr * 2; i++) tmp[i] = 0;
for (int i = 0; i <= Mxr - 1; i++)
for (int j = 0; j <= Mxr - 1; j++)
tmp[i + j] = add(tmp[i + j], a[i] * b[j] % mo);
for (int i = Mxr * 2 - 2; i >= Mxr; i--)
if (tmp[i]) {
int w = i - Mxr;
long long v = tmp[i];
for (int j = 0; j <= Mxr; j++)
tmp[w + j] = dec(tmp[w + j], v * Mo[j] % mo);
}
for (int i = 0; i <= Mxr - 1; i++) c[i] = tmp[i];
}
int main() {
n = get();
m = get();
scanf("%I64d", &k);
for (int i = 1; i <= n; i++) d[i] = get();
for (int i = 1; i <= m; i++) {
int x = get();
c[x]++;
Mxr = max(Mxr, x);
}
if (Mxr == 1) Mxr++;
Mo[Mxr] = 1;
for (int i = 1; i <= Mxr; i++) Mo[Mxr - i] = c[i] ? mo - c[i] : 0;
f0[0] = 1;
for (int i = 1; i <= Mxr - 1; i++)
for (int j = 1; j <= i; j++) f0[i] = add(f0[i], f0[i - j] * c[j] % mo);
for (int i = 0; i <= Mxr - 1; i++) sum[i] = 0;
for (int now = 1; now <= n; now++) {
int tim = d[now];
for (int i = 0; i <= Mxr - 1; i++) a[i] = ans[i] = 0;
a[1] = 1;
ans[0] = 1;
for (; tim; tim /= 2) {
if (tim & 1) multi(ans, a, ans);
multi(a, a, a);
}
for (int i = 0; i <= Mxr - 1; i++) sum[i] = add(sum[i], ans[i]);
}
long long tim = k;
for (int i = 0; i <= Mxr - 1; i++) a[i] = sum[i], ans[i] = 0;
ans[0] = 1;
for (; tim; tim /= 2) {
if (tim & 1) multi(ans, a, ans);
multi(a, a, a);
}
long long v = 0;
for (int i = 0; i <= Mxr - 1; i++) v = add(v, ans[i] * f0[i] % mo);
printf("%I64d\n", v);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
std::mt19937 mt(time(0));
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
int q;
cin >> n >> m >> q;
long long g = gcd(n, m);
for (int i = 0; i < int(q); ++i) {
long long sx, sy, ex, ey;
cin >> sx >> sy >> ex >> ey;
sy = (sy - 1) / ((sx == 1 ? n : m) / g);
ey = (ey - 1) / ((ex == 1 ? n : m) / g);
if (sy == ey)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a1, a2, b1, b2, c1, c2, d1, d2;
a1 = 0;
b1 = 0;
c1 = 0;
d1 = 1;
for (int i = 1; i <= n; i++) {
a2 = (b1 + c1 + d1);
if (a2 > 1000000000000000ll) {
a2 = a2 % 1000000007;
}
b2 = (a1 + c1 + d1);
if (b2 > 1000000000000000ll) {
b2 = b2 % 1000000007;
}
c2 = (a1 + b1 + d1);
if (c2 > 1000000000000000ll) {
c2 = c2 % 1000000007;
}
d2 = (a1 + b1 + c1);
if (d2 > 1000000000000000ll) {
d2 = d2 % 1000000007;
}
a1 = a2;
b1 = b2;
c1 = c2;
d1 = d2;
}
cout << d1 % 1000000007;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i, a[1000000], k, j = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
while (k--) {
a[j] = i + 1;
j++;
}
}
int m;
scanf("%d", &m);
while (m--) {
int g;
scanf("%d", &g);
printf("%d\n", a[g]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int t[maxn << 2], a[maxn], b[maxn];
const int inf = 998244353;
inline void pushUp(int rt) { t[rt] = min(t[rt << 1], t[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
t[rt] = a[l];
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushUp(rt);
}
void update(int pos, int l, int r, int rt) {
if (l == r) {
t[rt] = inf;
return;
}
int m = l + r >> 1;
if (pos <= m)
update(pos, l, m, rt << 1);
else
update(pos, m + 1, r, rt << 1 | 1);
pushUp(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return t[rt];
int ans = inf, m = l + r >> 1;
if (L <= m) ans = min(query(L, R, l, m, rt << 1), ans);
if (R > m) ans = min(query(L, R, m + 1, r, rt << 1 | 1), ans);
return ans;
}
queue<int> pos[maxn];
int main(int argc, char const *argv[]) {
int T, n;
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) {
while (!pos[i].empty()) pos[i].pop();
}
bool flag = true;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]].emplace(i);
}
build(1, n, 1);
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
if (pos[b[i]].empty()) {
flag = false;
break;
}
int r = pos[b[i]].front();
if (query(1, r, 1, n, 1) == b[i]) {
update(r, 1, n, 1);
a[r] = inf;
pos[b[i]].pop();
} else {
flag = false;
break;
}
}
cout << (flag ? "YES\n" : "NO\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, k, m, h, u[N], use[N], c1, c2, b1, b2, nrc, ans, ind, cc[N];
stack<int> s;
vector<int> v[N], vt[N], c[N];
set<int> g[N];
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
void dfs1(int k) {
use[k] = 1;
for (auto i : v[k])
if (!use[i]) dfs1(i);
s.push(k);
}
void dfs2(int k) {
use[k] = 1;
for (auto i : vt[k])
if (!use[i]) dfs2(i);
c[nrc].push_back(k);
cc[k] = nrc;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> h;
ans = n + 1;
for (int i = 1; i <= n; i++) cin >> u[i];
for (int i = 1; i <= m; i++) {
cin >> b1 >> b2;
assert(u[b1] != u[b2]);
if (u[b1] > u[b2]) swap(b1, b2);
if (u[b1] == 0 && u[b2] == h - 1) {
v[b2].push_back(b1);
vt[b1].push_back(b2);
}
if (u[b1] + 1 == u[b2]) {
v[b1].push_back(b2);
vt[b2].push_back(b1);
}
}
for (int i = 1; i <= n; i++)
if (v[i].size() == 0) return cout << "1\n" << i << '\n', 0;
for (int i = 1; i <= n; i++)
if (!use[i]) dfs1(i);
memset(use, 0, sizeof use);
while (!s.empty()) {
int a = s.top();
s.pop();
if (!use[a]) nrc++, dfs2(a);
}
for (int i = 1; i <= nrc; i++)
for (auto j : c[i])
for (auto k : v[j]) g[i].insert(cc[k]);
for (int i = 1; i <= nrc; i++)
if (ans > c[i].size() && c[i].size() > 1 && g[i].size() == 1)
ans = c[i].size(), ind = i;
cerr << "ind"
": "
<< ind << "\n";
cout << c[ind];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<bitset<7>> score;
vector<bitset<7>> bvec(10);
map<unsigned long, int> bmap;
bool flag = false;
long long ans = 0;
vector<string> anss;
int ccc = 0;
int ans_tab[2001][10][2001];
bool valid(vector<bitset<7>>& s, int cur, int dig, int cnt) {
if (ans_tab[cur][dig][cnt] != -1) return ans_tab[cur][dig][cnt];
ccc++;
bool vld = (score[cur] & bvec[dig]).to_ulong() == score[cur].to_ulong();
if (vld) {
int x = __builtin_popcount((char)(score[cur] ^ bvec[dig]).to_ulong());
if (cnt - x >= 0) {
if (cur == n - 1 && cnt - x == 0) {
flag = true;
return ans_tab[cur][dig][cnt] = true;
} else {
for (int j = 9; j >= 0; j--) {
if (ans_tab[cur][dig][cnt] = valid(s, cur + 1, j, cnt - x)) {
return true;
}
}
}
} else {
return ans_tab[cur][dig][cnt] = false;
}
}
return ans_tab[cur][dig][cnt] = false;
}
void solve() {
memset(ans_tab, -1, sizeof(ans_tab));
cin >> n >> k;
string in;
for (int i = 0; i < n; ++i) {
cin >> in;
score.emplace_back(in);
}
bvec = {bitset<7>("1110111"), bitset<7>("0010010"), bitset<7>("1011101"),
bitset<7>("1011011"), bitset<7>("0111010"), bitset<7>("1101011"),
bitset<7>("1101111"), bitset<7>("1010010"), bitset<7>("1111111"),
bitset<7>("1111011")};
for (int i = 0; i < (int)bvec.size(); ++i) {
bmap[bvec[i].to_ulong()] = i;
}
string test = "";
test = "";
int cc = k;
for (int j = 9; j >= 0; --j) {
valid(score, 0, j, cc);
}
if (flag) {
for (int i = 0; i < n; ++i) {
for (int j = 9; j >= 0; --j) {
bool vld = (score[i] & bvec[j]).to_ulong() >= score[i].to_ulong();
if (vld) {
int x = __builtin_popcount((char)(score[i] ^ bvec[j]).to_ulong());
if (cc - x >= 0) {
if (ans_tab[i][j][cc]) {
test += to_string(j);
cc -= x;
break;
}
}
}
}
}
cout << test << endl;
} else
cout << -1 << endl;
}
int main() { solve(); }
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) cout << i + 1 << " ";
cout << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int test;
cin >> test;
for (long long int tc = 1; tc <= test; tc++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int main() {
int n;
scanf("%d", &n);
int ans;
int x;
if (n & 1)
x = n / 2 + 1;
else
x = n / 2 + 1;
for (int i = x; i <= n; i++) {
int y = n - i;
if (gcd(i, y) == 1) {
printf("%d %d", y, i);
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 5e5 + 5;
const long long int mod = 1e9 + 7;
const int di[4] = {-1, 0, 1, 0};
const int dj[4] = {0, -1, 0, 1};
const double pi = 3.14159265358979323846;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool vis[N];
vector<long long int> adj[N];
void dfs(long long int x) {
vis[x] = true;
for (int i = 0; i < adj[x].size(); i++) {
if (!vis[adj[x][i]]) {
dfs(adj[x][i]);
}
}
}
long long int dis[N], ct[N];
void bfs(long long int x) {
queue<long long int> q;
q.push(x);
dis[x] = 1;
ct[x] = 1;
while (!q.empty()) {
long long int t = q.front();
q.pop();
for (auto i : adj[t]) {
if (!dis[i]) {
dis[i] = dis[t] + 1;
q.push(i);
ct[i] = 1;
} else if (dis[i] == dis[t] + 1)
ct[i]++;
}
}
}
bool cmp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return a.second < b.second;
}
long long int po(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return po((x * x) % 998244353, n / 2);
else
return (x * po((x * x) % 998244353, (n - 1) / 2)) % 998244353;
}
long long int fact[N];
long long int ncr(long long int n, long long int r) {
long long int d = fact[n];
long long int e = (fact[n - r] * fact[r]) % 998244353;
d *= po(e, 998244353 - 2);
return d % 998244353;
}
bool isPrime(long long int x) {
for (int i = 2; i <= sqrt(x); ++i)
if (x % i == 0) return false;
return true;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int a[n][n];
long long int x = 0;
for (int i = 0; i < n / 2; ++i) {
for (int j = 0; j < n / 2; ++j) {
a[i][j] = x * 4 + 1;
a[i][j + n / 2] = x * 4 + 2;
a[i + n / 2][j] = x * 4 + 3;
a[i + n / 2][j + n / 2] = x * 4;
x++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; ++j) cout << a[i][j] << ' ';
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double EPS = 1e-9;
long long cel(long long a, long long b) { return ((a - 1) / b + 1); }
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
return (b == 0) ? a : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long po(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = (ans * x) % 1000000007;
}
y >>= 1;
x = (x * x) % 1000000007;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, t, x, y, m, k;
cin >> n;
int ans = 0;
vector<int> deg(n), A(n);
queue<int> Q;
for (int i = 0; i < n; i++) {
cin >> x >> y;
deg[i] = x;
A[i] = y;
if (deg[i] == 1) {
Q.push(i);
}
ans += x;
}
cout << ans / 2 << "\n";
while (!Q.empty()) {
int from = Q.front();
Q.pop();
if (deg[from] == 0) {
continue;
}
int to = A[from];
deg[to]--;
A[to] ^= from;
cout << from << " " << to << "\n";
if (deg[to] == 1) {
Q.push(to);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 120;
char op[16][2];
int n, s, resa, resb, res, na, nb;
int dp[1 << 16][121], ta[16], tb[16], ra[1 << 16], rb[1 << 16];
int main() {
cin >> n;
s = 1 << n;
for (int i = 0; i < n; ++i) {
cin >> op[i] >> ta[i] >> tb[i];
resa += ta[i];
resb += tb[i];
}
for (int i = 0; i < s; ++i) {
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) {
ra[i] += op[j][0] == 'R' ? 1 : 0;
rb[i] += op[j][0] == 'B' ? 1 : 0;
}
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < s; ++i) {
for (int j = 0; j <= maxn; ++j) {
if (dp[i][j] == -1) continue;
for (int k = 0; k < n; ++k) {
if (i & (1 << k)) continue;
na = min(ta[k], ra[i]);
nb = min(tb[k], rb[i]);
dp[i | (1 << k)][j + na] = max(dp[i | (1 << k)][j + na], dp[i][j] + nb);
}
}
}
res = max(resa, resb);
for (int i = 0; i <= maxn; ++i) {
if (dp[s - 1][i] != -1) res = min(res, max(resa - i, resb - dp[s - 1][i]));
}
cout << res + n << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[200010], b[200010];
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(&a[1], &a[n + 1]);
int min, max, l = 1;
min = (int)sqrt(a[1]);
max = (int)sqrt(a[n]);
for (int i = min; i <= max + 1; i++) {
int x = i * i;
while (a[l] <= x) {
b[l] = x - a[l];
l++;
if (l == n + 1) break;
}
if (l == n + 1) break;
}
l = n;
for (int i = max; i >= min; i--) {
int x = i * i, y;
while (a[l] >= x) {
y = a[l] - x;
if (y < b[l]) b[l] = y;
l--;
if (!l) break;
}
if (!l) break;
}
sort(&b[1], &b[n + 1]);
long long ans = 0;
int st = n / 2 + 1;
for (; st <= n; st++) {
if (b[st])
break;
else {
if (!a[st])
ans += 2;
else
ans += 1;
}
}
n /= 2;
for (int i = 1; i <= n; i++) ans += b[i];
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
const int Z = 100;
const int N = Z * Z;
const int M = Z * Z * Z * 3;
int px[N], py[N];
int head[N], to[M], ct[M], w[M], nt[M];
int d[N], vis[N];
int pre[N], id[N];
int s, t, tot;
void add(int u, int v, int flow, int cost) {
to[tot] = v;
ct[tot] = cost;
w[tot] = flow;
nt[tot] = head[u];
head[u] = tot++;
to[tot] = u;
ct[tot] = -cost;
w[tot] = 0;
nt[tot] = head[v];
head[v] = tot++;
}
void init() {
memset(head, -1, sizeof(head));
tot = 0;
}
int spfa(int s, int t) {
queue<int> q;
memset(d, inf, sizeof(d));
memset(vis, 0, sizeof(vis));
memset(pre, -1, sizeof(pre));
d[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; ~i; i = nt[i]) {
if (w[i] > 0 && d[to[i]] > d[u] + ct[i]) {
d[to[i]] = d[u] + ct[i];
pre[to[i]] = u;
id[to[i]] = i;
if (!vis[to[i]]) {
vis[to[i]] = 1;
q.push(to[i]);
}
}
}
}
return d[t] < inf;
}
int MaxFlow(int s, int t) {
int Mi = inf;
int sum = 0;
int tt = 0;
while (spfa(s, t)) {
Mi = inf;
for (int i = t; i != s; i = pre[i]) Mi = min(Mi, w[id[i]]);
for (int i = t; i != s; i = pre[i]) {
w[id[i]] -= Mi;
w[id[i] ^ 1] += Mi;
}
tt += Mi;
sum += d[t] * Mi;
}
return sum;
}
int main() {
init();
int n, m, k, c, d;
scanf("%d%d%d%d%d", &n, &m, &k, &c, &d);
int s = 0, t = n * 100 + 1;
for (int i = 1; i <= 100; ++i) add(i, t, 100, 0);
for (int i = 1, v; i <= k; ++i) {
scanf("%d", &v);
add(s, (v - 1) * 100 + 1, 1, 0);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < 100; ++j) {
add((i - 1) * 100 + j, (i - 1) * 100 + j + 1, 100, c);
}
}
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
for (int j = 1; j < 100; ++j) {
int idx = (u - 1) * 100 + j;
int idy = (v - 1) * 100 + j + 1;
for (int k = 1; k <= 50; ++k) {
add(idx, idy, 1, c + (k * k - (k - 1) * (k - 1)) * d);
}
}
for (int j = 1; j < 100; ++j) {
int idx = (v - 1) * 100 + j;
int idy = (u - 1) * 100 + j + 1;
for (int k = 1; k <= 50; ++k) {
add(idx, idy, 1, c + (k * k - (k - 1) * (k - 1)) * d);
}
}
}
printf("%d\n", MaxFlow(s, t));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int dx44[6] = {0, -1, -1, 1, 1};
const int dy44[6] = {0, -1, 1, -1, 1};
char dir_box[] = {'j', 'N', 'S', 'W', 'E'};
char dir_man[] = {'j', 'n', 's', 'w', 'e'};
const int dx4[6] = {0, 1, 0, -1, 0};
const int dy4[6] = {0, 0, 1, 0, -1};
const int dx8[9] = {0, -1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[9] = {0, 0, 1, 0, -1, 1, -1, 1, -1};
const int dx82[9] = {0, -1, -1, 1, 1, 2, 2, -2, -2};
const int dy82[9] = {0, 2, -2, 2, -2, 1, -1, 1, -1};
long long po(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
void extgcd(long long a, long long b, long long &d, long long &x,
long long &y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
extgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long inverse(long long a, long long n) {
long long d, x, y;
extgcd(a, n, d, x, y);
return d == 1 ? (x + n) % n : -1;
}
const int maxn = 1e6 + 5;
const double PI = acos(-1.0);
const long long mod = 1e9 + 7;
const long long mod1 = 1e8 + 7;
const long long mod2 = 1e9 + 7;
void solve() {
long long x, y, z;
cin >> x >> y >> z;
long long ans = (x + y) / z;
long long ans1 = x / z;
long long ans2 = y / z;
long long pri1 = x / z * z;
long long pri2 = y / z * z;
long long minn = 1e18;
if (x % z >= (z - y % z)) {
minn = z - y % z;
}
if (y % z >= (z - x % z)) {
minn = min(minn, z - x % z);
}
if (minn == 1e18) {
cout << (x + y) / z << " " << 0 << endl;
} else {
cout << (x + y) / z << " " << minn << endl;
}
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
int cnt[N];
int need[N];
int n, m;
int getbit(int x, int i) { return (x >> i) & 1; }
void add(int x, int val) {
for (int mask = 0; mask < (1 << 6); mask++)
if (getbit(mask, x)) cnt[mask] += val;
}
bool check() {
for (int mask = 0; mask < (1 << 6); mask++)
if (cnt[mask] < need[mask]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
for (char c : s) add(c - 'a', 1);
n = s.size();
for (int i = 1; i <= n; i++) a[i] = 63;
cin >> m;
for (int i = 1; i <= m; i++) {
int id;
string t;
cin >> id >> t;
int mask = 0;
for (char c : t) mask |= (1 << (c - 'a'));
a[id] = mask;
}
for (int i = 1; i <= n; i++) need[a[i]]++;
for (int i = 0; i < 6; i++)
for (int mask = 0; mask < (1 << 6); mask++)
if (getbit(mask, i)) need[mask] += need[mask ^ (1 << i)];
string ans;
for (int i = 1; i <= n; i++) {
bool found = false;
for (int mask = 0; mask < (1 << 6); mask++)
if ((mask & a[i]) == a[i]) need[mask]--;
for (int j = 0; j <= 5; j++)
if (getbit(a[i], j)) {
add(j, -1);
if (check()) {
ans += (char)j + 'a';
found = true;
break;
}
add(j, 1);
}
if (!found) {
ans = "Impossible";
break;
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x;
cin >> x;
return x;
}
const int MAX_N = 15;
const int MAX_F = (1 << (MAX_N - 2)) + 4;
int n, m, nQ, id[MAX_N];
bool isEdge[MAX_N][MAX_N], isParent[MAX_N][MAX_N], isNotParent[MAX_N][MAX_N];
bool ok1[MAX_F][MAX_N], ok2[MAX_F][MAX_N], ok3[MAX_F][MAX_N][MAX_N],
ok4[MAX_F][MAX_F];
long long f[MAX_F][MAX_N];
vector<pair<int, int> > lca[MAX_N];
inline bool check_0(int u, int v, int r) {
if (u == v && r != u) return 0;
if ((u == 1 || v == 1) && r != 1) return 0;
return 1;
}
void init(int nMask) {
memset(ok2, 0, sizeof(ok2));
memset(ok3, 0, sizeof(ok3));
memset(ok4, 0, sizeof(ok4));
for (long long x = (0); x <= (nMask); ++x)
for (long long i = (1); i <= (n); ++i)
if (!(x & id[i])) {
ok2[x][i] = 1;
for (long long j = (1); j <= (n); ++j)
if (x & id[j])
if (isParent[j][i] || isParent[i][j] || isEdge[j][i] ||
isEdge[i][j]) {
ok2[x][i] = 0;
break;
}
}
for (long long x = (0); x <= (nMask); ++x)
for (long long i = (1); i <= (n); ++i)
if (x & id[i])
for (long long r = (1); r <= (n); ++r)
if (!(x & id[r])) {
ok3[x][i][r] = 1;
for (long long j = (1); j <= (n); ++j)
if (j != i && (x & id[j]))
if (isEdge[r][j]) {
ok3[x][i][r] = 0;
break;
}
}
for (long long x = (0); x <= (nMask); ++x) {
for (long long y = (0); y <= (nMask); ++y)
if (!(x & y)) {
ok4[x][y] = 1;
for (long long i = (1); i <= (n); ++i)
if (x & id[i]) {
for (long long j = (1); j <= (n); ++j)
if (y & id[j])
if (isParent[i][j] || isParent[j][i] || isEdge[i][j] ||
isEdge[j][i]) {
ok4[x][y] = 0;
break;
}
if (!ok4[x][y]) break;
}
}
}
}
inline bool check1(int newMask, int newR) {
for (long long i = (1); i <= (n); ++i)
if (i != newR && (newMask & id[i]))
if (isParent[i][newR] || isNotParent[newR][i]) return 0;
return 1;
}
inline bool checkLCA(int mask, int r) {
for (__typeof(lca[r].begin()) it = lca[r].begin(); it != lca[r].end(); it++)
if ((mask & id[it->first]) && (mask & id[it->second])) return 0;
return 1;
}
inline bool check(int mask, int r, int newMask, int newR) {
int x = mask - newMask;
return check1(newMask, newR) && ok2[x][newR] && ok3[newMask][newR][r] &&
ok4[newMask][x] && checkLCA(newMask, r);
}
long long solve(int mask, int par) {
if (mask == 0) return 1;
if (f[mask][par] > -1) return f[mask][par];
long long ans = 0;
int x = 0;
do {
if (x > 0 && __builtin_clz(x) == __builtin_clz(mask))
for (long long r = (1); r <= (n); ++r)
if (x & id[r]) {
if (!check(mask, par, x, r)) continue;
long long t = solve(x - id[r], r) * solve(mask - x, par);
ans += t;
}
x = (x + 1 + (~mask)) & mask;
} while (x);
return f[mask][par] = ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(9);
cout.setf(ios::fixed, ios::floatfield);
memset(isEdge, 0, sizeof(isEdge));
memset(isParent, 0, sizeof(isParent));
memset(isNotParent, 0, sizeof(isNotParent));
cin >> n >> m >> nQ;
for (long long i = (1); i <= (n); ++i) id[i] = 1 << (i - 1);
while (m--) {
int u, v;
cin >> u >> v;
isEdge[u][v] = isEdge[v][u] = 1;
}
while (nQ--) {
int u, v, r;
cin >> u >> v >> r;
if (!check_0(u, v, r)) {
cout << 0 << '\n';
return 0;
}
if (r != u) isNotParent[u][v] = 1;
if (r != v) isNotParent[v][u] = 1;
isParent[r][u] = isParent[r][v] = 1;
if (r != u && r != v) lca[r].push_back(make_pair(u, v));
}
for (long long i = (1); i <= (n); ++i) isParent[i][i] = isNotParent[i][i] = 0;
memset(f, -1, sizeof(f));
int mask = 0;
for (long long i = (2); i <= (n); ++i) mask |= id[i];
init(mask);
cout << solve(mask, 1) << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &i : a) cin >> i;
if (n % 2 == 0) {
cout << "YES\n";
} else {
bool ok = false;
for (int i = 0; i < n - 1; ++i) {
if (a[i] >= a[i + 1]) {
ok = true;
break;
}
}
cout << (ok ? "YES" : "NO") << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int EPS = 1e-9;
int main() {
ios_base ::sync_with_stdio();
int n, i, a;
long long sa = 0, sb = 0;
vector<int> va, vb;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (a > 0) {
sa += a;
va.push_back(a);
} else if (a < 0) {
sb += abs(a);
vb.push_back(-a);
}
}
bool f = 0;
if (sa != sb)
f = sa > sb;
else if (va != vb)
f = va > vb;
else
f = a > 0;
if (a == 0) f = 1;
if (f)
cout << "first\n";
else
cout << "second\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int K = 12;
const int N = (int)1e5 + 37;
int n;
int k;
int q;
int tab[K + 1][N];
bitset<1 << K> b[N];
bitset<K * N> init[K + 1];
int go[N * K];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> q;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
cin >> tab[i][j];
}
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= k; i++) {
int ones = 0;
for (int it = 1; it <= k; it++) {
ones += (tab[i][j] >= tab[it][j]);
}
for (int step = 1; step <= k; step++) {
init[i][(j - 1) * k + step - 1] = (step <= ones);
}
}
}
for (int j = 0; j < n * k; j++) {
int sum = 0;
for (int i = 0; i < k; i++) {
if (init[i + 1][j]) {
sum += (1 << i);
}
}
go[j] = sum;
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < n * k; j++) {
b[i][go[j]] = init[i][j];
}
}
int l = k;
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
l++;
b[l] = b[x] | b[y];
}
if (t == 2) {
l++;
b[l] = b[x] & b[y];
}
if (t == 3) {
int ones = 0;
int l = (y - 1) * k;
int r = y * k - 1;
for (int j = l; j <= r; j++) {
ones += b[x][go[j]];
}
vector<int> mipan;
for (int i = 1; i <= k; i++) {
mipan.push_back(tab[i][y]);
}
sort(mipan.begin(), mipan.end());
cout << mipan[ones - 1] << "\n";
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int MAXN = 500;
const int INF = 100000009;
int Min(int a, int b) { return a < b ? a : b; }
int a4, a7, a47, a74;
int main() {
int i;
while (cin >> a4 >> a7 >> a47 >> a74) {
if (a74 - a47 > 1 || a47 - a74 > 1) {
puts("-1");
continue;
}
if (a47 > a4 || a74 > a4 || a47 > a7 || a74 > a7) {
puts("-1");
continue;
}
if (a47 == a74) {
if (a4 == a47 && a7 == a47) {
puts("-1");
continue;
}
if (a7 == 2 && a4 == 1) {
if (a7 <= a74) {
puts("-1");
continue;
}
for (i = 0; i < a74; i++) printf("74");
puts("7");
continue;
}
if (a47 <= a4 - 1) {
for (i = a47; i < a4 - 1; i++) printf("4");
for (i = 0; i < a47; i++) printf("47");
for (i = a47; i < a7; i++) printf("7");
puts("4");
continue;
} else {
printf("7");
for (i = 0; i < a47; i++) printf("47");
for (i = a47; i < a7 - 1; i++) printf("7");
puts("");
continue;
}
}
if (a47 > a74) {
for (i = a47; i < a4; i++) printf("4");
for (i = 0; i < a47; i++) printf("47");
for (i = a47; i < a7; i++) printf("7");
puts("");
continue;
}
if (a74 > a47) {
printf("74");
for (i = a74; i < a4; i++) printf("4");
for (i = 0; i < a74 - 2; i++) printf("74");
for (i = a74; i < a7; i++) printf("7");
puts("74");
continue;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m;
int a[N], l[305], r[305];
vector<int> add[N], sub[N];
int ansc[305];
void change(int l, int r, int v) {
for (int i = l; i <= r; i++) a[i] += v;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
sub[l[i]].push_back(i);
add[r[i] + 1].push_back(i);
}
int maxi, mini;
maxi = mini = a[1];
for (int i = 2; i <= n; i++) maxi = max(maxi, a[i]), mini = min(mini, a[i]);
int ans = maxi - mini, id;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < add[i].size(); j++) {
int ind = add[i][j];
change(l[ind], r[ind], 1);
}
for (int j = 0; j < sub[i].size(); j++) {
int ind = sub[i][j];
change(l[ind], r[ind], -1);
}
if (!sub[i].empty() || !add[i].empty()) {
maxi = mini = a[1];
for (int i = 2; i <= n; i++)
maxi = max(maxi, a[i]), mini = min(mini, a[i]);
if (ans < maxi - mini) ans = maxi - mini, id = i;
}
}
printf("%d\n", ans);
int c = 0;
for (int i = 1; i <= m; i++)
if (l[i] <= id && id <= r[i]) ansc[c++] = i;
printf("%d\n", c);
for (int i = 0; i < c; i++) printf("%d ", ansc[i]);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
int mi1, mi2, mi3, ma1, ma2, ma3;
cin >> n;
cin >> mi1 >> ma1;
cin >> mi2 >> ma2;
cin >> mi3 >> ma3;
n -= mi1;
n -= mi2;
n -= mi3;
if (ma1 - mi1 > n) {
mi1 += n;
n = 0;
} else {
n -= (ma1 - mi1);
mi1 = ma1;
}
if (ma2 - mi2 > n) {
mi2 += n;
n = 0;
} else {
n -= (ma2 - mi2);
mi2 = ma2;
}
if (ma3 - mi3 > n) {
mi3 += n;
n = 0;
} else {
n -= (ma3 - mi3);
mi3 = ma3;
}
cout << mi1 << " " << mi2 << " " << mi3 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
int n, c = 0;
int ara[6];
scanf("%d", &n);
for (int j = 0; j <= 4; j++) {
if (n % 10 != 0) {
ara[j] = (n % 10) * (pow(10, j));
c++;
n = n / 10;
} else {
ara[j] = 0;
n = n / 10;
}
}
printf("%d\n", c);
for (int k = 0; k <= 4; k++) {
if (ara[k] != 0) {
printf("%d ", ara[k]);
}
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m;
vector<int> in[N];
int d[N];
void run() {
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
++d[u], ++d[v];
in[u].push_back(v);
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans += 1ll * (d[i] - (int)(in[i]).size()) * (int)(in[i]).size();
int q;
cin >> q;
while (q--) {
cout << ans << '\n';
int x;
cin >> x;
ans -= 1ll * (d[x] - (int)(in[x]).size()) * (int)(in[x]).size();
for (auto v : in[x]) {
ans -= 1ll * (d[v] - (int)(in[v]).size()) * (int)(in[v]).size();
in[v].push_back(x);
ans += 1ll * (d[v] - (int)(in[v]).size()) * (int)(in[v]).size();
}
in[x].clear();
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
while (cin >> n >> m) run();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
long long int x = a;
long long int y = b;
long long int r = 0;
if (b == 1 && a != 1) cout << a;
if (a == 1 && b != 1) cout << b;
if (a == 1 && b == 1) cout << a;
if (a != 1 && b != 1) {
while (1) {
if (x > y) {
r = r + (x / y);
x = x % y;
}
if (y > x) {
r = r + (y / x);
y = y % x;
}
if (y == 1) {
r = r + x;
break;
}
if (x == 1) {
r = r + y;
break;
}
}
cout << r;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main(void) {
int l, r, x, a[6], c, i = 0, k = 0, j, flag = 1;
scanf("%d %d", &l, &r);
for (x = l; x <= r; x++) {
k = 0;
flag = 1;
c = x;
i = 0;
while (c != 0) {
a[i] = c % 10;
c = c / 10;
i++;
k++;
}
for (i = 0; i < k - 1; i++) {
for (j = i + 1; j < k; j++)
if (a[i] == a[j]) {
flag = 0;
break;
}
if (flag == 0) break;
}
if (flag) {
printf("%d", x);
break;
}
}
if (flag == 0) printf("-1");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const int MAXSEG = 1 << 18;
const int MOD = 1000000007;
long long power[MAXN];
long long pre[MAXN];
long long digit[10];
int N, M, K;
string S;
long long seg[MAXSEG];
long long lazy[MAXSEG];
void build_tree(int node, int left, int right) {
if (left == right) {
seg[node] = power[left] * digit[S[left] - '0'] % MOD;
return;
}
int mid = (left + right) / 2;
build_tree(2 * node, left, mid);
build_tree(2 * node + 1, mid + 1, right);
seg[node] = (seg[2 * node] + seg[2 * node + 1]) % MOD;
}
void down(int node, int left, int right) {
if (lazy[node] != -1) {
int mid = (left + right) / 2;
long long hash1 = (pre[mid + 1] - pre[left]) % MOD;
if (hash1 < 0) hash1 += MOD;
long long hash2 = (pre[right + 1] - pre[mid + 1]) % MOD;
if (hash2 < 0) hash2 += MOD;
seg[2 * node] = hash1 * lazy[node] % MOD;
seg[2 * node + 1] = hash2 * lazy[node] % MOD;
lazy[2 * node] = lazy[2 * node + 1] = lazy[node];
lazy[node] = -1;
}
}
void update(int node, int left, int right, int ql, int qr, int d) {
if (left > right || right < ql || qr < left) return;
if (ql <= left && right <= qr) {
long long hash = (pre[right + 1] - pre[left]) % MOD;
if (hash < 0) hash += MOD;
seg[node] = hash * digit[d] % MOD;
lazy[node] = digit[d];
return;
}
down(node, left, right);
int mid = (left + right) / 2;
update(2 * node, left, mid, ql, qr, d);
update(2 * node + 1, mid + 1, right, ql, qr, d);
seg[node] = (seg[2 * node] + seg[2 * node + 1]) % MOD;
}
long long query(int node, int left, int right, int ql, int qr) {
if (left > right || right < ql || qr < left) return 0;
if (ql <= left && right <= qr) return seg[node];
down(node, left, right);
int mid = (left + right) / 2;
return (query(2 * node, left, mid, ql, qr) +
query(2 * node + 1, mid + 1, right, ql, qr)) %
MOD;
}
bool check(int ql, int qr, int p) {
int rem = (qr - ql + 1) % p;
long long hf = query(1, 0, N - 1, ql, ql + rem - 1),
extra = query(1, 0, N - 1, qr - rem + 1, qr);
if (hf * power[qr - rem + 1 - ql] % MOD != extra) return false;
long long hp = query(1, 0, N - 1, ql, ql + p - 1),
hq = query(1, 0, N - 1, ql, qr - rem);
long long nhash = (hq * power[p] % MOD + hp) % MOD;
nhash = (nhash - hq) % MOD;
if (nhash < 0) nhash += MOD;
return nhash == hp * power[qr - rem + 1 - ql] % MOD;
}
int main() {
ios::sync_with_stdio(0);
power[0] = 1;
for (int i = 1; i < MAXN; i++) power[i] = (power[i - 1] << 1) % MOD;
for (int i = 1; i < MAXN; i++) pre[i] = (pre[i - 1] + power[i - 1]) % MOD;
for (int i = 0; i < 10; i++)
digit[i] = (rand() * (long long)MAXN % MOD + rand()) % MOD;
memset(lazy, -1, sizeof(lazy));
cin >> N >> M >> K >> S;
build_tree(1, 0, N - 1);
for (int i = 0, type, ql, qr, x; i < M + K; i++) {
cin >> type >> ql >> qr >> x;
if (type == 1)
update(1, 0, N - 1, ql - 1, qr - 1, x);
else {
if (check(ql - 1, qr - 1, x))
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void model(vector<int>& a, const vector<pair<int, int> >& v) {
for (pair<int, int> p : v) swap(a[p.first], a[p.second]);
}
bool check(int n, const vector<pair<int, int> >& v) {
vector<int> a(n);
for (int i = 0; i < n; ++i) a[i] = i;
model(a, v);
for (int i = 0; i < n; ++i)
if (a[i] != i) return false;
return true;
}
vector<pair<int, int> > sol0, sol1, sol5;
void solve(int n, vector<pair<int, int> >& res) {
if (n < 4) return;
solve(n - 4, res);
for (int i = 0; i + 1 < n - 4; i += 2) {
res.push_back(pair<int, int>(i, n - 4));
res.push_back(pair<int, int>(i + 1, n - 3));
res.push_back(pair<int, int>(i + 1, n - 4));
res.push_back(pair<int, int>(i, n - 3));
res.push_back(pair<int, int>(i, n - 2));
res.push_back(pair<int, int>(i + 1, n - 1));
res.push_back(pair<int, int>(i + 1, n - 2));
res.push_back(pair<int, int>(i, n - 1));
}
if (n % 2) {
res.push_back(pair<int, int>(n - 5, n - 4));
res.push_back(pair<int, int>(n - 5, n - 3));
res.push_back(pair<int, int>(n - 5, n - 2));
res.push_back(pair<int, int>(n - 4, n - 1));
res.push_back(pair<int, int>(n - 5, n - 1));
for (pair<int, int> p : sol1) {
res.push_back(pair<int, int>(p.first + n - 4, p.second + n - 4));
}
} else {
for (pair<int, int> p : sol0) {
res.push_back(pair<int, int>(p.first + n - 4, p.second + n - 4));
}
}
assert(res.size() == n * (n - 1) / 2);
}
void solve0() {
vector<pair<int, int> > v;
for (int i = 0; i < 4; ++i)
for (int j = i + 1; j < 4; ++j) v.push_back(pair<int, int>(i, j));
do {
if (check(4, v)) {
sol0 = v;
break;
}
} while (next_permutation(v.begin(), v.end()));
assert(!sol0.empty());
}
void solve1() {
vector<pair<int, int> > v;
for (int i = 0; i < 4; ++i)
for (int j = i + 1; j < 4; ++j)
if (pair<int, int>(i, j) != pair<int, int>(0, 3))
v.push_back(pair<int, int>(i, j));
do {
vector<int> st = {3, 0, 1, 2};
vector<int> en = {0, 1, 2, 3};
model(st, v);
if (st == en) {
sol1 = v;
break;
}
} while (next_permutation(v.begin(), v.end()));
assert(!sol1.empty());
}
void solve5() {
vector<pair<int, int> > v;
for (int i = 0; i < 5; ++i)
for (int j = i + 1; j < 5; ++j) v.push_back(pair<int, int>(i, j));
do {
if (check(5, v)) {
sol5 = v;
break;
}
} while (next_permutation(v.begin(), v.end()));
assert(!sol5.empty());
}
int main() {
std::ios::sync_with_stdio(false);
solve0();
solve1();
int n;
cin >> n;
if (n * (n - 1) / 2 % 2) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
vector<pair<int, int> > res;
solve(n, res);
for (int i = 0; i < res.size(); ++i) {
cout << min(res[i].first, res[i].second) + 1 << " "
<< max(res[i].first, res[i].second) + 1 << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const long double inF = 11451419198101145141919810.1145141919810;
const long double pi = acosl(-1);
int s, p, g, n, m;
struct Point {
long double x, y;
Point() {}
Point(long double x, long double y) : x(x), y(y) {}
} t, b[1 << 17];
int main() {
scanf("%d%d%d%d", &s, &p, &g, &n);
t = Point((long double)1.0 * s / (s + p + g),
(long double)1.0 * p / (s + p + g));
int chs = 0, lns = 0, siz = 0;
map<long double, int> ss;
while (n--) {
char mode;
scanf(" %c", &mode);
if (mode == 'A') {
int s, p, g;
scanf("%d%d%d", &s, &p, &g);
b[++m] = Point((long double)1.0 * s / (s + p + g),
(long double)1.0 * p / (s + p + g));
if (fabs(b[m].x - t.x) < 1e-10 && fabs(b[m].y - t.y) < 1e-10)
chs++;
else {
long double jj = atan2l(b[m].y - t.y, b[m].x - t.x);
long double kk = atan2l(t.y - b[m].y, t.x - b[m].x);
auto x = ss.lower_bound(kk - 1e-10);
if (x != ss.end() && fabs(x->first - kk) < 1e-10) lns += x->second;
auto y = ss.lower_bound(jj - 1e-10);
if (y != ss.end() && fabs(y->first - jj) < 1e-10)
y->second++;
else
ss[jj] = 1;
}
siz++;
} else {
int m;
scanf("%d", &m);
if (fabs(b[m].x - t.x) < 1e-10 && fabs(b[m].y - t.y) < 1e-10)
chs--;
else {
long double jj = atan2l(b[m].y - t.y, b[m].x - t.x);
long double kk = atan2l(t.y - b[m].y, t.x - b[m].x);
auto x = ss.lower_bound(kk - 1e-10);
if (x != ss.end() && fabs(x->first - kk) < 1e-10) lns -= x->second;
auto y = ss.lower_bound(jj - 1e-10);
y->second--;
if (!y->second) ss.erase(y);
}
siz--;
}
if (chs)
puts("1");
else if (lns)
puts("2");
else {
if (!ss.size() || siz < 3) {
puts("0");
continue;
}
auto bk = ss.end();
bk--;
long double xju = ss.begin()->first + 2 * pi - bk->first;
auto x = ss.lower_bound(0);
if (x == ss.begin()) {
puts("0");
continue;
}
auto y = x;
y--;
long double yju = x->first - y->first;
if (xju > pi - 1e-10 || yju > pi - 1e-10) {
puts("0");
continue;
}
puts("3");
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100005;
int n, m, x, y;
long long a[2002];
long long sum, k;
string s, z;
vector<pair<int, int> > v;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
cin >> n;
bool f = true;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
if (a[i] != 1) f = false;
}
if (f) {
cout << 0;
return 0;
}
if (n == 1) {
if (a[0] == 1)
cout << 0;
else
cout << -1;
return 0;
}
int k = gcd(a[0], a[1]);
for (int i = 2; i < n; i++) {
k = gcd(k, a[i]);
}
if (k != 1) {
cout << -1;
return 0;
}
int c = 0, o = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) o++;
}
if (o) {
cout << n - o;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (gcd(a[i], a[i + 1]) == 1) {
cout << n;
return 0;
}
}
int mn = 2e9;
for (int i = 0; i < n - 1; i++) {
k = gcd(a[i], a[i + 1]);
int temp = k;
for (int j = i + 1; j < n; j++) {
k = gcd(k, a[j]);
if (k == 1) {
mn = min(mn, j - i);
break;
}
}
for (int j = i - 1; j >= 0; j--) {
temp = gcd(temp, a[j]);
if (temp == 1) {
mn = min(mn, i - j);
break;
}
}
}
cout << n + mn;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int mo = 1000000007;
const int inf = 0x3f3f3f3f;
double pi = 3.14159265358979323846;
double e = 2.71828182845904523536;
using namespace std;
long long a[200005], b[200005];
set<long long> s;
long long n, m, k;
long long ans = 0;
int main() {
cin >> n >> m;
k = n / m;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[a[i] % m]++;
}
for (int i = 0; i < m; i++)
if (b[i] < k) s.insert(i);
for (int i = 0; i < n; i++) {
if (b[a[i] % m] > k) {
b[a[i] % m]--;
set<long long>::iterator it;
it = s.lower_bound(a[i] % m);
if (it != s.end()) {
ans += (*it - a[i] % m);
a[i] += (*it - a[i] % m);
b[*it]++;
if (b[*it] == k) s.erase(it);
} else {
ans += (m - a[i] % m + *s.begin());
a[i] += (m - a[i] % m + *s.begin());
b[*s.begin()]++;
if (b[*s.begin()] == k) s.erase(s.begin());
}
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
cout << a[i];
cout << (i == n - 1 ? '\n' : ' ');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
void testCase() {
ll n;
cin >> n;
for (int i = 1; i * i <= 2 * n; i++) {
ll val = 2 * n - (i * (i + 1));
ll dis = sqrt((val * 4) + 1);
ll l = (-1 + dis) / 2;
if (l > 0 && (i * (i + 1)) + (l * (l + 1)) == 2 * n) {
cout << "YES"
<< "\n";
return;
}
}
cout << "NO"
<< "\n";
return;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
testCase();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, g, b, sum, x, y, z;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n >> g >> b;
x = (n + 1) / 2;
y = (x + g - 1) / g;
z = y - 1;
sum = (z * (b + g)) + (x - (z * g));
if (sum < n) {
cout << n << endl;
} else {
cout << sum << endl;
}
sum = 0;
x = 0;
y = 0;
z = 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000000LL;
const int maxn = 5005;
long long ans = INF, QZans, QZsize;
long long size[maxn], insi[maxn], sumto[maxn];
int x[maxn], y[maxn], z[maxn];
int N;
vector<pair<long long, long long> > F[maxn];
void dfs1(int s, int fa) {
size[s] = 1;
insi[s] = sumto[s] = 0;
long long cs;
for (int i = 0; i < F[s].size(); i++)
if (F[s][i].first != fa) {
dfs1(F[s][i].first, s);
size[s] += size[F[s][i].first];
insi[s] += insi[F[s][i].first];
if (insi[s] >= ans) return;
cs = sumto[F[s][i].first] +
(long long)F[s][i].second * size[F[s][i].first];
sumto[s] += cs;
insi[s] -= (long long)cs * size[F[s][i].first];
}
insi[s] += (long long)sumto[s] * (size[s] - 1) + sumto[s];
}
void dfs2(int s, int fa, long long nowans) {
QZans = min(QZans, nowans);
for (int i = 0; i < F[s].size(); i++)
if (F[s][i].first != fa)
dfs2(F[s][i].first, s,
nowans +
(long long)F[s][i].second * (QZsize - 2 * size[F[s][i].first]));
}
pair<long long, pair<long long, long long> > getinfo(int ROOT) {
dfs1(ROOT, 0);
QZans = INF;
QZsize = size[ROOT];
dfs2(ROOT, 0, sumto[ROOT]);
return make_pair(size[ROOT], make_pair(insi[ROOT], QZans));
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; i++) scanf("%d %d %d", &x[i], &y[i], &z[i]);
for (int i = 1; i < N; i++) {
for (int j = 0; j <= N; j++) F[j].clear();
for (int j = 1; j < N; j++)
if (j != i) {
F[x[j]].push_back(make_pair(y[j], z[j]));
F[y[j]].push_back(make_pair(x[j], z[j]));
}
pair<long long, pair<long long, long long> > ac1 = getinfo(x[i]);
if (ac1.second.first >= ans) continue;
pair<long long, pair<long long, long long> > ac2 = getinfo(y[i]);
if (ac2.second.first >= ans) continue;
ans = min(ans, (long long)ac1.second.first + ac2.second.first +
(long long)ac1.second.second * ac2.first +
(long long)ac1.first * ac2.second.second +
(long long)ac1.first * ac2.first * z[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool subset(long long int a, long long int b) {
for (int i = 0; i < 60; i++) {
long long int z1 = ((1LL << i) & a) > 0;
long long int z2 = ((1LL << i) & b) > 0;
if (z1 == 1 && z2 == 0) return false;
}
return true;
}
int main() {
long long int n, n1, i, j, k, p = 0, q, r;
cin >> n;
vector<long long int> v1, v2;
map<long long int, long long int> m1;
set<long long int> s1, s2;
set<long long int>::iterator it;
for (i = 0; i < n; i++) {
cin >> j;
v1.push_back(j);
m1[j]++;
}
for (i = 0; i < n; i++) {
cin >> j;
v2.push_back(j);
}
for (i = 0; i < n; i++) {
if (m1[v1[i]] >= 2) {
p += v2[i];
s1.insert(v1[i]);
}
}
for (i = 0; i < n; i++) {
if (m1[v1[i]] == 1) {
for (it = s1.begin(); it != s1.end(); it++) {
if (subset(v1[i], *it)) {
p += v2[i];
break;
}
}
}
}
cout << p << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
scanf("%d", &n);
vector<int> game(n + 1);
game[0] = game[1] = game[2] = 0;
vector<int> res(n + 1, -1);
for (int i = 3; i <= n; i++) {
int ok[300001];
memset(ok, 0, sizeof(0));
for (int j = 2; (j * (j - 1)) / 2 <= i; j++) {
int x = i - ((j) * (j - 1)) / 2;
if (x % j == 0) {
x /= j;
int Xor = 0;
for (int k = 0; k < j; k++) {
Xor ^= game[x + k];
}
ok[Xor] = i;
if (Xor == 0 && res[i] == -1) {
res[i] = j;
}
}
}
int r = 0;
while (ok[r] == i) r++;
game[i] = r;
if (game[i] == 0) res[i] = -1;
}
printf("%d\n", res[n]);
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, w, m;
scanf("%d%d%d", &n, &w, &m);
int cnt[100] = {0};
int used[100] = {0};
bool fail = false;
int x = 1;
for (int i = 1; i <= m; ++i) {
int r = n;
while (r) {
if (++cnt[x] > 2) fail = true;
int u = std::min(r, m - used[x]);
r -= u;
used[x] += u;
if (used[x] == m) ++x;
}
}
printf("%s\n", fail ? "NO" : "YES");
if (!fail) {
double piece = double(w) / m;
memset(used, 0, sizeof(used));
memset(cnt, 0, sizeof(cnt));
x = 1;
for (int i = 1; i <= m; ++i) {
int r = n;
bool first = true;
while (r) {
int u = std::min(r, m - used[x]);
r -= u;
used[x] += u;
printf("%s%d %lf", first ? "" : " ", x, u * piece);
first = false;
if (used[x] == m) ++x;
}
printf("\n");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100, inf = 1e5 + 50;
int n, k, q, r[maxn], age[maxn], mxted[maxn];
vector<int> seg[maxn * 4], fnmax[maxn * 4], srt;
bool cmp(int a, int b) { return r[a] < r[b]; }
bool cmp1(int a, int b) { return a < age[b]; }
bool cmp2(int a, int b) { return age[a] < b; }
bool cmp3(int a, int b) { return r[a] < b; }
bool cmp4(int a, int b) { return a < r[b]; }
void merge(int f, int l, int r) {
int sl = 0, sr = 0;
while (sl < (int)seg[l].size() && sr < (int)seg[r].size()) {
if (age[seg[l][sl]] < age[seg[r][sr]])
seg[f].push_back(seg[l][sl++]);
else
seg[f].push_back(seg[r][sr++]);
}
if (sl == (int)seg[l].size()) swap(sl, sr), swap(l, r);
for (; sl < (int)seg[l].size(); sl++) seg[f].push_back(seg[l][sl]);
}
void pre_pros(int be, int en, int ind) {
if (en - be <= 1) {
seg[ind].push_back(srt[be]);
fnmax[ind].resize(seg[ind].size() * 4);
return;
}
int mid = (be + en) / 2;
pre_pros(be, mid, ind * 2 + 1);
pre_pros(mid, en, ind * 2 + 2);
merge(ind, ind * 2 + 1, ind * 2 + 2);
fnmax[ind].resize((int)seg[ind].size() * 4);
}
int get_ted(int fi, int se, int val, int be, int en, int ind) {
if (fi >= en || se <= be) return 0;
if (fi <= be && en <= se) {
int meg = upper_bound(seg[ind].begin(), seg[ind].end(), val + k, cmp1) -
seg[ind].begin();
return meg - (lower_bound(seg[ind].begin(), seg[ind].end(), val - k, cmp2) -
seg[ind].begin());
}
int mid = (be + en) / 2;
int ret1 = get_ted(fi, se, val, be, mid, ind * 2 + 1);
int ret2 = get_ted(fi, se, val, mid, en, ind * 2 + 2);
return ret1 + ret2;
}
void go_pros(int id, int be, int en, int ind) {
if (en - be <= 1) {
fnmax[id][ind] = mxted[seg[id][be]];
return;
}
int mid = (en + be) / 2;
go_pros(id, be, mid, ind * 2 + 1);
go_pros(id, mid, en, ind * 2 + 2);
fnmax[id][ind] = max(fnmax[id][ind * 2 + 1], fnmax[id][ind * 2 + 2]);
}
void make_new_seg(int be, int en, int ind) {
go_pros(ind, 0, seg[ind].size(), 0);
if (en - be <= 1) return;
int mid = (be + en) / 2;
make_new_seg(be, mid, ind * 2 + 1);
make_new_seg(mid, en, ind * 2 + 2);
}
int find_max(int id, int fi, int se, int be, int en, int ind) {
if (fi >= en || se <= be) return 0;
if (fi <= be && en <= se) return fnmax[id][ind];
int mid = (be + en) / 2;
int ret1 = find_max(id, fi, se, be, mid, ind * 2 + 1);
int ret2 = find_max(id, fi, se, mid, en, ind * 2 + 2);
return max(ret1, ret2);
}
int get_ans(int fi, int se, int k1, int k2, int be, int en, int ind) {
if (fi >= en || se <= be) return 0;
if (fi <= be && en <= se) {
int pl1 = lower_bound(seg[ind].begin(), seg[ind].end(), k1, cmp2) -
seg[ind].begin();
int pl2 = upper_bound(seg[ind].begin(), seg[ind].end(), k2, cmp1) -
seg[ind].begin();
return find_max(ind, pl1, pl2, 0, seg[ind].size(), 0);
}
int mid = (be + en) / 2;
int ret1 = get_ans(fi, se, k1, k2, be, mid, ind * 2 + 1);
int ret2 = get_ans(fi, se, k1, k2, mid, en, ind * 2 + 2);
return max(ret1, ret2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
srt.resize(maxn);
for (int i = 0; i < maxn; i++) srt[i] = inf;
for (int i = 0; i < n; i++) {
cin >> r[i];
srt[i] = i;
}
for (int i = 0; i < n; i++) cin >> age[i];
r[inf] = 1e9 + 200;
age[inf] = 2e9 + 100;
mxted[inf] = -1;
sort(srt.begin(), srt.end(), cmp);
pre_pros(0, maxn, 0);
for (int i = 0; i < n; i++) {
int pl = upper_bound(srt.begin(), srt.end(), r[srt[i]], cmp4) - srt.begin();
mxted[srt[i]] = get_ted(0, pl, age[srt[i]], 0, maxn, 0);
}
make_new_seg(0, maxn, 0);
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--, b--;
if (abs(age[a] - age[b]) > 2 * k) {
cout << -1 << endl;
continue;
}
if (r[a] > r[b]) swap(a, b);
int pl = lower_bound(srt.begin(), srt.end(), r[b], cmp3) - srt.begin();
int ret = get_ans(pl, maxn, max(age[a], age[b]) - k,
min(age[a], age[b]) + k, 0, maxn, 0);
if (ret == 0)
cout << -1 << endl;
else
cout << ret << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int mod = 1e9 + 9;
int f[maxn], sfib[maxn], d[maxn], s[maxn], a[maxn];
int L[maxn / 100], R[maxn / 100];
void init() {
sfib[1] = f[1] = 1;
for (int i = 2; i <= maxn - 10; i++) {
f[i] = (f[i - 1] + f[i - 2]) % mod;
sfib[i] = (sfib[i - 1] + f[i]) % mod;
}
}
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s[i] = (s[i - 1] + a[i]) % mod;
}
int op, l, r, k = 1;
int SZ = sqrt(m + 0.5);
while (m--) {
scanf("%d%d%d", &op, &l, &r);
if (op == 1) {
L[k] = l, R[k++] = r;
d[l] = (d[l] + 1) % mod;
d[r + 1] = (d[r + 1] - f[r - l + 2] + mod) % mod;
d[r + 2] = (d[r + 2] - f[r - l + 1] + mod) % mod;
if (k > SZ) {
for (int i = 1; i <= n; i++) {
if (i >= 2) d[i] = ((d[i] + d[i - 1]) % mod + d[i - 2]) % mod;
a[i] = (a[i] + d[i]) % mod;
s[i] = (s[i - 1] + a[i]) % mod;
}
k = 1;
memset(d, 0, sizeof(d));
}
} else {
int ret = 0, lt, rt;
for (int i = 1; i < k; i++) {
lt = max(L[i], l), rt = min(R[i], r);
if (lt > rt) continue;
ret = (ret + sfib[rt - L[i] + 1] - sfib[lt - L[i]]) % mod;
}
ret = (ret + s[r] - s[l - 1]) % mod;
printf("%d\n", (ret % mod + mod) % mod);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace ::std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
long long a, b, k, m = 2, step = 1, tot = 0, q;
cin >> a >> b >> k;
for (long long i = 3; i <= k; i++) m = lcm(m, i);
for (long long x = m - 1, mx, i; x > 0; x -= mx, step++)
for (i = k, mx = 0; i >= 2 && mx < i - 1; i--) mx = max(mx, x % i);
q = (a - b) / m;
tot = q * step;
for (long long x = a - q * m, mx, i; x > b; x -= (mx ? mx : 1), tot++)
for (i = k, mx = 0; i >= 2 && mx < i - 1; i--)
if (x - x % i >= b) mx = max(mx, x % i);
cout << tot << endl;
return 0;
}
| 6 |
#include<iostream>
#include <iomanip>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i,a,b) for(int i=a;i<b;i++)
#define it(x,b) for(auto &x:b)
#define NUM 1000000007
typedef vector<ll> vll;
typedef pair<ll,ll> pll;
long long binpow(long long a, long long b) {
if (b == 0)
return 1;
long long res = binpow(a, b / 2)%NUM;
if (b % 2)
return (((res * res)%NUM)* a)%NUM;
else
return (res * res)%NUM;
}
struct prep
{
vll fact;
vll inv;
ll m;
explicit prep(int n)
{
ll mod=NUM;
int num=n;
m=mod;
fact.resize(n+31);
inv.resize(n+31);
fact[0]=1;
inv[0]=1;
for(int i=1;i<=num+30;i++)
{
fact[i]=(fact[i-1]*i)%mod;
inv[i]=binpow(fact[i],mod-2)%NUM;
}
}
ll ncr(ll n , ll r)
{
if(r>n||r<0)
{
return 0;
}
ll p = ((fact[n]*inv[r])%m);
p=(p*(inv[n-r])%m);
return p;
}
ll fac(ll num)
{
return fact[num];
}
};
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const
{
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};//unordered_map<pair<long long, long long>, bool, hash_pair> um;
bool isPrime(long long n) {
if (n == 1)return false;
if (n == 2)return true;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0)return false;
return true;
}
ll min(ll a,ll b)
{
if(a>b)
{
return b;
}
return a;
}
ll max(ll a, ll b)
{
if(a>b)
return a;
return b;
}
long long dif(long long a,long long b)
{
if(a>b)
return a-b;
return b-a;
}
long long gcd(long long a,long long b)
{
if(b==0)
return a;
return gcd(b,a%b);
}
long long lcm(long long a,long long b)
{
long long k=gcd(a,b);
return (a*b)/k;
}
void read(ll arr[],long long n)
{
for(long long i=0;i<n;i++)
{
cin>>arr[i];
}
}
void addedge(vector<vector<long long>>&v,long long p1,long long p2) {
v[p1].push_back({p2});
v[p2].push_back({p1});
}
bool mycmp(pair<long long ,float>p1,pair<long long ,float>p2)
{
return p1.first<p2.first;
}
void print(ll arr[],ll n)
{
for (long long i = 0; i < n; ++i) {
cout<<arr[i]<<" ";
}
cout<<endl;
}
vector<long long >prime;
void sieveOferatosthenes(long long MAX)
{
bool pri[MAX + 1];
memset(pri, true, sizeof(pri));
pri[1] = false;
for (long long p = 2; p * p <= MAX; p++) {
// If prime[p] is not changed, then it is a prime
if (pri[p]) {
// Set all multiples of p to non-prime
for (long long i = p * 2; i <= MAX; i += p)
pri[i] = false;
}
}
for(long long i=1;i<=MAX;i++)
{
if(pri[i])
{
prime.push_back(i);
}
}
}
int n;
void ask(int l,int r)
{
if(l>=1&&r<=n) {
cout << "?" << " " << l << " " << r << endl;
cout.flush();
}
}
bool check1(int p,int second)
{
if(p==second-1)
{
return true;
}
ask(p+1,second);
ll z;cin>>z;
if(z!=second)
{
return true;
}
return false;
}
bool check2(int second,int p)
{
if(p==second+1)
{
return true;
}
ask(second,p-1);
ll z;cin>>z;
if(z!=second)
{
return true;
}
return false;
}
void solve()
{
n;cin>>n;
int second;
ask(1,n);
cin>>second;
map<pll,ll>m;
m[{1,n}]=second;
bool l=false;
if(second!=1)
{
ll p;
if(m.find({1,second})==m.end()) {
ask(1, second);
cin >> p;
}
else
{
p=m[{1,second}];
}
if(p==second)
{
l=true;
}
}
if(l)
{
int high=second-1;
int low=1;
int mid;
ll res;
for(;low<=high;)
{
mid=(low+high)/2;
ll p;
if(m.find({mid,second})==m.end())
{
ask(mid,second);
cin>>p;
m[{mid,second}]=p;
}
else
{
p=m[{mid,second}];
}
if(p==second)
{
res=mid;
low=mid+1;
}
else
{
high=mid-1;
}
}
cout<<"!"<<" "<<res<<endl;
}
else
{
int high=n;
int low=second+1;
int mid;
ll res;
for(;low<=high;)
{
mid=(low+high)/2;
ll p;
if(m.find({second,mid})==m.end()) {
ask(second, mid);
cin >> p;
m[{second,mid}]=p;
}
else
{
p=m[{second,mid}];
}
if(p==second)
{
res=mid;
high=mid-1;
}
else
{
low=mid+1;
}
}
cout<<"!"<<" "<<res<<endl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;t=1;
//cin>>t;
// WE WILL WIN.
while(t--)
{
solve();
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0;
bool f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = getchar();
return f ? ans : -ans;
}
const int N = 1e5 + 5;
int n, k, s0[N], s1[N];
char s[N];
int mnl0[N], mxl0[N], mnl1[N], mxl1[N], mnr0[N], mxr0[N], mnr1[N], mxr1[N];
inline bool check0(int i) {
if (s1[i - k] && (s1[n] - s1[i])) return 0;
if (s1[i - k]) {
if (s1[i - k] > k) return 0;
if (mxl1[i - k] && mxl1[i - k] - mnl1[i - k] + 1 > k) return 0;
}
if (s1[n] - s1[i]) {
if (s1[n] - s1[i] > k) return 0;
if (mxr1[i + 1] && mxr1[i + 1] - mnr1[i + 1] + 1 > k) return 0;
}
return 1;
}
inline bool check1(int i) {
if (s0[i - k] && (s0[n] - s0[i])) return 0;
if (s0[i - k]) {
if (s0[i - k] > k) return 0;
if (mnl0[i - k] && mxl0[i - k] - mnl0[i - k] + 1 > k) return 0;
}
if (s0[n] - s0[i]) {
if (s0[n] - s0[i] > k) return 0;
if (mxr0[i + 1] && mxr0[i + 1] - mnr0[i + 1] + 1 > k) return 0;
}
return 1;
}
int main() {
n = read(), k = read();
scanf("%s", s + 1);
for (register int i = 1; i <= n; ++i) {
s0[i] = s0[i - 1] + (s[i] == '0');
s1[i] = s1[i - 1] + (s[i] == '1');
}
for (register int i = 1; i <= n; ++i) {
if (s[i] == '0') {
if (!mnl0[i - 1])
mnl0[i] = mxl0[i] = i;
else
mxl0[i] = i;
mnl1[i] = mnl1[i - 1];
mxl1[i] = mxl1[i - 1];
} else {
if (!mnl1[i - 1])
mnl1[i] = mxl1[i] = i;
else
mxl1[i] = i;
mnl0[i] = mnl0[i - 1];
mxl0[i] = mxl0[i - 1];
}
}
for (register int i = n; i; --i) {
if (s[i] == '0') {
if (!mxr0[i + 1])
mxr0[i] = mnr0[i] = i;
else
mnr0[i] = i;
mnr1[i] = mnr1[i + 1];
mxr1[i] = mxr1[i + 1];
} else {
if (!mxr1[i + 1])
mnr1[i] = mxr1[i] = i;
else
mnr1[i] = i;
mnr0[i] = mnr0[i + 1];
mxr0[i] = mxr0[i + 1];
}
}
for (register int i = k; i <= n; ++i) {
if (s0[n] == s0[i] - s0[i - k]) return puts("tokitsukaze"), 0;
if (s1[n] == s1[i] - s1[i - k]) return puts("tokitsukaze"), 0;
}
for (register int i = k; i <= n; ++i)
if (!check0(i) || !check1(i)) return puts("once again"), 0;
puts("quailty");
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
#define drep(i,x,y) for (int i=(x);i>=(y);i--)
#define sz 1010101
typedef long long ll;
bool chkmax(ll &x,ll y){return x<y?x=y,1:0;}
bool chkmin(ll &x,ll y){return x>y?x=y,1:0;}
int n;
ll w[sz],d[sz];
void Out()
{
static ll a[sz];
a[1]=0,a[2]=d[2];
rep(i,3,n) a[i]=a[i-1]+((d[i]+d[i-1]==w[i-1])==(a[i-1]>a[i-2])?1:-1)*d[i];
ll mn=a[1]; rep(i,2,n) chkmin(mn,a[i]);
rep(i,1,n) printf("%lld ",a[i]-mn);
}
void work(int l,ll L,ll R)
{
if (l==n) return d[l]=L,void();
auto in=[](ll x,ll l,ll r){return l<=x&&x<=r;};
static ll ok[sz];
set<ll>s;
ll tp=1,dt=0; int r=-1;
rep(i,l,n-1)
{
if (in(w[i],L,R)||s.count(tp*(w[i]-dt))) { r=i; break; }
chkmax(L,0ll),chkmin(R,w[i]);
auto it=s.begin();
while (it!=s.end()&&!in((*it)*tp+dt,0,w[i])) s.erase(it++);
it=s.end(); while (it!=s.begin()&&!in((*prev(it))*tp+dt,0,w[i])) s.erase(prev(it));
if (L<=R) ok[i]=L; else ok[i]=*(s.begin())*tp+dt;
if (L<=R) R=w[i]-R,L=w[i]-L,swap(L,R);
tp*=-1,dt=w[i]-dt;
if (L>R&&!s.size()) exit(puts("NO")&0);
s.insert(tp*(w[i]-dt));
}
ll W;
if (r!=-1) work(r+1,0,w[r]),W=w[r]; else r=n,W=(L<=R?L:*(s.begin())*tp+dt);
drep(i,r,l) { d[i]=W; if (W==w[i-1]) W=ok[i-1]; else W=w[i-1]-W; }
}
int main()
{
cin>>n>>w[sz-1];
rep(i,2,n-1) scanf("%lld",&w[i]);
work(2,0,w[2]);
puts("YES");
Out();
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, cnt[N];
struct edge {
int to, nx, dl, id;
} ee[N];
int eq[N], en = 1;
int dv[N], dvt;
void link(int u, int v, int id) {
swap(u, v);
ee[++en] = (edge){v, eq[u], 0, id}, eq[u] = en;
}
void dfs(int u) {
for (int j = eq[u], v; v = ee[j].to, j; j = ee[j].nx)
if (!ee[j].dl) {
ee[j].dl = 1;
dfs(v);
dv[dvt++] = ee[j].id;
}
}
int main() {
scanf("%d", &n);
if (n & 1) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; ++i) {
link(i >> 1, (2 * i) % n >> 1, i);
}
dfs(0);
int q = 0;
while (dv[q]) ++q;
for (int i = 0; i < n; ++i) {
printf("%d ", dv[(q + i) % n]);
}
printf("0\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, n, l, r;
long long k, x, sum, ans;
int main() {
int tt = 0;
scanf("%d", &tt);
while (tt--) {
scanf("%d%lld", &n, &k);
ans = 1ll << 60;
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a > c) {
swap(a, c);
swap(b, d);
}
if (c < b) {
k -= (min(b, d) - c) * (long long)n;
if (k <= 0) {
puts("0");
continue;
}
}
l = min(a, c);
r = max(b, d);
for (int i = 1; i <= n; i++) {
if (b < c) {
sum = (c - b) * (long long)i;
x = r - l;
} else {
sum = 0;
x = r - l - (min(b, d) - c);
}
x *= i;
if (x >= k) {
sum += k;
} else {
sum += k * 2 - x;
}
ans = min(ans, sum);
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#define _CRT_SECURE_NO_WARNINGS
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <cassert>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <functional>
#include <algorithm>
#include <stack>
#include <numeric>
#include <set>
#include <chrono>
#include <random>
//#pragma comment(linker, "/STACK:16777216")
using namespace std;
typedef long double C;
typedef complex<C> P;
#define X real()
#define Y imag()
#define have(X, Y) (X.find(Y) != X.end())
#define Size(X) (int)X.size()
#define ui unsigned int
#define int long long
#define endl '\n'
#define mp make_pair
#define timer fghge
#define y1 yjyjyju
#define all(X) (X).begin(), (X).end()
mt19937_64 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1e9 + 7;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1; y = 0;
return;
}
else {
extgcd(b, a % b, x, y);
int temp = y;
y = x - (a / b) * y;
x = temp;
}
}
int inv(int a, int mod) {
int x, y;
extgcd(a, mod, x, y);
x = (x % mod + mod) % mod;
return x;
}
const int MAXN = 1e5 + 10;
int f[MAXN];
int c(int n, int k) {
if (n < 0 || n < 0 || n - k < 0)
return 0;
return (f[n] * inv(f[n - k] * f[k], mod)) % mod;
}
int klimenko(int n, int k) {
return c(n + k - 1, k - 1);
}
int kuznets(int n, int k, int d) {
return klimenko(n - k * (d - 1) - d, d + 1);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("input.txt", "w", stdout);
f[0] = 1;
for (int i = 1; i < MAXN; i++)
f[i] = (f[i - 1] * i) % mod;
int t; cin >> t;
while (t--) {
int n, k; cin >> n >> k;
int ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + (kuznets(n, k - 1, i) * inv(c(n, i), mod)) % mod) % mod;
cout << (ans + 1) % mod << endl;
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, temp, i;
cin >> n;
int even[n], odd[n], evenlen = 0, oddlen = 0;
for (i = 0; i < n; i++) {
cin >> temp;
if (temp % 2 == 0) {
even[evenlen++] = temp;
} else {
odd[oddlen++] = temp;
}
}
long long ans = 0;
sort(even, even + evenlen);
sort(odd, odd + oddlen);
int remove = abs(evenlen - oddlen);
if (oddlen > evenlen) {
--remove;
for (i = 0; i < remove; i++) ans += odd[i];
} else if (oddlen < evenlen) {
--remove;
for (i = 0; i < remove; i++) ans += even[i];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e4 + 2000;
int cnt[10];
int cntt[10];
int digits;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
cnt[s[i] - 48]++;
digits++;
}
int low = 1;
int high = 10;
int k;
for (int i = 1; i < 7; i++) {
if (low <= digits - i && digits - i < high) {
k = digits - i;
break;
}
low *= 10;
high *= 10;
}
while (k) {
cnt[k % 10]--;
k /= 10;
}
string sub;
cin >> sub;
for (int i = 0; i < sub.size(); i++) {
cnt[sub[i] - 48]--;
}
if (s.size() == 2 && sub == "0") {
cout << 0;
return 0;
}
bool OK = 0;
int mn = 10;
for (int i = 0; i < sub.size() - 1; i++) {
if (sub[i] != sub[i + 1]) {
if (sub[i + 1] < sub[i]) {
OK = 1;
break;
} else {
OK = 0;
break;
}
}
}
for (int i = 9; i >= 1; i--) {
if (cnt[i] > 0) {
mn = i;
}
}
if (mn == 10) {
cout << sub;
while (cnt[0] > 0) {
cout << 0;
cnt[0]--;
}
return 0;
}
if (mn < sub[0] - 48) {
cout << mn;
cnt[mn]--;
for (int i = 0; i < 10; i++) {
if (sub[0] - 48 == i && OK) {
cout << sub;
}
while (cnt[i] > 0) {
cout << i;
cnt[i]--;
}
if (sub[0] - 48 == i && !OK) {
cout << sub;
}
}
return 0;
}
if (mn > sub[0] - 48) {
if (sub[0] - 48 != 0) {
cout << sub;
for (int i = 0; i < 10; i++) {
while (cnt[i] > 0) {
cout << i;
cnt[i]--;
}
}
} else {
cout << mn;
cnt[mn]--;
for (int i = 0; i < 10; i++) {
if (sub[0] - 48 == i && OK) {
cout << sub;
}
while (cnt[i] > 0) {
cout << i;
cnt[i]--;
}
if (sub[0] - 48 == i && !OK) {
cout << sub;
}
}
}
return 0;
}
string A = "", B = "";
for (int i = 0; i < 10; i++) cntt[i] = cnt[i];
if (mn == sub[0] - 48) {
A += sub;
for (int i = 0; i < 10; i++) {
while (cntt[i] > 0) {
A += char(i + 48);
cntt[i]--;
}
}
B += char(mn + 48);
cnt[mn]--;
for (int i = 0; i < 10; i++) {
if (sub[0] - 48 == i && OK) {
B += sub;
}
while (cnt[i] > 0) {
B += char(i + 48);
cnt[i]--;
}
if (sub[0] - 48 == i && !OK) {
B += sub;
}
}
cout << min(A, B);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long one, two, three, cnt = 0, n;
int main() {
ios_base::sync_with_stdio(false);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> one >> two >> three;
if (one + two + three >= 2) cnt++;
}
cout << cnt << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int freq[1010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T, n;
cin >> T;
while (T--) {
memset(freq, 0, sizeof(freq));
cin >> n;
vector<int> a;
a.resize(n + 10);
set<int> mex;
for (int j = 0; j <= n + 10; ++j) mex.insert(j);
for (int i = 0; i < n; ++i) {
cin >> a[i];
freq[a[i]]++;
mex.erase(a[i]);
}
vector<int> p;
int flag = 1;
set<int> seen;
for (int k = 0; k < n; ++k) {
if (a[k] < n && flag) {
seen.insert(a[k]);
flag = 0;
continue;
}
if (seen.find(a[k]) == seen.end() && a[k] != n) {
seen.insert(a[k]);
continue;
}
if (!mex.size()) break;
int mx = *mex.begin();
if (mx >= n) break;
freq[a[k]]--;
if (freq[a[k]] == 0) mex.insert(a[k]);
mex.erase(mx);
a[k] = mx;
freq[mx]++;
p.push_back(k);
}
if (flag) {
cout << "0\n\n";
continue;
}
vector<int> vis(n + 10, 0);
while (1) {
int nxt = -1, ind = 0;
for (int m = n - 1; m >= 0; m--) {
if (!vis[m]) {
nxt = m;
break;
}
}
if (nxt == -1) break;
for (int i = 0; i < n; ++i) {
if (a[i] == nxt) {
ind = i;
break;
}
}
vis[ind] = 1;
if (a[ind] == ind) continue;
int num = ind;
while (ind != a[ind]) {
p.push_back(ind);
ind = a[ind];
if (vis[ind]) break;
vis[ind] = 1;
}
p.push_back(num);
}
cout << p.size() << "\n";
for (int x : p) {
cout << x + 1 << " ";
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long int n;
cin >> n;
vector<long long int> v[n + 1];
for (long long int i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (long long int i = 0; i <= n; i++) {
if (v[i].size() == 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const long long MOD = 1e9 + 7;
int dX[] = {0, 0, 1, -1};
int dY[] = {1, -1, 0, 0};
int a[] = {100, 20, 10, 5, 1};
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i < 5; ++i) {
int am = n / a[i];
ans += am;
n -= am * a[i];
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int Maxn = 200005, Maxm = 300005, Mo = 10007,
sp[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
const long long oo = LLONG_MAX >> 2;
typedef int IArr[Maxn];
typedef long long LArr[Maxn];
typedef double DArr[Maxn];
struct Tree {
pair<long long, int> v, mk;
};
struct point {
int x, y, dir, id, mk = 0;
point(int n_x, int n_y, int n_dir, int n_id) {
x = n_x, y = n_y, dir = n_dir, id = n_id;
}
point(){};
};
struct node {
int v, h, id;
node(int n_v, int n_h, int n_id) { v = n_v, h = n_h, id = n_id; }
};
struct arrow {
int l, r, h, id, dir;
arrow(int n_l, int n_r, int n_h, int n_id, int n_dir) {
l = n_l;
r = n_r, h = n_h, id = n_id;
dir = n_dir;
}
arrow() {}
};
struct query {
int x, y, dir, id;
long long t;
query(int n_x, int n_y, long long n_t, int n_dir, int n_id) {
x = n_x, y = n_y;
t = n_t;
dir = n_dir, id = n_id;
}
query() {}
};
int n, m, q, i, j;
pair<long long, int> to[Maxn];
Tree t[Maxn * 4];
query Q[Maxn];
point p_all[Maxn];
arrow s_all[Maxn];
vector<arrow> s_x, s_y;
vector<point> p_x, p_y;
vector<node> pt[4];
LArr dis[60];
IArr nt[60];
bool cmp_x(point a, point b) {
if (a.y != b.y) return a.y < b.y;
return a.x < b.x;
}
bool cmp_y(point a, point b) {
if (a.x != b.x) return a.x <= b.x;
return a.y <= b.y;
}
bool cmp_s(arrow a, arrow b) { return a.h < b.h; }
bool cmp_n(node a, node b) { return a.h < b.h; }
void input() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
int x0, y0, x1, y1;
cin >> x0 >> y0 >> x1 >> y1;
if (y0 == y1) {
int dir = x0 < x1 ? 1 : -1;
int l = min(x0, x1);
int r = max(x0, x1);
s_x.push_back((arrow(l, r, y0, i, dir - 1 ? 0 : 1)));
p_x.push_back((point(x1, y1, dir, i)));
if (dir + 1)
pt[1].push_back((node(y1, x1, i)));
else
pt[0].push_back((node(y1, x1, i)));
p_all[i] = point(x1, y1, dir - 1 ? 0 : 1, i);
s_all[i] = arrow(l, r, y0, i, dir - 1 ? 0 : 1);
} else {
int l = min(y0, y1);
int r = max(y0, y1);
int dir = y0 < y1 ? 1 : -1;
s_y.push_back((arrow(l, r, x0, i, dir - 1 ? 3 : 2)));
p_y.push_back((point(x1, y1, dir, i)));
if (dir + 1)
pt[2].push_back((node(x1, y1, i)));
else
pt[3].push_back((node(x1, y1, i)));
p_all[i] = point(x1, y1, dir - 1 ? 3 : 2, i);
s_all[i] = arrow(l, r, x0, i, dir - 1 ? 3 : 2);
}
}
cin >> q;
for (i = 1; i <= q; i++) {
int x, y, dir;
long long t;
char ch;
cin >> x >> y >> ch >> t;
if (ch == 'L') dir = 0;
if (ch == 'R') dir = 1;
if (ch == 'U') dir = 2;
if (ch == 'D') dir = 3;
if (dir <= 1)
pt[dir].push_back((node(y, x, n + i)));
else
pt[dir].push_back((node(x, y, n + i)));
Q[i] = query(x, y, t, dir, i);
p_all[n + i] = point(x, y, dir, i + n);
}
sort(s_x.begin(), s_x.end(), cmp_s);
sort(s_y.begin(), s_y.end(), cmp_s);
sort(p_x.begin(), p_x.end(), cmp_x);
sort(p_y.begin(), p_y.end(), cmp_y);
for (i = 0; i < 4; i++) sort(pt[i].begin(), pt[i].end(), cmp_n);
}
bool ck(long long a, long long b, int d) {
if (d + 1)
return a >= b;
else
return a <= b;
}
void check(int k, int l, int r) {
if (!t[k].mk.second) return;
t[k].v = t[k].mk;
if (l != r) t[k * 2].mk = t[k].mk, t[k * 2 + 1].mk = t[k].mk;
t[k].mk = make_pair((0), (0));
}
void ins(int k, int l, int r, int x, int y, pair<long long, int> key, int d) {
check(k, l, r);
if (y < l || r < x) return;
if (x <= l && r <= y) {
t[k].mk = key;
check(k, l, r);
return;
}
int mid = (l + r) / 2;
ins(k * 2, l, mid, x, y, key, d);
ins(k * 2 + 1, mid + 1, r, x, y, key, d);
}
long long dist(point a, point b) { return abs(a.x - b.x) + abs(a.y - b.y); }
pair<long long, int> ask(int k, int l, int r, int pos, int id1) {
check(k, l, r);
if (l == r) {
int id2 = t[k].v.second;
return make_pair((dist(p_all[id1], p_all[id2])), (t[k].v.second));
}
int mid = (l + r) / 2;
if (pos <= mid)
return ask(k * 2, l, mid, pos, id1);
else
return ask(k * 2 + 1, mid + 1, r, pos, id1);
}
bool cover(int k, vector<point>& a, int v, int h) {
if (k < 0 || k >= a.size()) return 0;
int id = a[k].id;
if (s_all[id].h == h)
if (s_all[id].l <= v && v <= s_all[id].r) return 1;
return 0;
}
pair<long long, int> find_same_axe(point& A) {
point Q;
Q.x = A.x;
Q.y = A.y;
if (A.dir <= 1) {
int pos = lower_bound(p_x.begin(), p_x.end(), Q, cmp_x) - p_x.begin();
if (cover(pos, p_x, Q.x, Q.y))
return A.dir = s_all[p_x[pos].id].dir, A.mk = 1,
make_pair((abs(Q.x - p_x[pos].x)), (p_x[pos].id));
if (cover(pos - 1, p_x, Q.x, Q.y))
return A.dir = s_all[p_x[pos - 1].id].dir, A.mk = 1,
make_pair((abs(Q.x - p_x[pos - 1].x)), (p_x[pos - 1].id));
if (A.dir == 0) pos--;
if (pos < 0 || pos >= p_x.size() || p_x[pos].y != A.y)
return make_pair((oo), (0));
else
return make_pair((abs(Q.x - p_x[pos].x)), (p_x[pos].id));
} else {
int pos = lower_bound(p_y.begin(), p_y.end(), Q, cmp_y) - p_y.begin();
if (cover(pos, p_y, Q.y, Q.x))
return A.dir = s_all[p_y[pos].id].dir, A.mk = 1,
make_pair((abs(Q.y - p_y[pos].y)), (p_y[pos].id));
if (cover(pos - 1, p_y, Q.y, Q.x))
return A.dir = s_all[p_y[pos - 1].id].dir, A.mk = 1,
make_pair((abs(Q.y - p_y[pos - 1].y)), (p_y[pos - 1].id));
if (A.dir == 3) pos--;
if (pos < 0 || pos >= p_y.size() || p_y[pos].x != A.x)
return make_pair((oo), (0));
else
return make_pair((abs(Q.y - p_y[pos].y)), (p_y[pos].id));
}
}
void work(vector<node>& p, vector<arrow>& s, int i, int j, int d,
pair<long long, int>* ct) {
memset((t), 0, sizeof((t)));
int m1 = p.size(), m2 = s.size();
for (; 0 <= i && i < m1; i += d)
if (!p_all[p[i].id].mk) {
for (; 0 <= j && j < m2 && ck(p[i].h, s[j].h, d); j += d)
ins(1, 0, m, s[j].l, s[j].r, make_pair((s[j].h), (s[j].id)), d);
pair<long long, int> ans = ask(1, 0, m, p[i].v, p[i].id);
if (!ans.second) continue;
int nd = abs(s_all[ans.second].h - p[i].h);
if (!ct[p[i].id].second || nd < ct[p[i].id].first) ct[p[i].id] = ans;
if (!nd) {
ct[p[i].id] = ans;
p_all[p[i].id].dir = s_all[ans.second].dir;
}
}
}
void construct_graph() {
for (i = 0; i < p_x.size(); i++) {
int p = i + p_x[i].dir;
int id = p_x[i].id;
if (p < 0 || p >= p_x.size())
to[id] = make_pair((0), (0));
else if (p_x[p].y == p_x[i].y)
to[id] = make_pair((abs(p_x[i].x - p_x[p].x)), (p_x[p].id));
else
to[id] = make_pair((0), (0));
}
for (i = 0; i < p_y.size(); i++) {
int p = i + p_y[i].dir;
int id = p_y[i].id;
if (p < 0 || p >= p_y.size())
to[id] = make_pair((0), (0));
else if (p_y[p].x == p_y[i].x)
to[id] = make_pair((abs(p_y[i].y - p_y[p].y)), (p_y[p].id));
else
to[id] = make_pair((0), (0));
}
for (i = n + 1; i <= n + q; i++) to[i] = find_same_axe(p_all[i]);
work(pt[0], s_y, 0, 0, 1, to);
work(pt[1], s_y, pt[1].size() - 1, s_y.size() - 1, -1, to);
work(pt[2], s_x, pt[2].size() - 1, s_x.size() - 1, -1, to);
work(pt[3], s_x, 0, 0, 1, to);
}
void pre_query() {
for (i = 1; i <= n + q; i++) dis[0][i] = to[i].first, nt[0][i] = to[i].second;
for (i = 1; i <= 50; i++) {
for (j = 1; j <= n + q; j++) {
if (!nt[i - 1][j])
nt[i][j] = nt[i - 1][j], dis[i][j] = dis[i - 1][j];
else
nt[i][j] = nt[i - 1][nt[i - 1][j]],
dis[i][j] = dis[i - 1][j] + dis[i - 1][nt[i - 1][j]];
dis[i][j] = min(dis[i][j], oo);
}
}
}
pair<long long, long long> calc(query cur) {
int pos = cur.id + n;
long long T = cur.t;
for (int i = 50; i + 1; i--)
if (T >= dis[i][pos]) {
if (!nt[i][pos]) continue;
T -= dis[i][pos];
pos = nt[i][pos];
}
int dir = p_all[pos].dir;
pair<long long, long long> ans = make_pair((p_all[pos].x), (p_all[pos].y));
if (!to[pos].second) {
ans.first += sp[dir][0] * T;
ans.second += sp[dir][1] * T;
return ans;
}
int go = to[pos].second;
if (dir <= 1) {
int len = abs(p_all[pos].x - p_all[go].x);
if (len >= T) {
ans.first += sp[dir][0] * T;
return ans;
}
ans.first += sp[dir][0] * len;
T -= len;
ans.second += sp[p_all[go].dir][1] * T;
} else {
int len = abs(p_all[pos].y - p_all[go].y);
if (len >= T) {
ans.second += sp[dir][1] * T;
return ans;
}
ans.second += sp[dir][1] * len;
T -= len;
ans.first += sp[p_all[go].dir][0] * T;
}
return ans;
}
void do_query() {
pre_query();
for (i = 1; i <= q; i++) {
pair<long long, long long> ans = calc(Q[i]);
if (ans.first > m) ans.first = m;
if (ans.first < 0) ans.first = 0;
if (ans.second > m) ans.second = m;
if (ans.second < 0) ans.second = 0;
cout << ans.first << ' ' << ans.second << endl;
}
}
int main() {
ios::sync_with_stdio(0);
input();
construct_graph();
do_query();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long sum[(1 << 20) * 2][5];
long long num[(1 << 20) * 2];
void order(long long pos) {
do {
pos /= 2;
num[pos] = num[pos * 2] + num[pos * 2 + 1];
long long tmp = num[pos * 2] % 5;
for (long long i = 0; i < ((long long)5); i++)
sum[pos][i] = sum[pos * 2][i] + sum[pos * 2 + 1][(i + 5 - tmp) % 5];
} while (pos > 1);
}
int main() {
for (long long i = 0; i < ((long long)(1 << 20) * 2); i++)
for (long long j = 0; j < ((long long)5); j++) sum[i][j] = num[i] = 0;
set<long long> s;
vector<pair<long long, long long> > vec;
long long n;
cin >> n;
for (long long i = 0; i < ((long long)n); i++) {
string str;
cin >> str;
if (str == "sum") {
vec.push_back(make_pair(2, 0));
} else {
long long tmp;
cin >> tmp;
s.insert(tmp);
vec.push_back(make_pair((str == "del"), tmp));
}
}
long long cnt = 0;
map<long long, long long> con;
for (set<long long>::iterator it = s.begin(); it != s.end(); it++)
con[*it] = cnt++;
for (long long i = 0; i < ((long long)n); i++) {
long long pos = con[vec[i].second] + (1 << 20);
if (vec[i].first == 0) {
num[pos] = 1;
sum[pos][1] = vec[i].second;
order(pos);
} else if (vec[i].first == 1) {
num[pos] = sum[pos][1] = 0;
order(pos);
} else {
cout << sum[1][3] << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, m, s, e, c, a = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &c);
a += c;
}
a = n - abs(a);
for (int i = 0; i < m; i++) {
scanf("%d %d", &s, &e);
c = e - s + 1;
if (c % 2 == 0 & c <= a)
printf("%d \n", 1);
else
printf("%d \n", 0);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
using ii = pair<long long, long long>;
using vb = vector<bool>;
using vi = vector<long long>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
bool degree4(const vvi &g) {
for (long long i = 0; i < (long long)g.size(); i++) {
if (g[i].size() >= 4) return true;
}
return false;
}
bool internal_white(const vvi &g, const string &color) {
for (long long i = 0; i < (long long)g.size(); i++) {
if (g[i].size() >= 2 and color[i] == 'W') return true;
}
return false;
}
bool check122(long long x, const vvi &g) {
long long one = 0;
long long two = 0;
for (long long v : g[x]) {
if (g[v].size() == 1) one++;
if (g[v].size() >= 2) two++;
}
if (two >= 3 or (one >= 1 and two >= 2)) return true;
return false;
}
bool check_all122(const vvi &g) {
for (long long i = 0; i < (long long)g.size(); i++) {
if (check122(i, g)) return true;
}
return false;
}
bool is_bamboo(const vvi &g) {
for (long long i = 0; i < (long long)g.size(); i++) {
if (g[i].size() > 2) return false;
}
return true;
}
bool solve_bamboo(const vvi &g, const string &color) {
long long len = g.size();
long long white = 0;
for (long long i = 0; i < (long long)color.length(); i++) {
if (color[i] == 'W') white++;
}
if (white == 1 or white == 0) return false;
return (len % 2 == 1);
}
bool internal_white_nbr(const vvi &g, const string &color) {
for (long long i = 0; i < (long long)g.size(); i++) {
if (g[i].size() >= 3) {
for (long long v : g[i]) {
if (color[v] == 'W') return true;
}
}
}
return false;
}
bool is_small(const vvi &g) { return g.size() <= 3; }
bool solve_small(const vvi &g, const string &color) {
long long n = g.size();
if (n < 3) return false;
long long white = 0;
for (long long i = 0; i < (long long)color.size(); i++) {
if (color[i] == 'W') white++;
}
return (white == 2);
}
bool is_arrow(const vvi &g) {
long long deg3 = 0;
for (long long i = 0; i < (long long)g.size(); i++) {
if (g[i].size() == 3) {
deg3++;
}
}
return deg3 == 1;
}
bool solve_arrow(const vvi &g, const string &color) {
bool white = false;
for (char ch : color)
if (ch == 'W') white = true;
if (not white) return false;
long long n = g.size() - 2;
return (n % 2 == 0);
}
bool is_twinfork(const vvi &g) {
long long deg3 = 0;
for (long long i = 0; i < (long long)g.size(); i++) {
if (g[i].size() == 3) deg3++;
}
return (deg3 == 2);
}
bool solve_twinfork(const vvi &g) {
long long n = g.size();
return (n % 2 == 1);
}
bool solve() {
long long n;
cin >> n;
vvi g(n);
string color;
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
cin >> color;
if (is_small(g)) return solve_small(g, color);
if (degree4(g)) return true;
if (internal_white(g, color)) return true;
if (internal_white_nbr(g, color)) return true;
if (check_all122(g)) return true;
if (is_bamboo(g)) return solve_bamboo(g, color);
if (is_arrow(g)) return solve_arrow(g, color);
if (is_twinfork(g)) return solve_twinfork(g);
assert(false);
return false;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
bool res = solve();
cout << (res ? "White" : "Draw") << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 10;
vector<int> g[MAXN];
bool can[MAXN];
int cnt[MAXN], prob[MAXN];
int best[MAXN], n;
void dfs_down(int v, int p = -1) {
prob[v] = -1;
cnt[v] = 1;
for (int u : g[v]) {
if (u == p) continue;
dfs_down(u, v);
cnt[v] += cnt[u];
best[v] = max(best[v], best[u]);
if (cnt[u] <= n / 2)
best[v] = max(best[v], cnt[u]);
else
prob[v] = u;
}
if (prob[v] == -1 and n - cnt[v] <= n / 2)
can[v] = true;
else if (prob[v] != -1) {
int u = prob[v];
int x = best[u];
if (cnt[u] - x <= n / 2) can[v] = true;
}
}
void dfs_up(int v, int pass = 0, int p = -1) {
if (can[v] == false and prob[v] == -1) {
int x = n - cnt[v];
if (x - pass <= n / 2) can[v] = true;
}
set<pair<int, int> > s;
for (int u : g[v])
if (u != p) {
s.insert({best[u], u});
if (cnt[u] <= n / 2) s.insert({cnt[u], u});
}
s.insert({pass, v});
if (n - cnt[v] <= n / 2) s.insert({n - cnt[v], v});
for (int u : g[v]) {
if (u == p) continue;
s.erase({best[u], u});
if (cnt[u] <= n / 2) s.erase({cnt[u], u});
int x = s.rbegin()->first;
dfs_up(u, x, v);
s.insert({best[u], u});
if (cnt[u] <= n / 2) s.insert({cnt[u], u});
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
dfs_down(0);
dfs_up(0);
for (int i = 0; i < n; i++) cout << can[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, a1, b1;
cin >> a >> b >> a1 >> b1;
int x, y, x1, y1;
x = min(a, b);
y = max(a, b);
x1 = min(a1, b1);
y1 = max(a1, b1);
if (x + x1 == y && y == y1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| 0 |
//a.9
#include<bits/stdc++.h>
#define ll long long
#define endl '\n'
#define mod 1000000007
#define INF 0x3f3f3f3f
#define ios ios_base::sync_with_stdio(false); cin.tie(NULL)
using namespace std;
ll t,n,arr[300005],k,s;
ll func(ll i)
{
if((arr[i]>arr[i-1]&&arr[i]>arr[i+1])||(arr[i]<arr[i-1]&&arr[i]<arr[i+1]))return 1;
else return 0;
}
void solve()
{
ll n;cin>>n;
for(ll i=1;i<=n;i++)cin>>arr[i];
arr[0]=arr[1];arr[n+1]=arr[n];s=k=0;
for(ll i=2;i<n;i++)
{
ll p=0,q=0,w=arr[i];s+=func(i);
p=q=func(i-1)+func(i+1)+func(i);
arr[i]=arr[i-1];p-=func(i+1);
arr[i]=arr[i+1];q-=func(i-1);
arr[i]=w;
k=max(p,max(q,k));
}
cout<<s-k<<endl;
}
int main()
{
ios;
ll tc=1; cin>>tc;
while(tc--)
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long INF = 1e13;
int n, k;
long long A[N], B[N], C[N];
bool can(long long mid) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
for (int x = (0), qwerty = (n); x < qwerty; x++) {
long long a = A[x] / B[x];
C[x] = A[x];
pq.push({a, x});
}
for (int x = (0), qwerty = (k); x < qwerty; x++) {
if (!int((pq).size())) break;
pair<long long, int> tmp = pq.top();
pq.pop();
if (tmp.first < x) return 0;
C[tmp.second] += mid;
C[tmp.second] = min(C[tmp.second], INF);
if (C[tmp.second] == INF) continue;
tmp.first = C[tmp.second] / B[tmp.second];
pq.push(tmp);
}
return !int((pq).size()) || pq.top().first >= k - 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int x = (0), qwerty = (n); x < qwerty; x++) cin >> A[x];
for (int x = (0), qwerty = (n); x < qwerty; x++) cin >> B[x];
long long lw = 0, hg = INF, ans = INF, mid;
while (hg >= lw) {
mid = (hg + lw) / 2;
if (can(mid))
ans = min(ans, mid), hg = mid - 1;
else
lw = mid + 1;
}
if (ans == INF)
cout << "-1\n";
else
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y, z;
};
bool found = 0;
Point p[8];
long long dot(Point a, Point b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
bool IsCube() {
Point q[8];
for (int i = 0; i < 8; ++i) {
q[i].x = p[i].x - p[0].x;
q[i].y = p[i].y - p[0].y;
q[i].z = p[i].z - p[0].z;
}
pair<long long, int> d[8];
for (int i = 0; i < 8; ++i) {
d[i].first = dot(q[i], q[i]);
d[i].second = i;
}
sort(d, d + 8);
long long d1 = d[1].first;
if (d1 == 0) return false;
if (d[0].first == 0 && d1 == d[2].first && d1 == d[3].first &&
2 * d1 == d[4].first && 2 * d1 == d[5].first && 2 * d1 == d[6].first &&
3 * d1 == d[7].first) {
} else
return false;
int edges[6][4] = {{0, 1, 0, 2}, {0, 1, 0, 3}, {0, 2, 0, 3},
{7, 6, 7, 5}, {7, 5, 7, 4}, {7, 4, 7, 6}};
for (int i = 0; i < 6; ++i) {
Point A = q[d[edges[i][0]].second], B = q[d[edges[i][2]].second];
A.x -= q[d[edges[i][1]].second].x;
A.y -= q[d[edges[i][1]].second].y;
A.z -= q[d[edges[i][1]].second].z;
B.x -= q[d[edges[i][3]].second].x;
B.y -= q[d[edges[i][3]].second].y;
B.z -= q[d[edges[i][3]].second].z;
if (dot(A, B) != 0) return false;
if (dot(A, A) != d1) return false;
if (dot(B, B) != d1) return false;
}
for (int i = 1; i <= 3; ++i) {
long long dd[3];
for (int j = 4; j <= 6; ++j) {
Point E = q[d[i].second];
E.x -= q[d[j].second].x;
E.y -= q[d[j].second].y;
E.z -= q[d[j].second].z;
dd[j - 4] = dot(E, E);
}
sort(dd, dd + 3);
if (dd[0] == d1 && dd[1] == d1 && dd[2] == 3 * d1) {
} else
return false;
}
return true;
}
void Perm(int pos) {
if (found) return;
if (pos == 8) {
if (IsCube()) {
cout << "YES\n";
for (int i = 0; i < 8; ++i) {
cout << p[i].x << ' ' << p[i].y << ' ' << p[i].z << '\n';
}
found = true;
}
return;
}
long long xyz[3];
int ind[3] = {0, 1, 2};
xyz[0] = p[pos].x;
xyz[1] = p[pos].y;
xyz[2] = p[pos].z;
do {
p[pos].x = xyz[ind[0]];
p[pos].y = xyz[ind[1]];
p[pos].z = xyz[ind[2]];
Perm(pos + 1);
} while (next_permutation(ind, ind + 3));
p[pos].x = xyz[0];
p[pos].y = xyz[1];
p[pos].z = xyz[2];
}
int main() {
for (int i = 0; i < 8; ++i) {
cin >> p[i].x >> p[i].y >> p[i].z;
}
Perm(1);
if (!found) cout << "NO\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
long long ccw(point o, point u, point v) {
point fir = {u.x - o.x, u.y - o.y};
point sec = {v.x - o.x, v.y - o.y};
return 1ll * fir.x * sec.y - 1ll * fir.y * sec.x;
}
bool cmp(point a, point b) { return (a.x < b.x); }
int main() {
map<int, int> M;
int n, m, i, j, k;
cin >> n >> m;
point a[n], b[m];
for (i = 0; i < n; ++i) scanf("%d %d", &a[i].x, &a[i].y);
for (i = 0; i < m; ++i) {
scanf("%d %d", &b[i].x, &b[i].y);
M[b[i].x]++;
}
int cnt[n][n];
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
cnt[i][j] = 0;
}
}
sort(a, a + n, cmp);
for (i = 0; i < n; ++i) {
for (j = i + 1; j < n; ++j) {
for (k = 0; k < m; ++k) {
if (b[k].x >= a[i].x && b[k].x < a[j].x) {
if (ccw(b[k], a[i], a[j]) < 0) {
cnt[i][j]++;
}
}
}
cnt[j][i] = -cnt[i][j];
}
}
int ans = 0;
for (i = 0; i < n; ++i) {
for (j = i + 1; j < n; ++j) {
for (k = j + 1; k < n; ++k) {
if (cnt[i][j] + cnt[j][k] + cnt[k][i] == 0) {
++ans;
}
}
}
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n >= 6) {
printf("1 2\n1 3\n2 4\n2 5\n");
for (int i = 6; i <= n; i++) printf("1 %d\n", i);
} else {
printf("-1\n");
}
for (int i = 2; i <= n; i++) printf("1 %d\n", i);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long OO = 0x0101010101010101;
class debug_t {
public:
template <typename T>
debug_t& operator<<(const T& o) {
return *this;
}
} dout;
int n, m;
vector<pair<int, double>> vec;
int dp[5005][5005];
int solve(int idx, int last_idx) {
if (idx > n) return 0;
int& ret = dp[idx][last_idx];
if (ret + 1) return ret;
ret = 0;
int type = vec[idx].first;
double x = vec[idx].second;
int sol1, sol2;
sol1 = sol2 = 1e8;
if (x > vec[last_idx].second) sol1 = solve(idx + 1, idx);
sol2 = 1 + solve(idx + 1, last_idx);
return ret = min(sol1, sol2);
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> m;
vec.push_back({0, -1e8});
for (int i = 1; i <= n; i++) {
int t;
double x;
cin >> t >> x;
vec.push_back({t, x});
}
sort(vec.begin(), vec.end());
cout << solve(1, 0);
dout << "\nExecution Time = " << clock() * 1.0 / CLOCKS_PER_SEC << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long TC = 1;
while (TC--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long lcnt = 1, rcnt = 1;
for (long long i = 1; i < n; i++) {
if (a[i] > a[i - 1])
lcnt++;
else
break;
}
for (long long i = n - 1 - 1; i >= 0; i--) {
if (a[i] > a[i + 1])
rcnt++;
else
break;
}
if ((a[0] >= a[n - 1] && lcnt % 2) || (a[0] <= a[n - 1] && rcnt % 2)) {
cout << "Alice\n";
continue;
} else if (lcnt % 2 == 0 && rcnt % 2 == 0) {
cout << "Bob\n";
} else {
cout << "Alice\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ar[55];
bool v[55];
int main() {
int n, i, j, c;
long long k, x;
cin >> n >> k;
ar[n] = 1;
ar[n + 1] = 1;
for (i = n - 1; i >= 1; --i) ar[i] = ar[i + 1] + ar[i + 2];
for (i = 1; i <= n;) {
if (i == n) {
printf("%d", i);
break;
}
if (ar[i + 1] < k) {
printf("%d %d ", i + 1, i);
k -= ar[i + 1];
i += 2;
} else
printf("%d ", i), ++i;
}
putchar('\n');
}
| 5 |
#include <bits/stdc++.h>
const int N = 100005;
int n, pre[N], nxt[N];
std::string s;
std::vector<std::basic_string<int> > v[4];
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> s, n = s.size();
for (int i = 0; i < n; ++i) s[i] = s[i] == 'R';
std::queue<int> q[2];
for (int i = 0; i < n; ++i) nxt[i] = -1, pre[i] = -1;
for (int i = 0; i < n; ++i) {
if (q[!s[i]].size()) {
int t = q[!s[i]].front();
q[!s[i]].pop();
pre[i] = t, nxt[t] = i;
}
q[s[i]].emplace(i);
}
for (int i = 0; i < n; ++i)
if (pre[i] == -1) {
std::basic_string<int> q;
for (int j = i; ~j; j = nxt[j]) q += j;
v[s[q[0]] << 1 | s[*q.rbegin()]].emplace_back(q);
}
int sum = -1;
for (int i = 0; i < 4; ++i) sum += v[i].size();
std::cout << sum << '\n';
for (int i = 1; i < v[1].size(); ++i) v[1][0] += v[1][i];
for (int i = 1; i < v[2].size(); ++i) v[2][0] += v[2][i];
std::basic_string<int> ans;
if (v[0].size() || v[3].size()) {
if (!v[1].size()) v[1].emplace_back(std::basic_string<int>());
if (!v[2].size()) v[2].emplace_back(std::basic_string<int>());
if (v[0].size() >= v[3].size()) {
ans = v[1][0] + v[0][0] + v[2][0];
for (int i = 0; i < v[3].size(); ++i) {
ans += v[3][i];
if (i + 1 < v[0].size()) ans += v[0][i + 1];
}
} else {
ans = v[2][0] + v[3][0] + v[1][0];
for (int i = 1; i < v[3].size(); ++i) ans += v[0][i - 1] + v[3][i];
}
} else {
if (!v[1].size())
ans = v[2][0];
else if (!v[2].size())
ans = v[1][0];
else {
if (v[1][0][0] > v[2][0][0]) std::swap(v[1][0], v[2][0]);
v[2][0].insert(v[2][0].begin(), v[1][0][0]);
v[1][0].erase(v[1][0].begin());
ans = v[1][0] + v[2][0];
}
}
for (int i = 0; i < ans.size(); ++i) std::cout << ans[i] + 1 << ' ';
std::cout << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MOD = 1e6 + 3;
const int N = 1e5 + 5;
int n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> k;
vector<int> V(2 * n + 1);
for (int i = 0; i < 2 * n + 1; i++) {
cin >> V[i];
}
for (int i = 1; i < 2 * n; i++) {
if (k == 0) break;
if (V[i] - 1 > V[i - 1] && V[i] - 1 > V[i + 1]) {
V[i]--;
k--;
}
}
for (int i = 0; i < 2 * n + 1; i++) {
cout << V[i] << " ";
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.