solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
unsigned int powmod(unsigned int a, unsigned int b) {
unsigned int res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
a = a * a;
}
return res;
}
const int N = 111111, M = 111111;
int l, m, n, t, C, f[N];
char s[N];
int main() {
scanf("%d%s", &n, s + 1);
f[0] = 1;
int cnt = n, m = n / 2;
for (int _tmp = n, i = 1; i <= _tmp; ++i)
if (s[i] == '?') {
for (int _tmp = i - m < 0 ? 0 : i - m, j = i >> 1; j >= _tmp; --j)
f[j] += f[j - 1];
--cnt;
}
if (n & 1 || cnt > m)
puts("0");
else
printf("%u\n", f[m] * powmod(25, m - cnt));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, v;
bool operator<(const node& tt) const {
if (l == tt.l) return r < tt.r;
return l < tt.l;
}
} con[100008];
int ans[100008], rec[35][100008];
int main() {
int n, m, i, j, k;
bool f = true;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) scanf("%d%d%d", &con[i].l, &con[i].r, &con[i].v);
sort(con, con + m);
memset(ans, 0, sizeof(ans));
memset(rec, 0, sizeof(rec));
for (i = 0; i < 30; i++) {
k = 0;
for (j = 0; j < m; j++)
if ((con[j].v & (1 << i)) && con[j].r > k) {
for (k = max(k, con[j].l - 1); k < con[j].r; k++) {
ans[k] |= 1 << i;
rec[i][k] = 1;
}
}
}
for (i = 0; i < 30 && f; i++) {
for (j = 1; j < n; j++) rec[i][j] += rec[i][j - 1];
for (j = 0; j < m && f; j++)
if (!(con[j].v & (1 << i))) {
int tp = rec[i][con[j].r - 1];
if (con[j].l > 1) tp -= rec[i][con[j].l - 2];
if (tp == con[j].r - con[j].l + 1) f = false;
}
}
if (f) {
puts("YES");
for (i = 0; i < n; i++) printf("%d ", ans[i]);
} else
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int A[200005];
int ad[200005];
int sub[200005];
map<int, int> know;
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", A + i);
know[A[i]]++;
}
int M;
scanf("%d", &M);
for (int i = 0; i < M; i++) {
scanf("%d", ad + i);
}
for (int i = 0; i < M; i++) {
scanf("%d", sub + i);
}
int max1 = 0;
int half = 0;
int index = 0;
for (int i = 0; i < M; i++) {
int pleas = know[ad[i]];
int almost = know[sub[i]];
if (pleas > max1) {
max1 = pleas;
half = almost;
index = i;
} else if (pleas == max1 && almost > half) {
half = almost;
index = i;
}
}
printf("%d", index + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 0, n, m, k;
cin >> n >> m >> k;
int i, j;
vector<vector<char> > O(n + 1, vector<char>(m));
vector<vector<int> > A(n + 1, vector<int>(m + 1));
vector<vector<int> > B(n + 1, vector<int>(m + 1));
for (i = 1; i <= n; i++) {
for (j = 0; j < m; j++) cin >> O[i][j];
}
for (i = 2; i < n; i++)
for (j = 1; j < m - 1; j++)
if (O[i][j] == '1' && O[i][j - 1] == '1' && O[i][j + 1] == '1' &&
O[i - 1][j] == '1' && O[i + 1][j] == '1')
A[i][j + 1] = 1;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) A[i][j] = A[i][j] + A[i][j - 1];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) B[i][j] = B[i - 1][j] + A[i][j];
}
j = 1;
for (int d = 1; d <= n - 2; d++) {
for (int z = 2; z <= n; z++) {
j = 1;
for (i = 1; i <= m; i++) {
while (j <= m &&
B[z - 1][j - 1] + B[d][i] - B[z - 1][i] - B[d][j - 1] < k)
j++;
if (j > m) {
break;
}
ans += m - j + 1;
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int maxk = 5000 + 5;
const long long INF = 1LL << 60;
long long dp[3][maxk];
int a[maxn];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
sort(a, a + n);
int cnt1 = n % k, cnt2 = k - cnt1;
for (int i = 0; i < 2; ++i) {
fill(dp[i], dp[i] + cnt2 + 1, INF);
}
dp[0][0] = 0;
for (int i = 0; i <= cnt1; ++i) {
for (int j = 0; j <= cnt2; ++j) {
if (i == cnt1 && j == cnt2) {
printf("%I64d\n", dp[i & 1][j]);
}
int temp = i * (n / k + 1) + j * (n / k);
if (i < cnt1) {
dp[i & 1 ^ 1][j] =
min(dp[i & 1 ^ 1][j], dp[i & 1][j] + a[temp + n / k] - a[temp]);
}
if (j < cnt2) {
dp[i & 1][j + 1] = min(dp[i & 1][j + 1],
dp[i & 1][j] + a[temp + n / k - 1] - a[temp]);
}
dp[i & 1][j] = INF;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + (c - '0'), c = getchar();
return f * x;
}
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
template <typename T>
bool umax(T& a, T t) {
if (t > a) return a = t, 1;
return 0;
}
template <typename T>
bool umin(T& a, T t) {
if (t < a) return a = t, 1;
return 0;
}
const int MAXN = 1000011, mod = 1e9 + 7;
inline int S(int x) { return x < mod ? x : x - mod; }
char s[MAXN], tp[MAXN];
int f[MAXN], ed[MAXN];
namespace PTree {
int t[MAXN][26], fail[MAXN], len[MAXN], top[MAXN], sig[MAXN];
int last, tot, now;
void init() { last = tot = 1, len[0] = -1, top[0] = 0; }
int extend(int w) {
int pos = last;
while (pos && s[now - len[pos]] - 'a' != w) pos = fail[pos];
if (!t[pos][w]) {
t[pos][w] = ++tot, len[tot] = len[pos] + 2;
if (!pos)
fail[tot] = 1, top[tot] = tot;
else {
pos = fail[pos];
while (pos && s[now - len[pos]] - 'a' != w) pos = fail[pos];
fail[tot] = t[pos][w];
top[tot] =
(len[tot] - len[fail[tot]] == len[fail[tot]] - len[fail[fail[tot]]]
? top[fail[tot]]
: tot);
}
last = tot;
} else
last = t[pos][w];
++now;
return last;
}
void solve() {
int n = now;
f[0] = 1;
for (int i = 1; i <= n; ++i)
for (int x = ed[i]; x > 1; x = fail[top[x]]) {
sig[x] =
top[x] == x ? f[i - len[x]] : S(sig[fail[x]] + f[i - len[top[x]]]);
if (!(i & 1)) f[i] = S(f[i] + sig[x]);
}
printf("%d\n", f[n]);
}
} // namespace PTree
int main() {
scanf("%s", tp + 1);
int n = strlen(tp + 1);
for (int i = 1; i <= (n >> 1); ++i) s[2 * i - 1] = tp[i];
for (int i = n; i > (n >> 1); --i) s[2 * (n - i + 1)] = tp[i];
PTree::init();
for (int i = 1; i <= n; ++i) ed[i] = PTree::extend(s[i] - 'a');
PTree::solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
int arr[t][t];
for (int i = 0; i < t; i++) {
arr[i][0] = 1;
arr[0][i] = 1;
}
for (int i = 1; i < t; i++) {
for (int j = 1; j < t; j++) {
arr[i][j] = arr[i - 1][j] + arr[i][j - 1];
}
}
cout << arr[t - 1][t - 1] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-9;
const int INF = 1E9;
const int MAXN = 111;
int n, m, q;
pair<int, int> a[MAXN][MAXN];
int res[MAXN][MAXN];
int id, p, r, x;
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) a[i][j] = {i, j};
for (int i = 0; i < (int)(q); i++) {
scanf("%d", &id);
if (id == 1) {
scanf("%d", &p);
p--;
pair<int, int> tmp = a[p][0];
for (int j = 0; j < m - 1; j++) a[p][j] = a[p][j + 1];
a[p][m - 1] = tmp;
} else if (id == 2) {
scanf("%d", &p);
p--;
pair<int, int> tmp = a[0][p];
for (int j = 0; j < n - 1; j++) a[j][p] = a[j + 1][p];
a[n - 1][p] = tmp;
} else {
scanf("%d%d%d", &p, &r, &x);
p--, r--;
res[a[p][r].first][a[p][r].second] = x;
}
}
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++)
printf("%d%c", res[i][j], " \n"[j == m - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
optimizeIO();
long long int a, b, mod = 1000000007;
cin >> a >> b;
long long int t3, t2, t1 = ((b) * (b - 1) / 2) % mod;
t2 = ((a) * (a + 1) / 2) % mod;
t3 = (t2 * b + a) % mod;
long long int ans;
ans = (t1 * t3) % mod;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int TAM = 2e5 + 5;
long long n, m, k, l;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> l;
long long cant = (l + k + m - 1) / m;
if (cant * m > n)
cout << -1 << endl;
else
cout << cant << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int par[1000010];
int val[1000010];
int ch[1000010];
int same[1000010];
int ans = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
ch[1] = 0;
for (int i = 2; i <= n + 1; i++) {
cin >> par[i];
}
ans = 0;
for (int i = 2; i <= n + 1; i++) {
val[i] = 1;
same[i] = 0;
ch[i] = 0;
ch[par[i]]++;
int cur = i;
while (par[cur] != 1) {
if (val[par[cur]] == val[cur]) {
if (same[par[cur]] == 0) {
same[par[cur]]++;
break;
}
same[par[cur]] = 0;
val[par[cur]]++;
cur = par[cur];
} else if (val[par[cur]] < val[cur]) {
val[par[cur]] = val[cur];
same[par[cur]] = 1;
cur = par[cur];
} else
break;
}
if (par[cur] == 1) ans = max(ans, val[cur]);
cout << ans << " ";
}
cout << endl;
cin >> ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class heap : public priority_queue<T, vector<T>, greater<T> > {};
pair<int, int> operator+(const pair<int, int> x, const pair<int, int> y) {
return {x.first + y.first, x.second + y.second};
}
int mapa[210][210];
int visited[210][210];
int deg[210][210];
int deg2[210][210];
int len[210][210];
int n, m;
pair<int, int> mov[10];
char s[1000047];
int suf[1000047];
void dfs(pair<int, int> x) {
if (visited[x.first][x.second] != -1) return;
visited[x.first][x.second] = -2;
auto next = x + mov[mapa[x.first][x.second]];
if (next.first < 0 || next.first >= n || next.second < 0 || next.second >= m)
return;
if (visited[next.first][next.second] == -2) {
int seen = 1 << mapa[x.first][x.second];
auto it = next;
while (it != x) {
seen |= 1 << mapa[it.first][it.second];
it = it + mov[mapa[it.first][it.second]];
}
visited[x.first][x.second] = seen;
it = next;
while (it != x) {
visited[it.first][it.second] = seen;
it = it + mov[mapa[it.first][it.second]];
}
} else {
++deg[next.first][next.second];
dfs(next);
}
}
void dfs2(pair<int, int> x) {
if (visited[x.first][x.second] != -2) return;
visited[x.first][x.second] = 0;
auto next = x + mov[mapa[x.first][x.second]];
if (next.first < 0 || next.first >= n || next.second < 0 || next.second >= m)
return;
dfs2(next);
}
void print_arr(int a[210][210]) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) printf("%d ", a[i][j]);
printf("\n");
}
printf("\n");
}
int main(void) {
int q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; ++i) {
char ss[500];
scanf("%s\n", ss);
for (int j = 0; j < m; ++j) mapa[i][j] = ss[j] - '0';
}
for (int i = 0; i < 10; ++i) {
int a, b;
scanf("%d %d\n", &a, &b);
mov[i] = {a, b};
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) visited[i][j] = -1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
dfs({i, j});
dfs2({i, j});
}
while (q--) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
len[i][j] = 0;
deg2[i][j] = deg[i][j];
}
queue<pair<int, int> > qq;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (deg2[i][j] == 0) qq.push({i, j});
scanf("%s\n", s);
int ll = strlen(s);
suf[ll] = 0;
for (int i = ll - 1; i >= 0; --i) {
suf[i] = suf[i + 1] | (1 << (s[i] - '0'));
}
bool found = false;
while (!qq.empty()) {
auto x = qq.front();
qq.pop();
auto next = x + mov[mapa[x.first][x.second]];
int pos = len[x.first][x.second];
while (pos < ll && s[pos] - '0' == mapa[x.first][x.second]) ++pos;
if (pos == ll) {
found = true;
break;
}
if (next.first < 0 || next.first >= n || next.second < 0 ||
next.second >= m)
continue;
len[next.first][next.second] = max(len[next.first][next.second], pos);
--deg2[next.first][next.second];
if (visited[next.first][next.second] > 0) {
int need = suf[len[next.first][next.second]];
int have = visited[next.first][next.second];
if (((~have) & (have ^ need)) == 0) {
found = true;
break;
}
} else {
if (deg2[next.first][next.second] == 0) qq.push(next);
}
}
if (found)
puts("YES");
else
puts("NO");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
long long int inf = 1000000000000000000;
vector<int> ans, from, to;
string s;
int n;
void suka(char c, char cc) {
int sc = 0;
for (int i = 0; i < n; i++) {
if (s[i] == s[i + 1] && s[i] == c) sc++, i++;
}
for (int i = 0; i < n; i++) {
if (s[i] == s[i + 1] && s[i] == c)
ans.push_back(i + 1), s[i] = cc, s[i + 1] = cc, i++, sc--;
}
for (int i = 0; i < n; i++) {
if (s[i] == c) {
if (to.size() < from.size())
to.push_back(i);
else
from.push_back(i);
}
}
reverse(from.begin(), from.end());
reverse(to.begin(), to.end());
while (!from.empty()) {
while (from[from.size() - 1] != to[to.size() - 1])
ans.push_back(++from[from.size() - 1]);
from.pop_back();
to.pop_back();
}
}
int main() {
iostream::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cin >> s;
s += ' ';
s += ' ';
s += ' ';
int a[2]{0};
for (int i = 0; i < n; i++) {
if (s[i] == 'W')
a[0]++;
else
a[1]++;
}
if (a[0] == n || a[1] == n) {
cout << 0;
return 0;
}
if (a[0] % 2 && a[1] % 2) {
cout << "-1";
return 0;
}
if (a[0] % 2)
suka('B', 'W');
else
suka('W', 'B');
cout << ans.size() << "\n";
for (auto it : ans) cout << it << " ";
}
| 2 |
#include <bits/stdc++.h>
int main() {
int N;
int a[500], b[500], c[500];
int M;
int d[500], e[500], f[500];
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d %d %d", &a[i], &b[i], &c[i]);
scanf("%d", &M);
for (int i = 0; i < M; i++) scanf("%d %d %d", &d[i], &e[i], &f[i]);
int res = 0;
for (int i = 0; i < N; i++) {
int mini = -1;
for (int j = 0; j < M; j++) {
int all1 = (a[i] + b[i]) * 2;
int t1 = all1 / e[j] + (all1 % e[j] == 0 ? 0 : 1);
int t2 = d[j] / c[i];
if (t2 == 0) continue;
int all2 = t1 / t2 + (t1 % t2 == 0 ? 0 : 1);
if (mini == -1 || mini > all2 * f[j]) mini = all2 * f[j];
}
res += mini;
}
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool mark[int(5e6) + 10];
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
set<int> prev;
for (int i = 0; i < n; i++) {
set<int> st;
int a;
cin >> a;
for (int b : prev) {
st.insert(b | a);
mark[b | a] = true;
}
st.insert(a);
mark[a] = true;
prev = st;
}
int ans = 0;
for (int i = 0; i < int(5e6) + 10; i++) ans += mark[i];
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int inf = (int)1.01e9;
const long double eps = 1e-9;
const long double pi = acos(-1.0L);
void precalc() {}
const int maxn = (int)15e4 + 10;
int ps[maxn];
int ts[maxn];
int n;
bool read() {
if (scanf("%d", &n) < 1) {
return 0;
}
for (int i = 0; i < n; ++i) {
scanf("%d", ps + i);
}
for (int i = 0; i < n; ++i) {
scanf("%d", ts + i);
}
return 1;
}
int perm[maxn];
struct myComp {
inline int operator()(const int a, const int b) {
return (long long)ts[a] * ps[b] < (long long)ts[b] * ps[a];
}
};
pair<int, int> tosort[maxn];
long long times[maxn][2];
long long T;
bool isok(long double c) {
long double lastmax = -1e40;
for (int i = 0; i < n;) {
int i0 = i;
long double curmin = 1e40, curmax = -1e40;
while (i < n && tosort[i].first == tosort[i0].first) {
int v = tosort[i].second;
curmin = min(curmin, ps[v] * (T - c * times[v][1]));
curmax = max(curmax, ps[v] * (T - c * times[v][0]));
++i;
}
if (lastmax > curmin) {
return 0;
}
lastmax = max(lastmax, curmax);
}
return 1;
}
void solve() {
for (int i = 0; i < n; ++i) {
perm[i] = i;
tosort[i] = make_pair(ps[i], i);
}
sort(perm, perm + n, myComp());
sort(tosort, tosort + n);
long long passed = 0;
for (int i = 0; i < n;) {
int i0 = i;
long long passed0 = passed;
while (i < n && !myComp()(perm[i0], perm[i])) {
passed += ts[perm[i]];
++i;
}
for (int j = i0; j < i; ++j) {
int v = perm[j];
times[v][0] = passed0 + ts[v];
times[v][1] = passed;
}
}
T = passed;
long double left = 0, right = 1;
for (int iter = 0; iter < 30; ++iter) {
long double c = (left + right) / 2;
if (isok(c)) {
left = c;
} else {
right = c;
}
}
printf("%.18f\n", (double)left);
}
int main() {
srand(rdtsc());
precalc();
while (1) {
if (!read()) {
break;
}
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
string n;
int ans;
cin >> n;
int s = n.size();
for (int i = 0; i < s; i++) {
ans = (n[i] - '0');
if (ans % 8 == 0) {
cout << "YES\n";
cout << ans;
return 0;
}
for (int j = i + 1; j < s; j++) {
ans = (n[i] - '0') * 10 + (n[j] - '0');
if (ans % 8 == 0) {
cout << "YES\n";
cout << ans;
return 0;
}
for (int z = j + 1; z < s; z++) {
ans = (n[i] - '0') * 100 + (n[j] - '0') * 10 + (n[z] - '0');
if (ans % 8 == 0) {
cout << "YES\n";
cout << ans;
return 0;
}
}
}
}
cout << "NO\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e+6 + 5;
long long big = 1e+18 + 3;
long long mod = 1e+9 + 7;
long long freq[26] = {0}, vis[N];
long long maxv = -1;
long long sz = 0;
void dfs(string &s, vector<vector<long long>> &gr, long long ind) {
vis[ind] = 1;
sz++;
freq[s[ind] - (long long)'a']++;
for (auto it : gr[ind])
if (!vis[it]) dfs(s, gr, it);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
long long k;
cin >> n >> k;
string s;
for (long long i = 0; i <= n; i++) vis[i] = 0;
vector<vector<long long>> gr(n + 1);
long long moves = 0;
cin >> s;
for (long long i = 0; i <= n - 1; i++) {
if (i + k < n) gr[i].push_back(i + k), gr[i + k].push_back(i);
if (i - k >= 0) gr[i].push_back(i - k), gr[i - k].push_back(i);
gr[i].push_back(n - i - 1);
gr[n - i - 1].push_back(i);
}
for (long long i = 0; i <= n - 1; i++) {
if (vis[i]) continue;
dfs(s, gr, i);
for (long long x = 0; x <= 25; x++) maxv = max(maxv, freq[x]);
moves += (sz - maxv);
for (long long x = 0; x <= 25; x++) freq[x] = 0;
maxv = -1;
sz = 0;
}
cout << moves << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void checkmin(T& a, const T& b) {
if (a > b) a = b;
};
template <class T>
inline void checkmax(T& a, const T& b) {
if (a < b) a = b;
};
int main() {
for (int n; cin >> n;) {
vector<int> ans(n + 1);
if (n % 4 == 2 || n % 4 == 3) {
puts("-1");
continue;
}
int left = 1, right = n;
while (right - left + 1 >= 4) {
ans[left] = right - 1;
ans[left + 1] = left;
ans[right - 1] = right;
ans[right] = left + 1;
left += 2;
right -= 2;
}
if (left == right) {
ans[left] = right;
}
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 500;
const int MAX2 = 3007;
const int ADD = 1502;
const int BASE = 1000000000;
const int MOD = 1000000007;
long long a, b;
int main() {
cin >> a >> b;
long long res = 0;
for (int m = (1); m < (b); ++m) {
long long cnt = a;
long long sum = (a + b * (((a) * (a + 1) / 2) % MOD)) % MOD * m;
sum %= MOD;
res += sum;
res %= MOD;
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 5;
const double eps = 1e-9;
int n;
pair<double, double> orig;
double dist(pair<double, double> p1, pair<double, double> p2) {
return (p1.first - p2.first) * (p1.first - p2.first) +
(p1.second - p2.second) * (p1.second - p2.second);
}
struct Line {
pair<double, double> pi, pf;
double a, b, c;
void init(pair<double, double> p1, pair<double, double> p2) {
pi = p1, pf = p2;
a = p2.second - p1.second;
b = p1.first - p2.first;
c = a * p1.first + b * p1.second;
}
bool inside(pair<double, double> p) {
return sqrt(dist(p, pi)) + sqrt(dist(p, pf)) <= sqrt(dist(pi, pf)) + eps;
}
double shortestDist() {
if (b == 0) {
if (inside({c / a, orig.second})) {
return (c / a - orig.first) * (c / a - orig.first);
} else {
return min(dist(orig, pi), dist(orig, pf));
}
} else {
pair<double, double> pt;
double top = a * c / b + b * orig.first - a * orig.second,
bot = b + a * a / b;
pt.first = top / bot, pt.second = (c - a * pt.first) / b;
return inside(pt) ? dist(orig, pt) : min(dist(orig, pi), dist(orig, pf));
}
}
double longestDist() { return max(dist(orig, pi), dist(orig, pf)); }
void print() { printf("%lf %lf %lf\n", a, b, c); }
};
Line L[nax];
pair<double, double> P[nax];
int main() {
scanf("%d", &n);
scanf("%lf %lf", &orig.first, &orig.second);
for (int i = 0; i < n; ++i) scanf("%lf %lf", &P[i].first, &P[i].second);
for (int i = 0; i < n; ++i) L[i].init(P[i], P[(i + 1) % n]);
double r1 = 1e13, r2 = 0;
for (int i = 0; i < n; ++i) {
r1 = min(r1, L[i].shortestDist());
r2 = max(r2, L[i].longestDist());
}
cout << fixed << setprecision(12) << 3.14159265358979323846 * (r2 - r1)
<< endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long int n, m, a, b, ans1, ans2, i, p;
scanf("%I64d%I64d%I64d%I64d", &n, &m, &a, &b);
if (n % m == 0) {
printf("");
}
if (n < m) {
ans1 = ((m - n) * a);
ans2 = n * b;
} else {
ans1 = (n % m) * b;
ans2 = ((((n / m) + 1) * m) - n) * a;
}
if (ans1 < ans2)
printf("%I64d", ans1);
else
printf("%I64d", ans2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, p = 0, m = -1;
cin >> n;
while (n--) {
cin >> a >> b;
if (b < m || m == -1) {
m = b;
}
p += a * m;
}
cout << p;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500050;
struct node {
int ll, lr, rl, rr, li, lo, ri, ro, mi, mo;
int len;
int flip;
node()
: ll(0),
lr(0),
rl(0),
rr(0),
li(0),
lo(0),
ri(0),
ro(0),
mi(0),
mo(0),
len(0),
flip(0) {}
node(int ll, int lr, int rl, int rr, int li, int lo, int ri, int ro, int mi,
int mo, int len, int flip)
: ll(ll),
lr(lr),
rl(rl),
rr(rr),
li(li),
lo(lo),
ri(ri),
ro(ro),
mi(mi),
mo(mo),
len(len),
flip(flip) {}
void print() {
cout << "ll = " << ll << " lr = " << lr << " rl = " << rl << " rr = " << rr
<< " lo = " << lo << " li = " << li << " ro = " << ro << " ri = " << ri
<< " mo = " << mo << " mi = " << mi << '\n';
}
} tree[4 * N];
int ll(node x) {
if (x.flip) {
return x.lr;
}
return x.ll;
}
int lr(node x) {
if (x.flip) {
return x.ll;
}
return x.lr;
}
int rl(node x) {
if (x.flip) {
return x.rr;
}
return x.rl;
}
int rr(node x) {
if (x.flip) {
return x.rl;
}
return x.rr;
}
int li(node x) {
if (x.flip) {
return x.lo;
}
return x.li;
}
int lo(node x) {
if (x.flip) {
return x.li;
}
return x.lo;
}
int ri(node x) {
if (x.flip) {
return x.ro;
}
return x.ri;
}
int ro(node x) {
if (x.flip) {
return x.ri;
}
return x.ro;
}
int mi(node x) {
if (x.flip) {
return x.mo;
}
return x.mi;
}
int mo(node x) {
if (x.flip) {
return x.mi;
}
return x.mo;
}
int len(node x) { return x.len; }
inline int merge_li(node a, node b) {
assert(lr(a) <= len(a));
if (lr(a) == len(a)) {
if (li(b) > 0) {
return lr(a) + li(b);
} else if (ll(b) > 0) {
return lr(a) + ll(b);
}
}
assert(li(a) <= len(a));
if (li(a) == len(a)) {
return li(a) + ll(b);
}
return li(a);
}
inline int merge_ri(node a, node b) {
assert(rl(b) <= len(b));
if (rl(b) == len(b)) {
if (ri(a) > 0) {
return rl(b) + ri(a);
} else if (rr(a) > 0) {
return rl(b) + rr(a);
}
}
assert(ri(b) <= len(b));
if (ri(b) == len(b)) {
return ri(b) + rr(a);
}
return ri(b);
}
inline int merge_lo(node a, node b) {
assert(ll(a) <= len(a));
if (ll(a) == len(a)) {
if (lo(b) > 0) {
return ll(a) + lo(b);
} else if (lr(b) > 0) {
return ll(a) + lr(b);
}
}
assert(lo(a) <= len(a));
if (lo(a) == len(a)) {
return lo(a) + lr(b);
}
return lo(a);
}
inline int merge_ro(node a, node b) {
assert(rr(b) <= len(b));
if (rr(b) == len(b)) {
if (ro(a) > 0) {
return rr(b) + ro(a);
} else if (rl(a) > 0) {
return rr(b) + rl(a);
}
}
assert(ro(b) <= len(b));
if (ro(b) == len(b)) {
return ro(b) + rl(a);
}
return ro(b);
}
inline int merge_mi(node x, node a, node b) {
int ret = max(li(x), ri(x));
ret = max(ret, max(mi(a), mi(b)));
if (rr(a) > 0 && ll(b) > 0) {
ret = max(ret, rr(a) + ll(b));
}
if (ri(a) > 0) {
ret = max(ret, ri(a) + ll(b));
}
if (li(b) > 0) {
ret = max(ret, rr(a) + li(b));
}
return ret;
}
inline int merge_mo(node x, node a, node b) {
int ret = max(lo(x), ro(x));
ret = max(ret, max(mo(a), mo(b)));
if (rl(a) > 0 && lr(b) > 0) {
ret = max(ret, rl(a) + lr(b));
}
if (lo(b) > 0) {
ret = max(ret, rl(a) + lo(b));
}
if (ro(a) > 0) {
ret = max(ret, ro(a) + lr(b));
}
return ret;
}
inline node merge(node a, node b) {
node ret;
ret.ll = ll(a) + (ll(a) == len(a)) * ll(b);
ret.lr = lr(a) + (lr(a) == len(a)) * lr(b);
ret.rl = rl(b) + (rl(b) == len(b)) * rl(a);
ret.rr = rr(b) + (rr(b) == len(b)) * rr(a);
ret.li = merge_li(a, b);
ret.ri = merge_ri(a, b);
ret.lo = merge_lo(a, b);
ret.ro = merge_ro(a, b);
ret.mi = merge_mi(ret, a, b);
ret.mo = merge_mo(ret, a, b);
ret.len = len(a) + len(b);
return ret;
}
void build(int x, int l, int r, const string& s) {
if (l == r) {
tree[x] = node();
if (s[l] == '<') {
tree[x].ll = 1;
tree[x].rl = 1;
} else {
tree[x].lr = 1;
tree[x].rr = 1;
}
tree[x].len = 1;
return;
}
int y = (l + r) >> 1;
build(x + x, l, y, s);
build(x + x + 1, y + 1, r, s);
tree[x] = merge(tree[x + x], tree[x + x + 1]);
}
void push(int x) {
if (tree[x].flip) {
swap(tree[x].ll, tree[x].lr);
swap(tree[x].rl, tree[x].rr);
swap(tree[x].li, tree[x].lo);
swap(tree[x].ri, tree[x].ro);
swap(tree[x].mi, tree[x].mo);
tree[x].flip = 0;
tree[x + x].flip ^= 1;
tree[x + x + 1].flip ^= 1;
}
}
inline void pull(int x) { tree[x] = merge(tree[x + x], tree[x + x + 1]); }
node modify(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
tree[x].flip ^= 1;
return tree[x];
}
push(x);
int y = (l + r) >> 1;
node ret;
if (ll <= y && y + 1 <= rr) {
ret =
merge(modify(x + x, l, y, ll, rr), modify(x + x + 1, y + 1, r, ll, rr));
} else if (ll <= y) {
ret = modify(x + x, l, y, ll, rr);
} else if (y + 1 <= rr) {
ret = modify(x + x + 1, y + 1, r, ll, rr);
} else {
assert(0);
}
pull(x);
return ret;
}
int GetAns(node x) {
if (x.flip) {
return max(max(x.lr, x.rl), x.mo);
}
return max(max(x.ll, x.rr), x.mi);
}
void print(int x, int l, int r, const string& s) {
for (int i = l; i <= r; i++) {
cout << s[i];
}
if (l == r) {
return;
}
int y = (l + r) >> 1;
print(x + x, l, y, s);
print(x + x + 1, y + 1, r, s);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
build(1, 0, n - 1, s);
while (q--) {
int l, r;
cin >> l >> r;
--l;
--r;
node ans = modify(1, 0, n - 1, l, r);
assert(ans.len == r - l + 1);
cout << GetAns(ans) << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n0, n1, n2;
cin >> n0 >> n1 >> n2;
if (n1 == 0 && n2 == 0) {
cout << string(n0 + 1, '0') << endl;
continue;
}
string result = string(n2 + 1, '1');
char turn = '0';
while (n1--) {
result += turn;
if (turn == '0') {
turn = '1';
} else {
turn = '0';
}
}
if (result[result.size() - 1] == '0') {
result += string(n0, '0');
} else {
result = result.substr(0, result.size() - 1);
result = result + string(n0, '0') + "1";
}
cout << result << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int qr() {
int f = 0, fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + c - 48;
c = getchar();
}
return f * fu;
}
const int N = 2e5 + 10;
int head[N], ver[N << 1], Next[N << 1], tot;
int t[N], h[N], n;
long long f[N][2], ans;
inline void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dp(int x, int fa) {
bool up = h[fa] >= h[x] || x == 1;
bool down = h[fa] <= h[x] || x == 1;
vector<long long> tmp;
tmp.push_back(0);
long long sum = 0;
for (register int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (y == fa) continue;
dp(y, x), sum += f[y][0], tmp.push_back(f[y][1] - f[y][0]);
}
if (tmp.empty()) {
f[x][0] = up ? 0 : 1e12;
f[x][1] = down ? 0 : 1e12;
return;
}
f[x][0] = f[x][1] = 1e12;
sort(++tmp.begin(), tmp.end());
int len = tmp.size();
if (up) {
long long res = sum;
for (register int i = 0; i <= len - 1; ++i) {
res += tmp[i];
f[x][0] = min(f[x][0], res + 1ll * t[x] * max(len - i - 2 + (x == 1), i));
}
}
if (down) {
long long res = sum;
for (register int i = 0; i <= len - 1; ++i) {
res += tmp[i];
f[x][1] =
min(f[x][1], res + 1ll * t[x] * max(len - i - 1, i - 1 + (x == 1)));
}
}
}
int main() {
n = qr();
for (register int i = 1; i <= n; ++i) t[i] = qr();
for (register int i = 1; i <= n; ++i) h[i] = qr();
for (register int i = 1; i <= n - 1; ++i) {
int x = qr(), y = qr();
add(x, y), add(y, x);
}
dp(1, 0);
ans = max(f[1][0], f[1][1]);
for (register int i = 2; i <= n; ++i) ans += t[i];
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
double dp[5005][2505][2];
double A[5005], B[5005];
int n, m, x, y, z, k, w, l, r;
double dist(int x, int y) {
double a = (double)(A[x] - A[y]);
double b = (double)(B[x] - B[y]);
return sqrt(a * a + b * b);
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%lf %lf", &A[i], &B[i]);
A[i + n] = A[i];
B[i + n] = B[i];
}
double a, b;
for (int i = (2); i <= (n); i++) {
for (int j = (0); j < (2 * n); j++) {
l = j;
r = j + i - 1;
if (r >= 2 * n) break;
a = dp[l + 1][i - 1][1] + dist(r, l);
b = dp[l + 1][i - 1][0] + dist(l + 1, l);
dp[l][i][0] = max(a, b);
a = dp[l][i - 1][0] + dist(l, r);
b = dp[l][i - 1][1] + dist(r - 1, r);
dp[l][i][1] = max(a, b);
}
}
double ans = 0.0;
for (int i = (0); i < (2 * n); i++) {
ans = max(ans, dp[i][n][0]);
ans = max(ans, dp[i][n][1]);
}
printf("%.10lf\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[100005], b[100005], t, i = 0, j, k, x, y, z, count = 0, p,
flag = 0, ans = 0, sum = 0, l, n, m, max1,
min1, pos, tmp, q;
t = 1;
while (t--) {
scanf("%lld", &n);
map<long long, long long> M;
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
b[i] = a[i];
}
sort(b, b + n);
for (i = 0; i < n - 1; i++) {
M[b[i]] = b[i + 1];
}
M[b[n - 1]] = b[0];
for (i = 0; i < n; i++) printf("%lld ", M[a[i]]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
struct node {
double x, y;
} p[4 * 4];
node newnode(double x, double y) {
node tmp;
tmp.x = x, tmp.y = y;
return tmp;
}
node get_point() {
double x, y;
scanf("%lf%lf", &x, &y);
return newnode(x, y);
}
int cmp(double a, double b) {
if (fabs(a - b) < (1e-6))
return 0;
else
return a < b ? -1 : 1;
}
node operator+(node a, node b) { return newnode(a.x + b.x, a.y + b.y); }
node operator-(node a, node b) { return newnode(a.x - b.x, a.y - b.y); }
node operator*(node a, double p) { return newnode(a.x * p, a.y * p); }
node operator/(node a, double p) { return newnode(a.x / p, a.y / p); }
bool operator<(node a, node b) {
return cmp(a.x, b.x) < 0 || !cmp(a.x, b.x) && cmp(a.y, b.y) < 0;
}
bool operator==(node a, node b) { return (!cmp(a.x, b.x)) && (!cmp(a.y, b.y)); }
double dm(node a, node b) { return a.x * b.x + a.y * b.y; }
double cm(node a, node b) { return a.x * b.y - a.y * b.x; }
double len(node a) { return sqrt(dm(a, a)); }
double ang(node a, node b) { return acos(dm(a, b) / len(a) / len(b)); }
double angle(node v) { return atan2(v.y, v.x); }
double dist(node a, node b) {
return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}
node rotate(node a, double rad) {
return newnode(a.x * cos(rad) - a.y * sin(rad),
a.x * sin(rad) + a.y * cos(rad));
}
node normal(node a) {
double l = len(a);
return newnode(-a.y / l, a.x / l);
}
double d_to_r(double deg) { return deg / 180 * pi; }
node cross_point(node p, node u, node q, node v) {
return p + u * (cm(v, p - q) / cm(u, v));
}
double dl_dist(node p, node a, node b) {
node tmp1 = a - p, tmp2 = b - p;
return fabs(cm(tmp1, tmp2)) / len(a - b);
}
double ds_dist(node p, node a, node b) {
if (a == b) return len(p - a);
node v1 = b - a, v2 = p - a, v3 = p - b;
if (cmp(dm(v1, v2), 0) < 0)
return len(v2);
else if (cmp(dm(v1, v3), 0) > 0)
return len(v3);
else
return dl_dist(p, a, b);
}
bool onseg(node p, node a1, node a2) {
return !cmp(cm(a1 - p, a2 - p), 0) && cmp(dm(a1 - p, a2 - p), 0) < 0;
}
bool cross_or_not(node a1, node a2, node b1, node b2) {
double tmp1 = cm(a2 - a1, b1 - a1), tmp2 = cm(a2 - a1, b2 - a1),
tmp3 = cm(b2 - b1, a1 - b1), tmp4 = cm(b2 - b1, a2 - b1);
return cmp(tmp1, 0) * cmp(tmp2, 0) < 0 && cmp(tmp3, 0) * cmp(tmp4, 0) < 0;
}
double poly_area(node *p, int n) {
double area = 0;
for (int i = 2; i < n; ++i) area += cm(p[i] - p[1], p[i + 1] - p[1]);
return area * 0.5;
}
int inpoly(node p, vector<node> poly) {
int cnt = 0, n = poly.size();
for (int i = 0; i < n; ++i) {
if (onseg(p, poly[i], poly[(i + 1) % n])) return -1;
int t1 = cmp(cm(poly[(i + 1) % n] - poly[i], p - poly[i]), 0),
t2 = cmp(poly[i].y, p.y), t3 = cmp(poly[(i + 1) % n].y, p.y);
if (t1 > 0 && t2 <= 0 && t3 > 0) ++cnt;
if (t1 < 0 && t3 <= 0 && t2 > 0) --cnt;
}
if (cnt) return 1;
return 0;
}
int ch(node *p, int n, node *ans) {
sort(p + 1, p + n + 1);
int len = 0, tmp;
for (int i = 1; i <= n; ++i) {
while (len >= 2 && cm(ans[len] - ans[len - 1], p[i] - ans[len - 1]) <= 0)
--len;
ans[++len] = p[i];
}
tmp = len;
for (int i = n - 1; i > 0; --i) {
while (len >= tmp + 1 &&
cm(ans[len] - ans[len - 1], p[i] - ans[len - 1]) <= 0)
--len;
ans[++len] = p[i];
}
return len;
}
double diameter(node *p, int n) {
int t = 1;
double ans = 0;
for (int i = 1; i <= n; ++i) {
while (cm(p[i % n + 1] - p[i], p[t] - p[i]) <
cm(p[i % n + 1] - p[i], p[t % n + 1] - p[i]))
(t %= n) += 1;
ans = max(len(p[i] - p[t]), ans);
}
return ans;
}
struct line {
node p, v;
double ang;
node point(double t) { return p + v * t; }
};
bool operator<(line a, line b) { return a.ang < b.ang; }
line newline(node p, node v) {
line tmp;
tmp.p = p, tmp.v = v, tmp.ang = atan2(v.y, v.x);
return tmp;
}
bool onleft(line l, node p) { return cm(l.v, p - l.p) > 0; }
node cross_point(line a, line b) {
node u = a.p - b.p;
double t = cm(b.v, u) / cm(a.v, b.v);
return a.p + a.v * t;
}
int half_plane(line *l, int n, node *poly) {
sort(l + 1, l + n + 1);
int first, last;
node *p = new node[n];
line *q = new line[n];
q[first = last = 0] = l[1];
for (int i = 2; i <= n; ++i) {
while (first < last && !onleft(l[i], p[last - 1])) --last;
while (first < last && !onleft(l[i], p[first])) ++first;
q[++last] = l[i];
if (!cmp(cm(q[last].v, q[last - 1].v), 0)) {
--last;
if (onleft(q[last], l[i].p)) q[last] = l[i];
}
if (first < last) p[last - 1] = cross_point(q[last - 1], q[last]);
}
while (first < last && !onleft(q[first], p[last - 1])) --last;
if (last - first <= 1) return 0;
p[last] = cross_point(q[first], q[last]);
int m = 0;
for (int i = first; i <= last; ++i) poly[++m] = p[i];
return m;
}
struct circle {
node c;
double r;
node point(double a) { return newnode(c.x + cos(a) * r, c.y + sin(a) * r); }
} c[4];
int line_circle_cross(line l, circle C, double &t1, double &t2,
vector<node> &sol) {
double a = l.v.x, b = l.p.x - C.c.x, c = l.v.y, d = l.p.y - C.c.y,
e = a * a + c * c, f = 2 * (a * b + c * d),
g = b * b + d * d - C.r * C.r, delta = f * f - 4 * e * g;
if (cmp(delta, 0) < 0) return 0;
if (!cmp(delta, 0)) {
t1 = t2 = -f / (2 * e);
sol.push_back(l.point(t1));
return 1;
}
t1 = (-f - sqrt(delta)) / (2 * e), t2 = (-f + sqrt(delta)) / (2 * e);
sol.push_back(l.point(t1)), sol.push_back(l.point(t2));
}
int circle_circle_cross(circle c1, circle c2, vector<node> &sol) {
double d = len(c1.c - c2.c);
if (!cmp(d, 0)) {
if (!cmp(c1.r, c2.r)) return -1;
return 0;
}
if (cmp(c1.r + c2.r, d) < 0) return 0;
if (cmp(fabs(c1.r - c2.r), d) > 0) return 0;
double a = angle(c2.c - c1.c),
da = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
node p1 = c1.point(a - da), p2 = c1.point(a + da);
sol.push_back(p1);
if (p1 == p2) return 1;
sol.push_back(p2);
return 2;
}
int tangents(node p, circle c, node *v) {
node u = c.c - p;
double d = len(u);
if (d < c.r)
return 0;
else if (!cmp(d, c.r)) {
v[1] = rotate(u, pi / 2);
return 1;
} else {
double ang = asin(c.r / d);
v[1] = rotate(u, -ang);
v[2] = rotate(u, ang);
return 2;
}
}
int CCT(circle A, circle B, node *a, node *b) {
int cnt = 0;
if (A.r < B.r) swap(A, B), swap(a, b);
double d = dist(A.c, B.c), rd = A.r - B.r, rs = A.r + B.r;
if (cmp(d, rd) < 0) return 0;
if (!cmp(d, 0) && !cmp(A.r, B.r)) return -1;
double base = angle(B.c - A.c);
if (!cmp(d, rd)) {
a[++cnt] = A.point(base), b[cnt] = B.point(base);
return 1;
}
double ang = acos(rd / d);
a[++cnt] = A.point(base + ang), b[cnt] = B.point(base + ang);
a[++cnt] = A.point(base - ang), b[cnt] = B.point(base - ang);
if (!cmp(d, rs))
a[++cnt] = A.point(base), b[cnt] = B.point(pi + base);
else if (cmp(d, rs) > 0) {
double ang2 = acos(rs / d);
a[++cnt] = A.point(base + ang2), b[cnt] = B.point(pi + base + ang2);
a[++cnt] = A.point(base - ang2), b[cnt] = B.point(pi + base - ang2);
}
return cnt;
}
int tot, n, E, V, C;
bool not_useful[4], vis[4];
inline void Get_Circle_Cross(circle c1, circle c2) {
double d = len(c1.c - c2.c);
if (!cmp(d, 0)) return;
if (cmp(c1.r + c2.r, d) < 0) return;
if (cmp(fabs(c1.r - c2.r), d) > 0) return;
double a = angle(c2.c - c1.c),
da = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
node p1 = c1.point(a - da), p2 = c1.point(a + da);
p[++tot] = p1;
if (p1 == p2) return;
p[++tot] = p2;
return;
}
void init() {
tot = 0;
memset(not_useful, 0, sizeof(not_useful));
memset(vis, 0, sizeof(vis));
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%lf%lf%lf", &c[i].c.x, &c[i].c.y, &c[i].r);
}
inline bool is_cross(circle c1, circle c2) {
double d = len(c1.c - c2.c);
if (cmp(d, c1.r + c2.r) <= 0 && cmp(d, fabs(c1.r - c2.r)) >= 0) return 1;
return 0;
}
inline void dfs(int u) {
vis[u] = 1;
for (int i = 1; i <= n; ++i)
if (!vis[i] && is_cross(c[u], c[i])) dfs(i);
}
void solve() {
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) Get_Circle_Cross(c[i], c[j]);
for (int i = 1; i <= tot; ++i)
for (int j = 1; j <= i - 1; ++j)
if (p[i] == p[j]) not_useful[i] = 1;
int lim = tot;
tot = 0;
for (int i = 1; i <= lim; ++i)
if (!not_useful[i]) p[++tot] = p[i];
V = tot;
E = 0, C = 0;
for (int i = 1; i <= tot; ++i)
for (int j = 1; j <= n; ++j)
if (!cmp(len(p[i] - c[j].c), c[j].r)) ++E;
for (int i = 1; i <= n; ++i)
if (!vis[i]) C++, dfs(i);
printf("%d\n", E - V + C + 1);
}
int main() {
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, h, m, a[55], b[55], c[55], maxn[55], ans;
int main() {
cin >> n >> h >> m;
for (int i = 1; i <= n; i++) maxn[i] = h;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i] >> c[i];
for (int j = a[i]; j <= b[i]; j++) {
if (c[i] < maxn[j]) maxn[j] = c[i];
}
}
for (int i = 1; i <= n; i++) ans += (maxn[i] * maxn[i]);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dp[1009];
long long sub(long long a, long long b) {
return (((a % mod) - (b % mod)) + mod) % mod;
}
int main() {
dp[1] = 0LL;
long long n;
cin >> n;
long long p[n + 3];
for (long long i = 1; i <= n; i++) cin >> p[i];
for (long long i = 1; i <= n; i++) {
dp[i + 1] = (2LL * dp[i]) % mod + 2;
dp[i + 1] = sub(dp[i + 1], dp[p[i]]);
dp[i + 1] %= mod;
}
cout << dp[n + 1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct GOAL {
double x, y, t, p;
} a[1010];
int n;
double f[1010], ans;
bool cmp(GOAL a, GOAL b) { return a.t < b.t; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%lf%lf%lf%lf", &a[i].x, &a[i].y, &a[i].t, &a[i].p);
sort(&a[1], &a[n + 1], cmp);
for (int i = 1; i <= n; i++) {
f[i] = a[i].p;
for (int j = 1; j < i; j++) {
if (((a[i].t - a[j].t) * (a[i].t - a[j].t)) -
((a[i].x - a[j].x) * (a[i].x - a[j].x)) -
((a[i].y - a[j].y) * (a[i].y - a[j].y)) >
-1e-7)
f[i] = max(f[j] + a[i].p, f[i]);
}
ans = max(ans, f[i]);
}
printf("%.7f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, a[200] = {0}, dp[200] = {0};
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
}
dp[n - 1] = k - a[n - 1];
for (i = n - 2; i >= 0; i--) {
if (k == a[i]) {
dp[i] = 0;
} else {
dp[i] = max(k - a[i], dp[i + 1] + 1);
}
}
cout << dp[0] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111;
string tab[N][11];
int diff[N][N];
int n, m, k, w;
int pi[N], d[N], vis[N];
int getdiff(int a, int b) {
int d = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (tab[a][i][j] != tab[b][i][j]) d++;
return d;
}
int main() {
cin >> n >> m >> k >> w;
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) cin >> tab[i][j];
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++) {
int d = getdiff(i, j);
diff[i][j] = diff[j][i] = d;
}
vector<int> ord;
priority_queue<pair<int, int> > q;
for (int i = 0; i < k; i++) {
d[i] = n * m;
pi[i] = -1;
q.push(pair<int, int>(-d[i], i));
}
while (!q.empty()) {
int v = q.top().second;
q.pop();
if (vis[v]) continue;
vis[v] = 1;
ord.push_back(v);
for (int u = 0; u < k; u++)
if (u != v && !vis[u]) {
if (d[u] > w * diff[v][u]) {
d[u] = w * diff[v][u];
pi[u] = v;
q.push(pair<int, int>(-d[u], u));
}
}
}
int ans = 0;
for (int i = 0; i < k; i++) ans += d[i];
cout << ans << endl;
for (int i = 0; i < k; i++)
cout << ord[i] + 1 << " " << pi[ord[i]] + 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
priority_queue<int, vector<int>, greater<int> > q;
int ans[200005];
int main() {
scanf("%d", &n);
for (int a = 0; a < n; a++) {
scanf("%d", &t);
q.push(t + a);
}
ans[0] = q.top();
q.pop();
for (int a = 1; a < n; a++) {
if (q.top() - a < ans[a - 1]) {
printf(":(\n");
return 0;
}
ans[a] = q.top() - a;
q.pop();
}
for (int a = 0; a < n; a++) printf("%d%c", ans[a], a == n - 1 ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
int m, n, W, i, j, k, a[555555], b[555555], c[555555];
long long w[555555], rs;
double rq;
void solve(int l, int r, long long x) {
if (l == r) {
rs += (x * c[b[l]]) / w[b[l]];
rq += double((x * c[b[l]]) % w[b[l]]) / w[b[l]];
return;
}
int i = l, j = r, k, h = b[(l + r) >> 1];
long long e, f;
while (i <= j) {
while (c[b[i]] * w[h] < c[h] * w[b[i]]) i++;
while (c[b[j]] * w[h] > c[h] * w[b[j]]) j--;
if (i <= j) {
k = b[i];
b[i++] = b[j];
b[j--] = k;
}
}
for (f = e = 0, k = l; k < i; k++) {
f += w[b[k]];
e += c[b[k]];
if (f >= x) break;
}
if (k == i) {
rs += e;
solve(i, r, x - f);
} else if (k > j) {
f -= w[b[k]];
e -= c[b[k]];
rs += e + ((x - f) * c[b[k]]) / w[b[k]];
rq += double(((x - f) * c[b[k]]) % w[b[k]]) / w[b[k]];
} else
solve(l, j, x);
}
int main() {
srand(time(0));
scanf("%d%d%d", &m, &n, &W);
for (i = 0; i < n; i++) {
scanf("%I64d", &w[i]);
b[i] = i;
}
for (i = 0; i < n; i++) scanf("%d", &c[i]);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (j = 0; j < m; j++) {
if (j)
for (i = 0; i < n; i++) c[i] -= a[i];
solve(0, n - 1, W);
}
rs += int(rq);
rq -= int(rq);
rq += rs % 10;
rs /= 10;
if (rs != 0) printf("%I64d", rs);
printf("%.11lf\n", rq);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int trie[9000005][2];
int K;
int sz[9000005], ans[30], ar[30];
void convert(int x) {
int i;
for (i = 30 - 1; i >= 0; i--) {
ar[i] = (x & 1);
x /= 2;
}
return;
}
void update(int x) {
convert(x);
int i, p = 0;
for (i = 0; i < 30; i++) {
if (trie[p][ar[i]] == 0) trie[p][ar[i]] = K++;
p = trie[p][ar[i]];
sz[p]++;
}
return;
}
int query(int x) {
convert(x);
int i, a, p = 0;
for (i = 0; i < 30; i++) {
a = trie[p][ar[i]];
if (a > 0 && sz[a] > 0)
ans[i] = 0, p = a, sz[a]--;
else
ans[i] = 1, p = trie[p][1 ^ ar[i]], sz[p]--;
}
a = 1, p = 0;
for (i = 30 - 1; i >= 0; i--) {
if (ans[i]) p += a;
a *= 2;
}
return p;
}
int main() {
int n, i, x;
scanf("%d", &n);
vector<int> v(n);
for (i = 0; i < n; i++) scanf("%d", &v[i]);
K = 1;
for (i = 0; i < n; i++) scanf("%d", &x), update(x);
for (i = 0; i < n; i++) printf("%d ", query(v[i]));
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int l, r, d;
long long mx;
inline int log10(int x) {
int t = 0;
while (x) {
x /= 10;
t++;
}
return t;
}
inline long long mx10(int x) {
long long t = 1;
for (int i = 1; i < x; i++) {
t *= 10;
}
return t * 5 - 1;
}
inline long long mx9(int x) {
long long t = 1;
for (int i = 1; i < x; i++) {
t *= 10;
}
return t * 9;
}
long long calc(long long x) {
int a[20], t = 0;
long long tmp = x, res = 0;
while (tmp) {
a[t++] = tmp % 10;
tmp /= 10;
}
for (int i = t - 1; i >= 0; i--) {
res = res * 10 + 9 - a[i];
}
return 1ll * x * res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> l >> r;
d = log10(r);
mx = mx10(d);
if (l <= mx && r <= mx) {
cout << calc(r) << endl;
} else if (l <= mx && r > mx) {
cout << calc(mx) << endl;
} else {
cout << calc(l) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ar[105], n, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
for (int i = 0; i < n; i += 2) {
sum += ar[i + 1] - ar[i];
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long f[100005];
bool fe[100005];
long long v[100005];
int c[100005];
int i, j, n, a, b, q, c1, c2;
long long k1, k2, m1, m2;
cin >> n >> q;
for (i = 0; i < n; ++i) cin >> v[i];
for (i = 0; i < n; ++i) cin >> c[i];
for (i = 0; i < q; i++) {
cin >> a >> b;
for (j = 0; j <= n; ++j) f[j] = 0;
for (j = 0; j <= n; ++j) fe[j] = false;
m2 = 0;
c2 = n + 1;
f[c[0]] = v[0] * b;
fe[c[0]] = true;
m1 = f[c[0]];
c1 = c[0];
for (j = 1; j < n; ++j) {
k1 = v[j] * b;
if (fe[c[j]]) {
k2 = f[c[j]] + v[j] * a;
if (k2 > k1) k1 = k2;
}
if (c[j] != c1) {
k2 = m1 + v[j] * b;
if (k2 > k1) k1 = k2;
} else if (c2 != n + 1) {
k2 = m2 + v[j] * b;
if (k2 > k1) k1 = k2;
}
if (!fe[c[j]]) {
fe[c[j]] = true;
f[c[j]] = k1;
}
if (k1 > f[c[j]]) f[c[j]] = k1;
if (k1 > m1) {
if (c1 != c[j]) {
c2 = c1;
m2 = m1;
}
c1 = c[j];
m1 = k1;
} else if (((k1 > m2) | (c2 == n + 1)) & (c1 != c[j])) {
c2 = c[j];
m2 = k1;
}
}
if (m1 > 0)
cout << m1 << endl;
else
cout << 0 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int r;
cin >> r;
if (r % 2 == 0 || r < 4)
cout << "NO\n";
else {
long long int x = 1, y;
for (x = 1; x < 1000001; x++) {
y = (r - (x + 1) * (x + 1));
if (y % x == 0) {
if ((y / x + 1) % 2 == 0) {
y = (y / x + 1) / 2;
break;
}
}
}
cout << x << " " << y << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int dX[] = {0, 1, 1, 1, 0, -1, -1, -1};
int dY[] = {-1, -1, 0, 1, 1, 1, 0, -1};
char s[4010];
int a, n, v[4010];
int main(void) {
scanf("%d %s", &a, s);
n = strlen(s);
for (int((i)) = (0); ((i)) < ((n)); ((i))++) v[i] = (int)(s[i] - '0');
map<int, long long> d;
for (int((i)) = (0); ((i)) < ((n)); ((i))++) {
int c = 0;
for (int((j)) = (0); ((j)) < ((n - i)); ((j))++) {
c += v[i + j];
d[c]++;
}
}
long long r = 0;
for (int x = 1; x * x <= a; x++)
if (a % x == 0) {
r += d[x] * d[a / x];
if (x * x < a) r += d[a / x] * d[x];
}
if (a == 0)
r = 2 * d[0] * (long long)n * (long long)(n + 1) / (long long)2 -
d[0] * d[0];
cout << r;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int flag[20];
bool fun(int a) {
while (a) {
if (flag[a % 10]) return true;
a = a / 10;
}
return false;
}
int main() {
int n, t, i, sum;
while (scanf("%d", &n) != EOF) {
memset(flag, 0, sizeof(flag));
t = n;
while (t) {
flag[t % 10] = 1;
t = t / 10;
}
sum = 0;
for (i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (fun(i)) sum++;
if (n / i != i && fun(n / i)) sum++;
}
}
printf("%d\n", sum);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double dp[1005][1005] = {0};
int main() {
int w, b;
cin >> w >> b;
for (int i = 1; i <= w; i++) dp[i][0] = 1.0;
for (int i = 1; i <= w; i++) {
for (int j = 1; j <= b; j++) {
dp[i][j] = i * 1.0 / (i + j);
if (j >= 2)
dp[i][j] += j * 1.0 / (i + j) * (j - 1) * 1.0 / (i + j - 1) *
(i * 1.0) / (i + j - 2) * dp[i - 1][j - 2];
if (j >= 3)
dp[i][j] += j * 1.0 / (i + j) * (j - 1) * 1.0 / (i + j - 1) * (j - 2) *
1.0 / (i + j - 2) * dp[i][j - 3];
}
}
printf("%.9lf", dp[w][b]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 16;
vector<int> adj[N];
namespace Dinic {
using F = int;
const F INF = 1e9 + 1e8;
const int N = 222222;
const int M = 1111111;
int fst[N], nxt[M], to[M];
F cap[M];
int dis[N], q[N], ptr[N];
int V, E;
void init() {
memset(fst, -1, sizeof fst);
V = E = 0;
}
inline int add_node() {
V++;
return V - 1;
}
inline void add_edge(int u, int v, F c) {
to[E] = v, cap[E] = c, nxt[E] = fst[u], fst[u] = E++;
to[E] = u, cap[E] = 0, nxt[E] = fst[v], fst[v] = E++;
}
inline bool bfs(int S, int T, int n) {
memset(dis, -1, sizeof(int) * n);
int h = 0, t = 0;
dis[S] = 0, q[t++] = S;
while (h < t) {
int u = q[h++];
for (int e = fst[u]; ~e; e = nxt[e])
if (cap[e] > 0 && dis[to[e]] == -1) {
dis[to[e]] = dis[u] + 1, q[t++] = to[e];
if (to[e] == T) return 1;
}
}
return (dis[T] != -1);
}
F dfs(int u, int T, F f) {
if (u == T) return f;
for (int &e = ptr[u]; ~e; e = nxt[e])
if (cap[e] > 0 && dis[to[e]] > dis[u]) {
F ret = dfs(to[e], T, min(f, cap[e]));
if (ret > 0) {
cap[e] -= ret, cap[e ^ 1] += ret;
return ret;
}
}
return 0;
}
F max_flow(int S, int T, int n = V) {
F ret = 0;
while (bfs(S, T, n)) {
memcpy(ptr, fst, sizeof(int) * n);
for (F cur; (cur = dfs(S, T, INF)) > 0; ret += cur)
;
}
return ret;
}
F min_cut(int S, int T, int *ans, int n = V) {
F ret = max_flow(S, T, n);
for (int i = 0; i < n; i++) ans[i] = (dis[i] != -1);
return ret;
}
} // namespace Dinic
int a[N], b[N], ans[N], x[N], y[N], sz[N], dp[N], pid[N], st[N], E[N], node[N],
qnode[N], edge[N], hd[N], par[N];
const int inf = Dinic::INF;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
a[i] = u, b[i] = v;
adj[u].push_back(v);
adj[v].push_back(u);
}
function<void(int, int)> dfs = [&](int u, int p) {
sz[u] = 1;
dp[u] = dp[p] + 1;
par[u] = p;
for (int v : adj[u]) {
if (v == p) continue;
dfs(v, u);
sz[u] += sz[v];
}
};
int T = 0, pn = 0;
function<void(int, int)> hld = [&](int u, int p) {
st[u] = ++T;
if (!hd[pn]) hd[pn] = u;
pid[u] = pn;
int w = 0;
for (int v : adj[u]) {
if (v == p) continue;
if (w == 0 || sz[v] > sz[w]) w = v;
}
if (w) hld(w, u);
for (int v : adj[u]) {
if (v == p || v == w) continue;
++pn;
hld(v, u);
}
};
dfs(1, 0);
hld(1, 0);
for (int i = 1; i < n; i++) {
if (dp[a[i]] < dp[b[i]]) swap(a[i], b[i]);
E[a[i]] = i;
}
Dinic::init();
int source = Dinic::add_node();
int sink = Dinic::add_node();
function<void(int, int, int)> build = [&](int u, int l, int r) {
node[u] = Dinic::add_node();
if (l == r) {
edge[l] = node[u];
Dinic::add_edge(node[u], sink, 1);
return;
}
int mid = l + r >> 1;
build(u + u, l, mid);
build(u + u + 1, mid + 1, r);
Dinic::add_edge(node[u], node[u + u], inf);
Dinic::add_edge(node[u], node[u + u + 1], inf);
};
build(1, 1, n);
function<void(int, int, int, int, int, int)> add =
[&](int u, int l, int r, int ll, int rr, int x) {
assert(ll > 1);
if (ll <= l && r <= rr) {
Dinic::add_edge(x, node[u], inf);
return;
}
int mid = l + r >> 1;
if (ll <= mid) add(u + u, l, mid, ll, rr, x);
if (mid < rr) add(u + u + 1, mid + 1, r, ll, rr, x);
};
auto paint = [&](int r, int u, int v) {
while (pid[u] != pid[v]) {
int x = hd[pid[u]], y = hd[pid[v]];
if (dp[x] < dp[y]) swap(u, v), swap(x, y);
add(1, 1, n, st[x], st[u], r);
u = par[x];
}
if (dp[u] < dp[v]) swap(u, v);
if (u != v) add(1, 1, n, st[v] + 1, st[u], r);
};
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
qnode[i] = Dinic::add_node();
Dinic::add_edge(source, qnode[i], 1);
paint(qnode[i], x[i], y[i]);
}
int ret = Dinic::min_cut(source, sink, ans);
vector<int> A, B;
for (int i = 0; i < m; i++)
if (!ans[qnode[i]]) A.push_back(i + 1);
for (int i = 1; i <= n; i++)
if (ans[edge[st[i]]]) B.push_back(E[i]);
cout << ret << endl;
cout << A.size();
for (int x : A) cout << ' ' << x;
cout << endl;
cout << B.size();
for (int x : B) cout << ' ' << x;
cout << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2;
struct node {
int pre;
int realtion;
} f[maxn];
map<string, int> mp;
int find(int x) {
if (f[x].pre == -1) return x;
int tmp = f[x].pre;
f[x].pre = find(tmp);
f[x].realtion = (f[x].realtion + f[tmp].realtion) % 2;
return f[x].pre;
}
int main() {
int n, m, q, i, j, k, x, y, z, fx, fy, ans, cnt;
string s, s1, s2;
while (scanf("%d%d%d", &n, &m, &q) != EOF) {
mp.clear();
for (i = 1; i <= n; i++) {
cin >> s;
mp[s] = i;
}
for (i = 1; i <= n; i++) {
f[i].pre = -1;
f[i].realtion = 0;
}
for (i = 1; i <= m; i++) {
cin >> k >> s1 >> s2;
k--;
x = mp[s1];
y = mp[s2];
fx = find(x);
fy = find(y);
if (fx == fy) {
if ((f[x].realtion == f[y].realtion && !k) ||
(f[x].realtion != f[y].realtion && k))
printf("YES\n");
else
printf("NO\n");
} else {
f[fy].pre = fx;
f[fy].realtion = abs(f[x].realtion + k - f[y].realtion) % 2;
printf("YES\n");
}
}
for (i = 1; i <= q; i++) {
cin >> s1 >> s2;
x = mp[s1];
y = mp[s2];
fx = find(x);
fy = find(y);
if (fx != fy)
printf("3\n");
else
printf("%d\n", abs(-f[y].realtion + f[x].realtion) + 1);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int num = 0;
char c = getchar();
if (c == '-') return -read();
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num;
}
inline long long READ() {
long long num = 0;
char c = getchar();
if (c == '-') return -READ();
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num;
}
vector<int> nz[100007], nf[100007];
pair<int, int> en[100007];
int cost[100007];
int djg = 0;
bool lgl[100007], l8[100007];
int minv = ((int)0x3f3f3f3f), mincnt = 0;
long long ans = 1, ans2 = 0;
int n, m;
void dfs(int now) {
l8[now] = 1;
for (int i = 0; i < ((int)(nz[now]).size()); i++)
if (!l8[nz[now][i]]) dfs(nz[now][i]);
en[now] = make_pair(djg++, now);
}
void dfs2(int now) {
lgl[now] = 1;
if (cost[now] < minv) {
minv = cost[now];
mincnt = 1;
} else if (cost[now] == minv)
mincnt++;
for (int i = 0; i < ((int)(nf[now]).size()); i++)
if (!lgl[nf[now][i]]) dfs2(nf[now][i]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", cost + i);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
nz[a].push_back(b);
nf[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (!l8[i]) dfs(i);
sort(en + 1, en + n + 1);
for (int i = n; i >= 1; i--)
if (!lgl[en[i].second]) {
minv = ((int)0x3f3f3f3f);
dfs2(en[i].second);
ans = ans * mincnt % 1000000007;
ans2 += minv;
}
printf("%I64d %I64d\n", ans2, ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int MAX_N = 1e7 + 5;
const long long M = (long long)1e9 + 7;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void Char(char* ch) { scanf("%s", ch); }
template <typename t>
inline t abs(t a) {
if (a >= 0) return a;
return -a;
}
template <typename t>
inline t gcd(t a, t b) {
return !b ? a : gcd(b, a % b);
}
template <typename t>
inline t lcm(t a, t b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T modpow(T b, T p, T Mod) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
res %= Mod;
}
b *= b;
b %= Mod;
p >>= 1;
}
return res;
}
template <typename T>
inline T ModInv(T b, T Mod) {
return modpow(b, Mod - 2, Mod);
}
template <typename T>
inline T pwr(T b, T p) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
}
b *= b;
p >>= 1;
}
return res;
}
int e1, e2, d1;
template <typename T>
inline void extgcd(T a, T b) {
if (!b) {
e1 = 1, e2 = 0, d1 = a;
return;
}
extgcd(b, a % b);
T x1 = e2;
T y1 = e1 - (a / b) * e2;
e1 = x1;
e2 = y1;
}
template <typename T>
inline vector<T> Unique(vector<T> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[8] = {-1, 0, 1, 1, -1, 1, 0, -1};
int main() {
int t = 1, tc = 0;
while (t--) {
int n = Int(), m = Int();
string s[n + 1];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
int cnt = 0;
for (int k = 0; k < 8; k++) {
int x = i + dx[k], y = j + dy[k];
if (x >= 0 and x < n and y >= 0 and y < m) {
if (s[x][y] == '*') cnt++;
}
}
if (cnt) return puts("NO"), 0;
} else if (s[i][j] >= '1' and s[i][j] <= '8') {
int f = s[i][j] - '0';
int cnt = 0;
for (int k = 0; k < 8; k++) {
int x = i + dx[k], y = j + dy[k];
if (x >= 0 and x < n and y >= 0 and y < m) {
if (s[x][y] == '*') cnt++;
}
}
if (cnt != f) return puts("NO"), 0;
}
}
}
puts("YES");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1510;
map<int, vector<pair<int, int> > > d;
int arr[maxn], n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
int sum = 0;
for (int j = i; j >= 1; j--) {
sum += arr[j];
d[sum].push_back(make_pair(j, i));
}
}
int value = 0, ind = 0;
for (auto i : d) {
int l = 0, r = 0;
int br = 0;
for (auto j : d[i.first]) {
if (j.first > r) {
l = j.first;
r = j.second;
br++;
}
}
if (br > value) {
value = br;
ind = i.first;
}
}
cout << value << "\n";
int l = 0, r = 0;
for (auto j : d[ind]) {
if (j.first > r) {
cout << j.first << " " << j.second << "\n";
l = j.first;
r = j.second;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 7001, INF = 1e9;
int n;
int used[MAXN], sz[MAXN];
long long c[MAXN];
vector<int> g[MAXN];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) {
continue;
}
if ((a[i] & a[j]) == a[i]) {
g[j].push_back(i);
++sz[i];
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (!sz[j] && !used[j]) {
used[j] = 1;
for (int &k : g[j]) {
--sz[k];
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (!used[i]) {
ans += c[i];
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x;
int y;
char ch;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<char>> v(n, vector<char>(n, '0'));
queue<Node> q;
Node node;
node.x = 0;
node.y = 0;
node.ch = 'W';
q.push(node);
while (!q.empty()) {
auto curr = q.front();
q.pop();
int x = curr.x;
int y = curr.y;
if (x < 0 || x >= n || y < 0 || y >= n) continue;
if (v[x][y] != '0') continue;
char ch = curr.ch;
v[x][y] = ch;
char next;
if (ch == 'W') next = 'B';
if (ch == 'B') next = 'W';
Node dir1;
dir1.x = x - 2;
dir1.y = y - 1;
dir1.ch = next;
q.push(dir1);
Node dir2;
dir2.x = x - 2;
dir2.y = y + 1;
dir2.ch = next;
q.push(dir2);
Node dir3;
dir3.x = x + 2;
dir3.y = y - 1;
dir3.ch = next;
q.push(dir3);
Node dir4;
dir4.x = x + 2;
dir4.y = y + 1;
dir4.ch = next;
q.push(dir4);
Node dir5;
dir5.x = x - 1;
dir5.y = y + 2;
dir5.ch = next;
q.push(dir5);
Node dir6;
dir6.x = x - 1;
dir6.y = y - 2;
dir6.ch = next;
q.push(dir6);
Node dir7;
dir7.x = x + 1;
dir7.y = y - 2;
dir7.ch = next;
q.push(dir7);
Node dir8;
dir8.x = x + 1;
dir8.y = y + 2;
dir8.ch = next;
q.push(dir8);
}
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v[0].size(); j++) {
if (v[i][j] == '0')
cout << 'B';
else
cout << v[i][j];
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a[44], b[44];
int n, q, ans;
void dfs(int l, string cur) {
if (l == n) {
ans++;
return;
}
for (int i = 1; i <= q; i++) {
if (cur[0] != b[i][0]) continue;
string nxt = string(cur.begin() + 1, cur.end());
nxt = a[i][0] + nxt;
dfs(l + 1, nxt);
}
}
int main(void) {
cin >> n >> q;
for (int i = 1; i <= q; i++) cin >> a[i] >> b[i];
string cur = "a";
dfs(1, cur);
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-12, PI = acos(-1);
const int N = 6e5 + 9, M = 5e3 + 9, OO = 1e9 + 7, MOD = 1e9 + 7;
const long long inf = 1e18 + 9;
long long arr[M], tree[4 * M], tree2[4 * M];
int n, k, x, L;
long long query(int node, int start, int end, int lvl, int l, int r) {
int l_ = L + l;
int r_ = L + r;
long long ans = -1;
while (l_ <= r_) {
ans = max(ans, tree[l_]);
ans = max(ans, tree[r_]);
if ((l_ & 1) == 1) l_++;
if ((r_ & 1) == 0) r_--;
l_ >>= 1, r_ >>= 1;
}
return ans;
}
void update(int node, int start, int end, int lvl, int idx, long long val) {
int i = idx + L;
tree2[i] = max(tree2[i], val);
while (i != 1) i /= 2, tree2[i] = max(tree2[i * 2], tree2[i * 2 + 1]);
}
int main() {
cout << fixed << setprecision(12), ios::sync_with_stdio(false),
cin.tie(nullptr), cout.tie(nullptr);
cin >> n >> k >> x;
L = n;
while (L & (L - 1)) L++;
for (int i = 1; i <= n; ++i) cin >> arr[i];
memset(tree2, -1, sizeof tree2);
update(1, 0, L - 1, x, 0, 0);
for (int left = x - 1; left >= 0; --left) {
swap(tree, tree2);
memset(tree2, -1, sizeof tree2);
for (int i = 1; i <= n; ++i) {
int l = max(0, i - k), r = i - 1;
long long mx = query(1, 0, L - 1, left + 1, l, r);
if (mx == -1) continue;
update(1, 0, L - 1, left, i, mx + arr[i]);
}
}
long long ans = -1;
swap(tree, tree2);
for (int i = n - k + 1; i <= n; ++i)
ans = max(ans, query(1, 0, L - 1, 0, i, i));
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans, a[51][51], sz[51], f[51][51][51][4], g[4][51][2501],
jie[10001], fac[51][51][51], p = 1e9 + 7;
long long jia(long long &x, long long y) { x = (x + y) % p; }
int main() {
long long i, j, k, ii, jj, kk, x, id;
scanf("%lld%lld", &n, &m);
jie[0] = 1;
for (i = 1; i <= n; i++) jie[i] = jie[i - 1] * i % p;
for (i = 1; i <= n; i++) {
scanf("%lld%lld", &x, &id);
a[id][++sz[id]] = x;
}
for (i = 1; i <= 3; i++) {
g[i][0][0] = 1;
for (j = 1; j <= sz[i]; j++)
for (jj = j; jj; jj--)
for (k = m; k >= a[i][j]; k--) {
g[i][jj][k] = (g[i][jj][k] + g[i][jj - 1][k - a[i][j]]) % p;
}
}
f[0][0][0][1] = 1;
for (i = 0; i <= sz[1]; i++)
for (j = 0; j <= sz[2]; j++)
for (k = 0; k <= sz[3]; k++) {
fac[i][j][k] = jie[i] * jie[j] % p * jie[k] % p;
if (i == 0 && j == 0 && k == 0) {
if (sz[1]) f[1][0][0][1] = 1;
if (sz[2]) f[0][1][0][2] = 1;
if (sz[3]) f[0][0][1][3] = 1;
continue;
}
if (i < sz[1]) {
jia(f[i + 1][j][k][1], f[i][j][k][2] + f[i][j][k][3]);
}
if (j < sz[2]) {
jia(f[i][j + 1][k][2], f[i][j][k][1] + f[i][j][k][3]);
}
if (k < sz[3]) {
jia(f[i][j][k + 1][3], f[i][j][k][1] + f[i][j][k][2]);
}
}
for (i = 0; i <= sz[1]; i++)
for (ii = 0; ii <= i * 50 && ii <= m; ii++)
if (g[1][i][ii]) {
for (j = 0; j <= sz[2]; j++)
for (jj = 0; jj <= j * 50 && ii + jj <= m; jj++)
if (g[2][j][jj]) {
kk = m - ii - jj;
for (k = 0; k <= sz[3]; k++)
if (g[3][k][kk])
ans = (ans + (f[i][j][k][1] + f[i][j][k][2] + f[i][j][k][3]) *
g[1][i][ii] % p * g[2][j][jj] % p *
g[3][k][kk] % p * fac[i][j][k] % p) %
p;
}
}
printf("%lld", ans);
}
| 9 |
#include <bits/stdc++.h>
int func(const void *a, const void *b) { return (*(int *)a - *(int *)b); }
int main() {
int i, j, k, arr[13], sum = 0;
scanf("%d", &k);
for (i = 0; i < 12; i++) {
scanf("%d", &arr[i]);
sum += arr[i];
}
if (k == 0) {
printf("0\n");
return (0);
}
if (sum < k)
printf("-1\n");
else {
sum = 0;
j = 0;
qsort(arr, 12, sizeof(int), func);
for (i = 11; i >= 0; i--) {
if (sum + arr[i] >= k) {
j++;
printf("%d\n", j);
break;
}
j++;
sum += arr[i];
}
}
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r, x1, y1, x2, y2, p, k;
cin >> r >> x1 >> y1 >> x2 >> y2;
p = sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
k = ceil(p / (2 * r));
cout << k << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, imi;
long double x, y, mi;
vector<complex<long double> > v;
vector<pair<long double, int> > vv;
complex<long double> aux;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
aux = complex<long double>(x, y);
v.push_back(aux);
vv.push_back(make_pair(arg(aux), i));
}
sort(vv.begin(), vv.end());
mi = 4.0 * acos(0.0);
imi = -1;
for (i = 0; i < n; i++) {
aux = v[vv[i].second] / v[vv[(i + 1) % n].second];
if (mi > fabs(arg(aux))) {
mi = fabs(arg(aux));
imi = i;
}
}
cout << (vv[imi].second + 1) << " " << (vv[(imi + 1) % n].second + 1) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y);
long long mpower(long long x, long long y, long long p);
long long modInv(long long a, long long m);
long long gcdExtended(long long a, long long b, long long *x, long long *y);
bool isPrime(long long n);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, i, j, k, l, h, p, q, r, x, y, z, a, b, c, d, f, n, m,
M = 1000000007;
char ch, ch2, ch3;
string s, s1, s2, s3;
vector<long long> v, w;
set<long long> S;
cin >> t;
while (t--) {
cin >> n;
long long A[n], B[n];
for (i = 0; i < n; i++) {
cin >> A[i];
}
for (i = 0; i < n; i++) {
cin >> B[i];
}
f = 0;
c = 0;
for (i = 0; i < n; i++) {
p = max(A[i] - c, (long long)0);
q = max((long long)0, B[i] - p);
c = q;
}
for (i = 0; i < n; i++) {
p = max(A[i] - c, (long long)0);
q = max((long long)0, B[i] - p);
if (B[i] < p) {
f = 1;
break;
}
c = q;
}
if (f) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
long long modInv(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
long long res = (x % m + m) % m;
return res;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long mpower(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
long long p = sqrt(n);
for (int i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n,sol[200005];
int mic[1000005][3],mare[1000005][3],valmic[1000005],valmare[1000005];
struct date
{
int poz,val;
} v[200005];
bool comp(date a, date b)
{
return a.val<b.val;
}
void propmic(int nod)
{
int x=mic[nod][2];
for(auto i:{0,1,2})
{
mic[nod*2][i]+=x;
mic[nod*2+1][i]+=x;
}
}
void propmare(int nod)
{
int x=mare[nod][2];
for(auto i:{0,1,2})
{
mare[nod*2][i]+=x;
mare[nod*2+1][i]+=x;
}
}
void updatemic(int nod,int st,int dr,int a, int b,int val)
{
if(mic[nod][2]!=0)
{
if(st!=dr)
propmic(nod);
mic[nod][2]=0;
}
if(st>=a&&dr<=b)
{
mic[nod][0]+=val;
mic[nod][1]+=val;
mic[nod][2]+=val;
return;
}
int mij=(st+dr)/2;
if(a<=mij)
updatemic(nod*2,st,mij,a,b,val);
if(b>mij)
updatemic(nod*2+1,mij+1,dr,a,b,val);
mic[nod][0]=min(mic[nod*2][0],mic[nod*2+1][0]);
mic[nod][1]=max(mic[nod*2][1],mic[nod*2+1][1]);
}
void updatemare(int nod,int st,int dr,int a, int b,int val)
{
if(mare[nod][2]!=0)
{
if(st!=dr)
propmare(nod);
mare[nod][2]=0;
}
if(st>=a&&dr<=b)
{
mare[nod][0]+=val;
mare[nod][1]+=val;
mare[nod][2]+=val;
return;
}
int mij=(st+dr)/2;
if(a<=mij)
updatemare(nod*2,st,mij,a,b,val);
if(b>mij)
updatemare(nod*2+1,mij+1,dr,a,b,val);
mare[nod][0]=min(mare[nod*2][0],mare[nod*2+1][0]);
mare[nod][1]=max(mare[nod*2][1],mare[nod*2+1][1]);
}
int minimMIC(int nod,int st,int dr,int a, int b)
{
if(mic[nod][2]!=0)
{
if(st!=dr)
propmic(nod);
mic[nod][2]=0;
}
if(st>=a&&dr<=b)
return mic[nod][0];
int mij=(st+dr)/2;
int ans=1e18;
if(a<=mij)
ans=min(ans,minimMIC(nod*2,st,mij,a,b));
if(b>mij)
ans=min(ans,minimMIC(nod*2+1,mij+1,dr,a,b));
return ans;
}
int minimMARE(int nod,int st,int dr,int a, int b)
{
if(mare[nod][2]!=0)
{
if(st!=dr)
propmare(nod);
mare[nod][2]=0;
}
if(st>=a&&dr<=b)
return mare[nod][0];
int mij=(st+dr)/2;
int ans=1e18;
if(a<=mij)
ans=min(ans,minimMARE(nod*2,st,mij,a,b));
if(b>mij)
ans=min(ans,minimMARE(nod*2+1,mij+1,dr,a,b));
return ans;
}
int maximMIC(int nod,int st,int dr,int a, int b)
{
if(mic[nod][2]!=0)
{
if(st!=dr)
propmic(nod);
mic[nod][2]=0;
}
if(st>=a&&dr<=b)
return mic[nod][1];
int mij=(st+dr)/2;
int ans=-1e18;
if(a<=mij)
ans=max(ans,maximMIC(nod*2,st,mij,a,b));
if(b>mij)
ans=max(ans,maximMIC(nod*2+1,mij+1,dr,a,b));
return ans;
}
int maximMARE(int nod,int st,int dr,int a, int b)
{
if(mare[nod][2]!=0)
{
if(st!=dr)
propmare(nod);
mare[nod][2]=0;
}
if(st>=a&&dr<=b)
return mare[nod][1];
int mij=(st+dr)/2;
int ans=-1e18;
if(a<=mij)
ans=max(ans,maximMARE(nod*2,st,mij,a,b));
if(b>mij)
ans=max(ans,maximMARE(nod*2+1,mij+1,dr,a,b));
return ans;
}
void make(int poz,int vmic,int vmare)
{
updatemic(1,0,n,poz,n,-valmic[poz]);
updatemare(1,0,n,poz,n,-valmare[poz]);
valmic[poz]=vmic;
valmare[poz]=vmare;
updatemic(1,0,n,poz,n,valmic[poz]);
updatemare(1,0,n,poz,n,valmare[poz]);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>v[i].val;
v[i].poz=i;
}
sort(v+1,v+n+1,comp);
for(int i=1;i<=n;i++)
{
valmic[i]=-1,valmare[i]=1;
updatemic(1,0,n,i,n,-1);
updatemare(1,0,n,i,n,1);
}
for(int p=1;p<=n;p++)
{
int nr=v[p].val,poz=v[p].poz;
if(nr!=v[p-1].val)
{
for(int j=p;j<=n&&v[j].val==nr;j++)
make(v[j].poz,1,1);
for(int j=p-1;j>=1&&v[j].val==v[p-1].val;j--)
make(v[j].poz,1,-1);
}
make(poz,0,0);
int dif1=maximMARE(1,0,n,poz,n)-minimMARE(1,0,n,0,poz-1);
int dif2=maximMIC(1,0,n,poz,n)-minimMIC(1,0,n,0,poz-1);
int dif=max(dif1,dif2);
// insert formula
sol[poz]=max(dif1/2+dif1%2,dif2/2);
make(poz,1,1);
}
for(int i=1;i<=n;i++)
cout<<sol[i]<<" ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101010;
int deg[MAXN], n, e[MAXN];
vector<pair<int, int> > G[MAXN];
int main() {
memset(e, -1, sizeof e);
scanf("%d", &n);
if (n == 2) {
puts("0");
return 0;
}
int z = 0;
for (int i = 1; i < n; ++i) {
static int u, v;
scanf("%d%d", &u, &v);
G[u].emplace_back(v, i - 1);
G[v].emplace_back(u, i - 1);
deg[u]++;
deg[v]++;
}
queue<int> q;
for (int i = 1; i <= n; ++i)
if (deg[i] == 1) e[G[i][0].second] = z++;
for (int i = 0; i < n - 1; ++i) {
if (e[i] == -1) e[i] = z++;
printf("%d\n", e[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 0;
cin >> n;
bool isPrime = false;
for (int m = 1; m < 1000; m++) {
int z = (n * m) + 1;
for (int i = 2; i <= z / 2; ++i) {
if (z % i == 0) {
isPrime = true;
cout << m << endl;
break;
}
}
if (isPrime) {
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e6 + 6;
long long n;
long long a[max_n];
long long cnt = 1;
int main() {
cin >> n;
for (int i = 2; i < max_n; i++) {
if (a[i] != 0) continue;
a[i] = cnt;
for (int j = 2 * i; j < max_n - 1; j += i) {
a[j] = cnt;
}
cnt++;
}
for (int i = 2; i <= n; i++) cout << a[i] << " ";
cout << '\n';
return 0;
}
| 2 |
/* Author : Anmol Gera
NSIT 4th Year */
#include<bits/stdc++.h>
using namespace std;
#define int long long
void anmol()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool isPerfectSquare(long double x)
{
// Find floating point value of
// square root of x.
long double sr = sqrt(x);
// If square root is an integer
return ((sr - floor(sr)) == 0);
}
/*
while(lo < hi) {
int mid = lo + (hi - lo) / 2;
if(Special condition passed)(optional):
return mid;
if(condition passed)
hi = mid;
else
lo = mid + 1;
}
return lo;
*/
int mod = 1e9 + 7,mxn=3e5 + 5;
int add(int a, int b,int mod) {
a%=mod;
b%=mod;
a += b;
if (a >= mod) a -= mod;
if(a<0)
{
a += mod;
a %= mod;
}
return a;
}
int mul(int a, int b,int mod) {
a%=mod;
b%=mod;
a *= b;
a += mod;
return a % mod;
}
int po(int a,int b,int mod)
{
if(b==0)
return 1;
if(b%2==0)
return po(mul(a,a,mod),b/2,mod);
return mul(a,po(mul(a,a,mod),(b-1)/2,mod),mod);
}
int fact[200003];
int inv[200003];
void fact0()
{
int i,j;
fact[0]=1;
for(i=1;i<=200000;i++)
{
fact[i]=i*fact[i-1]%mod;
}
inv[0]=1;
inv[1]=1;
int p=mod;
for (i=2; i<=200000; i++)
inv[i] = (p - (p/i) * inv[p%i] % p) % p;
for(i=2;i<=200000;i++)
{
inv[i]*=inv[i-1];
inv[i]%=mod;
}
}
int Comb(int a,int b)
{
// cout<<a<<" "<<b<<endl;
int an = fact[a];
//cout<<an<<endl;
an *= inv[b];
an %= mod;
an *= inv[a-b];
an %= mod;
return an;
}
void solve(){
int n,k;
cin>>n>>k;
int a[n];
map<int,int> mp;
for(int i =0; i<n; i++){
cin>>a[i];
mp[a[i]]++;
}
sort(a,a+n);
reverse(a,a+n);
int total = mp[a[k]];
int r =0;
for(int i =0; i<k; i++){
if(a[k]==a[i]){
r++;
}
}
//cout<<total<<r<<endl;
cout<<Comb(total,r)<<endl;
}
int32_t main(){
anmol();
fact0();
int t;
///t =1;
cin>>t;
while(t--){
//hhgfhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
//hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
//hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
//hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
/// hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh'b'
//int a,b;
//cin>>a>>b;
solve();
//""""""""""""
//cout<<fact[a] - fact[b];
// look for base cases always
//lkjgfdsaqwertyuiop.,mnbvcxz=-87564321`()hH" "
/*Hello Kanika,
I am Anmol Gera currently in my final year. I came across a FTE opening at Amazon - Bangalore.
The job id for the same is: 1391296
Here, is the link for the same:
https://www.amazon.jobs/en/jobs/1391296/software-development-engineer
Leetcode -https://leetcode.com/anmolgera/
Codeforces -https://codeforces.com/profile/DumbCarlsen69
I have Solved around 1000 questions on all the sites Combined. Have participated in more than 70 contests on codeforces and Currently a specialist.
You can see my cv, I have attached that as well.
Thanks a lot for your valuable time.
*/
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long mod1 = 998244353;
const int N = 2e6 + 12;
bool p[N];
long long a[2000], n, c = 0;
vector<int> ans;
void show() {
cout << (long long)ans.size() << "\n";
for (auto it : ans) cout << it << " ";
return;
}
void solve() {
for (int i = 0; i < N; i++) p[i] = 1;
p[0] = p[1] = 0;
for (long long i = 2; i < N; i++)
if (p[i]) {
for (long long j = i * i; j < N; j += i) p[j] = 0;
}
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) c += (a[i] == 1);
if (c > 1) {
for (int i = 0; i < c; i++) ans.push_back(1);
for (int i = c; i < n; i++)
if (p[a[i] + 1]) {
ans.push_back(a[i]);
break;
}
show();
return;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (p[a[i] + a[j]]) {
ans.push_back(a[i]);
ans.push_back(a[j]);
show();
return;
}
}
}
ans.push_back(a[0]);
show();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int MAXN = 1e5 + 5;
const int MAXM = 2e6 + 5;
const int MOD = 1e9 + 7;
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
long long pw(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void inc(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
void dec(long long &a, long long b) {
a -= b;
if (a < 0) a += MOD;
}
int mul(int a, int b) {
long long c = 1ll * a * b;
return c - c / MOD * MOD;
}
struct SAM {
int fail[MAXN * 2], nxt[MAXN * 2][26];
int len[MAXN * 2], right[MAXN * 2];
int cnt;
int new_node(int v) {
++cnt;
fail[cnt] = 0, right[cnt] = 0, len[cnt] = v;
for (int i = 0; i < 26; i++) nxt[cnt][i] = 0;
return cnt;
}
int root, last;
SAM() { clear(); }
void clear() { root = last = new_node(cnt = 0); }
void add(int c) {
int p = last, np = new_node(len[p] + 1);
while (p && !nxt[p][c]) nxt[p][c] = np, p = fail[p];
if (!p)
fail[np] = root;
else {
int q = nxt[p][c];
if (len[p] + 1 == len[q])
fail[np] = q;
else {
int nq = new_node(len[p] + 1);
for (int i = 0; i < 26; i++) nxt[nq][i] = nxt[q][i];
fail[nq] = fail[q], fail[q] = fail[np] = nq;
while (p && nxt[p][c] == q) nxt[p][c] = nq, p = fail[p];
}
}
last = np, right[np] = 1;
}
int d[MAXN * 2], b[MAXN * 2];
void topo() {
for (int i = 0; i < cnt + 1; i++) d[i] = 0;
int mx = 0;
for (int i = 1; i < cnt + 1; i++) mx = max(mx, len[i]), d[len[i]]++;
for (int i = 1; i < mx + 1; i++) d[i] += d[i - 1];
for (int i = 1; i < cnt + 1; i++) b[d[len[i]]--] = i;
}
void upd() {
topo();
for (int i = cnt + 1 - 1; i >= 2; i--) right[fail[b[i]]] += right[b[i]];
}
void work() {
long long ans = 0;
for (int i = 2; i < cnt + 1; i++)
ans += 1ll * (len[i] - len[fail[i]]) * (right[i] + 1) * right[i] / 2;
printf("%lld\n", ans);
}
} sm;
char s[MAXN];
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) sm.add(s[i] - 'a');
sm.upd();
sm.work();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1050;
int n, a[N], cnt[N], sol, mx = 0;
void cl() {
for (int i = 0; i < N; i++) cnt[i] = 0;
}
int main() {
scanf("%i", &n);
cl();
sol = n;
for (int i = 0; i < n; i++) {
scanf("%i", &a[i]);
cnt[a[i]]++, mx = max(mx, cnt[a[i]]);
if (cnt[a[i]] >= 2) sol--;
}
printf("%i %i", mx, sol);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int ding = 1000005;
const double eps = 1e-8;
long long n, m, z, x[100005], y[100005], a[2000011], l, r, mi, sum, node, t;
long long tx[100005], ty[100005];
long double ans, zc;
double fans;
inline int pre(int l) {
if (l > 1)
return l - 1;
else
return n;
}
inline int next(int l) {
if (l < n)
return l + 1;
else
return 1;
}
inline int workx(int p, int l, int r) {
int a, b;
if (x[l] == x[pre(l)])
a = min(y[l], y[pre(l)]) - 1;
else
a = ceil(y[l] + (y[pre(l)] - y[l]) / (1.0 * x[pre(l)] - x[l]) * (p - x[l]) -
eps) -
1;
if (x[r] == x[next(r)])
b = max(y[r], y[next(r)]);
else
b = floor(y[r] +
(y[next(r)] - y[r]) / (1.0 * x[next(r)] - x[r]) * (p - x[r]) +
eps);
return b - a;
}
inline int worky(int p, int l, int r) {
int a, b;
if (y[l] == y[pre(l)])
a = max(x[l], x[pre(l)]);
else
a = floor(x[l] +
(x[pre(l)] - x[l]) * (p - y[l]) / (1.0 * y[pre(l)] - y[l]));
if (y[r] == y[next(r)])
b = min(x[r], x[next(r)]) - 1;
else
b = ceil(x[r] +
(x[next(r)] - x[r]) * (p - y[r]) / (1.0 * y[next(r)] - y[r])) -
1;
return a - b;
}
inline void work() {
zc = 0;
for (long long i = 0; i <= 2 * ding; ++i)
if (a[i] > 0) {
z = i - ding;
zc += 1.0 * a[i] * z * z;
sum += a[i] * z;
}
ans += zc / (node * 1.0);
zc = 0;
for (long long i = 0; i <= 2 * ding; ++i)
if (a[i] > 0) {
z = i - ding;
zc += 1.0 * a[i] * z * (sum - z);
}
ans -= zc / (node * 1.0) / ((node - 1) * 1.0);
}
int main() {
scanf("%I64d", &n);
mi = 2 * ding;
for (int i = 1; i <= n; ++i) {
scanf("%I64d%I64d", &x[i], &y[i]);
if (x[i] + ding < mi) mi = x[i] + ding, l = i;
}
for (int i = 1; i <= n; ++i)
tx[i] = x[(i + l - 2) % n + 1], ty[i] = y[(i + l - 2) % n + 1];
for (int i = 1; i <= n; ++i) x[i] = tx[i], y[i] = ty[i];
if (y[2] < y[n])
for (int i = 2; i <= (n + 1) / 2; ++i)
swap(x[i], x[n - i + 2]), swap(y[i], y[n - i + 2]);
t = x[1];
r = l = 1;
for (int i = 1; i <= n - 1; ++i) {
if (x[pre(l)] <= x[next(r)]) {
for (int j = t; j < x[pre(l)]; ++j) a[j + ding] = workx(j, l, r);
l = pre(l);
t = x[l];
} else {
for (int j = t; j < x[next(r)]; ++j) a[j + ding] = workx(j, l, r);
r = next(r);
t = x[r];
}
}
a[x[l] + ding] = workx(x[l], next(l), r);
node = 0;
for (long long i = 0; i <= 2 * ding; ++i) node += a[i];
work();
memset(a, 0, sizeof(a));
sum = 0;
mi = 2 * ding;
for (int i = 1; i <= n; ++i)
if (y[i] + ding < mi) mi = y[i] + ding, l = i;
r = l;
t = y[l];
for (int i = 1; i <= n - 1; ++i) {
if (y[pre(l)] <= y[next(r)]) {
for (int j = t; j < y[pre(l)]; ++j) a[j + ding] = worky(j, l, r);
l = pre(l);
t = y[l];
} else {
for (int j = t; j < y[next(r)]; ++j) a[j + ding] = worky(j, l, r);
r = next(r);
t = y[r];
}
}
a[y[l] + ding] = worky(y[l], next(l), r);
work();
fans = ans;
printf("%.10lf", fans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
long long n, m, t, a[300001], b[300001], c[300001];
long long i, j, k, realm;
vector<long long> vec;
void solution() {
cin >> n;
;
cin >> m;
;
for (i = 0; i < n; i++) {
cin >> a[i];
;
a[i]--;
b[i] = 0;
}
for (i = 0; i < n; i++) {
b[(n + i - a[i]) % n]++;
}
for (k = 0; k < n; k++) {
if (b[k] >= n / 3) {
for (i = 0; i < n; i++) {
if ((n + i - a[i]) % n == k) {
c[i] = 1;
} else {
c[i] = 0;
}
}
realm = 0;
for (i = 0; i < n; i++) {
if (c[i] == 0) {
c[i] = 1;
j = (a[i] + k) % n;
while (c[j] == 0) {
c[j] = 1;
j = (a[j] + k) % n;
realm++;
}
}
}
if (realm <= m) {
vec.push_back(k);
}
}
}
cout << vec.size();
;
for (i = 0; i < vec.size(); i++) {
cout << ' ';
;
cout << vec[i];
;
}
cout << '\n';
;
vec.clear();
}
int main() {
ios::sync_with_stdio(false);
long long ttt;
cin >> ttt;
;
while (ttt--) {
solution();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, Pos, Low, High;
string str;
cin >> N >> M;
Low = 0, High = N + 1;
Pos = 0;
bool flag = false;
for (int i = 0; i < M; i++) {
cin >> str;
cin >> str;
cin >> str;
bool whattodo = false;
if (str == "left") whattodo = true;
cin >> str;
cin >> Pos;
if (Pos > Low && Pos < High) {
if (whattodo)
High = Pos;
else
Low = Pos;
} else {
if (Pos <= Low && whattodo == true) flag = true;
if (Pos >= High && whattodo == false) flag = true;
}
}
int res = High - Low - 1;
if (res < 1 || flag)
cout << "-1\n";
else
cout << High - Low - 1 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p1, p2, q1, q2;
int ope(int o, int a, int b, int c, int d) {
if (!o || a > b || c > d) return 0;
if (a > c || (a == c && b > d)) return ope(o, c, d, a, b);
if (d <= b) return d - c + 1;
if (a == c) return b - a + 1;
int k = (1 << o) >> 1;
if (d < k) return ope(o - 1, a, b, c, d);
if (a > k) return ope(o - 1, a - k, b - k, c - k, d - k);
if (b < k && c > k) return ope(o - 1, a, b, c - k, d - k);
if (b < k) return max(ope(o - 1, a, b, c, k - 1), ope(o - 1, a, b, 1, d - k));
if (c > k)
return max(ope(o - 1, a, k - 1, c - k, d - k),
ope(o - 1, 1, b - k, c - k, d - k));
return max(min(b, d) - c + 1, max(ope(o - 1, a, k - 1, 1, d - k),
ope(o - 1, c, k - 1, 1, b - k)));
}
int main() {
scanf("%d%d%d%d", &p1, &p2, &q1, &q2);
printf("%d\n", ope(30, p1, p2, q1, q2));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, x, k;
int a[100000 + 5];
int cal(int i, int j) {
int ii = a[i], jj = a[j];
return max(ii, jj) / x - (min(ii, jj) - 1) / x;
}
int bsearch1(int id) {
int left = 1, right = n, mid, ans = -1;
while (left <= right) {
mid = (left + right) >> 1;
int cur = cal(id, mid);
if (a[mid] < a[id] || cur < k) {
left = mid + 1;
} else if (cur == k) {
ans = mid;
right = mid - 1;
} else {
right = mid - 1;
}
}
return ans;
}
int bsearch2(int id) {
int left = 1, right = n, mid, ans = -1;
while (left <= right) {
mid = (left + right) >> 1;
int cur = cal(id, mid);
if (a[mid] < a[id] || cur < k) {
left = mid + 1;
} else if (cur == k) {
ans = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
return ans;
}
long long solve() {
long long ans = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int pos1 = bsearch1(i), pos2 = bsearch2(i);
if (pos1 != -1 && pos2 != -1) ans += 1LL * (pos2 - pos1 + 1);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &x, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
return !printf("%I64d\n", solve());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve(int ar[], int l) {
for (int i = l - 1; i >= 0; i--) {
cout << ar[i] << " ";
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l;
cin >> l;
int arr[l];
for (int tt = 0; tt < l; tt++) {
cin >> arr[tt];
}
solve(arr, l);
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct Point {
long long x, y;
Point(long long x = 0, long long y = 0) : x(x), y(y) {}
Point operator-(const Point& B) { return Point(x - B.x, y - B.y); }
} Point;
int cmp(const Point& a, const Point& b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
Point p[400005], q[400005];
long long Cross(const Point& A, const Point& B) {
return A.x * B.y - A.y * B.x;
}
int dis(const Point& a, const Point& b) {
return max(abs(a.x - b.x), abs(a.y - b.y));
}
int n0, n, N;
long long ans;
int Andrew_convexhull() {
sort(p, p + n, cmp);
int m = 0;
for (int i = 0; i < n; i++) {
while (m > 1 && Cross(q[m - 1] - q[m - 2], p[i] - q[m - 2]) <= 0) m--;
q[m++] = p[i];
}
for (int k = m, i = n - 2; i >= 0; i--) {
while (m > k && Cross(q[m - 1] - q[m - 2], p[i] - q[m - 2]) <= 0) m--;
q[m++] = p[i];
}
if (n > 1) m--;
return m;
}
int main(void) {
scanf("%d", &n0);
long long x, y;
for (int i = 0; i < n0; i++) {
scanf("%lld%lld", &x, &y);
p[n++] = Point(x + 1, y);
p[n++] = Point(x - 1, y);
p[n++] = Point(x, y + 1);
p[n++] = Point(x, y - 1);
}
N = Andrew_convexhull(), q[N] = q[0];
for (int i = 1; i <= N; i++) ans += dis(q[i], q[i - 1]);
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long int c[100001];
using namespace std;
int main() {
long long int i, j, k;
long long int n, sum = 0;
cin >> n;
long long int a[n];
map<long long int, long long int> mp;
for (i = 0; i < n; i++) cin >> a[i], mp[a[i]]++;
c[0] = 0;
c[1] = mp[1];
for (i = 2; i <= 100001; i++) {
c[i] = max(c[i - 1], c[i - 2] + (i * mp[i]));
}
cout << c[100001];
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 5010;
using namespace std;
int ans[N];
int getSum(int i, int j) {
int sum;
printf("? %d %d\n", i, j);
fflush(stdout);
scanf("%d", &sum);
return sum;
}
int main() {
int n;
scanf("%d", &n);
int ab, ac, bc;
ab = getSum(1, 2);
ac = getSum(1, 3);
bc = getSum(2, 3);
int c = (bc - ab + ac) / 2;
int b = bc - c;
int a = ac - c;
ans[1] = a;
ans[2] = b;
ans[3] = c;
for (int i = 3; i < n; i++) {
ans[i + 1] = getSum(i, i + 1) - ans[i];
}
printf("!");
for (int i = 1; i <= n; i++) {
printf(" %d", ans[i]);
}
putchar('\n');
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e18;
struct pt {
double x, y;
pt() {}
pt(double a, double b) {
x = a;
y = b;
}
};
int d[4][2];
double dist(pt a, pt b) {
double x = a.x - b.x;
double y = b.y - a.y;
return sqrt(x * x + y * y);
}
double ma(pt a, pt b) {
double res = fabs(a.x - b.x) + fabs(a.y - b.y);
return res;
}
int main() {
double a, b, c;
cin >> a >> b >> c;
pt A, B;
cin >> A.x >> A.y >> B.x >> B.y;
cout.precision(15);
cout.fixed;
long long manh = ma(A, B);
if (a == 0 || b == 0) {
cout << manh;
return 0;
}
d[0][0] = 0;
d[0][1] = 0;
d[1][0] = 0;
d[1][1] = 1;
d[2][0] = 1;
d[2][1] = 0;
d[3][0] = 1;
d[3][1] = 1;
double ans = INF;
for (int i = 0; i <= 3; i++) {
int a1, a2;
a1 = d[i][0];
a2 = d[i][1];
double cur;
pt o1, o2;
if (a1 == 0 && a2 == 0) {
double y1 = -(A.x * a + c) / double(b);
double y2 = -(B.x * a + c) / double(b);
o1 = pt(A.x, y1);
o2 = pt(B.x, y2);
}
if (a1 == 0 && a2 == 1) {
double y1 = -(A.x * a + c) / double(b);
double x2 = -(B.y * b + c) / double(a);
o1 = pt(A.x, y1);
o2 = pt(x2, B.y);
}
if (a1 == 1 && a2 == 0) {
double x1 = -(A.y * b + c) / double(a);
double y2 = -(B.x * a + c) / double(b);
o1 = pt(x1, A.y);
o2 = pt(B.x, y2);
}
if (a1 == 1 && a2 == 1) {
double x1 = -(A.y * b + c) / double(a);
double x2 = -(B.y * b + c) / double(a);
o1 = pt(x1, A.y);
o2 = pt(x2, B.y);
}
cur = dist(o1, o2) + ma(A, o1) + ma(o2, B);
ans = min(ans, cur);
}
ans = min(ans, ma(A, B));
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const long long INF = 1e18 + 7;
const int MAXN = 1e3 + 5;
const double eps = 1e-9;
using namespace std;
long long a[MAXN], dist[MAXN];
pair<long long, long long> loc[MAXN];
int par[MAXN];
long long cost(int x, int y, long long d) {
return d * (abs(loc[x].first - loc[y].first) +
abs(loc[x].second - loc[y].second));
}
int main() {
long long n, d;
scanf("%I64d", &(n)), scanf("%I64d", &(d));
for (int i = 1; i + 1 < n; i++) scanf("%I64d", &(a[i]));
for (int i = 0; i < n; i++)
scanf("%I64d", &(loc[i].first)), scanf("%I64d", &(loc[i].second)),
dist[i] = INF;
dist[0] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push({0, 0});
while (!pq.empty()) {
pair<long long, long long> cur = pq.top();
pq.pop();
for (int i = 0; i < n; i++) {
if (i == cur.second) continue;
long long c = cost(i, cur.second, d);
if (dist[i] > dist[cur.second] + c - a[i]) {
dist[i] = dist[cur.second] + c - a[i];
pq.push({dist[i], i});
par[i] = cur.second;
}
}
}
printf("%I64d\n", (dist[n - 1]));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, p, ans[1000 + 10], a[5], c[5];
int solve(int x, int p) {
int sol = 10000;
a[1] = c[1] = x / 1000 % 10;
a[2] = c[2] = x / 100 % 10;
a[3] = c[3] = x / 10 % 10;
a[4] = c[4] = x % 10;
for (int i = 1; i <= 9; i++) {
a[1] = i;
int nr = a[1] * 1000 + a[2] * 100 + a[3] * 10 + a[4];
if (nr >= 1000 && nr <= 2011 && nr < sol && nr >= p) sol = nr;
}
a[1] = c[1];
for (int i = 2; i <= 4; i++) {
for (int j = 0; j <= 9; j++) {
a[i] = j;
int nr = a[1] * 1000 + a[2] * 100 + a[3] * 10 + a[4];
if (nr >= 1000 && nr <= 2011 && nr < sol && nr >= p) sol = nr;
}
a[i] = c[i];
}
if (sol >= 1000 && sol <= 2011 && sol >= p) return sol;
return -1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
int y = solve(x, p);
if (y == -1) {
cout << "No solution" << '\n';
return 0;
} else
ans[i] = y;
p = y;
}
for (int i = 1; i <= n; i++) cout << ans[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
#define aashish_999 ios_base::sync_with_stdio(false);cin.tie(NULL)
void solve()
{
//read the question properly
int n;
cin >> n;
string s;
cin >> s;
vector<int> pos;
int in = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '*')
pos.push_back(i);
}
int mn = 0;
int center = (pos.size() + 1) / 2 - 1;
for (int i = 0; i < pos.size(); i++) {
mn += abs(pos[center] - pos[i]) - abs(center - i);
}
cout << mn << endl;
}
int32_t main()
{
aashish_999;
int testcases = 1;
cin >> testcases;
while (testcases--)
{
solve();
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
long long int ans[100001];
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
int i, j, n, t, x, y, a, b, c, p, r, s;
string str;
cin >> t;
while (t--) {
cin >> n;
cin >> a >> b >> c;
cin >> str;
r = 0;
p = 0;
s = 0;
for (i = 0; i < n; i++) {
if (str[i] == 'R')
r++;
else if (str[i] == 'P')
p++;
else
s++;
}
x = min(r, b) + min(p, c) + min(s, a);
if (x < (n + 1) / 2) {
cout << "NO"
<< "\n";
continue;
}
cout << "YES"
<< "\n";
for (i = 0; i < n; i++) ans[i] = -1;
for (i = 0; i < n; i++) {
if (str[i] == 'R' && b > 0) {
ans[i] = 1;
b--;
} else if (str[i] == 'P' && c > 0) {
ans[i] = 2;
c--;
} else if (str[i] == 'S' && a > 0) {
ans[i] = 0;
a--;
}
}
for (i = 0; i < n; i++) {
if (ans[i] != -1) continue;
if (a > 0) {
ans[i] = 0;
a--;
} else if (b > 0) {
ans[i] = 1;
b--;
} else {
ans[i] = 2;
c--;
}
}
for (i = 0; i < n; i++) {
if (ans[i] == 0)
cout << "R";
else if (ans[i] == 1)
cout << "P";
else
cout << "S";
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
vector<int> V[5005], RV[5005], id[5005];
int vis[5005];
int ord[5005], ft;
int col[5005], C, ok[5005];
int n, m, ans;
void DFS(int u) {
vis[u] = 1;
for (int i = 0; i < V[u].size(); i++) {
int v = V[u][i];
if (!vis[v]) DFS(v);
}
ord[ft--] = u;
}
void DFS_(int u) {
vis[u] = 1;
col[u] = C;
for (int i = 0; i < RV[u].size(); i++) {
int v = RV[u][i];
if (!vis[v]) DFS_(v);
}
}
int q[5005], d[5005][5005], T;
void run() {
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= n; i++) id[col[i]].push_back(i);
ans = n;
for (int i = 1; i <= C; i++)
if (!ok[i]) {
int cnt = (int)id[i].size();
if (cnt == 1) continue;
for (int j = 0; j < cnt; j++) {
int k = id[i][j];
int h = 0, t = 0;
++T;
vis[k] = T;
q[t++] = k;
d[k][k] = 0;
while (h < t) {
int tp = q[h++];
for (int r = 0; r < (int)V[tp].size(); r++) {
int rr = V[tp][r];
if (col[rr] != i || vis[rr] == T) continue;
vis[rr] = T;
q[t++] = rr;
d[k][rr] = d[k][tp] + 1;
}
}
}
int mn = 5005;
for (int j = 0; j < cnt; j++) {
int k = id[i][j];
for (int r = 0; r < (int)V[k].size(); r++) {
int rr = V[k][r];
if (col[rr] != i) continue;
if (mn > d[rr][k]) mn = d[rr][k];
}
}
ans += 998 * (mn + 1) + 1;
}
printf("%d\n", ans);
}
int main() {
scanf("%d%d", &n, &m);
for (int k = 1; k <= m; k++) {
int i, j;
scanf("%d %d", &i, &j);
V[i].push_back(j);
RV[j].push_back(i);
}
ft = n;
for (int i = 1; i <= n; i++)
if (!vis[i]) DFS(i);
for (int i = 1; i <= n; i++) vis[i] = 0;
C = 0;
for (int i = 1; i <= n; i++)
if (!vis[ord[i]]) {
C++;
DFS_(ord[i]);
}
for (int i = 1; i <= n; i++) {
int cc = col[i];
for (int j = 0; j < (int)V[i].size(); j++) {
int k = V[i][j];
if (col[k] != cc) ok[cc] = 1;
}
}
run();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int crush[110];
int vis[110];
int n, a;
long long ans;
int gcd(int a, int b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
void dfs(int f, int v, int num) {
vis[v] = 1;
int tmp = crush[v];
if (vis[tmp]) {
if (tmp != f)
ans = -1;
else {
if (num % 2 == 0) num /= 2;
ans /= gcd(ans, num);
ans *= num;
}
return;
}
dfs(f, tmp, num + 1);
}
int main() {
while (cin >> n) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) cin >> crush[i];
ans = 1;
for (int i = 1; i <= n; i++) {
if (ans == -1) break;
if (!vis[i]) {
vis[i] = 1;
dfs(i, i, 1);
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[200005];
stack<int> sk;
string s;
int main() {
cin >> n;
int w;
for (int i = 0; i < n; i++) {
cin >> w;
a[i] = {w, i + 1};
}
sort(a, a + n);
cin >> s;
int c = 0;
int beta[n + 1];
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
cout << a[c].second << (i != 2 * n - 1 ? " " : "\n");
sk.push(a[c].second);
c++;
} else {
int r = sk.top();
cout << r << (i != 2 * n - 1 ? " " : "\n");
sk.pop();
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
vector<int> ans;
vector<int> r_ans;
int l = 0;
int r = s.size() - 1;
while (l < r) {
if (s[l] == '(' && s[r] == '(') {
--r;
} else if (s[l] == '(' && s[r] == ')') {
ans.push_back(l);
r_ans.push_back(r);
++l, --r;
} else {
++l;
}
}
if (!ans.size()) {
cout << 0 << endl;
return 0;
}
cout << 1 << endl;
cout << ans.size() * 2 << endl;
reverse(begin(r_ans), end(r_ans));
for (int p : ans) {
cout << p + 1 << ' ';
}
for (int p : r_ans) {
cout << p + 1 << ' ';
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 22;
int n, a[maxn];
namespace basis {
int G[55], N;
void reset(int n) {
N = n;
std::memset(G, 0, sizeof(G));
}
int insert(int x) {
for (int i = N - 1; i >= 0; i--) {
if (x & (1 << i)) {
if (G[i])
x ^= G[i];
else {
G[i] = x;
return 1;
}
}
}
return 0;
}
} // namespace basis
std::vector<int> gray_code(int x) {
if (x == 0) return {0};
std::vector<int> v = gray_code(x - 1);
std::vector<int> q;
for (int i = 0; i < (1 << (x - 1)); ++i) q.push_back(v[i] + (1 << (x - 1)));
while (q.size()) {
v.push_back(q.back());
q.pop_back();
}
return v;
}
int check(int x, int opt) {
basis::reset(x);
std::vector<int> v;
for (int i = 1; i <= n; ++i) {
if (a[i] >= (1 << x)) continue;
if (basis::insert(a[i])) v.push_back(a[i]);
}
if (v.size() != x) return 0;
if (!opt) return 1;
std::vector<int> g = gray_code(x);
for (int i = 0; i < g.size(); ++i) {
int w = 0;
for (int j = 0; j < x; ++j)
if (g[i] & (1 << j)) w ^= v[j];
printf("%d ", w);
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = 0;
for (int x = 1; x <= 20; ++x)
if (check(x, 0)) ans = x;
printf("%d\n", ans);
check(ans, 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma G++ optimize(2)
using namespace std;
const int MAX_N = 2e5 + 5;
struct SAM {
int root, last, siz;
int nxt[MAX_N << 1][26], fa[MAX_N << 1], ml[MAX_N << 1];
int Right[MAX_N << 1], cnt[MAX_N << 1], id[MAX_N << 1];
int pos[MAX_N << 1], ed[MAX_N << 1];
void init() {
root = last = siz = 1;
ml[root] = fa[root] = Right[root] = 0;
memset(nxt[root], 0, sizeof(nxt[root]));
}
void add(int c) {
int p = last, np = ++siz;
memset(nxt[np], 0, sizeof(nxt[np]));
last = np, ml[np] = ml[p] + 1, Right[np] = 1;
for (; p && !nxt[p][c]; p = fa[p]) nxt[p][c] = np;
if (!p)
fa[np] = root;
else {
int q = nxt[p][c];
if (ml[p] + 1 == ml[q])
fa[np] = q;
else {
int nq = ++siz;
ml[nq] = ml[p] + 1, Right[nq] = 0;
memcpy(nxt[nq], nxt[q], sizeof(nxt[q]));
fa[nq] = fa[q], fa[q] = fa[np] = nq;
for (; p && nxt[p][c] == q; p = fa[p]) nxt[p][c] = nq;
}
}
}
void build(char *s) {
init();
int len = strlen(s + 1);
for (register int i = 1; i <= len; ++i) add(s[i] - 'a'), pos[i] = last;
}
void solve(char *s) {
int now = root, len = strlen(s + 1);
for (register int i = 1; i <= len; ++i) {
if (nxt[now][s[i] - 'a'])
now = nxt[now][s[i] - 'a'];
else
return;
}
ed[now]++;
}
void toposort() {
int ML = 0;
for (register int i = 1; i <= siz; ++i) cnt[i] = 0;
for (register int i = 1; i <= siz; ++i) cnt[ml[i]]++, ML = max(ML, ml[i]);
for (register int i = 1; i <= ML; ++i) cnt[i] += cnt[i - 1];
for (register int i = 1; i <= siz; ++i) id[cnt[ml[i]]--] = i;
for (register int i = 1; i <= siz; ++i) ed[id[i]] += ed[fa[id[i]]];
}
} sam1, sam2;
char s[MAX_N], t[MAX_N];
int main() {
scanf("%s", s + 1);
int n;
scanf("%d", &n);
sam1.init(), sam2.init();
sam1.build(s);
int len = strlen(s + 1);
reverse(s + 1, s + 1 + len);
sam2.build(s);
for (register int i = 1; i <= n; ++i) {
scanf("%s", t + 1);
sam1.solve(t);
int len = strlen(t + 1);
reverse(t + 1, t + 1 + len);
sam2.solve(t);
}
reverse(sam2.pos + 1, sam2.pos + 1 + len);
sam1.toposort(), sam2.toposort();
long long ans = 0;
for (register int i = 1; i <= len; ++i)
ans += 1ll * sam1.ed[sam1.pos[i]] * sam2.ed[sam2.pos[i + 1]];
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long n, m, k;
cin >> n >> m >> k;
bool isEven = (k % 2) == 0;
long long p = n * m;
if (isEven) k /= 2;
if (p % k != 0) {
puts("NO");
return 0;
}
long long x = gcd(n, k);
k /= x;
long long a = n / x;
x = gcd(m, k);
k /= x;
long long b = m / x;
if (!isEven) {
if (a < n)
a += a;
else {
b += b;
}
}
puts("YES");
puts("0 0");
cout << 0 << " " << b << endl;
cout << a << " " << 0 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> fun(string s) {
int n = (int)s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
vector<int> f;
string s;
int n, k;
int bal[2000100];
bool good[2000100];
int main() {
cin >> n >> k;
cin >> s;
f = fun(s);
f[0] = n;
for (int i = 1; i <= n; i++) {
int pos = 0;
bool ok = true;
for (int j = 1; j <= k; j++) {
if (pos >= n) {
ok = false;
break;
}
if (f[pos] < i) {
ok = false;
break;
}
pos += i;
}
if (ok == true && pos > 0) {
good[pos - 1] = true;
}
if (ok == true && pos < n) {
int dist = min(i, f[pos]);
bal[pos]++;
bal[pos + dist]--;
}
}
int cur = 0;
for (int i = 0; i < n; i++) {
cur += bal[i];
if (cur > 0 || good[i]) {
printf("1");
} else {
printf("0");
}
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)(2e18);
const long double eps = 1e-6;
const unsigned long long infu = (unsigned long long)(1e36);
const long double pi = 3.141592653589793;
long long power(long long a, long long k) {
if (k == 0) return 1;
if (k % 2) return power(a, k - 1) * a;
long long x = power(a, k / 2);
return x * x;
}
vector<long long> pFunc(string s) {
long long n = s.length();
vector<long long> p(n, 0);
for (long long i = 1; i < n; i++) {
long long j = p[i - 1];
while (j && (s[i] != s[j])) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
return p;
}
vector<long long> pFunc(string s1, string s2) { return pFunc(s2 + '$' + s1); }
long long gcd(long long a, long long b) {
while (a && b) {
a %= b;
swap(a, b);
}
return a + b;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long l, r;
cin >> l >> r;
if (r - l <= 1000) {
map<long long, long long> cnt;
for (long long i = l; i <= r; i++) {
for (long long j = 2; j * j <= i; j++) {
if (i % j == 0) {
cnt[j]++;
if (j * j != i) cnt[i / j]++;
}
}
cnt[i]++;
}
long long mx = 1;
for (auto i : cnt) {
if (cnt[mx] < i.second) mx = i.first;
}
cout << mx << endl;
} else
cout << "2\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int sqr(int x) { return x * x; }
inline int cube(int x) { return x * x * x; }
inline long long sqrLL(long long x) { return x * x; }
inline long long cubeLL(long long x) { return x * x * x; }
const long long LLINF = 9223372036854775807LL;
const long long LLINF17 = 100000000000000000LL;
const int INF = 1000000000;
const int INF9 = 1000000000;
const long long MOD = 1000000007;
const double eps = 1e-7;
const double PI = acos(-1.0);
template <typename T>
void check(T &a, const T &b) {
if (a >= b) {
a %= b;
}
}
template <typename T>
void read(T &x) {
register T c = getchar();
x = 0;
int t = 0;
if (c == '-') t = 1, c = getchar();
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (t) x = -x;
}
template <typename T>
T gcd(T u, T v) {
if (u == v) return u;
if (u == 0) return v;
if (v == 0) return u;
if (~u & 1) {
if (v & 1)
return gcd(u >> 1, v);
else
return gcd(u >> 1, v >> 1) << 1;
}
if (~v & 1) return gcd(u, v >> 1);
if (u > v) return gcd((u - v) >> 1, v);
return gcd((v - u) >> 1, u);
}
long long mulmod(long long a, long long b, long long m) {
long long q = (long long)(((long double)a * (long double)b) / (long double)m);
long long r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T, typename S>
T expo(T e, S n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T power(T e, T n, T &m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mod(x * p, m);
p = mod(p * p, m);
n >>= 1;
}
return x;
}
template <typename T>
T powerL(T e, T n, T &m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mulmod(x, p, m);
p = mulmod(p, p, m);
n >>= 1;
}
return x;
}
template <typename T>
T InverseEuler(T a, T &m) {
return (a == 1 ? 1 : power(a, m - 2, m));
}
int main() {
int n;
read(n);
string s[2] = {"white", "black"};
if (n & 1) {
cout << "black";
} else {
cout << "white"
<< "\n"
<< 1 << " " << 2;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str1, str;
int sum = 0, strlen, slen;
int flag111 = 1;
getline(cin, str1);
getline(cin, str);
strlen = str1.length();
slen = str.length();
if (!strlen) {
cout << slen << endl;
goto key;
}
if (!slen) {
cout << strlen << endl;
goto key1;
}
if (str1 == str) {
cout << "0" << endl;
goto key2;
}
strlen--;
slen--;
while (str1[strlen] == str[slen]) {
strlen--;
slen--;
if (strlen == -1 || slen == -1) {
flag111 = 0;
break;
}
}
if (flag111)
cout << strlen + slen + 2 << endl;
else
cout << strlen + slen + 2 << endl;
key2:
key1:
key:
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 102;
double f[N][N], g[N][N], dp[N][N], sum[N];
int n, k, q;
double p;
struct matrix {
double f[N][N];
} gt, f1, f2;
inline matrix operator*(matrix a, matrix b) {
matrix c = gt;
for (int i = 1; i <= q + 1; i++)
for (int j = 1; j <= q + 1; j++)
for (int k = 1; k <= q + 1; k++)
c.f[i][k] = c.f[i][k] + a.f[i][j] * b.f[j][k];
return c;
}
int main() {
cin >> n >> k, q = 100, p = k / 1000000000.0;
for (int i = 1; i <= q; i++) f[i][1] = p;
f[1][2] = 1 - p, f[2][2] = 1 - p + p * p;
for (int i = 2; i <= q; i++) f[i][2] = f[2][2], g[i][2] = 1 - p;
for (int i = 1; i <= q; i++)
for (int j = 3; j <= q; j++) f[i][j] = f[i][j - 1] * f[i - 1][j - 1];
g[1][2] = 1 - p;
for (int i = 2; i <= q; i++)
for (int j = 3; j <= q; j++) g[i][j] = g[i][j - 1] * f[i - 1][j - 1];
for (int i = q; i >= 1; i--)
for (int j = 1; j <= q; j++)
f[i][j] = f[i][j] * (1 - f[i - 1][j]),
g[i][j] = g[i][j] * (1 - f[i - 1][j]);
for (int i = 1; i <= q; i++) {
for (int j = 2; j <= i + 1; j++) {
double zt = 0;
for (int k = 1; k < j; k++) {
zt += f[i - 1][k];
}
if (zt == 0) {
dp[i][j] = j;
continue;
}
for (int k = 1; k < j; k++) {
dp[i][j] = dp[i][j] + dp[i - 1][k] * f[i - 1][k] / zt;
}
dp[i][j] += j;
}
double zt = 0;
for (int k = 2; k <= q; k++) zt += g[i - 1][k];
if (zt == 0) {
dp[i][1] = 1;
continue;
}
for (int k = 2; k <= q; k++)
dp[i][1] = dp[i][1] + dp[i - 1][k] * g[i - 1][k] / zt;
dp[i][1] += 1;
}
double ans = 0;
if (n <= q) {
for (int i = 1; i <= q; i++) ans = ans + dp[n][i] * f[n][i];
printf("%.15lf\n", ans);
} else {
for (int j = 2; j <= q; j++) {
double zt = 0;
for (int k = 1; k < j; k++) zt += f[q][k];
for (int k = 1; k < j; k++) f1.f[k][j] = f[q][k] / zt;
f1.f[q + 1][j] = j;
}
double zt = 0;
for (int i = 2; i <= q; i++) zt += g[q][i];
for (int k = 2; k <= q; k++) f1.f[k][1] = g[q][k] / zt;
f1.f[q + 1][1] = 1, f1.f[q + 1][q + 1] = 1;
bool fg = 0;
n -= q;
while (n > 0) {
if (n & 1) {
if (!fg)
fg = 1, f2 = f1;
else
f2 = f1 * f2;
}
f1 = f1 * f1, n = n >> 1;
}
dp[q][q + 1] = 1;
double ans = 0;
for (int i = 1; i <= q + 1; i++)
for (int j = 1; j <= q; j++) sum[j] = sum[j] + dp[q][i] * f2.f[i][j];
for (int i = 1; i <= q; i++) ans = ans + sum[i] * f[q][i];
printf("%.15lf\n", ans);
}
}
| 12 |
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> nums(n + 5);
for (int i = 0; i < n; ++i)
cin >> nums[i];
vector<long long> curr(n + 5);
long long ans = 0;
for (int i = 0; i < n; ++i) {
auto tmp = curr[i];
if (tmp < nums[i] - 1) {
ans += nums[i] - 1 - tmp;
tmp += nums[i] - 1 - tmp;
}
curr[i + 1] += tmp - nums[i] + 1;
if (i + 2 < n) {
for (int j = i + 2; j < min(n, i + nums[i] + 1); ++j) {
curr[j]++;
}
}
}
cout << ans << endl;
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long arr[300001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long counter = 0;
for (long long i = 0; i < n; i++) {
if (i == n - 1) {
counter += (i + 1) * (long long)arr[i];
} else {
counter += (i + 2) * (long long)arr[i];
}
}
cout << counter << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
return (b > a) ? gcd(b, a) : (b == 0) ? a : gcd(b, a % b);
}
int bitcount(int a) { return (a != 0) ? bitcount(a & (a - 1)) + 1 : 0; }
long long bigmod(long long num, long long pow, long long prime) {
if (pow == 0ll) return 1ll;
long long ans = bigmod(num, pow / 2ll, prime);
ans = (ans * ans) % prime;
if (pow % 2ll) ans = (ans * num) % prime;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, now = 0, sum = 0, lvl = 0;
cin >> n;
for (int i = 1;; i++) {
now += i;
sum += now;
if (sum <= n)
lvl++;
else
break;
}
cout << lvl << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1000000000;
const ll LINF = 1001002003004005006ll;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
struct IOSetup {
IOSetup() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(12);
}
} iosetup;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i + 1 == (int)v.size() ? "" : " ");
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename Monoid>
struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
private:
int sz;
vector<Monoid> seg;
Monoid query(int a, int b, int k, int l, int r) {
if (a <= l and r <= b) return seg[k];
if (b <= l or r <= a) return M0;
Monoid L = query(a, b, 2 * k, l, (l + r) / 2);
Monoid R = query(a, b, 2 * k + 1, (l + r) / 2, r);
return f(L, R);
}
template <typename C>
int find_first(int a, const C &check, Monoid &acc, int k, int l, int r) {
if (k >= sz) {
acc = f(acc, seg[k]);
if (check(acc))
return -1;
else
return k - sz;
}
int m = (l + r) / 2;
if (m <= a) return find_first(a, check, acc, 2 * k + 1, m, r);
if (a <= l and check(f(acc, seg[k]))) {
acc = f(acc, seg[k]);
return -1;
}
int x = find_first(a, check, acc, 2 * k + 0, l, m);
if (x >= 0) return x;
return find_first(a, check, acc, 2 * k + 1, m, r);
}
template <typename C>
int find_last(int b, const C &check, Monoid &acc, int k, int l, int r) {
if (k >= sz) {
acc = f(acc, seg[k]);
if (check(acc))
return -1;
else
return k - sz + 1;
}
int m = (l + r) / 2;
if (b <= m) return find_last(b, check, acc, 2 * k, l, m);
if (r <= b and check(f(acc, seg[k]))) {
acc = f(acc, seg[k]);
return -1;
}
int x = find_last(b, check, acc, 2 * k + 1, m, r);
if (x >= 0) return x;
return find_last(b, check, acc, 2 * k, l, m);
}
public:
F f;
Monoid M0;
SegmentTree(int n, F f, Monoid M0) : f(f), M0(M0) {
sz = 1;
while (sz < n) sz <<= 1;
seg.assign(2 * sz, M0);
}
void set(int k, Monoid x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) seg[k] = f(seg[2 * k], seg[2 * k + 1]);
}
void update(int k, Monoid x) {
k += sz;
seg[k] = x;
k >>= 1;
for (; k; k >>= 1) seg[k] = f(seg[2 * k], seg[2 * k + 1]);
}
Monoid query(int a, int b) { return query(a, b, 1, 0, sz); }
Monoid operator[](const int &k) const { return seg[k + sz]; }
template <typename C>
int find_first(int a, const C &check) {
Monoid val = M0;
return find_first(a, check, val, 1, 0, sz);
}
template <typename C>
int find_last(int b, C &check) {
Monoid val = M0;
return find_last(b, check, val, 1, 0, sz);
}
};
int f(int a, int b) { return a + b; }
signed main() {
int n;
cin >> n;
vector<int> xs;
xs.push_back(0);
xs.push_back(1000000001);
map<int, vector<int>> yx;
for (int i = 0; i < (n); i++) {
int x, y;
cin >> x >> y;
yx[-y].push_back(x);
xs.push_back(x);
}
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
auto get = [&](int t) {
return int(lower_bound(begin(xs), end(xs), t) - begin(xs));
};
SegmentTree<int> seg(xs.size() + 1, f, 0);
seg.build();
auto update = [&](int t) {
int p = get(t);
seg.update(p, 1);
};
auto query = [&](int l, int r) {
int pl = get(l);
int pr = get(r);
return seg.query(pl, pr);
};
ll ans = 0;
for (auto &p : yx) {
int prev = 0;
auto &w = p.second;
sort(begin(w), end(w));
w.erase(unique(begin(w), end(w)), end(w));
ll add = 0;
for (auto &x : w) {
ll k = query(prev + 1, x);
add -= k * (k + 1) / 2;
prev = x;
update(x);
}
ll k = query(prev + 1, 1000000001);
add -= k * (k + 1) / 2;
ll tot = query(0, 1000000001);
add += tot * (tot + 1) / 2;
ans += add;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 ran(time(0));
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long Bpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans *= a;
ans %= mod;
}
a = a * a % mod;
b >>= 1;
}
return ans;
}
map<pair<long long, long long>, long long> pos;
void P(long long i, long long j, long long k,
vector<pair<long long, long long>>& a) {
pair<long long, long long> t = a[k];
a[k] = a[j];
a[j] = a[i];
a[i] = t;
pos[a[i]] = i;
pos[a[j]] = j;
pos[a[k]] = k;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<pair<long long, long long>> a;
map<long long, long long> now;
bool ff = false;
for (long long i = 0; i < n; i++) {
long long b;
cin >> b;
a.push_back({b, now[b]++});
if (now[b] == 2) {
ff = true;
}
}
if (ff) {
cout << "YES\n";
continue;
}
vector<pair<long long, long long>> b = a;
sort(b.begin(), b.end());
for (long long i = 0; i < n; i++) {
pos[a[i]] = i;
}
bool f = false;
for (long long i = 0; i < n; i++) {
if (a[i] == b[i]) continue;
if (pos[b[i]] != i + 1) {
P(i, i + 1, pos[b[i]], a);
} else {
if (i + 1 == n - 1) {
if (a[i].first == a[i + 1].first) break;
if (a[i + 1].second) {
P(i, i + 1, pos[{a[i + 1].first, a[i + 1].second - 1}], a);
break;
}
f = true;
break;
}
P(i, i + 2, pos[b[i]], a);
}
}
if (f)
cout << "NO\n";
else
cout << "YES\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 7;
const int Inf = 1e8 + 7;
const int tmp = 1e3;
int P[Maxn], Time;
bool mark[Maxn];
vector<pair<int, int> > ans;
void dfs(int u, int v, int node, int root) {
if (u == v) return;
mark[u] = true;
ans.push_back(make_pair(node, u));
u = P[u];
swap(node, root);
dfs(u, v, node, root);
}
void go(int u, int v) {
if (u == v) return;
++Time;
u = P[u];
go(u, v);
}
void print() {
cout << "YES" << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, root = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> P[i], root = (P[i] == i) ? i : root;
if (root) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++)
if (root != i) cout << i << " " << root << endl;
cout << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
if (P[P[i]] == i) {
ans.push_back(make_pair(i, P[i]));
for (int j = 1; j <= n; j++) {
if (j == P[i] || j == i || mark[j]) continue;
int p = P[i], q = P[j];
Time = 1;
mark[j] = true;
ans.push_back(make_pair(p, j));
go(q, j);
if (Time & 1) {
cout << "NO" << endl;
return 0;
}
dfs(q, j, i, p);
}
print();
}
}
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int i = 0;
scanf("%d%d", &n, &m);
while (n > 0 && m > 0) {
--n;
--m;
++i;
}
if (i % 2 == 0)
printf("Malvika");
else
printf("Akshat");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long xi[4] = {1, -1, 0, 0};
long long yi[4] = {0, 0, 1, -1};
char t[2001][2001];
bool vis[2001][2001];
long long xx[2001][2001];
long long yy[2001][2001];
long long x, y;
bool valid1(long long a, long long b) {
return (a >= 0 && a < n && b >= 0 && b < m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(vis, 0, sizeof vis);
memset(xx, -1, sizeof xx);
memset(yy, -1, sizeof yy);
cin >> n >> m;
long long r, c;
cin >> r >> c;
r--;
c--;
cin >> x >> y;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> t[i][j];
}
queue<pair<long long, long long> > q;
q.push({r, c});
xx[r][c] = x;
yy[r][c] = y;
while (!q.empty()) {
long long curx = q.front().first;
long long cury = q.front().second;
q.pop();
if (xx[curx][cury] >= 0 && yy[curx][cury] >= 0)
vis[curx][cury] = true;
else
continue;
for (long long i = 0; i < 4; i++) {
long long cx = curx + xi[i];
long long cy = cury + yi[i];
if (i == 2) {
if (valid1(cx, cy) && t[cx][cy] != '*' && yy[curx][cury] - 1 >= 0 &&
(xx[curx][cury] > xx[cx][cy] || yy[curx][cury] - 1 > yy[cx][cy])) {
xx[cx][cy] = max(xx[curx][cury], xx[cx][cy]);
yy[cx][cy] = max(yy[curx][cury] - 1, yy[cx][cy]);
q.push({cx, cy});
}
} else if (i == 3) {
if (valid1(cx, cy) && t[cx][cy] != '*' && xx[curx][cury] - 1 >= 0 &&
(xx[curx][cury] - 1 > xx[cx][cy] || yy[curx][cury] > yy[cx][cy])) {
xx[cx][cy] = max(xx[curx][cury] - 1, xx[cx][cy]);
yy[cx][cy] = max(yy[curx][cury], yy[cx][cy]);
q.push({cx, cy});
}
} else {
if (valid1(cx, cy) && t[cx][cy] != '*' &&
(xx[curx][cury] > xx[cx][cy] || yy[curx][cury] > yy[cx][cy])) {
xx[cx][cy] = max(xx[curx][cury], xx[cx][cy]);
yy[cx][cy] = max(yy[curx][cury], yy[cx][cy]);
q.push({cx, cy});
}
}
}
}
long long res = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++)
if (vis[i][j]) res++;
}
cout << res;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.