solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
using namespace std;
void solution() {
int m;
vector<vector<int> > graph(5);
cin >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 0; i < 5; i++) {
if ((int)graph[i].size() <= 1 || (int)graph[i].size() >= 3) {
cout << "WIN" << '\n';
return;
}
}
cout << "FAIL" << '\n';
return;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (int i = 1; i <= t; i++) {
solution();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const int MAXR = 10;
const int MAXN = 70;
int N, R;
double win_p[MAXN][MAXN];
double dp[MAXN][MAXR];
vector<int> comp[MAXN][MAXR];
bool can_meet(int a, int b, int r) {
for (int i = 0; (i) < (r); ++(i)) a /= 2;
for (int i = 0; (i) < (r); ++(i)) b /= 2;
return (a ^ 1) == b;
}
double max_score_game[MAXN][MAXR];
double solve(int winner, int round) {
double res = 0;
if (round == 0) return dp[winner][0];
if (max_score_game[winner][round] > -0.5)
return max_score_game[winner][round];
for (int p : comp[winner][round]) {
maxa(res, solve(winner, round - 1) + solve(p, round - 1));
}
res += dp[winner][round] * (1 << round);
return max_score_game[winner][round] = res;
}
int main() {
cin >> R;
N = 1 << R;
for (int i = 0; (i) < (N); ++(i)) {
for (int j = 0; (j) < (N); ++(j)) {
int first;
cin >> first;
win_p[i][j] = 1.0 * first / 100;
}
}
for (int i = 0; (i) < (N); ++(i)) {
for (int j = 0; (j) < (i); ++(j)) {
for (int k = 0; (k) < (R); ++(k)) {
if (can_meet(i, j, k)) {
comp[i][k].push_back(j);
comp[j][k].push_back(i);
}
}
}
}
for (int i = 0; (i) < (N); ++(i)) dp[i][0] = win_p[i][i ^ 1];
for (int i = 0; (i) < (N); ++(i))
for (int j = 0; (j) < (R); ++(j)) max_score_game[i][j] = -1;
for (int j = 1; j < R; j++) {
for (int i = 0; (i) < (N); ++(i)) {
dp[i][j] = 0;
for (int p : comp[i][j]) {
dp[i][j] += dp[p][j - 1] * win_p[i][p];
}
dp[i][j] *= dp[i][j - 1];
}
}
double ans = 0;
for (int i = 0; (i) < (N); ++(i)) {
maxa(ans, solve(i, R - 1));
}
printf("%.9lf\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int N, M, D;
long long ans;
map<int, int> C;
set<pair<int, int> > S;
int main() {
scanf("%d %d %d", &D, &N, &M), C[D] = 1e9 + 3;
for (int i = 0; i <= M; i++) {
int x, c;
if (i != 0)
scanf("%d %d", &x, &c);
else
x = c = 0;
if (!C.count(x))
C[x] = c;
else if (c < C[x])
C[x] = c;
int y = x + N;
if (y > D) y = D;
if (!C.count(y)) C[y] = 1e9 + 3;
}
int lst = 0;
auto j = C.begin();
S.insert(make_pair(C[0], 0));
for (map<int, int>::iterator it = C.begin(); it != C.end(); it++) {
if (it->first == 0) continue;
while (j->first + N < it->first)
S.erase(S.find(make_pair(j->second, j->first))), j++;
if (S.empty()) {
printf("-1\n");
return 0;
}
pair<int, int> bst = *(S.begin());
if (bst.first > 1e9) {
printf("-1\n");
return 0;
}
ans += 1LL * (it->first - lst) * bst.first,
lst = it->first, S.insert(make_pair(it->second, it->first));
}
printf("%I64d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2100;
bool l[MAXN][MAXN], r[MAXN][MAXN], d[MAXN][MAXN], u[MAXN][MAXN];
char c[MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (c[i][j] == '.')
l[i][j] = true;
else
break;
for (int j = m - 1; j >= 0; j--)
if (c[i][j] == '.')
r[i][j] = true;
else
break;
for (int j = 0; j < m; j++)
if (i == 0 and c[i][j] == '.')
u[i][j] = true;
else if (i != 0)
u[i][j] = (u[i - 1][j] and (c[i][j] == '.'));
}
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < m; j++)
if (i == n - 1 and c[i][j] == '.')
d[i][j] = true;
else
d[i][j] = (d[i + 1][j] and c[i][j] == '.');
long long ans = 0;
for (int i = 1; i < n - 1; i++)
if (r[i][0]) ans++;
for (int i = 1; i < m - 1; i++)
if (d[0][i]) ans++;
for (int i = 1; i < n - 1; i++)
for (int j = 1; j < m - 1; j++) {
ans += (l[i][j] and u[i][j]);
ans += (l[i][j] and d[i][j]);
ans += (r[i][j] and u[i][j]);
ans += (r[i][j] and d[i][j]);
}
for (int j = 1; j < m - 1; j++) {
long long cntl = 0, cntr = 0;
for (int i = 1; i < n - 1; i++) {
if (c[i][j] != '.') {
cntl = cntr = 0;
continue;
}
if (l[i][j]) {
if (i > 1 and l[i - 1][j])
ans += cntl - 1;
else
ans += cntl;
ans += cntr;
}
if (r[i][j]) {
if (i > 1 and r[i - 1][j])
ans += cntr - 1;
else
ans += cntr;
ans += cntl;
}
cntr += r[i][j];
cntl += l[i][j];
}
}
for (int i = 1; i < n - 1; i++) {
long long cntu = 0, cntd = 0;
for (int j = 1; j < m - 1; j++) {
if (c[i][j] != '.') {
cntu = cntd = 0;
continue;
}
if (d[i][j]) {
if (j > 1 and d[i][j - 1])
ans += cntd - 1;
else
ans += cntd;
ans += cntu;
}
if (u[i][j]) {
if (j > 1 and u[i][j - 1])
ans += cntu - 1;
else
ans += cntu;
ans += cntd;
}
cntu += u[i][j];
cntd += d[i][j];
}
}
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > v;
vector<bool> th(1010), ch(1010);
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
void swap(char a, char b) {
char t;
t = a;
a = b;
b = t;
}
long long fact(long long n) {
if (n <= 1)
return 1;
else
return n * fact(n - 1);
}
long long comb(long long n, long long k) {
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long GCD(long long a, long long b) {
if (b == 1)
return 1;
else
return GCD(b, a % b);
}
long long dig(long long n) {
long long c = 0;
while (n > 0) {
long long x = n % 10;
if (x != 0) c++;
n = n / 10;
}
return c;
}
bool DFS(long long n) {
bool ch[1010];
stack<long long> s;
long long ans = 0;
ch[n] = true;
s.push(n);
if (th[n] == true) ans++;
while (s.size() > 0) {
long long x = s.top();
s.pop();
cout << "X";
for (long long i = 0; i < v[x].size(); i++) {
if (ch[v[x][i]] == false) {
s.push(v[x][i]);
ch[v[x][i]] = true;
if (th[v[x][i]] == true) ans++;
if (ans >= 2) {
return false;
}
}
}
}
return true;
}
queue<int> q;
void BFS(long long n) {
long long i, le[n + 1];
q.push(n);
le[n] = 0;
ch[n] = true;
while (q.size() > 0) {
long long x = q.front();
q.pop();
for (i = 0; i < v[x].size(); i++) {
if (ch[v[x][i]] == false) {
q.push(v[x][i]);
ch[v[x][i]] = true;
le[v[x][i]] = le[x] + 1;
}
}
}
}
long long count(long long n) {
long long c = 1, k = n;
while (k > 0) {
long long x = k % 10;
if (x != 0) c = c * x;
k = k / 10;
}
return c;
}
int main() {
long long n, i;
string s;
char loc, loc2;
cin >> s;
n = s.length();
map<char, long long> fr;
for (i = 0; i < n; i++) fr[s[i]]++;
stack<char> t;
loc = 'a';
for (i = 0; i < n; i++) {
if (s[i] == loc) {
cout << loc;
fr[loc]--;
} else {
t.push(s[i]);
fr[s[i]]--;
}
if (fr[loc] == 0) {
while (fr[loc] == 0 && loc <= 'z') loc++;
while (t.size() > 0) {
if (t.top() <= loc) {
cout << t.top();
t.pop();
} else
break;
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long _;
cin >> _;
while (_--) {
long long n;
cin >> n;
vector<long long> a(n), b(n);
vector<long long> cnt1(n), cnt2(n);
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
cnt1[a[i] - 1]++, cnt2[b[i] - 1]++;
}
long long cnt = 0;
for (long long i = 0; i < n; i++)
cnt += (cnt1[a[i] - 1] - 1) * (cnt2[b[i] - 1] - 1);
long long all = n * (n - 1) * (n - 2) / 6;
cout << all - cnt << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
if (x == y && z == 0)
cout << 0 << endl;
else if (x > y) {
if (x > y + z)
cout << "+" << endl;
else
cout << "?" << endl;
} else {
if (y > x + z)
cout << "-" << endl;
else
cout << "?" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long first = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9';) {
if (ch == '-') f = -1;
ch = getchar();
}
for (; ch >= '0' && ch <= '9';) {
first = first * 10 + ch - '0';
ch = getchar();
}
return first * f;
}
int a[100010];
int main() {
int n = read();
int cnt = 0, lst = 0, ans = 0;
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) {
if (a[i] == a[i - 1]) {
cnt++;
} else {
lst = cnt;
cnt = 1;
}
if (cnt <= lst) ans = ans > cnt * 2 ? ans : cnt * 2;
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, d;
int f(int x) { return x + ceil((double)d / (x + 1)) - n; }
int main() {
int T;
scanf("%d", &T);
while (T--) {
bool v = false;
scanf("%d %d", &n, &d);
int l = 0, r = n, mid;
while (l <= r) {
mid = (r + l) / 2;
if (f(mid) > 0)
r = mid - 1;
else if (f(mid) < 0)
l = mid + 1;
else {
v = true;
break;
}
}
if (v)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, s = 0, i;
cin >> n >> d;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
if ((n - 1) * 10 + s > d)
cout << "-1";
else
cout << (d - s) / 5;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, m, i, x;
cin >> n >> m;
priority_queue<int> pq;
priority_queue<int, vector<int>, greater<int>> gq;
for (i = 0; i < m; i++) {
cin >> x;
pq.push(x);
gq.push(x);
}
long long int mx = 0, mn = 0, tmp;
while (n--) {
tmp = pq.top();
pq.pop();
if (tmp - 1 > 0) pq.push(tmp - 1);
mx += tmp;
tmp = gq.top();
gq.pop();
if (tmp - 1 > 0) gq.push(tmp - 1);
mn += tmp;
}
cout << mx << " " << mn;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, k, p[100005], w[100005], num, v, x, ac, part;
int parent(int x) {
if (x == p[x]) return x;
int y = p[x];
int z = parent(p[x]);
w[x] += w[y];
w[x] = w[x] % 1000000007;
p[x] = z;
return z;
}
int main() {
scanf("%d", &n);
num = 0;
ac = 0;
while (n--) {
++num;
p[num] = num;
w[num] = 0;
scanf("%d", &k);
while (k--) {
scanf("%d%d", &v, &x);
part = parent(v);
p[part] = num;
w[part] = (x + w[v]) % 1000000007;
ac = (ac + w[part]) % 1000000007;
if (ac < 0) ac += 1000000007;
}
}
printf("%d\n", ac);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int R, C;
char M[501][501], F[501][501][9];
int main() {
while (scanf("%d %d", &R, &C) == 2) {
for (int i = 0; i < R; i++) scanf("%s", M[i]);
for (int i = 0; i + 1 < R; i++) {
for (int j = 0; j + 1 < C; j++) {
int mask = 0;
if (M[i][j] == '*') mask += 1;
if (M[i][j + 1] == '*') mask += 2;
if (M[i + 1][j] == '*') mask += 4;
if (M[i + 1][j + 1] == '*') mask += 8;
F[i][j][1] = mask;
}
}
int ans = 0;
for (int k = 2; k < 9; k++) {
int L = 1 << (k - 1);
for (int i = 0; i + (L << 1) <= R; i++) {
for (int j = 0; j + (L << 1) <= C; j++) {
int mask = 0;
if (F[i][j][k - 1] == 15) mask += 1;
if (F[i][j + L][k - 1] == 15) mask += 2;
if (F[i + L][j][k - 1] == 15) mask += 4;
if (F[i + L][j + L][k - 1] == 15) mask += 8;
bool ok = 1;
if (F[i][j][k - 1] != 15) ok &= (mask == F[i][j][k - 1]);
if (F[i][j + L][k - 1] != 15) ok &= (mask == F[i][j + L][k - 1]);
if (F[i + L][j][k - 1] != 15) ok &= (mask == F[i + L][j][k - 1]);
if (F[i + L][j + L][k - 1] != 15)
ok &= (mask == F[i + L][j + L][k - 1]);
if (ok) {
F[i][j][k] = mask;
ans++;
} else
F[i][j][k] = -1;
}
}
}
cout << ans << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
map<string, set<string> > file, folder;
char s[105][105];
int main() {
int i, j, k = 0, T;
while (scanf("%s", s[k]) != EOF) {
string S = s[k];
vector<string> current;
string x = "", y = "";
for (int i = 0; i < S.size(); i++) {
x += S[i];
if (S[i] == '\\' && S[i - 1] != ':') {
for (int j = 0; j < current.size(); j++) folder[current[j]].insert(x);
y = "";
current.push_back(x);
}
if ((isalpha(S[i]) || isdigit(S[i]) || S[i] == '.') && i != 0) y += S[i];
}
for (int j = 0; j < current.size(); j++) file[current[j]].insert(x);
k++;
}
int ret1 = 0, ret2 = 0;
for (int T = 0; T < k; T++) {
string S = s[T];
vector<string> current;
string x = "";
for (int i = 0; i < S.size(); i++) {
x += S[i];
if (S[i] == '\\' && S[i - 1] != ':') {
for (int j = 0; j < current.size(); j++)
ret1 = max(ret1, (int)folder[current[j]].size());
current.push_back(x);
}
}
for (int j = 0; j < current.size(); j++)
ret2 = max(ret2, (int)file[current[j]].size());
}
printf("%d %d\n", ret1, ret2);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1002000;
int n, k, fa[maxn];
vector<int> g[maxn];
int dep[maxn], minn[maxn];
int f[maxn], d[maxn];
void read() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i]);
g[fa[i]].push_back(i);
}
}
void dfs(int now, int dp) {
dep[now] = dp;
if (g[now].size() == 0) {
minn[now] = dp;
return;
}
minn[now] = 1e8;
for (int i = 0; i < g[now].size(); i++) {
dfs(g[now][i], dp + 1);
minn[now] = min(minn[now], minn[g[now][i]]);
}
}
void dfs2(int now) {
if (g[now].size() == 0) {
f[now] = d[now] = 1;
return;
}
for (int i = 0; i < g[now].size(); i++) dfs2(g[now][i]);
for (int i = 0; i < g[now].size(); i++)
if (minn[g[now][i]] - dep[now] <= k) d[now] += d[g[now][i]];
for (int i = 0; i < g[now].size(); i++) {
if (minn[g[now][i]] - dep[now] <= k)
f[now] = max(f[now], d[now] - d[g[now][i]] + f[g[now][i]]);
else
f[now] = max(f[now], d[now] + f[g[now][i]]);
}
}
void work() {
dfs(1, 1);
dfs2(1);
printf("%d\n", f[1]);
}
int main() {
read();
work();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> fb(1000010 + 1, 0), fe(1000010 + 1, 0);
void update(long long which, long long idx, long long val) {
if (which == 1) {
while (idx < 1000010) {
fb[idx] += val;
idx += idx & -idx;
}
} else {
while (idx < 1000010) {
fe[idx] += val;
idx += idx & -idx;
}
}
}
long long query(long long which, long long idx) {
if (which == 1) {
long long ans = 0;
while (idx > 0) {
ans += fb[idx];
idx -= idx & -idx;
}
return ans;
} else {
long long ans = 0;
while (idx > 0) {
ans += fe[idx];
idx -= idx & -idx;
}
return ans;
}
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long begtime = clock();
;
map<long long, long long> comp;
long long n;
cin >> n;
vector<long long> arr(n);
for (long long i = 0; i < n; ++i) cin >> arr[i];
vector<long long> arr2 = arr;
sort(arr2.begin(), arr2.end());
long long cur = 1;
for (long long i = 0; i < n; i += 1) comp[arr2[i]] = cur, cur += 1;
long long ans = 0;
for (long long i = 0; i < n; i += 1) {
update(2, comp[arr[i]], 1);
}
for (long long i = 0; i < n; i += 1) {
long long le = query(2, comp[arr[i]] - 1);
long long gr = query(1, 1000010) - query(1, comp[arr[i]]);
ans += le * gr;
update(1, comp[arr[i]], 1);
update(2, comp[arr[i]], -1);
}
cout << ans << endl;
long long endtime = clock();
cerr << endl
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC
<< " ms";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long pw = 1;
const long long X = 1000000009;
for (int i = 0; i < m; ++i) {
pw = (pw * 2) % 1000000009;
}
pw = pw % 1000000009;
long long all = 1;
for (int i = 1; i <= n; ++i) {
long long r;
if (pw - i < 0) {
r = X - (i - pw);
} else {
r = pw - i;
}
all = (all * r) % X;
}
cout << all << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int a[MaxN], ax[MaxN], r[MaxN], mp[MaxN];
long long s[MaxN];
int N, M, K, cnt;
long long tr[2][MaxN];
bool cmpR(const int& i, const int& j) { return ax[i] < ax[j]; }
void init() {
ax[N] = 0;
for (int i = 0; i <= N; i++) {
r[i] = i;
s[i] = (i == 0 ? 0 : s[i - 1]) + ax[i];
}
sort(r, r + N + 1, cmpR);
mp[1] = ax[r[0]];
ax[r[0]] = K = 1;
for (int i = 1; i <= N; i++) {
if (ax[r[i]] == mp[K])
ax[r[i]] = K;
else
mp[++K] = ax[r[i]], ax[r[i]] = K;
}
}
void add(int k, int v) {
int value = mp[k];
while (k <= K) {
tr[0][k] += v;
tr[1][k] += value * v;
k += k & -k;
}
}
pair<long long, long long> read(int k) {
pair<long long, long long> ret = make_pair(0LL, 0LL);
while (k) {
ret.first += tr[0][k];
ret.second += tr[1][k];
k -= k & -k;
}
return ret;
}
int find(int k) {
int idx = 0;
for (int i = 20; i >= 0; i--) {
idx ^= 1 << i;
if (idx <= K && tr[0][idx] < k)
k -= tr[0][idx];
else
idx ^= 1 << i;
}
return idx + 1;
}
long long findS(int k) {
int v = find(k);
pair<long long, long long> res = read(v - 1);
long long ret = res.second;
ret += (k - res.first) * mp[v];
return -ret;
}
long long getS(int L, int R) {
if (L == 0)
return s[R];
else
return s[R] - s[L - 1];
}
long long maxAdd() {
int x = read(ax[N] - 1).first;
x = min(x, cnt);
return 2 * findS(x);
}
long long sol() {
long long ret = 0;
for (int i = 0; i + M <= N; i++) {
if (i == 0) {
for (int j = 0; j < M; j++) add(ax[j], 1);
} else {
add(ax[i - 1], -1);
add(ax[i + M - 1], 1);
}
ret = max(ret, getS(i, i + M - 1) + maxAdd());
}
return ret;
}
int main() {
long long ret;
while (scanf("%d%d", &N, &M) == 2) {
for (int i = 0; i < N; i++) {
scanf("%d", &a[i]);
ax[i] = a[i];
}
ret = 0;
init();
memset(tr, 0, sizeof(tr));
scanf("%d", &cnt);
ret = sol();
for (int i = 0; i < N; i++) ax[i] = -a[i];
init();
memset(tr, 0, sizeof(tr));
ret = max(ret, sol());
printf("%I64d\n", ret);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rnd(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200;
const int MAXCARD = 6 * MAXN;
int n, ncard;
int col[MAXCARD];
vector<vector<int>> ans;
bool can[MAXCARD][MAXCARD];
int prv[MAXCARD + 1][4];
vector<vector<int>> lst;
vector<int> par;
vector<vector<int>> ch;
vector<bool> done;
vector<int> rem;
void build(int s, int t) {
vector<pair<int, vector<int>>> stck;
for (int i = (s); i <= (t); ++i) {
if (stck.empty() || stck.back().first != col[i]) {
stck.push_back(make_pair(col[i], vector<int>(1, i)));
} else {
stck.back().second.push_back(i);
if (((int)(stck.back().second).size()) == 3) {
vector<int> cur = stck.back().second;
lst.push_back(cur);
stck.pop_back();
}
}
}
assert(((int)(stck).size()) == 0);
}
bool inside(const vector<int>& a, const vector<int>& b) {
bool pos1 = true, pos2 = true;
for (int i = (0); i < (((int)(a).size())); ++i) {
if (a[i] < b[0] || a[i] > b[1]) pos1 = false;
if (a[i] < b[1] || a[i] > b[2]) pos2 = false;
}
return pos1 || pos2;
}
bool conflicting(const vector<int>& a, const vector<int>& b) {
if (inside(a, b) || inside(b, a)) return false;
if (a[2] < b[0] || b[2] < a[0]) return false;
return true;
}
void solve() {
for (int s = (0); s < (ncard); ++s) {
vector<pair<int, int>> stck;
for (int i = (s); i < (ncard); ++i) {
if (stck.empty() || stck.back().first != col[i])
stck.push_back(make_pair(col[i], 1));
else if (stck.back().second == 2)
stck.pop_back();
else
++stck.back().second;
can[s][i] = stck.empty();
}
}
for (int i = (0); i <= (ncard); ++i)
for (int j = (0); j <= (3); ++j) prv[i][j] = -2;
for (int i = (0); i < (ncard); ++i)
if (col[i] == 1 && (i == 0 || can[0][i - 1])) prv[i][0] = -1;
for (int i = (0); i < (ncard); ++i)
for (int j = (0); j < (3); ++j)
if (prv[i][j] != -2) {
for (int k = (i + 1); k <= (ncard); ++k)
if ((k == ncard || col[k] == 1) && (k == i + 1 || can[i + 1][k - 1]))
prv[k][j + 1] = i;
}
assert(prv[ncard][3] != -2);
vector<int> last;
for (int i = prv[ncard][3], j = 2; i != -1; i = prv[i][j], --j)
last.push_back(i);
reverse(last.begin(), last.end());
lst.clear();
for (int j = (0); j <= (3); ++j) {
int s = j == 0 ? 0 : last[j - 1] + 1;
int t = j == 3 ? ncard - 1 : last[j] - 1;
if (s <= t) build(s, t);
}
lst.push_back(last);
int lastid = ((int)(lst).size()) - 1;
assert(((int)(lst).size()) == ncard / 3);
ch = vector<vector<int>>(((int)(lst).size()));
par = vector<int>(((int)(lst).size()), -1);
for (int i = (0); i < (((int)(lst).size())); ++i)
for (int j = (i + 1); j < (((int)(lst).size())); ++j) {
assert(!conflicting(lst[i], lst[j]));
assert(!inside(lst[j], lst[i]));
if (inside(lst[i], lst[j])) {
bool direct = true;
for (int k = (i + 1); k < (j); ++k)
if (inside(lst[i], lst[k]) && inside(lst[k], lst[j])) {
direct = false;
break;
}
if (direct) {
assert(col[lst[i][0]] != col[lst[j][0]]);
par[i] = j;
ch[j].push_back(i);
}
}
}
rem = vector<int>(((int)(lst).size()), 0);
for (int i = (0); i < (((int)(lst).size())); ++i)
rem[i] = ((int)(ch[i]).size());
done = vector<bool>(((int)(lst).size()), false);
ans.clear();
for (int i = (0); i < (((int)(lst).size())); ++i) {
int c = i % 2;
int use = -1;
for (int j = (0); j < (((int)(lst).size())); ++j)
if (!done[j] && col[lst[j][0]] == c && rem[j] == 0) {
use = j;
break;
}
assert(use != -1);
done[use] = true;
if (par[use] != -1) --rem[par[use]];
ans.push_back(lst[use]);
}
}
void run() {
scanf("%d", &n);
ncard = 6 * n;
for (int i = (0); i < (ncard); ++i) col[i] = 1;
for (int i = (0); i < (3 * n); ++i) {
int x;
scanf("%d", &x);
--x;
col[x] = 0;
}
solve();
for (int i = (0); i < (((int)(ans).size())); ++i) {
for (int j = (0); j < (((int)(ans[i]).size())); ++j) {
if (j != 0) printf(" ");
printf("%d", ans[i][j] + 1);
}
puts("");
}
}
int main() {
run();
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
string compare(string x) {
if (x.size() % 2) return x;
string a = compare(string(x, 0, x.size() / 2));
string b = compare(string(x, x.size() / 2, x.size()));
if (a < b)
return a + b;
else
return b + a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string x, y;
cin >> x >> y;
x = compare(x);
y = compare(y);
if (x == y)
cout << "YES";
else
cout << "NO";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void print(vector<int> x) {
for (int i = 0; i < x.size(); i++) cout << x[i] << " ";
cout << endl;
}
vector<int> dp1[500], dp2[500];
void F(int n) {
dp1[n] = dp2[n - 1];
dp2[n] = {0};
dp2[n].insert(dp2[n].end(), dp1[n].begin(), dp1[n].end());
for (int i = 0; i < dp1[n - 1].size(); i++)
dp2[n][i] = (dp2[n][i] % 2 + dp1[n - 1][i] % 2) % 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
dp1[0] = {0};
dp2[0] = {1};
for (int i = 1; i <= n; i++) F(i);
cout << dp2[n].size() - 1 << endl;
print(dp2[n]);
cout << dp1[n].size() - 1 << endl;
print(dp1[n]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
string s;
int n;
struct node {
int l, r, par, link;
map<char, int> next;
node(int l = 0, int r = 0, int par = -1) : l(l), r(r), par(par), link(-1) {}
int len() { return r - l; }
int &get(char c) {
if (!next.count(c)) next[c] = -1;
return next[c];
}
};
const int NMAX = 200000;
node t[2 * NMAX + 100];
int sz;
struct state {
int v, pos;
state(int v, int pos) : v(v), pos(pos) {}
};
state ptr(0, 0);
state go(state st, int l, int r) {
while (l < r)
if (st.pos == t[st.v].len()) {
st = state(t[st.v].get(s[l]), 0);
if (st.v == -1) return st;
} else {
if (s[t[st.v].l + st.pos] != s[l]) return state(-1, -1);
if (r - l < t[st.v].len() - st.pos) return state(st.v, st.pos + r - l);
l += t[st.v].len() - st.pos;
st.pos = t[st.v].len();
}
return st;
}
int split(state st) {
if (st.pos == t[st.v].len()) return st.v;
if (st.pos == 0) return t[st.v].par;
node v = t[st.v];
int id = sz++;
t[id] = node(v.l, v.l + st.pos, v.par);
t[v.par].get(s[v.l]) = id;
t[id].get(s[v.l + st.pos]) = st.v;
t[st.v].par = id;
t[st.v].l += st.pos;
return id;
}
int get_link(int v) {
if (t[v].link != -1) return t[v].link;
if (t[v].par == -1) return 0;
int to = get_link(t[v].par);
return t[v].link = split(
go(state(to, t[to].len()), t[v].l + (t[v].par == 0), t[v].r));
}
void tree_extend(int pos) {
for (;;) {
state nptr = go(ptr, pos, pos + 1);
if (nptr.v != -1) {
ptr = nptr;
return;
}
int mid = split(ptr);
int leaf = sz++;
t[leaf] = node(pos, n, mid);
t[mid].get(s[pos]) = leaf;
ptr.v = get_link(mid);
ptr.pos = t[ptr.v].len();
if (!mid) break;
}
}
void build_tree() {
sz = 1;
for (int i = 0; i < n; ++i) tree_extend(i);
}
long long ans = 0;
int cnt[2 * NMAX + 100];
void dfs(int v) {
cnt[v] = t[v].next.empty() ? 1 : 0;
for (map<char, int>::iterator it = t[v].next.begin(); it != t[v].next.end();
it++) {
dfs(it->second);
cnt[v] += cnt[it->second];
}
}
void calc(int v) {
for (map<char, int>::iterator it = t[v].next.begin(); it != t[v].next.end();
it++) {
calc(it->second);
long long cur = (cnt[it->second] * 1LL * (cnt[it->second] + 1)) >> 1;
long long curcnt = t[it->second].len();
ans += cur * curcnt;
}
}
int main() {
getline(cin, s);
s += '$';
n = int((s).size());
build_tree();
dfs(0);
calc(0);
cerr << ans << endl;
cout << ans - int((s).size()) << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize("fast-math")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long INF = 1e9 + 228;
const long long INFLL = 1e18;
const long long MOD = 1e9 + 7;
const long double eps = 1e-4;
const long double eps2 = 1e-9;
const long long MOD2 = 998244353;
const long long dosz = 5e5;
const long long SZ = (1 << 18);
const long double PI = atan2l(0, -1);
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> nums(n);
for (long long i = 0; i < n; i++) {
cin >> nums[i];
}
long long l = 0, r = 1e9;
long long ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
vector<long long> dp(n, 0);
dp[0] = (nums[0] <= mid);
dp[1] = max((long long)(nums[1] <= mid), dp[0]);
for (long long i = 2; i < n; i++) {
dp[i] = max(dp[i - 2] + (nums[i] <= mid), dp[i - 1]);
}
vector<long long> dp1(n, 0);
dp1[0] = 0;
dp1[1] = (nums[1] <= mid);
for (long long i = 2; i < n; i++) {
dp1[i] = max(dp1[i - 2] + (nums[i] <= mid), dp1[i - 1]);
}
if (k & 1) {
if (dp[n - 1] >= (k + 1) / 2 || dp1[n - 2] >= (k) / 2) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
} else {
if (dp[n - 2] >= k / 2 || dp1[n - 1] >= k / 2) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
}
cout << ans << endl;
}
signed main() {
fast_io();
srand(time(NULL));
cout << fixed << setprecision(12);
long long q = 1;
while (q--) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, d, songc = 0, k;
cin >> n >> d;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
songc += arr[i];
}
songc += (n - 1) * 10;
if (songc <= d) {
cout << (d - songc + (n - 1) * 10) / 5;
} else {
cout << "-1";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<int> v[100 + 50];
int main() {
long long n, m;
cin >> n >> m;
long long aios = 0LL;
for (long long i = 1; i <= m; i++) {
long long tmp = 0;
for (long long j = 1LL; j <= m; j++) {
if ((i * i + j * j) % m == 0LL) {
tmp++;
}
}
tmp = tmp * (n / m);
long long rem = n % m;
for (long long j = 1; j <= rem; j++) {
if ((i * i + j * j) % m == 0LL) {
tmp++;
}
}
aios += tmp;
}
long long ans = 0;
ans = ans + aios * (n / m);
long long remm = n % m;
aios = 0;
for (long long i = 1; i <= remm; i++) {
long long tmp = 0;
for (long long j = 1LL; j <= m; j++) {
if ((i * i + j * j) % m == 0LL) {
tmp++;
}
}
tmp = tmp * (n / m);
long long rem = n % m;
for (long long j = 1; j <= rem; j++) {
if ((i * i + j * j) % m == 0LL) {
tmp++;
}
}
aios += tmp;
}
ans += aios;
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Tedge {
int v, pre;
} edge[200010 * 2];
int n, k, en, cur[200010], val[200010], fa[200010], tot, h[200010], typ[200010],
siz[200010], dis[200010], vst[200010];
int getint() {
int x, f = 1;
char ch;
while (!isdigit(ch = getchar())) f = ch == '-' ? -1 : 1;
x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
return f * x;
}
void addedge(int u, int v) {
edge[++en] = (Tedge){v, cur[u]}, cur[u] = en;
edge[++en] = (Tedge){u, cur[v]}, cur[v] = en;
}
bool dfs1(int p, int f, int now) {
if (val[p] < now) return false;
h[++tot] = p, siz[p] = 1, vst[p] = 1;
bool blk = true;
int ch = 0, wn = 0;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (v != f) {
ch++;
bool res = dfs1(v, p, now);
blk &= res;
if (res)
siz[p] += siz[v];
else
wn++;
}
if (blk)
typ[p] = 2;
else if (!f && wn == 1) {
typ[p] = 2;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 2) siz[p] += siz[v];
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) siz[v] += siz[p];
}
return blk;
}
void dfs2(int p) {
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) {
p = v;
break;
}
while (1) {
int wn = 0;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) wn++;
if (wn != 1) break;
typ[p] = 2;
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (typ[v] == 1) {
siz[v] += siz[p], p = v;
break;
}
}
}
void dfs3(int p, int f, int d) {
if (typ[p] != 1) return;
dis[p] = (d += siz[p]);
for (int i = cur[p], v = edge[i].v; i; i = edge[i].pre, v = edge[i].v)
if (v != f) dfs3(v, p, d);
}
int find(int p) {
dfs3(p, 0, 0);
int ans = p;
for (int i = 1; i <= tot; i++)
if (typ[h[i]] == 1 && dis[h[i]] > dis[ans]) ans = h[i];
return ans;
}
bool check(int now) {
memset(vst, 0, sizeof(vst));
for (int i = 1; i <= n; i++) typ[i] = val[i] >= now;
for (int i = 1; i <= n; i++)
if (typ[i] && !vst[i]) {
tot = 0;
dfs1(i, 0, now);
if (typ[i] == 2) dfs2(i);
if (tot < k) continue;
int wt = -1;
for (int i = 1; i <= tot; i++)
if (typ[h[i]] == 1) {
wt = h[i];
break;
}
if (wt == -1) return true;
int x = find(wt);
x = find(x);
if (dis[x] >= k) return true;
}
return false;
}
int main() {
(n = getint()), (k = getint());
for (int i = 1; i <= n; i++) (val[i] = getint());
for (int i = 1; i <= n - 1; i++) addedge(getint(), getint());
int l = 0, r = 1000000, ans;
while (l <= r)
if (check(((l + r) >> 1)))
ans = ((l + r) >> 1), l = ((l + r) >> 1) + 1;
else
r = ((l + r) >> 1) - 1;
printf("%d\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long ch[130], n;
string s;
long long jc[100005], inv[100005];
long long mul;
long long dp[100005];
long long ans[130][130];
void init() {
jc[0] = 1;
for (int i = 1; i <= 100000; i++) jc[i] = jc[i - 1] * i % mod;
inv[1] = inv[0] = 1;
for (int i = 2; i <= 100000; i++) {
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
for (int i = 2; i <= 100000; i++) {
inv[i] = inv[i - 1] * inv[i] % mod;
}
mul = 1;
for (int i = 'A'; i <= 'z'; i++) {
mul = mul * inv[ch[i]] % mod;
}
mul = mul * jc[n / 2] % mod;
mul = mul * jc[n / 2] % mod;
dp[0] = 1;
for (int i = 'A'; i <= 'z'; i++) {
if (ch[i] == 0) continue;
for (int j = n; j >= ch[i]; j--) {
dp[j] = dp[j] + dp[j - ch[i]];
if (dp[j] > mod) dp[j] -= mod;
}
}
}
void Mul(int t) {
for (int i = n; i >= t; i--) {
dp[i] = dp[i] + dp[i - t];
if (dp[i] > mod) dp[i] -= mod;
}
}
void Div(int t) {
for (int i = t; i <= n; i++) {
dp[i] = dp[i] - dp[i - t];
if (dp[i] < 0) dp[i] += mod;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
ch[s[i]]++;
}
init();
int _;
cin >> _;
int x, y;
memset(ans, -1, sizeof(ans));
while (_--) {
cin >> x >> y;
x--;
y--;
char xx = s[x], yy = s[y];
if (xx > yy) swap(xx, yy);
if (ans[xx][yy] != -1) {
cout << ans[xx][yy] << endl;
continue;
}
Div(ch[s[x]]);
if (s[x] != s[y]) {
Div(ch[s[y]]);
}
long long out = mul * dp[n / 2] * 2 % mod;
ans[xx][yy] = out;
cout << out << endl;
Mul(ch[s[x]]);
if (s[x] != s[y]) {
Mul(ch[s[y]]);
}
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
static void call(const char* it) {}
template <typename T, typename... valT>
static void call(const char* it, T val, valT... rest) {
string var = "";
for (; *it && *it != ','; it++)
if (*it != ' ') var += *it;
cerr << var << '=' << val << " ";
call(++it, rest...);
}
};
int main() {
int n;
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
}
int k;
cin >> k;
int left = n;
for (int i = 0; i < n; i++) {
if (k > v[i].second) left--;
}
cout << left << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
const unsigned long long N = 1e6 + 5;
unsigned long long p[N], n, c[N], sum, h[N];
map<unsigned long long, unsigned long long> us;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (unsigned long long i = 1; i < N; i++) p[i] = i;
for (unsigned long long i = 2; i < N; i++) {
if (p[i] != i) continue;
for (unsigned long long j = i; j < N; j += i) {
p[j] = min(p[j], i);
}
c[i] = rnd();
}
for (unsigned long long i = 1; i <= n; i++) {
unsigned long long x = i;
while (x > 1) {
h[i] ^= c[p[x]];
x /= p[x];
}
h[i] ^= h[i - 1];
sum ^= h[i];
}
if (sum == 0) {
cout << n << endl;
for (unsigned long long i = 1; i <= n; i++) {
cout << i << " ";
}
cout << endl;
return 0;
} else {
for (unsigned long long i = 1; i <= n; i++) {
if ((sum ^ h[i]) == 0) {
cout << n - 1 << endl;
for (unsigned long long j = 1; j <= n; j++) {
if (j == i) continue;
cout << j << " ";
}
cout << endl;
return 0;
}
}
for (unsigned long long i = 1; i <= n; i++) {
unsigned long long v = (h[i] ^ sum);
if (us.count(v)) {
cout << n - 2 << endl;
for (unsigned long long j = 1; j <= n; j++) {
if (j == i || j == us[v]) continue;
cout << j << " ";
}
cout << endl;
return 0;
}
us[h[i]] = i;
}
cout << n - 3 << endl;
for (unsigned long long i = 1; i <= n; i++) {
if (i == 2 || i == n || i == (n - 1) / 2) continue;
cout << i << " ";
}
cout << endl;
return 0;
}
}
| 21 |
#include <bits/stdc++.h>
int main(int n) {
std::cin >> n;
std::cout << n * 2 - 1 << " " << 2 << std::endl << 1 << " " << 2;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[105][105], c[105], r[105];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
c[j] += a[i][j];
r[i] += a[i][j];
}
int co = 0;
set<int> sc, sr;
set<int>::iterator it;
while (co <= 101) {
for (int i = 1; i <= n; i++)
if (r[i] < 0) {
if (sr.find(i) != sr.end())
sr.erase(sr.find(i));
else
sr.insert(i);
r[i] = -r[i];
for (int j = 1; j <= m; j++) c[j] -= 2 * a[i][j];
for (int j = 1; j <= m; j++) a[i][j] = -a[i][j];
}
for (int j = 1; j <= m; j++)
if (c[j] < 0) {
if (sc.find(j) != sc.end())
sc.erase(sc.find(j));
else
sc.insert(j);
c[j] = -c[j];
for (int i = 1; i <= n; i++) r[i] -= 2 * a[i][j];
for (int i = 1; i <= n; i++) a[i][j] = -a[i][j];
}
co++;
}
cout << sr.size() << " ";
for (it = sr.begin(); it != sr.end(); it++) cout << *it << " ";
cout << endl;
cout << sc.size() << " ";
for (it = sc.begin(); it != sc.end(); it++) cout << *it << " ";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, rez, sol, v[1010];
int main() {
scanf("%d", &n);
v[1] = 1000;
for (int i = 1; i <= n; ++i) scanf("%d", &v[i]);
for (int i = 1; i <= n; ++i) {
sol = 19999;
for (int cif = 1; cif <= 9; ++cif) {
rez = v[i] + ((cif - (v[i] / 1000) % 10) * 1000);
if (rez < sol && rez >= v[i - 1] && rez <= 2011) sol = rez;
}
for (int cif = 0; cif <= 9; ++cif) {
rez = v[i] + ((cif - (v[i] / 100) % 10) * 100);
if (rez < sol && rez >= v[i - 1] && rez <= 2011) sol = rez;
}
for (int cif = 0; cif <= 9; ++cif) {
rez = v[i] + ((cif - (v[i] / 10) % 10) * 10);
if (rez < sol && rez >= v[i - 1] && rez <= 2011) sol = rez;
}
for (int cif = 0; cif <= 9; ++cif) {
rez = v[i] + ((cif - (v[i]) % 10));
if (rez < sol && rez >= v[i - 1] && rez <= 2011) sol = rez;
}
if (sol == 19999) {
printf("No solution\n");
return 0;
}
v[i] = sol;
}
for (int i = 1; i <= n; ++i) printf("%d\n", v[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, f;
cin >> n >> f;
long long int k[n], l[n], a[n], sum = 0;
for (int i = 0; i < n; i++) {
cin >> k[i] >> l[i];
sum += min(k[i], l[i]);
a[i] = min(2 * k[i], l[i]) - min(k[i], l[i]);
}
sort(a, a + n);
for (int i = n - f; i < n; i++) sum += a[i];
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, k, t;
int main() {
scanf("%d%d%d", &n, &k, &t);
if (t <= k)
printf("%d", t);
else if (t <= n)
printf("%d", k);
else
printf("%d", k - (t - n));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int TN = 1;
const int N = 1e5 + 1;
void solve() {
int n, k;
long long m;
cin >> n >> m >> k;
long long b[n];
vector<pair<long long, int> > x;
for (int i = 0; i < n; i++) {
cin >> b[i];
if (i > 0) {
x.push_back({b[i] - b[i - 1], i});
}
}
if (n == 0) {
cout << 0;
return;
}
sort((x).begin(), (x).end());
long long ans = 0ll, cnt = n;
for (int i = 0; i < n - k; i++) {
ans += x[i].first;
cnt--;
}
ans += cnt;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
while (TN--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int a, b, s;
cin >> a >> b >> s;
s -= abs(a) + abs(b);
if (s < 0 || s % 2)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int qs(int a, int b) {
long long int i = 1;
for (a; a <= b; a++) {
i *= a;
i %= 1000000007;
}
return i;
}
int main() {
int n, i, j, eve = 0;
long long int a, b = 2, c = 1;
cin >> n;
for (i = 0; i < n; i++) {
cin >> j;
if (j % 2 == 1) {
eve += 1;
}
}
if (eve == 1) a = c;
if (eve == 2) a = b;
for (i = 3; i <= eve; i++) {
a = (b + c * (i - 1)) % 1000000007;
c = b;
b = a;
}
cout << (a * qs(eve + 1, n)) % 1000000007 << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int s, t, cap, next;
} e[5010];
int head[5010], cnt;
void addedge(int s, int t, int cap) {
e[cnt].s = s;
e[cnt].t = t;
e[cnt].cap = cap;
e[cnt].next = head[s];
head[s] = cnt++;
}
int n, m, k, u, v, w;
int degree[5010], ans[5010];
long long f[5010][5010];
short pre[5010][5010];
queue<int> q;
int main() {
scanf("%d%d%d", &n, &m, &k);
memset(head, 0xff, sizeof(head));
cnt = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w);
degree[v]++;
}
for (int i = 1; i <= n; i++)
if (!degree[i]) q.push(i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = 1LL << 60;
f[1][1] = 0;
while (!q.empty()) {
int tmp = q.front();
q.pop();
for (int i = head[tmp]; i != -1; i = e[i].next) {
degree[e[i].t]--;
for (int j = 2; j <= n; j++)
if (f[tmp][j - 1] + e[i].cap < f[e[i].t][j]) {
f[e[i].t][j] = f[tmp][j - 1] + e[i].cap;
pre[e[i].t][j] = tmp;
}
if (!degree[e[i].t]) q.push(e[i].t);
}
}
for (int i = n; i >= 2; i--)
if (f[n][i] <= k) {
printf("%d\n", i);
int tmp = n;
for (int j = i; j >= 1; j--) {
ans[j] = tmp;
tmp = pre[tmp][j];
}
for (int j = 1; j <= i; j++) printf("%d%c", ans[j], " \n"[j == i]);
break;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
using ld = long double;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int m = a[0].size();
vector<ll> dp(1 << m, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) {
int x = 0;
for (int k = 0; k < m; k++)
if (a[i][k] == a[j][k]) x |= 1 << k;
dp[x] |= (1ll << i) | (1ll << j);
}
for (int j = 0; j < m; j++)
for (int i = 0; i < 1 << m; i++)
if (i & (1 << j)) dp[i ^ (1 << j)] |= dp[i];
ld ans = 0;
vector<ld> f(m + 1);
f[0] = 1;
for (int i = 1; i <= m; i++) f[i] = i * f[i - 1];
0;
for (int i = 0; i < 1 << m; i++) {
int x = __builtin_popcount(i);
ans += __builtin_popcountll(dp[i]) * f[x] * f[m - x] / f[m] / n;
}
cout << setprecision(25) << fixed << ans << "\n";
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
long long C(long long n, long long k) {
if (k > n) return 0;
if (k * 2 > n) k = n - k;
if (k == 0) return 1;
long long result = n;
for (long long i = 2; i <= k; ++i) {
result *= (n - i + 1);
result /= i;
}
return result;
}
long long power(long long x, unsigned long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
const long long Nmax = 1e5 + 2;
vector<long long> adj[Nmax];
bool v[Nmax];
signed main() {
long long a[15] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};
long long cnt = 0;
for (long long i = 0; i < 15; ++i) {
cout << a[i] << "\n";
string s;
cin >> s;
if (s == "yes") cnt++;
}
for (long long i = 0; i < 4; ++i) {
cout << a[i] * a[i] << "\n";
string s;
cin >> s;
if (s == "yes") cnt++;
}
if (cnt <= 1)
cout << "prime\n";
else
cout << "composite\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
string s, t;
cin >> s >> t;
int ox = 0, rx1 = 0, rx2 = 0;
for (i = 0; i < (2 * n); i = i + 1) {
if (s[i] == '1' && t[i] == '1') {
ox++;
} else if (s[i] == '1') {
rx1++;
} else if (t[i] == '1') {
rx2++;
}
}
if (ox % 2 == 0) {
if (rx1 == rx2 || rx1 + 1 == rx2)
cout << "Draw" << endl;
else if (rx1 > rx2)
cout << "First" << endl;
else
cout << "Second" << endl;
} else {
rx1++;
if (rx1 == rx2 || rx1 + 1 == rx2)
cout << "Draw" << endl;
else if (rx1 > rx2)
cout << "First" << endl;
else
cout << "Second" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int minv = 1e8;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
minv = min(minv, y - x + 1);
}
printf("%d\n", minv);
for (int i = 1; i < n; i++) printf("%d ", i % minv);
printf("%d\n", n % minv);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int a[1010], b[1010], n;
void sort(int sta, int end) {
if (sta >= end) return;
int i, j, t;
i = sta;
j = end;
while (i != j) {
while (a[j] >= a[sta]) {
if (i >= j) break;
j--;
}
while (a[i] <= a[sta]) {
if (i >= j) break;
i++;
}
t = a[i];
a[i] = a[j];
a[j] = t;
}
t = a[sta];
a[sta] = a[i];
a[i] = t;
sort(sta, i - 1);
sort(i + 1, end);
}
void sort1() {
int i = 1, j1, j2, j;
for (i = 1; i <= n; i++) b[i] = a[i];
i = 1;
for (j = 1; j <= n; j += 2) {
a[j] = b[i++];
}
for (j = 2; j <= n; j += 2) {
a[j] = b[i++];
}
}
int main() {
int i;
while (scanf("%d", &n) != EOF) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(1, n);
sort1();
int flag = 1;
for (i = 2; i <= n; i++) {
if (i % 2 == 1) {
if (a[i - 1] < a[i]) {
flag = 0;
;
break;
}
} else {
if (a[i] < a[i - 1]) {
flag = 0;
break;
}
}
}
if (flag) {
for (i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
} else
printf("Impossible\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10 + 5;
bool t[N][N];
int r, c, n, k;
int main() {
cin >> r >> c >> n >> k;
int help1, help2;
for (int i = 0; i < n; ++i) {
cin >> help1 >> help2;
t[help1 - 1][help2 - 1] = true;
}
int help;
int ans = 0;
for (int x1 = 0; x1 < r; ++x1)
for (int y1 = 0; y1 < c; ++y1)
for (int x2 = x1; x2 < r; ++x2)
for (int y2 = y1; y2 < c; ++y2) {
help = 0;
for (int i = x1; i < x2 + 1; ++i)
for (int j = y1; j < y2 + 1; ++j)
if (t[i][j]) help++;
if (help >= k) ans++;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
int max_val = 0;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i], max_val = max(max_val, a[i]);
auto ck = [&](long long mid) {
double sum = 0;
for (int i = 0; i < n; ++i) {
if (!a[i]) continue;
long long x = mid - 1;
long long y = x + n - 1 - i;
x = min(y - x, x);
double temp = a[i];
for (long long j = 1; j <= x; ++j) {
temp = temp * (y - x + j) / j;
if (temp >= k) return 1;
}
sum += temp;
if (sum >= k) return 1;
}
return 0;
};
auto bf = [&]() {
if (max_val >= k) {
cout << 0 << '\n';
return;
}
long long l = 1, r = k;
while (l <= r) {
long long mid = (l + r) / 2;
if (ck(mid))
r = mid - 1;
else
l = mid + 1;
}
cout << l << '\n';
};
bf();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int K = 52 + 1;
const int N = 2e6;
const int INF = 1e9;
long long a[K][K], f[N], s[N];
vector<int> ans;
int getNum(char c) {
if (c >= 'a' && c <= 'z')
return 1 + c - 'a';
else
return 1 + 26 + (c - 'A');
}
char getChar(int n) {
if (n <= 26)
return (char)('a' + n - 1);
else
return (char)('A' + n - 26 - 1);
}
void solve(int n) {
long long m = n;
vector<long long> u(n + 1), v(m + 1), p(m + 1), way(m + 1);
for (int i = 1; i <= n; i++) {
p[0] = i;
long long j0 = 0;
vector<long long> minv(m + 1, INF);
vector<char> used(m + 1, false);
do {
used[j0] = true;
long long i0 = p[j0], delta = INF, j1;
for (int j = 1; j <= m; j++)
if (!used[j]) {
long long cur = a[i0][j] - u[i0] - v[j];
if (cur < minv[j]) minv[j] = cur, way[j] = j0;
if (minv[j] < delta) delta = minv[j], j1 = j;
}
for (int j = 0; j <= m; j++)
if (used[j])
u[p[j]] += delta, v[j] -= delta;
else
minv[j] -= delta;
j0 = j1;
} while (p[j0] != 0);
do {
long long j1 = way[j0];
p[j0] = p[j1];
j0 = j1;
} while (j0);
}
ans.assign(n + 1, 0);
for (int j = 1; j <= m; j++) ans[p[j]] = j;
}
int main() {
int n, k;
char c;
cin >> n >> k;
scanf("%c", &c);
for (int i = 0; i < n; i++) {
scanf("%c", &c);
f[i] = getNum(c);
}
scanf("%c", &c);
for (int i = 0; i < n; i++) {
scanf("%c", &c);
s[i] = getNum(c);
}
for (int i = 0; i < n; i++) a[f[i]][s[i]]++;
for (int i = 1; i <= k; i++)
for (int j = 1; j <= k; j++) a[i][j] = n - a[i][j];
solve(k);
int val = 0;
for (int i = 1; i <= k; i++) val += n - a[i][ans[i]];
cout << val << endl;
for (int i = 1; i <= k; i++) cout << getChar(ans[i]);
cout << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
const int maxn = 211111;
long long n, k, p[maxn], ans, cnt[maxn], phi[maxn], mu[maxn], f[maxn];
vector<int> h[maxn];
void cc(int x, int y) {
for (auto v : h[x]) {
int r = y / v;
for (auto vv : h[v]) cnt[vv] += mu[v / vv] * r;
}
}
long long pow_(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % M;
x = x * x % M;
y >>= 1;
}
return ret;
}
int main() {
cin >> n >> k;
for (int i = 1; i < maxn; i++) phi[i] = i;
mu[1] = 1;
for (int i = 1; i < maxn; i++)
for (int j = 2; j * i < maxn; j++) phi[i * j] -= phi[i], mu[i * j] -= mu[i];
for (int i = 1; i < maxn; i++)
for (int j = 1; j * i < maxn; j++) h[i * j].push_back(i);
for (int i = 1; i < n; i++) cc(i, n - i);
for (int i = n + 1; i <= n * 2 - 2; i++) {
int l, r;
l = i - n;
r = n - 1;
for (auto v : h[i]) {
int t = r / v - l / v;
for (auto vv : h[v]) f[vv] += mu[v / vv] * t;
}
for (auto v : h[i]) {
cnt[max(v, i - (int)n)] += f[v];
f[v] = 0;
}
}
for (int i = 0; i < maxn; i++) cnt[i] %= M;
for (int i = 0; i < maxn; i++) (ans += pow_(k, i) * cnt[i]) %= M;
long long inv = pow_(k, M - 2);
ans = ans * pow_(inv, n) % M;
cout << ans << endl;
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int n, w, m;
vector<pair<int, double> > v[55];
int main() {
cin >> n >> w >> m;
double sum = w * n / double(m);
double curCup = 0.0;
int cur = 0;
for (int i = 0; i < n; ++i) {
double curMilk = w;
if (curCup + curMilk - 1e-6 > sum) {
v[cur].push_back(make_pair(i, sum - curCup));
curMilk -= sum - curCup;
if (curMilk - 1e-6 > sum) {
cout << "NO" << endl;
return 0;
}
++cur;
if (cur == m) {
cout << "NO" << endl;
return 0;
}
curCup = curMilk;
v[cur].push_back(make_pair(i, curMilk));
if (fabs(curCup - sum) < 1e-6) {
++cur;
curCup = 0;
if (cur == m + 1) {
cout << "NO" << endl;
return 0;
}
}
} else {
curCup += curMilk;
v[cur].push_back(make_pair(i, curMilk));
if (fabs(curCup - sum) < 1e-6) {
++cur;
curCup = 0;
if (cur == m + 1) {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES" << endl;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < v[i].size(); ++j)
printf("%d %.6lf ", v[i][j].first + 1, v[i][j].second);
printf("\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 5;
const int inf = 1e8;
const double PI = acos(-1.0);
const long long mod = 100000007;
int n, k;
set<pair<int, int> > vis;
struct node {
int i, j, water;
void inti() {
i = 0;
j = 0;
water = -1;
}
};
queue<node> que;
node op1(node x) {
node ss = x;
ss.j--;
return ss;
}
node op2(node x) {
node ss = x;
ss.j++;
return ss;
}
node op3(node x) {
node ss = x;
if (ss.i == 1)
ss.i = 0;
else
ss.i = 1;
ss.j += k;
return ss;
}
node op4(node x) {
node ss = x;
if (ss.i == 1)
ss.i = 0;
else
ss.i = 1;
ss.j -= k;
return ss;
}
int main() {
bool flag = false;
string wall[2];
cin >> n >> k;
cin >> wall[0] >> wall[1];
n--;
node srt;
srt.inti();
vis.insert(make_pair(0, 0));
que.push(srt);
while (!que.empty() && !flag) {
node now = que.front();
que.pop();
node next1 = now;
node next;
next1.water = now.water + 1;
next = op1(next1);
if (!vis.count(make_pair(next.i, next.j)) && next.water < next.j) {
if (next.j > n) {
flag = true;
break;
}
if (next.j >= 0 && wall[next.i][next.j] == '-') {
que.push(next);
vis.insert(make_pair(next.i, next.j));
}
}
next = op2(next1);
if (!vis.count(make_pair(next.i, next.j)) && next.water < next.j) {
if (next.j > n) {
flag = true;
break;
}
if (next.j >= 0 && wall[next.i][next.j] == '-') {
que.push(next);
vis.insert(make_pair(next.i, next.j));
}
}
next = op3(next1);
if (!vis.count(make_pair(next.i, next.j)) && next.water < next.j) {
if (next.j > n) {
flag = true;
break;
}
if (next.j >= 0 && wall[next.i][next.j] == '-') {
que.push(next);
vis.insert(make_pair(next.i, next.j));
}
}
next = op4(next1);
if (!vis.count(make_pair(next.i, next.j)) && next.water < next.j) {
if (next.j > n) {
flag = true;
break;
}
if (next.j >= 0 && wall[next.i][next.j] == '-') {
que.push(next);
vis.insert(make_pair(next.i, next.j));
}
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int test(int xl, int yb, int xr, int yt) {
if (xl <= xr && xr <= n && xl >= 1 && yb <= yt && yt <= n && yb >= 1) {
printf("? %d %d %d %d\n", xl, yb, xr, yt);
fflush(stdout);
int t;
scanf("%d", &t);
return t;
} else
return 0;
}
int mxl, myb, mxr, myt;
void find(int xl, int yb, int xr, int yt) {
int l, r, mid;
l = xl, r = xr + 1;
while (l + 1 < r) {
mid = (l + r) >> 1;
if (test(mid, yb, xr, yt) == 1)
l = mid;
else
r = mid;
}
xl = l;
l = xl - 1, r = xr;
while (l + 1 < r) {
mid = (l + r) >> 1;
if (test(xl, yb, mid, yt) == 1)
r = mid;
else
l = mid;
}
xr = r;
l = yb, r = yt + 1;
while (l + 1 < r) {
mid = (l + r) >> 1;
if (test(xl, mid, xr, yt) == 1)
l = mid;
else
r = mid;
}
yb = l;
l = yb - 1, r = yt;
while (l + 1 < r) {
mid = (l + r) >> 1;
if (test(xl, yb, xr, mid) == 1)
r = mid;
else
l = mid;
}
yt = r;
mxl = xl;
myb = yb;
mxr = xr;
myt = yt;
return;
}
int xl, yb, xr, yt;
int main() {
cin >> n;
xl = yb = 1, xr = yt = n;
int l, r, mid, t, fl1 = 0, fl2 = 0;
l = xl - 1, r = xr + 1;
while (l + 1 < r) {
mid = (l + r) >> 1;
t = test(xl, yb, mid, yt);
if (t == 0)
l = mid;
else if (t == 2)
r = mid;
else {
fl1 = mid;
break;
}
}
l = 0, r = n + 1;
while (l + 1 < r) {
mid = (l + r) >> 1;
t = test(xl, yb, xr, mid);
if (t == 0)
l = mid;
else if (t == 2)
r = mid;
else {
fl2 = mid;
break;
}
}
int xl1, xr1, yb1, yt1, xl2, xr2, yb2, yt2;
if (fl1 != 0)
find(1, 1, fl1, n);
else
find(1, 1, n, fl2);
xl1 = mxl, xr1 = mxr, yb1 = myb, yt1 = myt;
if (test(xr1 + 1, 1, n, n) == 1)
find(xr1 + 1, 1, n, n);
else if (test(1, yt1 + 1, n, n) == 1)
find(1, yt1 + 1, n, n);
else if (test(1, 1, xl1 - 1, n) == 1)
find(1, 1, xl1 - 1, n);
else if (test(1, 1, n, yb1 - 1) == 1)
find(1, 1, n, yb1 - 1);
xl2 = mxl, xr2 = mxr, yb2 = myb, yt2 = myt;
printf("! %d %d %d %d %d %d %d %d\n", xl1, yb1, xr1, yt1, xl2, yb2, xr2, yt2);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
static long long ans;
static int N, K, D, pos[MAXN], val[MAXN], lft[MAXN], rgt[MAXN], num[MAXN << 2],
dsc[MAXN << 2];
static pair<int, int> bot[MAXN];
inline int get_dsc(int x) { return lower_bound(dsc, dsc + D, x) - dsc + 1; }
inline int lowbit(int x) { return x & -x; }
inline void modify(int p, int x) {
for (int i = p; i <= D; i += lowbit(i)) num[i] += x;
}
inline int query(int p) {
int ans = 0;
for (int i = p; i; i -= lowbit(i)) ans += num[i];
return ans;
}
void solve(int l, int r) {
if (l >= r) return;
int lm = (l + r) / 2, rm = lm + 1, fl = rm, fr = rm;
solve(l, lm);
solve(rm, r);
for (int i = l; i <= lm; i++) {
while (fl <= r && val[bot[fl].second] < val[bot[i].second] - K)
modify(pos[bot[fl++].second], -1);
while (fr <= r && val[bot[fr].second] <= val[bot[i].second] + K)
modify(pos[bot[fr++].second], +1);
ans += query(rgt[bot[i].second]) - query(lft[bot[i].second] - 1);
}
while (fl < fr) modify(pos[bot[fl++].second], -1);
static pair<int, int> tmp[MAXN];
int i = l, pl = l, pr = rm;
while (pl <= lm && pr <= r) {
if (val[bot[pl].second] < val[bot[pr].second])
tmp[i++] = bot[pl++];
else
tmp[i++] = bot[pr++];
}
while (pl <= lm) tmp[i++] = bot[pl++];
while (pr <= r) tmp[i++] = bot[pr++];
for (int j = l; j <= r; j++) bot[j] = tmp[j];
}
int main() {
scanf("%d%d", &N, &K);
for (int i = 0, rad; i < N; i++) {
scanf("%d%d%d", &pos[i], &rad, &val[i]);
dsc[D++] = pos[i];
dsc[D++] = lft[i] = pos[i] - rad;
dsc[D++] = rgt[i] = pos[i] + rad;
bot[i] = make_pair(rad, i);
}
sort(dsc, dsc + D);
sort(bot, bot + N);
D = unique(dsc, dsc + D) - dsc;
for (int i = 0; i < N; i++) {
pos[i] = get_dsc(pos[i]);
lft[i] = get_dsc(lft[i]);
rgt[i] = get_dsc(rgt[i]);
}
solve(0, N - 1);
printf("%lld\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long int Mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t-- > 0) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int e, f;
e = a + b;
f = d + c;
e = max(e, f);
cout << e << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef struct _Query {
int from, to, leftPt, rightPt;
} Query;
vector<Query> que;
map<pair<int, int>, vector<pair<int, int> > > mp;
long long int ans[300010], val;
int parent[300010 << 1], siz[2][300010 << 1], qNum;
stack<pair<int *, int> > stk;
int getParent(int cntPt) {
if (parent[cntPt] == cntPt) return cntPt;
return getParent(parent[cntPt]);
}
bool merge(int fstPt, int sndPt) {
fstPt = getParent(fstPt), sndPt = getParent(sndPt);
if (fstPt == sndPt) return false;
if (siz[0][fstPt] + siz[1][fstPt] < siz[0][sndPt] + siz[1][fstPt])
swap(fstPt, sndPt);
stk.push(make_pair(parent + sndPt, parent[sndPt]));
parent[sndPt] = fstPt;
for (int t = 0; t < 2; t++) {
stk.push(make_pair(siz[t] + fstPt, siz[t][fstPt]));
siz[t][fstPt] += siz[t][sndPt];
}
return true;
}
void undo() {
if (stk.empty()) return;
*stk.top().first = stk.top().second;
stk.pop();
}
void divideConquer(int leftPt, int rightPt, const vector<Query> &vec) {
int midPt = (leftPt + rightPt) >> 1, stkSiz = stk.size();
long long int prev = val;
vector<Query> leftVec, rightVec;
for (const auto &q : vec) {
if (q.leftPt == leftPt && q.rightPt == rightPt) {
int from = getParent(q.from << 1), to = getParent(q.to << 1 | 1);
if (from == to) continue;
val -= 1ll * siz[0][from] * siz[1][from] + 1ll * siz[0][to] * siz[1][to];
merge((q.from << 1), (q.to << 1 | 1));
from = getParent(q.from << 1);
val += 1ll * siz[0][from] * siz[1][from];
} else {
if (q.leftPt <= midPt)
leftVec.push_back(Query{q.from, q.to, q.leftPt, min(q.rightPt, midPt)});
if (q.rightPt > midPt)
rightVec.push_back(
Query{q.from, q.to, max(q.leftPt, midPt + 1), q.rightPt});
}
}
if (leftPt == rightPt) {
ans[leftPt] = val;
while ((int)stk.size() != stkSiz) undo();
val = prev;
return;
}
divideConquer(leftPt, midPt, leftVec);
divideConquer(midPt + 1, rightPt, rightVec);
while ((int)stk.size() != stkSiz) undo();
val = prev;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int len;
qNum = 0;
val = 0;
cin >> len;
for (int i = 0; i < (300010 << 1); i++)
parent[i] = i, siz[i & 1][i] = 1, siz[(i & 1) ^ 1][i] = 0;
for (int i = 0; i < len; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
auto &v = mp[make_pair(x, y)];
if (v.size() == 0 || v.back().second != len - 1)
v.push_back(make_pair(i, len - 1));
else
v.back().second = i - 1;
}
for (const auto &p : mp)
for (const auto &p1 : p.second)
que.push_back({p.first.first, p.first.second, p1.first, p1.second});
divideConquer(0, len - 1, que);
for (int i = 0; i < len; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
int len(long long x) {
int res = 0;
while (x) res++, x /= 10;
return res;
}
int last(long long x) { return x % 10; }
int first(long long x) {
int res = 0;
while (x) {
res = x % 10;
x /= 10;
}
return res;
}
long long in(long long n) {
vector<int> v;
while (n) v.push_back(n % 10), n /= 10;
v.pop_back();
for (int i = v.size() - 1; i > 0; i--) n *= 10, n += v[i];
return n;
}
long long solve(long long ll, long long rr) {
long long ans = 0;
if (ll == l && rr == r && len(l) < len(r)) {
long long a = len(ll);
a = ceil(pow(10, a)) - 1;
ans += solve(ll, a);
ans += solve(a + 1, rr);
} else if (len(ll) > len(l) && len(ll) < len(rr)) {
int a = len(ll), z = len(rr);
for (int i = a; i < z; i++) ans += 9 * ceil(pow(10, i - 2));
ans += solve(ceil(pow(10, z - 1)), rr);
} else if (len(ll) == len(rr)) {
if (len(ll) == 1)
ans += rr - ll + 1;
else {
long long a = ceil(pow(10, len(ll) - 2)), fl = first(ll), fr = first(rr);
for (int i = fl + 1; i < fr; i++) ans += a;
if (fl == fr) {
if (last(ll) <= first(ll) && last(rr) >= first(rr))
ans += in(rr)-in(ll) + 1;
else if (last(ll) <= first(ll) || last(rr) >= first(rr))
ans += in(rr)-in(ll);
else
ans += max(0ll, in(rr)-in(ll)-1);
} else {
long long x = a - 1;
if (last(ll) <= first(ll))
ans += x - in(ll) + 1;
else
ans += x - in(ll);
if (last(rr) >= first(rr))
ans += in(rr) + 1;
else
ans += in(rr);
}
}
}
return ans;
}
int main() {
cin >> l >> r;
cout << solve(l, r) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e18 + 9;
const int INF = 1e9 + 7;
const int SIZE = 2 * 1e5 + 10;
const long long MOD = 1e9 + 7;
int n, m, x, y, z, k, c, r, l;
long long lans;
int ans[5][5];
int toi[5] = {0, 0, 0, 1, -1};
int toj[5] = {0, 1, -1, 0, 0};
string second;
void solve() {
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> x;
if (x % 2 == 1)
for (int to = 0; to < 5; ++to) {
ans[i + 1 + toi[to]][j + 1 + toj[to]] =
!ans[i + 1 + toi[to]][j + 1 + toj[to]];
}
}
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
cout << !ans[i + 1][j + 1];
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int maxn = 1e6 + 10;
const int maxm = 1e5 + 10;
const int mod = 1e9 + 7;
const long long int INF = 1e18 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
using namespace std;
int a[maxn], ans[maxn], pre[maxn];
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
void Union(int x, int y) { pre[find(x)] = pre[find(y)]; }
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
for (int i = 0; i <= n; i++) pre[i] = i, ans[i] = 0;
for (int i = 1; i <= n; i++) cin >> a[i], Union(a[i], i);
for (int i = 1; i <= n; i++) ans[find(i)]++;
for (int i = 1; i <= n; i++)
printf("%d%c", ans[find(i)], i == n ? '\n' : ' ');
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool smin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int maxn = 1e5 + 10, maxA = 1e4 + 10, sq = 322;
int n, m, ar[maxn], cnt[sq][maxA], lz[sq];
bool mark[maxA];
vector<int> vc;
int g(int p) { return p / sq; }
void make(int v = 0) {
if (v >= maxA) return;
if (v) mark[v] = 1, vc.push_back(v);
make(v * 10 + 4);
make(v * 10 + 7);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> ar[i];
cnt[g(i)][ar[i]]++;
}
make();
while (m--) {
string typ;
cin >> typ;
if (typ[0] == 'c') {
int l, r;
cin >> l >> r;
int res = 0;
l--;
while (l < r) {
if (!(l % sq) && l + sq <= r) {
for (int e : vc) {
if (e - lz[g(l)] >= 0) res += cnt[g(l)][e - lz[g(l)]];
}
l += sq;
} else
res += (mark[ar[l] + lz[g(l)]]), ++l;
}
cout << res << '\n';
} else {
int l, r, d;
cin >> l >> r >> d;
l--;
while (l < r) {
if (!(l % sq) && l + sq <= r) {
lz[g(l)] += d;
l += sq;
} else {
cnt[g(l)][ar[l]]--;
ar[l] += d;
cnt[g(l)][ar[l]]++;
++l;
}
}
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a, b, v;
cin >> k >> a >> b >> v;
for (int i = 0; i < 1005; i++) {
int sect = min(i * k, b + i);
if (v * sect >= a) {
cout << i;
return 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int N = 2e5 + 5, mod = 998244353, M = 1e7 + 7;
const long long MAX = 5e18;
int n;
pair<int, int> a[N];
long long ans;
struct BIT {
long long s[N][2], sum[2];
void init() {
memset(s, 0, sizeof s);
sum[0] = sum[1] = 0;
}
void add(int x, int v) {
while (x < N) {
s[x][0] += v;
s[x][1]++;
x += x & -x;
}
sum[0] += v;
sum[1]++;
}
pair<long long, long long> lSum(int x) {
pair<long long, long long> c = {0, 0};
while (x) {
c.first += s[x][0];
c.second += s[x][1];
x -= x & -x;
}
return c;
}
pair<long long, long long> rSum(int x) {
pair<long long, long long> ret = lSum(x - 1);
ret.first = sum[0] - ret.first;
ret.second = sum[1] - ret.second;
return ret;
}
} p, nz;
void compress() {
map<int, int> mp[2];
set<int> s[2];
for (int i = 0; i < n; i++) {
if (a[i].second > 0)
s[0].insert(a[i].second);
else
s[1].insert(-a[i].second);
}
for (int i = 0; i < 2; i++) {
int c = 1;
for (int j : s[i]) mp[i][j] = c++;
}
for (int i = 0; i < n; i++) {
if (a[i].second > 0)
a[i].second = mp[0][a[i].second];
else
a[i].second = -mp[1][-a[i].second];
}
}
void add(pair<int, int> x) {
pair<long long, long long> s;
if (x.second > 0) {
s = p.rSum(x.second);
ans += s.first - s.second * x.first;
p.add(x.second, x.first);
} else {
x.second *= -1;
s = p.rSum(1);
ans += s.first - s.second * x.first;
s = nz.lSum(x.second);
ans += s.first - s.second * x.first;
nz.add(x.second, x.first);
}
}
int main() {
p.init();
nz.init();
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i].first);
for (int i = 0; i < n; i++) scanf("%d", &a[i].second);
sort(a, a + n);
compress();
for (int i = n - 1; i >= 0; i--) add(a[i]);
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x1, y1, x2, y2;
double ans = 0;
cin >> n >> k;
cin >> x1 >> y1;
for (int i = 1; i < n; i++) {
cin >> x2 >> y2;
ans += sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
x1 = x2;
y1 = y2;
}
printf("%.9lf\n", ans / 50 * k);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long int;
using ii = pair<int, int>;
using ii64 = pair<i64, i64>;
int f[27];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, l, k;
cin >> n >> l >> k;
string s;
cin >> s;
sort((s).begin(), (s).end());
for (int i = s.size() - 1; i >= 0; i--) f[s[i] - 'a'] = i;
int off = 0;
int order = k - 1;
vector<string> result(n);
while (result[k - 1].size() < l) {
char c = s[off + order];
for (int i = 0; i <= order; i++)
result[k - 1 - order + i].push_back(s[off + i]);
int cf = f[c - 'a'];
int norder = off + order - max(off, cf);
off += order + 1;
order = norder;
}
for (int i = 0; i < n; i++) {
while (result[i].size() < l) {
result[i].push_back(s[off]);
off++;
}
}
for (int i = 0; i < n; i++) cout << result[i] << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[(1 << 22) + 10], b[(1 << 22) + 10], c[(1 << 22) + 10], d[30];
void sc(int e) {
if (b[e]) sc(b[e]);
printf("%d ", c[e]);
}
int main() {
int e, f;
scanf("%d%d", &e, &f);
memset(a, 0x3f, sizeof(a));
for (int g = 1; g <= e; g++) d[g] = 1 << (g - 1);
for (int g = 1; g <= f; g++) {
int h, i;
scanf("%d%d", &h, &i);
d[h] |= 1 << (i - 1);
d[i] |= 1 << (h - 1);
}
if (f == e * (e - 1) / 2) {
printf("0\n");
return 0;
}
for (int g = 1; g <= e; g++) {
a[d[g]] = 1;
c[d[g]] = g;
}
for (int g = 1; g < 1 << e; g++) {
if (a[g] ^ 0x3f3f3f3f) {
for (int h = 1; h <= e; h++) {
if ((g >> (h - 1) & 1) && a[g | d[h]] > a[g] + 1) {
a[g | d[h]] = a[g] + 1;
b[g | d[h]] = g;
c[g | d[h]] = h;
}
}
}
}
printf("%d\n", a[(1 << e) - 1]);
sc((1 << e) - 1);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d = 0, t = 0, k;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
t = max(t, k = max(i + 1, a[i]));
if (i + 1 == t) d++;
}
cout << d;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t;
string isPalindrome(string str) {
string str1 = "";
t = 0;
int ln = str.length();
int ln1 = ln / 2;
if (ln % 2 == 0) {
ln1--;
}
for (int i = 0, j = ln - 1; i <= ln1; i++, j--) {
if (str[i] != str[j]) {
str1 += str[i];
t++;
j++;
} else {
str1 += str[i];
}
}
for (int i = ln / 2; i >= 0; i--) {
str1 += str[i];
}
return str1;
}
int main() {
string str;
cin >> str;
int ln = str.length();
string str1 = isPalindrome(str);
string str2 = "";
for (int i = str1.length() - 1; i >= 0; i--) str2 += str1[i];
if (str2 == str1 && t == 1) {
cout << str1 << endl;
return 0;
}
str2 = "";
for (int i = str.length() - 1; i >= 0; i--) {
str2 += str[i];
}
str1 = isPalindrome(str2);
string str3 = "";
for (int i = str1.length() - 1; i >= 0; i--) str3 += str1[i];
if (str1 == str3 && t == 1) {
cout << str1 << endl;
} else if (t > 1) {
cout << "NA" << endl;
} else {
for (int i = 0; i < ln; i++) {
if (ln / 2 == i) {
cout << str[i];
}
cout << str[i];
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INFLL = 1e18;
const int INF = 1e9 + 1;
const int MAXC = 1e6;
mt19937 gen(time(0));
vector<int> e(MAXC + 5);
void precalc() {
vector<int> p;
for (int i = 2; i <= MAXC; i++) {
if (e[i] == 0) {
e[i] = i;
p.emplace_back(i);
}
for (int j = 0; j < (int)p.size() && p[j] * i <= MAXC && p[j] <= e[i];
j++) {
e[p[j] * i] = p[j];
}
}
}
int f(int x) {
int ans = 1;
vector<int> p;
while (x > 1) {
p.emplace_back(e[x]);
x /= e[x];
}
for (int i = 0; i < (int)p.size(); i++) {
if (i + 1 == (int)p.size() || p[i + 1] != p[i]) ans *= p[i];
}
return ans;
}
void gauss(int need, vector<int> &lst, vector<int> &ans,
vector<vector<int>> &sz, vector<vector<vector<int>>> &v) {
int n = lst.size();
vector<bitset<20>> a(n);
for (int i = 0; i < n; i++) a[i] = lst[i];
bitset<20> b = need;
vector<bitset<260>> l(n);
for (int i = 0; i < n; i++) l[i][i] = 1;
int i = 0;
vector<int> col(20, -1);
int bas_sz = 0;
for (int j = 0; j < 20 && i < n; j++) {
int i1 = i;
while (i1 < n && a[i1][j] == 0) i1++;
if (i1 == n) continue;
swap(a[i], a[i1]);
swap(l[i], l[i1]);
bas_sz++;
col[j] = i;
for (int i2 = i + 1; i2 < n; i2++) {
if (a[i2][j]) {
a[i2] ^= a[i];
l[i2] ^= l[i];
}
}
i++;
}
bitset<20> res;
bitset<260> path;
for (int j = 0; j < 20; j++) {
if (res[j] != b[j] && col[j] == -1) {
exit(0);
}
if (res[j] == b[j]) continue;
res ^= a[col[j]];
path ^= l[col[j]];
}
if (a.back().count() != 0) {
for (int i = 0; i < n; i++) {
if (path[i]) ans.emplace_back(lst[i]);
}
return;
}
vector<int> diff_sz(300);
sz.emplace_back();
v.emplace_back();
for (int it = 0; it < 100; it++) {
bitset<260> now = path;
for (int i = 0; i < n - bas_sz; i++) {
if (gen() % 2) now ^= l[bas_sz + i];
}
int now_sz = now.count();
if (diff_sz[now_sz]) continue;
v.back().emplace_back();
for (int i = 0; i < n; i++) {
if (now[i]) v.back().back().emplace_back(lst[i]);
}
diff_sz[now_sz] = 1;
sz.back().emplace_back(now_sz);
}
}
vector<int> mem(2 * MAXC + 5, -1);
int query(int x) { return mem[f(x)]; }
void solve(int n, int c) {
vector<int> calc(c + 1);
vector<vector<int>> total(c + 1);
for (int x = 1; x <= c; x++) total[f(x)].emplace_back(x);
vector<int> need;
for (int x = 1; x <= c; x++) {
if (total[x].size()) need.emplace_back(x);
}
cout << need.size() << " ";
for (auto &c : need) cout << c << " ";
cout << endl;
for (auto &c : need) {
int x;
cin >> x;
mem[c] = x;
}
int total_xor = query(1);
for (int x = 1; x <= c; x++) {
if (total[x].empty()) continue;
for (int y = x; y <= c; y += x) calc[y] ^= (query(x) ^ total_xor);
}
calc[1] = total_xor;
for (int x = c; x >= 1; x--) {
if (total[x].empty()) continue;
for (int y = 2 * x; y <= c; y += x) {
if (total[y].size()) calc[x] ^= calc[y];
}
}
vector<int> ans;
vector<vector<int>> sz;
vector<vector<vector<int>>> v;
for (int x = 1; x <= c; x++) {
if (total[x].empty()) continue;
gauss(calc[x], total[x], ans, sz, v);
}
vector<bitset<40000>> bag(sz.size() + 1);
bag[0][0] = 1;
for (int i = 1; i <= (int)sz.size(); i++) {
for (auto &x : sz[i - 1]) {
bag[i] |= (bag[i - 1] << x);
}
}
int now = n - ans.size();
for (int i = (int)sz.size(); i >= 1; i--) {
for (int j = 0; j < (int)sz[i - 1].size(); j++) {
int x = sz[i - 1][j];
if (now - x >= 0 && bag[i - 1][now - x]) {
now -= x;
for (auto &y : v[i - 1][j]) ans.emplace_back(y);
break;
}
}
}
sort((ans).begin(), (ans).end());
for (auto &c : ans) cout << c << " ";
cout << endl;
}
int main() {
precalc();
int c, n;
cin >> c >> n;
solve(n, c);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(0) * 2;
const double EPS = 1e-8;
const long long MOD = 1e9 + 7;
const int MAXN = 3e5 + 5;
const int oo = 1e9;
const double foo = 1e30;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcounll(s);
}
template <class T>
T sqr(T x) {
return x * x;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first)
return a.first > b.first;
else
return a.second < b.second;
}
int n;
long long t[MAXN], w[MAXN];
vector<pair<long long, long long> > v;
priority_queue<pair<long long, long long> > st, has;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &t[i], &w[i]);
if (i) v.push_back(make_pair(t[i], w[i]));
}
pair<long long, long long> a = make_pair(t[0], w[0]);
v.push_back(make_pair(0, 0));
sort(v.begin(), v.end(), cmp);
int find = ((int)(v).size());
if (v[0].first <= a.first) {
cout << 1;
return 0;
}
int ans = n - 1;
long long ball = 0;
for (int i = 0; i < ((int)(v).size()); i++) {
if (v[i].first <= a.first) {
if (i && v[i].first == v[i - 1].first) {
long long rem = v[i].second - v[i].first + 1;
if (!st.empty()) {
long long cur = st.top().first;
if (cur > rem) {
ball = ball - cur + rem;
pair<long long, long long> gg = st.top();
st.pop();
st.push(make_pair(rem, i));
has.push(make_pair(-gg.first, gg.second));
} else
has.push(make_pair(-rem, i));
} else
has.push(make_pair(-rem, i));
} else {
long long chg = a.first - v[i].first;
while (!has.empty() && ball - has.top().first <= chg) {
pair<long long, long long> gg = has.top();
st.push(make_pair(-gg.first, gg.second));
has.pop();
ball -= gg.first;
}
long long rem = v[i].second - v[i].first + 1;
if (!st.empty()) {
long long cur = st.top().first;
if (cur > rem) {
ball = ball - cur + rem;
pair<long long, long long> gg = st.top();
st.pop();
st.push(make_pair(rem, i));
has.push(make_pair(-gg.first, gg.second));
} else
has.push(make_pair(-rem, i));
} else
has.push(make_pair(-rem, i));
}
int pos = i - st.size();
ans = min(ans, pos);
} else {
long long rem = v[i].second - v[i].first + 1;
has.push(make_pair(-rem, i));
}
}
cout << ans + 1;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
struct node {
int a, b, k, vt;
};
int n, m, res[MAX], cnt;
node data[MAX];
multimap<int, int> myMap;
multimap<int, int>::iterator itSet;
bool cmp(const node& x, const node& y) {
if (x.a != y.a) return x.a > y.a;
if (x.b != y.b) return x.b < y.b;
return x.k < y.k;
}
multimap<int, int>::iterator findSet(const int& val) {
if (myMap.empty()) return myMap.end();
multimap<int, int>::iterator res = myMap.lower_bound(val);
if (res == myMap.end() || res->first != val)
if (res == myMap.begin())
return myMap.end();
else
--res;
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> data[i].a >> data[i].b;
data[i].vt = i;
}
cin >> m;
for (int i = n + 1; i <= n + m; ++i) {
cin >> data[i].a >> data[i].b >> data[i].k;
data[i].vt = i - n;
}
sort(data + 1, data + 1 + n + m, cmp);
myMap.clear();
for (int i = 1; i <= n + m; ++i)
if (data[i].k) {
do {
map<int, int>::iterator it = findSet(data[i].b);
if (it == myMap.end()) break;
res[it->second] = data[i].vt;
++cnt;
myMap.erase(it);
--data[i].k;
} while (data[i].k);
} else {
myMap.insert(pair<int, int>(data[i].b, data[i].vt));
}
if (cnt < n)
cout << "NO";
else {
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << res[i] << ' ';
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long n, mx = 0, mn = 1e18;
int main() {
scanf("%lld", &n);
for (int i = 1; i * i * i <= n; i++) {
for (int j = 1; j * j * i <= n; j++) {
if (n % (i * j) == 0) {
long long a = i;
long long b = j;
long long c = n / (i * j);
mx = max(mx, (a + 1) * (b + 2) * (c + 2));
mx = max(mx, (b + 1) * (a + 2) * (c + 2));
mx = max(mx, (c + 1) * (a + 2) * (b + 2));
mn = min(mn, (a + 1) * (b + 2) * (c + 2));
mn = min(mn, (b + 1) * (a + 2) * (c + 2));
mn = min(mn, (c + 1) * (a + 2) * (b + 2));
}
}
}
cout << (mn - n) << " " << (mx - n) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, l, v1, v2, k;
cin >> d >> l >> v1 >> v2;
k = l - d;
k /= (v1 + v2);
printf("%.6f\n", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 2 == 0)
cout << n - 4 << " " << 4;
else
cout << n - 9 << " " << 9;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 7;
int n, m;
bool Prime[N];
int p[N >> 3], phi[N], mns[N], pin[N], tot, tnt[N];
void xxs(int x) {
phi[1] = 1;
for (int i = (2); i <= (x); ++i) {
if (!Prime[i]) p[++tot] = i, phi[i] = i - 1, pin[i] = 1;
for (int j = 1; j <= tot && p[j] * i <= x; j++) {
Prime[p[j] * i] = 1, mns[p[j] * i] = p[j], pin[p[j] * i] = pin[i] + 1,
tnt[p[j]]++;
if (i % p[j] == 0) {
phi[p[j] * i] = phi[i] * p[j], pin[p[j] * i]--;
break;
}
phi[p[j] * i] = phi[i] * (p[j] - 1);
}
}
}
long long ns;
int main() {
cin >> n, xxs(n);
int n2 = 0;
for (int i = (1); i <= (tot); ++i)
if (p[i] * 2 <= n) n2 = i;
ns += (long long)3 * n2 * (n2 - 1) / 2;
for (int i = (1); i <= (tot); ++i)
for (int j = (i + 1); j <= (tot); ++j) {
if ((long long)p[i] * p[j] > n) break;
ns--;
}
int hs = 0;
for (int i = (2); i <= (n); ++i)
if (Prime[i]) ++hs, ns -= i - phi[i] - pin[i] - 1;
ns += (long long)hs * (hs - 1);
ns += (long long)n2 * hs * 3;
for (int i = (1); i <= (tot); ++i)
for (int j = (1); j <= (tot); ++j) {
if ((long long)p[i] * p[j] > n) break;
ns -= tnt[p[j]];
}
for (int i = (1); i <= (tot); ++i) {
for (int j = p[i] * 2; j <= n; j += p[i]) {
if ((long long)mns[j] * p[i] <= n)
ns--;
else
ns++;
}
}
cout << ns << "\n";
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> a[150000];
map<long long, long long> t;
vector<int> v;
map<int, vector<int> > g;
void add(long long x, long long v) {
for (; x <= 1000000100; x |= (x + 1)) t[x] += v;
}
long long get(long long x) {
long long r = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) r += t[x], r %= 1000000007;
return r;
}
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.second < b.second) return 1;
if (a.second == b.second && a.first < b.first) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
g[y].push_back(x);
v.push_back(x);
v.push_back(y);
}
sort(v.begin(), v.end());
long long mod = 1000000007;
add(0, 1);
for (int i = 0; i < v.size(); ++i) {
if (i && v[i] == v[i - 1]) continue;
for (int j = 0; j < g[v[i]].size(); ++j) {
int u = g[v[i]][j];
long long x = get(v[i] - 1) - get(u - 1);
x %= mod;
x += mod;
x %= mod;
add(v[i], x);
}
}
cout << ((get(n) - get(n - 1)) % mod + mod) % mod << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1147483646;
const long long MX2 = 3223372036854775800;
const int MOD = 998244353;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
vector<pair<int, int> > v;
void ans() {
cout << "Possible\n";
for (pair<int, int> x : v) cout << x.first << " " << x.second << "\n";
exit(0);
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int i;
for (i = 2; i <= n; i++) {
v.push_back({1, i});
m--;
}
if (m < 0) goto fail;
if (m == 0) ans();
int j;
for (i = 2; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
if (gcd(i, j) == 1) {
v.push_back({i, j});
m--;
}
if (m == 0) ans();
if (i % 2 == 0) j++;
}
}
fail:
cout << "Impossible";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
if (n == 1) {
cout << "YES" << '\n';
cout << s[0] << '\n' << 0 << '\n';
return 0;
}
vector<int> id(n);
iota(id.begin(), id.end(), 0);
sort(id.begin(), id.end(), [&](int i, int j) { return s[i] < s[j]; });
for (int i = 1; i < n; i++) {
assert(s[i] != s[i - 1]);
}
vector<int> a(n), b(n);
int BLOCK = (n + 2) / 3;
for (int i = 0; i < BLOCK; i++) {
a[id[i]] = i;
b[id[i]] = s[id[i]] - a[id[i]];
}
for (int i = BLOCK; i < 2 * BLOCK; i++) {
b[id[i]] = i;
a[id[i]] = s[id[i]] - b[id[i]];
}
for (int i = 2 * BLOCK; i < n; i++) {
b[id[i]] = n - i - 1;
a[id[i]] = s[id[i]] - b[id[i]];
}
cout << "YES" << '\n';
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << a[i];
}
cout << '\n';
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << b[i];
}
cout << '\n';
for (int i = 0; i < n; i++) {
assert(a[i] + b[i] == s[i]);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long a[1010];
long long c[1010][1010];
void preDeal() {
c[0][0] = c[1][0] = c[1][1] = 1;
for (int i = 1; i < 1010; i++) {
c[i][i] = c[i][0] = 1;
for (int j = 1; j < i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
}
int main() {
int i;
long long k, sum, sum1;
preDeal();
while (scanf("%lld", &k) != EOF) {
sum1 = 1;
sum = 0;
for (i = 1; i <= k; i++) {
scanf("%lld", &a[i]);
sum += a[i];
}
for (i = k; i >= 1; i--) {
sum1 = (sum1 % 1000000007) * (c[sum - 1][a[i] - 1] % 1000000007);
sum1 = sum1 % 1000000007;
sum = sum - a[i];
}
printf("%lld\n", sum1 % 1000000007);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int LIM = 1e5;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<vector<int>> h(n, vector<int>(2));
vector<vector<long long>> dp(n, vector<long long>(2));
long long ans = 0;
for (int i = 0; i < 2; i++)
for (int j = 0; j < n; j++) cin >> h[j][i];
dp[0][0] = h[0][0];
dp[0][1] = h[0][1];
ans = max(dp[0][0], dp[0][1]);
for (int i = 1; i < n; i++) {
for (int j = 0; j < 2; j++) {
dp[i][j] = h[i][j];
;
if (i >= 2)
dp[i][j] += max({dp[i - 1][1 ^ j], dp[i - 2][0], dp[i - 2][1]});
else
dp[i][j] += dp[i - 1][1 ^ j];
ans = max(ans, dp[i][j]);
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long arr[(int)3e5 + 5];
bool solve(int num) {
for (int i = num; i < 1e6; i += num) {
int l = 0, r = n - 1, mid, ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (arr[mid] >= i && arr[mid] < i + num)
ans = arr[mid], l = mid + 1;
else if (arr[mid] >= i)
r = mid - 1;
else
l = mid + 1;
}
if (ans != -1 && ans % num > k) return false;
}
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = arr[0]; i >= 1; i--)
if (solve(i)) return cout << i, 0;
cout << 1;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 44;
int n, t[4 * N];
int getMax(int v, int vl, int vr, int l, int r) {
if (vl > r || vr < l)
return 0;
else if (vl >= l && vr <= r)
return t[v];
else {
int vm = vl + (vr - vl) / 2;
return max(getMax(2 * v + 1, vl, vm, l, r),
getMax(2 * v + 2, vm + 1, vr, l, r));
}
}
void update(int v, int vl, int vr, int ind, int val) {
if (vl == vr) {
t[v] = val;
} else {
int vm = vl + (vr - vl) / 2;
if (ind <= vm) {
update(2 * v + 1, vl, vm, ind, val);
} else {
update(2 * v + 2, vm + 1, vr, ind, val);
}
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<pair<int, pair<int, int>>> v;
vector<int> tmp;
for (int i = 0; i < n; i++) {
int x, w;
cin >> x >> w;
tmp.push_back(x);
tmp.push_back(x - w);
tmp.push_back(x + w);
v.push_back({x, {x - w, x + w}});
}
sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
for (int i = 0; i < v.size(); i++) {
v[i].first = lower_bound(tmp.begin(), tmp.end(), v[i].first) - tmp.begin();
v[i].second.first =
lower_bound(tmp.begin(), tmp.end(), v[i].second.first) - tmp.begin();
v[i].second.second =
lower_bound(tmp.begin(), tmp.end(), v[i].second.second) - tmp.begin();
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
int diff = v[i].second.first;
int mx = getMax(0, 0, N, 0, diff);
update(0, 0, N, v[i].second.second, mx + 1);
}
cout << getMax(0, 0, N, 0, N);
}
| 10 |
#include <bits/stdc++.h>
inline long long sbt(long long x) { return __builtin_popcount(x); }
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long res;
string s;
long long adj[200003][27];
long long lft[200003], rgt[200003];
long long p[200003];
long long slink[200003];
long long tv;
long long tp;
long long nd_idx;
long long la;
void add_leaf_r1(long long c) {
adj[tv][c] = nd_idx;
lft[nd_idx] = la;
p[nd_idx++] = tv;
tv = slink[tv];
tp = rgt[tv] + 1;
}
void split_the_edge() {
lft[nd_idx] = lft[tv];
rgt[nd_idx] = tp - 1;
p[nd_idx] = p[tv];
adj[nd_idx][s[tp] - 'a'] = tv;
}
void add_c_transition_leaf(long long c) {
adj[nd_idx][c] = nd_idx + 1;
lft[nd_idx + 1] = la;
p[nd_idx + 1] = nd_idx;
}
void go_down() {
while (tp <= rgt[nd_idx - 2]) {
tv = adj[tv][s[tp] - 'a'];
tp += rgt[tv] - lft[tv] + 1;
}
}
void st_iteration(long long c) {
slable:;
if (rgt[tv] < tp) {
if (adj[tv][c] == -1) {
add_leaf_r1(c);
goto slable;
}
tv = adj[tv][c];
tp = lft[tv];
}
if (tp == -1 || c == s[tp] - 'a') {
tp++;
} else {
split_the_edge();
add_c_transition_leaf(c);
lft[tv] = tp;
p[tv] = nd_idx;
adj[p[nd_idx]][s[lft[nd_idx]] - 'a'] = nd_idx;
nd_idx += 2;
tv = slink[p[nd_idx - 2]];
tp = lft[nd_idx - 2];
go_down();
if (tp == rgt[nd_idx - 2] + 1)
slink[nd_idx - 2] = tv;
else
slink[nd_idx - 2] = nd_idx;
tp = rgt[tv] - (tp - rgt[nd_idx - 2]) + 2;
goto slable;
}
}
void init_st(long long start_idx) {
tv = 0;
tp = 0;
nd_idx = start_idx;
fill(rgt, rgt + 200003, s.size() - 1);
memset(adj, -1, sizeof adj);
slink[0] = 1;
for (long long i = 0; i < start_idx; i++) {
lft[i] = -1;
rgt[i] = -1;
if (i) memset(adj[i], 0, sizeof adj[i]);
}
long long m = s.size();
for (la = 0; la < m; la++) st_iteration(s[la] - 'a');
}
long long l[200003], substring_starting[200003];
void dfs(long long i) {
bool isleaf = 1;
long long neeche = 0;
long long endings = 0;
for (long long ch = 0; ch <= 26; ch++) {
if (adj[i][ch] != -1) {
dfs(adj[i][ch]);
endings += l[adj[i][ch]];
neeche += substring_starting[adj[i][ch]];
isleaf = 0;
}
}
if (isleaf) {
l[i] = 1;
} else {
l[i] = endings;
}
long long no_of_substr_on_edge =
(rgt[i] - lft[i] + (rgt[i] != (s.size() - 1)));
substring_starting[i] = (no_of_substr_on_edge * l[i] * l[i]);
if (i) res += substring_starting[i];
}
long long n;
long long k, curr;
int32_t main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
memset(substring_starting, 0, sizeof substring_starting);
memset(l, 0, sizeof l);
cin >> s;
n = s.size();
s = s + '{';
n++;
res = 0;
init_st(2);
dfs(0);
cout << res << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
void enable_io() {}
template <typename T>
void debug(vector<T> v) {
for (auto it : v) {
cout << it << " ";
}
cout << endl;
}
int n, k;
vector<int> adj[1001];
void solve() {
for (int i = 0; i < 1001; i++) {
adj[i].clear();
}
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
string ans;
if (adj[k].size() <= 1) {
ans = "Ayush";
} else {
int rem = n - 3;
if (rem & 1) {
ans = "Ayush";
} else {
ans = "Ashish";
}
}
cout << ans << "\n";
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
enable_io();
int T = 1;
cin >> T;
for (int tid = 1; tid <= T; tid++) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int freq[1000005], arr[1000005], ans[1000005];
int main(void) {
int n, m, i, j, x, y, k;
cin >> n;
k = n + 1;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
for (i = 0; i < n; i++) {
for (j = 0; j <= n; j++) freq[j] = 0;
int maxTillNow = 0, idx = i;
for (j = i; j < n; j++) {
freq[arr[j]]++;
if (freq[arr[j]] > maxTillNow) {
maxTillNow = freq[arr[j]];
idx = j;
} else if (freq[arr[j]] == maxTillNow) {
if (arr[j] < arr[idx]) idx = j;
}
ans[arr[idx]]++;
}
}
for (i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 2e6 + 7;
const int lim = 2e5;
const int mod = 998244353;
const int inf = 0x3f3f3f3f;
int a[N];
int main() {
int n, k, t = 1, sum = 0, ans;
scanf("%d%d", &n, &k);
while (k > t) k -= t, t++;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
if (i == k) ans = x;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, k = 1, ans, d = 1, jog;
string s1, s2;
int main() {
cin >> l >> r;
for (int i = 1; i <= 63; i++) {
if (l & k)
s1 += '1';
else
s1 += '0';
if (r & k)
s2 += '1';
else
s2 += '0';
k *= 2;
}
reverse(s1.begin(), s1.end());
reverse(s2.begin(), s2.end());
while (1) {
int q = 0;
if (s1[q] == s2[q] && s1[q] == '0') {
s1.erase(0, 1);
s2.erase(0, 1);
} else
break;
}
while (1) {
int q = 0;
if (s1[q] == s2[q]) {
s1.erase(0, 1);
s2.erase(0, 1);
} else
break;
if (s1 == "") break;
}
for (int i = 0; i < s2.size(); i++)
if (s2[i] == '1') {
ans = s2.size() - i;
break;
}
for (int i = 1; i <= ans; i++) {
jog += d;
d *= 2;
}
cout << jog;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void sc(int& a) { scanf("%d", &a); }
void sc(long long int& a) { scanf("%lld", &a); }
void sc(int& a, int& b) {
sc(a);
sc(b);
}
void sc(long long int& a, long long int& b) {
sc(a);
sc(b);
}
void sc(int& a, int& b, int& c) {
sc(a, b);
sc(c);
}
void sc(long long int& a, long long int& b, long long int& c) {
sc(a, b);
sc(c);
}
void prl(int a) { printf("%d\n", a); }
void prl(long long int a) { printf("%lld\n", a); }
void prl() { printf("\n"); }
void prs(int a) { printf("%d ", a); }
void prs(long long int a) { printf("%lld ", a); }
void prl(long long int a, long long int b) {
cout << a << " " << b << " " << endl;
}
void prl(long long int a, long long int b, long long int c) {
cout << a << " " << b << " " << c << " " << endl;
}
void prl(long long int a, long long int b, long long int c, long long int d) {
cout << a << " " << b << " " << c << " " << d << endl;
}
void prl(long long int a, long long int b, long long int c, long long int d,
long long int e) {
cout << a << " " << b << " " << c << " " << d << " " << e << endl;
}
void prl(long long int a, long long int b, long long int c, long long int d,
long long int e, long long int f) {
cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << endl;
}
int mod = 1000000007;
long long int modpow(long long int a, long long int b, long long int mod) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b / 2;
}
return res % mod;
}
int dist[200000 + 5], minn[200000 + 5];
pair<int, int> p[200000 + 5];
vector<int> v;
int main() {
int d, n, m, flag = 0;
sc(d, n, m);
for (int i = 1; i <= m; i++) {
sc(p[i].first, p[i].second);
}
sort(p + 1, p + m + 1);
p[m + 1] = make_pair(d, 0);
v.push_back(1);
for (int i = 1; i <= m; i++) minn[i] = INT_MAX;
int i = 2;
while (i <= m) {
if (v.empty()) {
v.push_back(i);
i++;
continue;
}
if (p[i].second > p[v.back()].second) {
v.push_back(i);
i++;
continue;
}
while (!v.empty() and p[i].second <= p[v.back()].second) {
minn[v.back()] = i;
v.pop_back();
}
v.push_back(i);
i++;
}
long long int ans = 0, curr_fuel = n, fuel_bought, dist_to_next_station,
dist_to_dest;
for (int i = 1; i <= m + 1; i++) {
if (p[i].first - p[i - 1].first > curr_fuel) {
prl(-1);
return 0;
}
if (i == m + 1) break;
curr_fuel -= (p[i].first - p[i - 1].first);
int next_station = minn[i];
if (next_station == INT_MAX) {
dist_to_dest = p[m + 1].first - p[i].first;
if (curr_fuel >= dist_to_dest)
fuel_bought = 0;
else
fuel_bought = min(dist_to_dest - curr_fuel, n - curr_fuel);
curr_fuel += fuel_bought;
ans += 1LL * fuel_bought * p[i].second;
} else {
dist_to_next_station = p[next_station].first - p[i].first;
if (curr_fuel >= dist_to_next_station)
fuel_bought = 0;
else
fuel_bought = dist_to_next_station - curr_fuel;
fuel_bought = min(fuel_bought, n - curr_fuel);
curr_fuel += fuel_bought;
ans += 1LL * fuel_bought * p[i].second;
}
}
prl(ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int cont = -1;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
if (i % 2 != 0)
cout << '#';
else {
if (cont % 2 != 0) {
if (j == m)
cout << "#";
else
cout << ".";
} else {
if (j == 1)
cout << "#";
else
cout << ".";
}
if (j == m) cont++;
}
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
const long double PI = 3.141592653589793236L;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
cin >> t;
while (t--) {
long double n, ans;
cin >> n;
ans = 1 / tan(PI / 2 / n);
printf("%Lf\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
stack<pair<int, int>> lef, rig;
long long n, arr[maxn], l[maxn], r[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
while (lef.size() && lef.top().first > arr[i]) {
lef.pop();
}
if (lef.empty()) {
l[i] = (i + 1) * arr[i];
} else {
int j = lef.top().second;
l[i] = l[j] + (i - j) * arr[i];
}
lef.push({arr[i], i});
}
for (int i = n - 1; i >= 0; i--) {
while (rig.size() && rig.top().first > arr[i]) {
rig.pop();
}
if (rig.empty()) {
r[i] = (n - i) * arr[i];
} else {
int j = rig.top().second;
r[i] = r[j] + (j - i) * arr[i];
}
rig.push({arr[i], i});
}
long long value = 0, index = 0;
for (int i = 0; i < n; i++) {
if (l[i] + r[i] - arr[i] > value) {
value = l[i] + r[i] - arr[i];
index = i;
}
}
for (int i = index - 1; i >= 0; i--) {
arr[i] = min(arr[i + 1], arr[i]);
}
for (int i = index + 1; i < n; i++) {
arr[i] = min(arr[i - 1], arr[i]);
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s, string t) {
if (s == t) return true;
int l = s.length();
int m = s.length();
if (l & 1 || l == 0 || m == 0 || m & 1) return false;
if (check(s.substr(0, l / 2), t.substr(m / 2, m / 2)) &&
check(s.substr(l / 2, l / 2), t.substr(0, m / 2)))
return true;
if (check(s.substr(0, l / 2), t.substr(0, m / 2)) &&
check(s.substr(l / 2, l / 2), t.substr(m / 2, m / 2)))
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
int l = s.length();
if (check(s, t))
cout << "YES";
else
cout << "NO";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, z = 0, o = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '0')
z++;
else
o++;
}
if (o != z)
cout << 1 << endl << s;
else {
cout << 2 << endl << s[0] << " ";
for (int i = 1; i <= n - 1; i++) {
cout << s[i];
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans[100010];
int main() {
while (scanf("%d", &n) == 1) {
int i;
if ((n & 3) == 2 || (n & 3) == 3) {
puts("-1");
continue;
}
for (i = 1; i <= n / 2; i += 2) {
ans[i] = i + 1, ans[n - i + 1] = n - i;
ans[i + 1] = n - i + 1, ans[n - i] = i;
}
if (n & 1) ans[(n + 1) >> 1] = (n + 1) >> 1;
for (i = 1; i < n; i++) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 2E+9;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
if (n == 1 && m == 2) {
cout << 0 << endl;
cout << 1 << " " << 1 << endl;
cout << 1 << " " << 2 << endl;
cout << 1 << " " << 1 << endl;
return 0;
}
if (m == 1 && n == 2) {
cout << 0 << endl;
cout << 1 << " " << 1 << endl;
cout << 2 << " " << 1 << endl;
cout << 1 << " " << 1 << endl;
return 0;
}
if (n == 1) {
cout << 1 << endl;
cout << 1 << " " << m << " " << 1 << " " << 1 << endl;
for (long long int i = 1; i <= m; i++) cout << 1 << " " << i << endl;
cout << 1 << " " << 1 << endl;
return 0;
} else if (m == 1) {
cout << 1 << endl;
cout << n << " " << 1 << " " << 1 << " " << 1 << endl;
for (long long int i = 1; i <= n; i++) cout << i << " " << 1 << endl;
cout << 1 << " " << 1 << endl;
return 0;
}
if (n % 2 == 0) {
cout << 0 << endl;
for (long long int i = 1; i <= n; i++) cout << i << " " << 1 << endl;
for (long long int i = n; i >= 1; i--) {
if ((n - i) % 2 == 0) {
for (long long int j = 2; j <= m; j++) cout << i << " " << j << endl;
} else {
for (long long int j = m; j >= 2; j--) {
cout << i << " " << j << endl;
}
}
}
} else if (m % 2 == 0) {
cout << 0 << endl;
for (long long int j = 1; j <= m; j++) cout << 1 << " " << j << endl;
for (long long int j = m; j >= 1; j--) {
if ((m - j) % 2 == 0) {
for (long long int i = 2; i <= n; i++) cout << i << " " << j << endl;
} else {
for (long long int i = n; i >= 2; i--) {
cout << i << " " << j << endl;
}
}
}
} else {
cout << 1 << endl;
cout << 1 << " " << m << " " << 1 << " " << 1 << endl;
for (long long int i = 1; i <= n; i++) cout << i << " " << 1 << endl;
for (long long int i = n; i >= 1; i--) {
if ((n - i) % 2 == 0) {
for (long long int j = 2; j <= m; j++) cout << i << " " << j << endl;
} else {
for (long long int j = m; j >= 2; j--) {
cout << i << " " << j << endl;
}
}
}
}
cout << 1 << " " << 1 << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, f[2 * 100005], res = 0, Max = 0;
pair<int, int> a[100005];
vector<int> x;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
a[i].second--;
x.push_back(a[i].first);
x.push_back(a[i].second);
}
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 1; i <= n; i++) {
int b = lower_bound(x.begin(), x.end(), a[i].first) - x.begin() + 1;
int c = lower_bound(x.begin(), x.end(), a[i].second) - x.begin() + 1;
f[b]++;
f[c + 1]--;
}
for (int i = 1; i <= 2 * n; i++) {
f[i] += f[i - 1];
if (f[i] > Max) {
Max = f[i];
res = i;
}
}
for (int i = 1; i <= n; i++) {
int b = lower_bound(x.begin(), x.end(), a[i].first) - x.begin() + 1;
if (b == res) {
res = a[i].first;
break;
}
b = lower_bound(x.begin(), x.end(), a[i].second) - x.begin() + 1;
if (b == res) {
res = a[i].second;
break;
}
}
cout << res << " " << Max;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long exp, long long mod = (1000000007LL)) {
long long res = 1;
while (exp > 0) {
if (exp % 2) {
res = (res * base) % mod;
}
base = (base * base) % mod;
exp /= 2;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
gcd(b, a % b);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
inline string rs() {
char x[1234567];
scanf("%s", x);
string s = x;
return s;
}
inline int ri() {
int x;
scanf("%d", &x);
return x;
}
inline long long rl() {
long long x;
scanf("%lld", &x);
return x;
}
const int N = 12345;
int main() {
long long a, b;
scanf("%lld %lld", &a, &b);
if (b - a > 10) {
return 0 * puts("0");
}
long long ans = 1;
for (long long i = a + 1; i <= b; ++i) {
ans = ((ans % 10) * (i % 10)) % 10;
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int tc = 0; tc < t; ++tc) {
int n;
cin >> n;
int len = 2;
while (len * (len + 1) / 2 <= n) ++len;
n -= len * (len - 1) / 2;
assert(n >= 0);
assert(n <= 45000);
string s = "133";
while (n > 0) {
--n;
s += "7";
}
len -= 2;
while (len > 0) {
--len;
s += "3";
}
s += "7";
cout << s << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int len, k;
void sw(string &str, int k) {
string ss = str.substr(0, k + 1);
reverse(ss.begin(), ss.end());
for (int i = 0; i <= k; i++) str[i] = ss[i];
}
int main() {
string str;
scanf("%d", &len);
scanf("%d", &k);
cin >> str;
map<char, int> make_pair;
for (int i = 0; i < len; ++i) {
make_pair[str[i]] += 1;
}
char lim;
bool flag = true;
int del = 0;
long long int sum = 0;
char i;
for (i = 'a'; i <= 'z'; ++i) {
sum += make_pair[i];
if (sum == k) {
lim = i;
del = 0;
break;
}
if (sum > k) {
lim = i - 1;
sum -= make_pair[i];
del = k - sum;
break;
}
}
if (i > 'z' && sum <= k) {
cout << "\n";
return 0;
}
for (int i = 0; i < len; ++i) {
if (str[i] >= 'a' && str[i] <= lim) str[i] = '?';
}
int p = 0;
for (int i = 0; p < del && i < len; ++i) {
if (str[i] == lim + 1) {
str[i] = '?';
++p;
}
}
for (int i = 0; i < len; ++i) {
if (str[i] != '?') cout << str[i];
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char ss[100];
int main() {
cin >> ss;
int ans = 0;
for (int i = 0; i < strlen(ss); i++) {
if (ss[i] == 'a' || ss[i] == 'e' || ss[i] == 'i' || ss[i] == 'o' ||
ss[i] == 'u') {
ans++;
} else if (ss[i] == '1' || ss[i] == '3' || ss[i] == '5' || ss[i] == '7' ||
ss[i] == '9') {
ans++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, result = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i] == 0 && arr[i + 1] == 1 && arr[i - 1] == 1) {
result++;
if (arr[i + 2] == 0 && arr[i + 3] == 1) {
i += 3;
}
}
}
cout << result << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
string s, s1;
long long t, n, k, mit, pal, l;
vector<pair<long long, long long> > p;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
cin >> s;
s1 = "";
for (int i = 0; i < k - 1; i++) s1 += "()";
for (int i = 0; i < n / 2 - (k - 1); i++) s1 += "(";
for (int i = 0; i < n / 2 - (k - 1); i++) s1 += ")";
p.resize(0);
for (int i = n - 1; i >= 0; i--)
if (s[i] != s1[i]) {
l = i;
while (s[l] != s1[i]) l--;
p.push_back({l + 1, i + 1});
swap(s[i], s[l]);
}
cout << p.size() << "\n";
for (int i = 0; i < p.size(); i++)
cout << p[i].first << " " << p[i].second << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> g[N];
int n, m, depth[N], chain[N];
pair<int, int> edges[N];
set<int> white[N];
void dfs(int u, int pa, int chain_id, int dpth = 1) {
depth[u] = dpth;
chain[u] = chain_id;
for (int v : g[u]) {
if (v == pa) continue;
dfs(v, u, chain_id, dpth + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
edges[i] = {u, v};
}
int root = 0, mx_edges = 0;
for (int i = 1; i <= n; i++) {
if (g[i].size() > mx_edges) {
root = i;
mx_edges = g[i].size();
}
}
for (int i = 0; i < g[root].size(); i++) {
dfs(g[root][i], root, i);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int id;
scanf("%d", &id);
id--;
int u = edges[id].first;
int v = edges[id].second;
if (v == root) swap(u, v);
if (u == root) {
int chain_id = chain[v];
white[chain_id].erase(depth[v]);
} else {
white[chain[u]].erase(max(depth[u], depth[v]));
}
} else if (type == 2) {
int id;
scanf("%d", &id);
id--;
int u = edges[id].first;
int v = edges[id].second;
if (v == root) swap(u, v);
if (u == root) {
int chain_id = chain[v];
white[chain_id].insert(depth[v]);
} else {
white[chain[u]].insert(max(depth[u], depth[v]));
}
} else {
int u, v;
scanf("%d%d", &u, &v);
if (depth[u] > depth[v]) swap(u, v);
if (chain[u] == chain[v]) {
auto it = white[chain[u]].lower_bound(depth[u] + 1);
if (it == white[chain[u]].end() || *it > depth[v])
printf("%d\n", depth[v] - depth[u]);
else
printf("-1\n");
} else {
auto it1 = white[chain[u]].lower_bound(1);
auto it2 = white[chain[v]].lower_bound(1);
if (it1 == white[chain[u]].end() || *it1 > depth[u]) {
if (it2 == white[chain[v]].end() || *it2 > depth[v]) {
printf("%d\n", depth[u] + depth[v]);
} else
printf("-1\n");
} else
printf("-1\n");
}
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int p[N];
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
int main() {
int n, m;
cin >> n >> m;
vector<int> val[m];
int disc[n];
int ans = n - 1;
for (int i = 0; i < m; i++) p[i] = i;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
disc[i] = x;
ans -= (i && disc[i] == disc[i - 1]);
val[disc[i]].push_back(i);
}
cout << ans << '\n';
for (int i = 0; i < m - 1; i++) {
int u, v;
cin >> u >> v;
u = find(u - 1), v = find(v - 1);
if (val[u].size() < val[v].size()) swap(u, v);
for (int x : val[v]) {
if (x) ans -= disc[x - 1] == u;
if (x < n - 1) ans -= disc[x + 1] == u;
}
for (int x : val[v]) {
val[u].push_back(x);
disc[x] = u;
}
p[v] = u;
cout << ans << '\n';
}
return 0;
}
| 15 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.