solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, MOD = 1e9 + 7;
int n;
int second[N];
int u[N], v[N];
vector<int> g[N];
pair<int, int> P[N];
int D[N];
void dfs(int k, int p) {
second[k] = 1;
for (int to : g[k]) {
if (to == p) continue;
dfs(to, k);
second[k] += second[to];
}
}
vector<int> V1, V2;
int nn;
int mas[N];
map<pair<int, int>, int> M;
void go(int k, int p) {
D[k] = mas[nn];
nn--;
int dif = D[k] - D[p];
M[{k, p}] = dif;
M[{p, k}] = dif;
for (int to : g[k]) {
if (to != p) go(to, k);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u[i] >> v[i];
g[u[i]].push_back(v[i]);
g[v[i]].push_back(u[i]);
}
long long ans = 2 * n * n / 9;
for (int I = 1; I <= n; I++) {
dfs(I, 0);
int m = (int)g[I].size();
for (int i = 0; i < m; i++) {
P[i + 1] = {second[g[I][i]], g[I][i]};
}
sort(P + 1, P + m + 1);
V1.clear();
V2.clear();
long long x = 0, y = 0;
for (int i = m; i >= 1; i--) {
if (x <= y) {
V1.push_back(P[i].second);
x += P[i].first;
} else {
V2.push_back(P[i].second);
y += P[i].first;
}
}
if (x * y + x + y < ans) continue;
nn = x;
for (int i = 1; i <= nn; i++) mas[i] = nn - i + 1;
for (int no : V1) {
go(no, I);
}
nn = y;
for (int i = nn; i >= 1; i--) mas[nn - i + 1] = i * (x + 1);
for (int no : V2) {
go(no, I);
}
for (int i = 1; i < n; i++)
cout << u[i] << " " << v[i] << " " << M[{u[i], v[i]}] << endl;
return 0;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const double E = exp(1.0);
const int M = 2e6 + 5;
int prime[M];
int huiwen[M];
int sum[M];
void getprime() {
for (int i = 2; i < M; ++i) {
sum[i] = sum[i - 1];
if (!prime[i]) {
prime[++prime[0]] = i;
sum[i]++;
}
for (int j = 1; j <= prime[0] && prime[j] * i < M; ++j) {
prime[prime[j] * i] = 1;
if (i % prime[j] == 0) break;
}
}
}
bool judge(int x) {
int p[11];
int len = 0;
while (x) {
p[len++] = x % 10;
x /= 10;
}
for (int i = 0; i <= len / 2; ++i)
if (p[i] != p[len - i - 1]) return 0;
return 1;
}
void gethuiwen() {
int cnt = 1;
for (int i = 1; i < M; ++i) {
huiwen[i] = huiwen[i - 1];
if (judge(i)) huiwen[i]++;
}
}
int main() {
gethuiwen();
getprime();
int p, q;
cin >> p >> q;
for (int i = M - 2; i >= 0; --i) {
if (q * sum[i] <= p * huiwen[i]) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
char dx[N], nb[N];
int n, m;
signed main() {
cin >> n >> m;
cin >> dx + 1 >> nb + 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
vector<vector<bool> > check(n + 1, vector<bool>(m + 1));
check[i][j] = 1;
vector<pair<int, int> > q;
q.push_back({i, j});
for (int k = 0; k < q.size(); ++k) {
int x2 = q[k].first, y2 = q[k].second;
int x3 = x2, y3 = y2;
if (nb[y3] == '^')
--x3;
else
++x3;
if (x3 >= 1 && x3 <= n && !check[x3][y3]) {
q.push_back(make_pair(x3, y3));
check[x3][y3] = 1;
}
int x4 = x2, y4 = y2;
if (dx[x4] == '<')
--y4;
else
++y4;
if (y4 >= 1 && y4 <= m && !check[x4][y4]) {
q.push_back(make_pair(x4, y4));
check[x4][y4] = 1;
}
}
for (int x2 = 1; x2 <= n; ++x2) {
for (int y2 = 1; y2 <= m; ++y2) {
if (!check[x2][y2]) {
puts("NO");
return 0;
}
}
}
}
}
puts("YES");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, tot, ans, now;
long long head[100005], nx[200005], to[200005], w[200005];
long long sum[100005], sz[100005];
struct node {
long long zhi, id, qwq;
};
vector<node> a[100005];
long long read() {
char aa = getchar();
long long pp = 1, kk = 0;
while (aa < '0' || aa > '9') {
if (aa == '-') pp = -1;
aa = getchar();
}
while (aa >= '0' && aa <= '9') {
kk = kk * 10 + aa - '0';
aa = getchar();
}
return kk * pp;
}
void write(long long z) {
if (z < 0) {
putchar('-');
z = -z;
}
if (z >= 10) {
write(z / 10);
}
putchar(z % 10 + '0');
}
void jia(long long aa, long long bb, long long cc) {
tot++;
nx[tot] = head[aa];
to[tot] = bb;
w[tot] = cc;
head[aa] = tot;
return;
}
void dfs(long long rt, long long fa, long long dd) {
sz[rt] = 1;
for (long long i = head[rt]; i; i = nx[i]) {
long long yy = to[i];
if (yy == fa) continue;
dfs(yy, rt, dd + w[i]);
sz[rt] += sz[yy];
sum[rt] += sum[yy] + 2 * w[i];
}
return;
}
bool cmp(node aa, node bb) { return sz[bb.id] * aa.zhi < sz[aa.id] * bb.zhi; }
void getans(long long rt, long long fa) {
for (long long i = head[rt]; i; i = nx[i]) {
long long yy = to[i];
if (yy == fa) continue;
a[rt].push_back((node){(sum[yy] + w[i] * 2), yy, w[i]});
}
sort(a[rt].begin(), a[rt].end(), cmp);
ans += now;
long long len = a[rt].size();
for (long long i = 0; i < len; ++i)
now += a[rt][i].qwq, getans(a[rt][i].id, rt), now += a[rt][i].qwq;
}
int main() {
n = read();
for (long long i = 1; i < n; ++i) {
long long x = read(), y = read(), z = read();
jia(x, y, z);
jia(y, x, z);
}
dfs(1, 1, 0);
getans(1, 1);
printf("%.11lf", (double)ans / (double)(n - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int inf = 1e9;
void dao(int x, int y, int z) {
if (x) printf("%d %d %d\n", x, y, z);
}
int n, k, v, a[N], b[N];
bool f[N][N], g[N][N];
int main() {
int i, j, t, r, s = 0;
scanf("%d%d%d", &n, &k, &v);
for (i = 1; i <= n; i = i + 1) scanf("%d", a + i), s += a[i];
if (s < v) {
printf("NO\n");
return 0;
}
if (v % k == 0) {
printf("YES\n");
for (i = 2; i <= n; i = i + 1)
if (a[i]) dao((a[i] - 1) / k + 1, i, 1);
dao(v / k, 1, 2);
return 0;
}
f[0][0] = 1;
for (i = 1; i <= n; i = i + 1)
for (j = 0; j < k; j = j + 1) {
if (f[i - 1][j]) f[i][j] = 1, g[i][j] = 0;
if (f[i - 1][(j - a[i] % k + k) % k]) f[i][j] = 1, g[i][j] = 1;
}
if (!f[n][v % k]) {
printf("NO\n");
return 0;
}
j = v % k;
for (i = n; i >= 1; i = i - 1) {
if (g[i][j])
b[i] = 1, t = i, j = (j - a[i] % k + k) % k;
else
b[i] = 0, r = i;
}
printf("YES\n");
s = a[t];
for (i = 1; i <= n; i = i + 1)
if (a[i] && b[i] && i != t) dao((a[i] - 1) / k + 1, i, t), r = i, s += a[i];
for (i = 1; i <= n; i = i + 1)
if (a[i] && !b[i] && i != r) dao((a[i] - 1) / k + 1, i, r);
if (s >= v)
dao((s - v) / k, t, r);
else
dao((v - s) / k, r, t);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, i, c = 0, n, age;
string a, s[18] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
cin >> n;
while (n--) {
cin >> a;
stringstream strm(a);
strm >> age;
if (a[0] <= '9' && age < 18) {
c++;
}
for (i = 0; i < 11; i++) {
if (a == s[i]) c++;
}
}
cout << c << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dxx[] = {0, 0, 1, -1, -1, 1, -1, 1};
int dyy[] = {1, -1, 0, 0, -1, 1, 1, -1};
bool sortbysec(const pair<int, int>& a, const pair<int, int>& b) {
return (a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, f = 1;
cin >> n;
string s;
cin >> s;
int sum = 0;
for (int i = 0; s[i]; i++) sum += (int)(s[i] - '0');
vector<int> v;
v.push_back(0);
for (int i = 1; i * i <= sum; i++) {
if (sum % i == 0) {
v.push_back(i);
if (i == sum / i) continue;
v.push_back(sum / i);
}
}
for (auto k : v) {
int ns = 0, c = 0;
for (int i = 0; s[i]; i++) {
ns += s[i] - '0';
if (ns == k) {
c++;
ns = 0;
}
}
if (c > 1 && ns == 0) {
cout << "YES" << '\n';
return 0;
}
}
cout << "NO" << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 3.1415926535897932384626433832795028841;
map<string, int> ssol;
void checkAdd(string vs) {
if (ssol.find(vs) != ssol.end()) {
return;
}
ssol[vs] = 1;
}
bool TST = 0;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void Show(int *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
void ShowLL(long long *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
const int maxn = 1e6 + 20;
const int maxl = 26;
int n;
int act;
int sz[maxn], lvl[maxn];
int clen[maxl][maxn];
int maxlvl = 1;
vector<int> conn[maxn];
vector<int> nlvl[maxn];
int compute_sz(int head_small, int head_big) {
int ans = 1;
for (int l = 0; l < maxl; l++) {
if (clen[l][head_small] != -1 and clen[l][head_big] != -1) {
ans += compute_sz(clen[l][head_small], clen[l][head_big]);
} else if (clen[l][head_small] != -1) {
ans += sz[clen[l][head_small]];
} else if (clen[l][head_big] != -1) {
ans += sz[clen[l][head_big]];
}
}
return ans;
}
int generate(vector<int> nodes) {
int top = act++;
sz[top] = 1;
for (int l = 0; l < maxl; l++) {
vector<int> list;
for (int i = 0; i < nodes.size(); i++) {
if (clen[l][nodes[i]] != -1) list.push_back(clen[l][nodes[i]]);
}
if (list.size() > 1) {
clen[l][top] = generate(list);
} else if (list.size() == 1) {
clen[l][top] = list[0];
} else {
clen[l][top] = -1;
}
if (clen[l][top] != -1) sz[top] += sz[clen[l][top]];
}
return top;
}
void dfs(int i, int depth) {
sz[i] = 1;
lvl[i] = depth;
nlvl[lvl[i]].push_back(i);
maxlvl = max(maxlvl, depth);
for (int j = 0; j < conn[i].size(); j++) {
dfs(conn[i][j], depth + 1);
sz[i] += sz[conn[i][j]];
}
}
int try_on(int i) {
if (conn[i].size() == 0) return 1;
if (conn[i].size() == 1) return sz[i] - 1;
int big = -1;
int bignum = 0;
for (int j = 0; j < conn[i].size(); j++) {
if (sz[conn[i][j]] > bignum) {
bignum = sz[conn[i][j]];
big = j;
}
}
vector<int> list;
for (int j = 0; j < conn[i].size(); j++) {
if (j == big) continue;
list.push_back(conn[i][j]);
}
int head_small = generate(list);
int size_new = compute_sz(head_small, conn[i][big]);
act = n;
return size_new;
}
int process(int lvl) {
int total = sz[0];
for (int i = 0; i < nlvl[lvl].size(); i++) {
int foo = try_on(nlvl[lvl][i]);
total -= sz[nlvl[lvl][i]];
total += foo;
}
return total;
}
int main() {
cin >> n;
act = n;
for (int i = 0; i < maxl; i++) fill(clen[i], clen[i] + n, -1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
char x;
cin >> x;
conn[u].push_back(v);
clen[x - 'a'][u] = v;
}
dfs(0, 1);
int best_ans = INT_MAX;
int i_ans = -1;
for (int i = 1; i <= maxlvl; i++) {
int ans = process(i);
if (ans < best_ans) {
best_ans = ans;
i_ans = i;
}
}
cout << best_ans << '\n' << i_ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
int coins[n];
for (int i = 0; i < n; i++) {
coins[i] = 0;
}
int hardness = 1;
int last = n;
cout << 1 << " ";
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
temp -= 1;
coins[temp] = 1;
if (temp == last - 1) {
int j = temp;
while (coins[j] == 1 && j >= 0) j--;
last = j + 1;
}
cout << i + 2 - (n - last) << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int root[1001], child[1001], valid[1001];
int main() {
int n, i, j, v, x, pos, t, flag;
cin >> n >> x;
vector<int> num;
for (i = 1; i <= n; i++) {
cin >> v;
if (!v)
root[i] = 1;
else
child[v] = i;
}
for (i = 1; i <= n; i++)
if (root[i]) {
t = 0;
flag = 0;
for (v = i; v; v = child[v]) {
t++;
if (x == v) {
pos = t;
flag = 1;
}
}
if (!flag) num.push_back(t);
}
valid[0] = 1;
for (j = 0; j < num.size(); j++) {
v = num[j];
for (i = n; i >= v; i--)
if (valid[i - v]) valid[i] = 1;
}
for (i = 0; i <= n; i++)
if (valid[i]) cout << i + pos << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct road {
int x, next;
} r[100005 * 2];
int N, M, D, ans;
int vis[100005], p[100005];
int down[100005], up[100005];
int st[100005], w;
void add(int x, int y) {
r[++w].x = y, r[w].next = st[x];
st[x] = w;
}
void Make_Down(int x, int fr) {
int i, tmp;
if (vis[x])
down[x] = 0;
else
down[x] = -0x7ffffff;
for (i = st[x]; i; i = r[i].next) {
tmp = r[i].x;
if (tmp == fr) continue;
Make_Down(tmp, x);
down[x] = max(down[x], down[tmp] + 1);
}
}
void Dfs(int x, int fr) {
int i, tmp;
int m1 = 0, m2 = 0;
if (vis[x]) up[x] = max(up[x], 0);
if (max(down[x], up[x]) <= D) ans++;
for (i = st[x]; i; i = r[i].next) {
tmp = r[i].x;
if (tmp == fr) continue;
if (down[m1] <= down[tmp])
m2 = m1, m1 = tmp;
else if (down[m2] <= down[tmp])
m2 = tmp;
}
for (i = st[x]; i; i = r[i].next) {
tmp = r[i].x;
if (tmp == fr) continue;
if (tmp == m1)
up[tmp] = max(up[x] + 1, down[m2] + 2);
else
up[tmp] = max(up[x] + 1, down[m1] + 2);
Dfs(tmp, x);
}
}
int main() {
int i, j;
int fr, to;
scanf("%d %d %d", &N, &M, &D);
for (i = 1; i <= M; i++) scanf("%d", &p[i]), vis[p[i]] = 1;
for (i = 1; i < N; i++) {
scanf("%d %d", &fr, &to);
add(fr, to), add(to, fr);
}
down[0] = up[0] = -0x7ffffff;
memset(up, 200, sizeof(up));
Make_Down(1, 0);
Dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const char IO_MODE = 0;
inline long long ReadInt() {
long long x = 0, s = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') s = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return s * x;
}
inline void WriteInt(long long x) {
char c[20];
if (!x) {
putchar('0');
return;
}
if (x < 0) putchar('-'), x = -x;
int i = 0;
while (x > 0) c[++i] = x % 10, x /= 10;
while (i) putchar(c[i--] + 48);
}
template <typename T>
inline void out(T x) {
if (IO_MODE & 1)
WriteInt(x);
else if (typeid(x) == typeid(int))
printf("%i", x);
else
printf("%lld", (long long)x);
}
template <typename T, typename... Args>
inline void out(T x, Args... args) {
out(x);
putc(' ', stdout);
out(args...);
}
template <typename T>
inline void in(T &x) {
if (IO_MODE & 2)
x = ReadInt();
else if (typeid(x) == typeid(int))
scanf("%i", &x);
else if (typeid(x) == typeid(long long))
scanf("%lld", &x);
}
template <typename T, typename... Args>
inline void in(T &x, Args &...args) {
in(x);
in(args...);
}
int aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, mm, nn, oo, pp, qq, rr, ss, tt,
uu, vv, ww, xx, yy, zz;
int tc;
int n;
double ev, cur, p;
int main() {
in(n);
for (int i = 0; i < n; i++) {
cin >> p;
cur = p * (cur + 1);
ev += 2 * cur - p;
}
cout << fixed << setprecision(7) << ev << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char fi[5005][5005];
int ps[5005][5005];
int n, m;
int main() {
for (int i = 0; i <= 5000; i++)
for (int j = 0; j <= 5000; j++) fi[i][j] = '0';
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
getchar();
for (int j = 1; j <= m; j++) {
scanf("%c", &fi[i][j]);
}
}
for (int i = 1; i <= 5000; i++) {
for (int j = 1; j <= 5000; j++) {
ps[i][j] = fi[i][j] - '0';
ps[i][j] += ps[i - 1][j];
ps[i][j] += ps[i][j - 1];
ps[i][j] -= ps[i - 1][j - 1];
}
}
int ans = 6000 * 6000;
for (int k = 2; k <= 2500; k++) {
int tmp = 0;
for (int i = k; i <= 5000; i += k) {
for (int j = k; j <= 5000; j += k) {
int lala = ps[i][j] - ps[i - k][j] - ps[i][j - k] + ps[i - k][j - k];
tmp += min(lala, k * k - lala);
}
}
ans = min(ans, tmp);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
vector<long long> V;
long long k = n;
for (long long i = 2; i * i <= n; ++i) {
if (k % i == 0) V.push_back(i);
while (k % i == 0) k /= i;
}
if (k > 1) V.push_back(k);
for (int i = 0; i < V.size(); ++i) {
n /= V[i];
n *= (V[i] - 1);
}
return n;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
long long k;
cin >> n >> k;
while (k > 0 and n > 1) {
k -= 2;
n = f(n);
}
n %= 1000000007ll;
cout << n << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
while (cin >> s) {
int len = s.length(), maxans = 0;
long long ans[27];
memset(ans, 0, sizeof ans);
pair<int, int> mp[27];
const int maxn = 999999999;
for (int i = 0; i < 26; i++) mp[i].first = maxn, mp[i].second = i;
mp[26].first = -1, mp[26].second = 26;
for (int i = 0; i < len; i++) {
for (int j = 0; j < 27; j++)
if (mp[j].second == s[i] - 'a')
maxans += (mp[j].first == maxn ? 1 : 0), mp[j].first = i;
sort(mp, mp + 27);
for (int j = maxans, k = 0; j > 0; j--, k++)
ans[j] += mp[k + 1].first - mp[k].first;
}
cout << maxans << endl;
for (int i = 1; i <= maxans; i++) cout << ans[i] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[110000];
int n, f[110000], num[110000];
int bit1[110000], bit2[110000];
int query1(int x) {
int ans = 0;
while (x) {
ans = max(ans, bit1[x]);
x -= ((x) & (-(x)));
}
return ans;
}
void update1(int x, int newv) {
while (x <= n) {
bit1[x] = max(bit1[x], newv);
x += ((x) & (-(x)));
}
}
int query2(int x) {
int ans = 0;
while (x) {
ans = max(ans, bit2[x]);
x -= ((x) & (-(x)));
}
return ans;
}
void update2(int x, int newv) {
while (x <= n) {
bit2[x] = max(bit2[x], newv);
x += ((x) & (-(x)));
}
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) num[i] = s[i] - '0';
f[1] = 1;
if (num[1])
update2(1, 1);
else
update1(1, 1);
for (int i = 2; i <= n; i++) {
if (num[i]) {
f[i] = query1(i - 1) + 1;
update2(i, f[i]);
} else {
f[i] = query2(i - 1) + 1;
update1(i, f[i]);
}
}
int maxlen = 0;
for (int i = 1; i <= n; i++) maxlen = max(maxlen, f[i]);
printf("%d\n", min(n, maxlen + 2));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a, b, x, y;
set<pair<int, int> > P[1001];
vector<vector<pair<int, pair<int, int> > > > V;
vector<pair<int, int> > ans;
int aa = -1;
void dfs(int idx, int l, int r) {
if (r - l + 1 < aa) return;
if (r < l) return;
auto it = P[idx].lower_bound({l, r});
if (it != P[idx].begin()) {
it--;
if (it->second >= r) return;
} else if (it != P[idx].end()) {
if (it->first == l && it->second == r) return;
if (it->first >= l && it->second <= r) P[idx].erase(it);
}
if (P[idx].find({l, r}) != P[idx].end()) return;
P[idx].insert({l, r});
if (idx == n) {
aa = max(aa, r - l + 1);
return;
}
for (int i = 0; i < V[idx].size(); i++)
dfs(V[idx][i].first, max(l, V[idx][i].second.first),
min(r, V[idx][i].second.second));
}
int main() {
scanf("%d%d", &n, &m);
V.resize(n + 1);
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &a, &b, &x, &y);
V[a].push_back({b, {x, y}});
V[b].push_back({a, {x, y}});
}
dfs(1, 1, 1000000);
if (aa == -1)
printf("Nice work, Dima!");
else
printf("%d", aa);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%.12f", a * a * a * sqrt(2) / 12 + b * b * b * sqrt(2) / 6 +
c * c * c * (5 + sqrt(5)) / 24);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, cnt = 0;
cin >> n;
string a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i] == b[j]) {
b[j] = "N";
cnt++;
break;
}
cout << n - cnt << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 500000;
int head[N + 50], num, a[N + 50], n, siz[N + 50], dep[N + 50], ans[N + 50],
maxson[N + 50], s[N + 50], maxv, f[N * 20], inf;
struct Node {
int next, to;
} edge[N + 50];
void Addedge(int u, int v) {
edge[++num] = (Node){head[u], v};
head[u] = num;
return;
}
void Dfs1(int x, int fa) {
siz[x] = 1;
dep[x] = dep[fa] + 1;
if (x != 1) s[x] = s[fa] ^ (1 << a[x]);
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
Dfs1(v, x);
siz[x] += siz[v];
if (siz[v] > siz[maxson[x]]) maxson[x] = v;
}
return;
}
void Calc(int rt, int x) {
int now = s[x];
maxv = max(maxv, f[now] + dep[x] - 2 * dep[rt]);
if ((s[x] ^ s[rt]) == 0) maxv = max(maxv, dep[x] - dep[rt]);
for (int i = 0; i < 22; i++) {
now = (1 << i) ^ s[x];
maxv = max(maxv, f[now] + dep[x] - 2 * dep[rt]);
if ((s[x] ^ s[rt]) == (1 << i)) maxv = max(maxv, dep[x] - dep[rt]);
}
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
Calc(rt, v);
}
return;
}
void Change(int x, int k) {
if (k)
f[s[x]] = max(f[s[x]], dep[x]);
else
f[s[x]] = inf;
for (int i = head[x]; i; i = edge[i].next) Change(edge[i].to, k);
return;
}
void Dfs2(int x, int remain) {
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == maxson[x]) continue;
Dfs2(v, 0);
}
if (maxson[x]) Dfs2(maxson[x], 1);
maxv = 0;
int now = s[x];
maxv = max(maxv, f[now] - dep[x]);
for (int i = 0; i < 22; i++) {
now = (1 << i) ^ s[x];
maxv = max(maxv, f[now] - dep[x]);
}
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == maxson[x]) continue;
Calc(x, v);
Change(v, 1);
}
ans[x] = maxv;
if (!remain) {
for (int i = head[x]; i; i = edge[i].next) Change(edge[i].to, 0);
f[s[x]] = inf;
} else
f[s[x]] = max(f[s[x]], dep[x]);
return;
}
void Erase(int x) {
for (int i = head[x]; i; i = edge[i].next) {
int v = edge[i].to;
Erase(v);
ans[x] = max(ans[x], ans[v]);
}
return;
}
int main() {
scanf("%d", &n);
char tmp;
for (int i = 2, fa; i <= n; i++) {
scanf("%d", &fa);
cin >> tmp;
Addedge(fa, i);
a[i] = tmp - 'a';
}
Dfs1(1, 0);
memset(f, 128, sizeof(f));
inf = f[0];
Dfs2(1, 0);
Erase(1);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, k;
cin >> n >> c >> k;
if (n <= c && n <= k)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-9;
long long exp(long long b, long long e) {
long long ans = b;
while (--e) ans *= b;
return ans;
}
int sum(int x) {
if (!x) return 0;
return x % 10 + sum(x / 10);
}
int main() {
ios_base::sync_with_stdio(false);
long long a, b, c;
cin >> a >> b >> c;
int maxn = 81;
vector<int> vans;
for (int i = 1; i <= maxn; ++i) {
long long x = exp(i, a) * b + c;
if (x < inf and sum(x) == i) {
vans.push_back(x);
}
}
sort(vans.begin(), vans.end());
cout << vans.size() << endl;
if (vans.size()) {
for (int i = 0; i < int(vans.size()); ++i)
cout << (i ? " " : "") << vans[i];
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
int N, K, A, B, Q, a[200001], TA[524288], TB[524288];
void P(int x) {
int p = 1, l = 1, r = N;
while (l < r) {
int m = l + r >> 1;
if (x <= m)
r = m, p <<= 1;
else
l = m + 1, p = p << 1 | 1;
}
TA[p] = std::min(a[x], A);
TB[p] = std::min(a[x], B);
while (p > 1) {
p >>= 1;
TA[p] = TA[p << 1] + TA[p << 1 | 1];
TB[p] = TB[p << 1] + TB[p << 1 | 1];
}
}
int G(int *T, int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return T[p];
int m = l + r >> 1;
if (R <= m) return G(T, p << 1, l, m, L, R);
if (L > m) return G(T, p << 1 | 1, m + 1, r, L, R);
return G(T, p << 1, l, m, L, R) + G(T, p << 1 | 1, m + 1, r, L, R);
}
int main() {
scanf("%d%d%d%d%d", &N, &K, &A, &B, &Q);
while (Q--) {
int ty, u, w;
scanf("%d%d", &ty, &u);
if (ty == 1) {
scanf("%d", &w);
a[u] += w;
P(u);
} else
printf("%d\n", (u > 1 ? G(TB, 1, 1, N, 1, u - 1) : 0) +
(u > N - K ? 0 : G(TA, 1, 1, N, u + K, N)));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int n, m, p;
int s[10];
char mp[1002][1002];
int vis[1002][1002];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
void bfs() {
queue<int> q[10][2];
int now = 0;
for (int i = 1; i <= p; ++i) {
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (mp[x][y] - '0' == i) {
vis[x][y] = i;
q[i][0].push(x * m + y);
}
}
}
}
int num = 0;
int round = 0;
while (true) {
round++;
if (round > n * m + 2) {
cout << "fuck2" << endl;
return;
}
for (int i = 1; i <= p; ++i) {
int now = 0;
if (q[i][now].empty() && !q[i][now ^ 1].empty()) {
now ^= 1;
}
for (int j = 1; j <= s[i]; ++j) {
if (q[i][now].empty()) break;
while (!q[i][now].empty()) {
int cur = q[i][now].front();
q[i][now].pop();
int cx = cur / m;
int cy = cur % m;
for (int d = 0; d < 4; ++d) {
int nx = dx[d] + cx;
int ny = dy[d] + cy;
if (nx >= 0 && nx < n && ny >= 0 && ny < m && !vis[nx][ny] &&
mp[nx][ny] == '.') {
q[i][now ^ 1].push(nx * m + ny);
vis[nx][ny] = i;
}
}
}
now ^= 1;
}
}
int i;
for (i = 1; i <= p; ++i) {
if (!q[i][0].empty() || !q[i][1].empty()) break;
}
if (i > p) {
break;
}
}
}
int main() {
cin >> n >> m >> p;
for (int i = 1; i <= p; ++i) {
scanf("%d", &s[i]);
}
for (int i = 0; i < n; ++i) {
char st[1002];
scanf("%s", st);
for (int j = 0; j < m; ++j) {
mp[i][j] = st[j];
}
}
memset(vis, 0, sizeof(vis));
bfs();
for (int i = 1; i <= p; ++i) {
int cnt = 0;
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (vis[x][y] == i) {
cnt++;
}
}
}
printf("%d", cnt);
if (i < p)
cout << " ";
else
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int t;
cin >> t;
while(t--)
{
int n;
cin >> n;
vector<int> b(n);
set<int> s;
for(int i = 1; i <= 2*n; i++) s.insert(i);
rep(i, n)
{
cin >> b[i];
s.erase(b[i]);
}
vector<int> a(n);
auto itr = s.begin();
rep(i, n) {
a[i] = *itr;
itr++;
}
function<int(vector<int>, vector<int>)> getMax = [&](vector<int> a, vector<int> b) {
int ib = 0;
for(int i = 0; i < a.size(); i++) {
while(ib < b.size() && b[ib] < a[i]) ib++;
if(ib >= b.size()) return i;
ib++;
}
return (int)a.size();
};
int mx = getMax(b, a);
int mix = n - getMax(a, b);
cout << mx - mix + 1 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long g[32];
vector<int> divs[63];
void prec() {
for (int i = 1; i < 61; i++)
for (int j = 1; j < i; j++)
if (i % j == 0) divs[i].push_back(j);
}
inline int lg(long long n) {
int l = 0;
while (n) {
l++;
n >>= 1;
}
return l;
}
inline void upd(int i) {
for (__typeof((divs[i]).begin()) j = (divs[i]).begin(); j != (divs[i]).end();
j++)
g[i] -= g[*j];
}
long long mu[65];
long long dp[65];
void precalc() {
mu[1] = 1;
for (int i = 2; i < 65; ++i) {
mu[i] = 1;
int ii = i;
for (int j = 2; j <= ii; ++j) {
if (ii % j != 0) continue;
ii /= j;
mu[i] *= -1;
if (ii % j == 0) {
mu[i] = 0;
break;
}
}
}
dp[1] = 2;
for (int i = 2; i < 65; ++i) {
for (int j = 2; j <= i; ++j) {
if (i % j) continue;
dp[i] += -mu[j] * (1LL << (i / j));
}
}
}
long long f(long long n) {
if (n <= 1) return 0;
long long ans = 0;
int l = lg(n);
ans += f((1ll << (l - 1)) - 1);
memset((g), 0, sizeof(g));
for (__typeof((divs[l]).begin()) it = (divs[l]).begin();
it != (divs[l]).end(); it++) {
int i = *it;
long long t = n >> (l - i);
long long p = t;
for (int j = 0; j < (int)(l / i - 1); j++) p = (p << i) + t;
if (p <= n) g[i]++;
g[i] += t - (1ll << (i - 1));
ans += g[i] * -mu[l / i];
}
return ans;
}
int main() {
prec();
precalc();
long long l, r;
cin >> l >> r;
cout << f(r) - f(l - 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define N 500005
const int M = 998244353;
int n, k, a[N];
signed main()
{
int T; cin >> T;
while(T --)
{
cin >> n >> k;
int tp = k;
for(int i = k - (n - k); i <= k; ++ i)
a[i] = tp, -- tp;
for(int i = k - (n - k) - 1; i >= 0; -- i)
a[i] = tp, -- tp;
for(int i = 1; i <= k; ++ i)
cout << a[i] << " ";
cout << "\n";
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1009;
long long a[MX], b[MX], p[MX], q[MX];
vector<pair<pair<long long, long long>, pair<long long, long long> > > ans;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = i;
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
q[b[i]] = i;
}
for (long long i = 1; i < n; i++) {
if (p[i] == i && q[i] == i) continue;
ans.push_back({{p[i], i}, {i, q[i]}});
long long t = q[i], s = p[i];
p[a[i]] = s;
q[b[i]] = t;
a[s] = a[i];
b[t] = b[i];
}
cout << ans.size() << '\n';
for (auto p : ans)
cout << p.first.first << " " << p.first.second << " " << p.second.first
<< " " << p.second.second << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> nums[5];
int tt[21][5] = {};
int cnt[21][5] = {};
int numm[20];
int rows[5];
int cols[20];
int res[20];
char vis[22][22][22][22][22][22] = {};
int dfs(int k) {
vector<int>::iterator it, end;
char& viss = vis[k][cnt[k][0] << 1 | tt[k][0]][cnt[k][1] << 1 | tt[k][1]]
[cnt[k][2] << 1 | tt[k][2]][cnt[k][3] << 1 | tt[k][3]]
[cnt[k][4] << 1 | tt[k][4]];
if (viss)
return 0;
else {
viss = 1;
}
int i;
int u;
if (k == M) {
memcpy(res, numm, sizeof(res));
return 1;
}
it = nums[cols[k]].begin();
end = nums[cols[k]].end();
for (; it != end; ++it) {
u = *it;
numm[k] = u;
for (i = 0; i < N; ++i) {
if (u & (1 << i)) {
tt[k + 1][i] = 1;
if (!tt[k][i])
cnt[k + 1][i] = cnt[k][i] + 1;
else
cnt[k + 1][i] = cnt[k][i];
} else {
tt[k + 1][i] = 0;
cnt[k + 1][i] = cnt[k][i];
}
if (cnt[k + 1][i] > rows[i] || cnt[k + 1][i] + (M - k) / 2 < rows[i])
break;
}
if (i != N) continue;
if (dfs(k + 1)) return 1;
}
return 0;
}
int main() {
int i;
int k;
int t = 0;
int tcnt;
cin >> N >> M;
for (i = 0; i < N; ++i) cin >> rows[i];
for (i = 0; i < M; ++i) cin >> cols[i];
for (i = (1 << N) - 1; i >= 0; --i) {
t = 0;
tcnt = 0;
k = i;
while (k) {
if (k & 1 && !t) {
++tcnt;
t = 1;
} else if (!(k & 1)) {
t = 0;
}
k >>= 1;
}
nums[tcnt].push_back(i);
}
dfs(0);
int j;
for (i = 0; i < N; ++i) {
for (j = 0; j < M; ++j) {
if (res[j] & (1 << i))
putchar('*');
else
putchar('.');
}
putchar('\n');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T max(T &a, T &b) {
return (!(a < b) ? a : b);
}
template <class T>
T min(T &a, T &b) {
return (a < b ? a : b);
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
T mod(T a, T b) {
return (a < b ? a : a % b);
}
int power(int a, int b, int c) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % c;
}
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int main() {
int n, k, arr[105];
cin >> n >> k;
for (int i = 0; i < (n); i++) cin >> arr[i];
int one = 0, two = 0, ans = 0;
for (int i = 0; i < k; i++) {
one = two = 0;
int m = n / k;
for (int j = 0; j < m; j++) {
if (arr[i + k * j] == 1)
one++;
else
two++;
}
ans += min(one, two);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
vector<long long> arr(n);
set<long long> occ;
queue<pair<long long, long long> > q;
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
occ.insert(arr[i]);
}
for (int i = 0; i < n; i++) {
if (!occ.count(arr[i] + 1)) {
q.push({arr[i] + 1, 1});
occ.insert(arr[i] + 1);
}
if (!occ.count(arr[i] - 1)) {
q.push({arr[i] - 1, 1});
occ.insert(arr[i] - 1);
}
}
long long cnt = 0, res = 0;
vector<long long> ans;
while (cnt < m) {
pair<long long, long long> t = q.front();
q.pop();
int x = t.first, y = t.second;
ans.push_back(x);
cnt++;
res += y;
occ.insert(x);
if (!occ.count(x + 1)) {
q.push({x + 1, y + 1});
occ.insert(x + 1);
}
if (!occ.count(x - 1)) {
q.push({x - 1, y + 1});
occ.insert(x - 1);
}
}
printf("%lld\n", res);
for (int i = 0; i < m; i++) printf("%lld ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> n;
vector<int> v1, v2;
for (int i = (0); i < (int)(n); i++) {
cin >> a >> b;
v1.push_back(a);
v2.push_back(b);
}
int sum = 0;
for (int i = 0; i < v2.size(); i++) {
for (int j = 0; j < v1.size(); j++)
if (v2[i] == v1[j]) sum++;
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m;
vector<pair<int, int> > nei[105];
bool fd[105][105][27];
bool dp[105][105][27];
bool dfs(int x, int y, int c) {
if (fd[x][y][c]) return dp[x][y][c];
for (int i = 0; i < nei[x].size(); i++) {
if (nei[x][i].second >= c) {
bool res = dfs(y, nei[x][i].first, nei[x][i].second);
if (!res) {
fd[x][y][c] = true;
dp[x][y][c] = true;
return true;
}
}
}
fd[x][y][c] = true;
dp[x][y][c] = false;
return false;
}
int main(int argc, char* argv[]) {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
char c;
cin >> a >> b >> c;
a--;
b--;
c -= 'a';
nei[a].push_back(make_pair(b, c));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dfs(i, j, -1) == true) {
putchar('A');
} else {
putchar('B');
}
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long power(long long x, long long y, long long p) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool isPrime(long long n);
void solve(long long testCaseNo) {
long long n;
cin >> n;
string s;
map<string, long long> goals;
for (long long i = 0ll; i < n; i++) {
cin >> s;
goals[s]++;
}
auto itr = goals.begin();
auto itr2 = goals.rbegin();
if ((itr->first) == (itr2->first)) {
cout << (itr->first);
} else {
if ((itr->second) > (itr2->second)) {
cout << (itr->first);
} else {
cout << (itr2->first);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1ll;
long long tTemp = 1ll;
while (tTemp <= t) {
solve(tTemp);
tTemp++;
}
return 0;
}
bool isPrime(long long n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
vector<int> front, back;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'l')
back.push_back(i + 1);
else
front.push_back(i + 1);
}
for (int i = 0; i < front.size(); i++) cout << front[i] << "\n";
for (int i = back.size() - 1; i >= 0; i--) cout << back[i] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double x[5], y[5], r[5], ang[5];
const double eps = 1e-5;
double disn(double x1, double y1, double x2, double y2) {
return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
double F(double X, double Y) {
double sum = 0.0;
for (int i = 0; i < 3; i++) {
ang[i] = disn(x[i], y[i], X, Y) / r[i];
sum += ang[i];
}
sum /= 3.0;
double deta = 0.0;
for (int i = 0; i < 3; i++) {
deta += (ang[i] - sum) * (ang[i] - sum);
}
return deta;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
double X = 0.0, Y = 0.0;
for (int i = 0; i < 3; i++) {
scanf("%lf%lf%lf", &x[i], &y[i], &r[i]);
X += x[i];
Y += y[i];
}
X /= 3.0;
Y /= 3.0;
double t = 1.0;
while (t > eps) {
double ans = F(X, Y), xx, yy;
int i;
for (i = 0; i < 4; i++) {
xx = X + dx[i] * t;
yy = Y + dy[i] * t;
if (F(xx, yy) < ans) break;
}
if (i == 4)
t *= 0.82;
else {
X = xx;
Y = yy;
}
}
if (fabs(F(X, Y)) < eps) printf("%.5f %.5f\n", X, Y);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int adj[401][401];
double P[401];
double Q[401];
double attemptSecondRun(int x, vector<int>& cand) {
for (int i = 1; i <= N; i++) P[i] = 0.0;
vector<int> w;
for (auto& u : cand) {
int deg = 0;
for (int v = 1; v <= N; v++)
if (adj[u][v] == 1) deg++;
for (int v = 1; v <= N; v++)
if (adj[u][v] == 1) P[v] += 1.0 / deg;
}
for (int i = 1; i <= N; i++)
if (P[i] > 0.0) w.push_back(i);
double ret = 0.0;
for (int i = 1; i <= N; i++) {
for (auto& j : w) Q[adj[i][j]] = max(Q[adj[i][j]], P[j]);
double sum = 0.0;
for (auto& j : w) {
sum += Q[adj[i][j]];
Q[adj[i][j]] = 0.0;
}
ret = max(ret, sum);
}
return ret;
}
double startAtCityX(int x) {
double ret = 0.0;
for (int i = 0; i < N; i++) {
vector<int> cand;
int cnt = 0;
for (int j = 1; j <= N; j++)
if (adj[x][j] == i) cnt++, cand.push_back(j);
if (cnt == 1)
ret += 1.0;
else if (cnt > 1)
ret += max(1.0, attemptSecondRun(x, cand));
}
return ret;
}
int main() {
scanf("%d%d", &N, &M);
memset(adj, 0x3f, sizeof adj);
for (int i = 1; i <= N; i++) adj[i][i] = 0;
for (int i = 0; i < M; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a][b] = adj[b][a] = 1;
}
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]);
double ans = 0.0;
for (int i = 1; i <= N; i++) ans = max(ans, startAtCityX(i));
printf("%.9f\n", ans / N);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
const double PI = acos(-1);
const int64_t root = 565042129;
const int64_t root_1 = 950391366;
const int64_t root_pw = 1 << 20;
int64_t fact[310000];
int64_t ifact[310000];
int64_t mpow(int64_t x, int64_t y, int64_t m) {
if (y == 0) return 1;
int64_t temp = mpow(x, y / 2, m);
if (y & 1) {
temp = temp * temp;
temp %= m;
return (temp * x) % m;
}
return (temp * temp) % m;
}
int64_t inverse(int64_t a, int64_t mod) { return mpow(a, mod - 2, mod); }
void fft(vector<int64_t>& a, bool invert) {
int64_t n = a.size();
for (int64_t i = 1, j = 0; i < n; i++) {
int64_t bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int64_t len = 2; len <= n; len <<= 1) {
int64_t wlen = invert ? root_1 : root;
for (int64_t i = len; i < root_pw; i <<= 1)
wlen = (int64_t)(1LL * wlen * wlen % MOD);
for (int64_t i = 0; i < n; i += len) {
int64_t w = 1;
for (int64_t j = 0; j < len / 2; j++) {
int64_t u = a[i + j], v = (int64_t)(1LL * a[i + j + len / 2] * w % MOD);
a[i + j] = u + v < MOD ? u + v : u + v - MOD;
a[i + j + len / 2] = u - v >= 0 ? u - v : u - v + MOD;
w = (int64_t)(1LL * w * wlen % MOD);
}
}
}
if (invert) {
int64_t n_1 = inverse(n, MOD);
for (int64_t& x : a) x = (int64_t)(1LL * x * n_1 % MOD);
}
}
int64_t nCr(int64_t n, int64_t r) {
if (n < 0 || r < 0 || n < r) return 0;
int64_t ans = 1;
ans *= fact[n];
ans *= ifact[r];
ans %= MOD;
ans *= ifact[n - r];
ans %= MOD;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fact[0] = 1;
ifact[0] = 1;
for (int64_t i = 1; i < 310000; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
ifact[i] = inverse(fact[i], MOD);
}
int64_t n, k;
cin >> n >> k;
vector<int64_t> w(n);
for (int64_t i = 0; i < n; i++) cin >> w[i];
vector<int64_t> r(k);
for (int64_t i = 0; i < k; i++) cin >> r[i];
int64_t q;
cin >> q;
vector<int64_t> p(q);
vector<int64_t> qans(q, 0);
for (int64_t i = 0; i < q; i++) cin >> p[i];
sort(w.begin(), w.end());
map<int64_t, int64_t> freq;
for (int64_t it : w) freq[it]++;
for (int64_t i = 0; i < k; i++) {
int64_t cnt1 = 0, cnt2 = 0;
for (auto it : freq) {
if (it.first >= r[i]) break;
if (it.second == 1)
cnt1++;
else
cnt2++;
}
vector<int64_t> a;
vector<int64_t> b;
for (int64_t i = 0; i <= (2 * cnt2); i++) {
a.push_back(nCr(2 * cnt2, i));
}
for (int64_t i = 0; i <= cnt1; i++) {
b.push_back((nCr(cnt1, i) * mpow(2, i, MOD)) % MOD);
}
int64_t t = 1;
while (t < cnt1 + 2 * cnt2 + 2) t <<= 1;
a.resize(t);
b.resize(t);
fft(a, false);
fft(b, false);
for (int64_t i = 0; i < t; i++) {
a[i] = (a[i] * b[i]) % MOD;
}
fft(a, true);
for (int64_t j = 0; j < q; j++) {
if (p[j] % 2 == 1) continue;
if (p[j] < 2 * r[i] + 2) {
continue;
} else {
if ((p[j] - 2 * r[i] - 2) / 2 < a.size())
qans[j] += a[(p[j] - 2 * r[i] - 2) / 2];
qans[j] %= MOD;
}
}
}
for (int64_t i = 0; i < q; i++) cout << qans[i] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long int mn = 0, temp = 0, ans2 = 0;
for (int(i) = 0; (i) < (s.size()); ++(i)) {
if (s[i] == '+') {
temp += 1;
}
if (s[i] == '-') {
temp -= 1;
}
if (temp < mn) {
mn = temp;
ans2 += i + 1;
}
}
cout << ans2 + s.length() << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v, p, r, rr;
vector<int> nu;
vector<bool> v2;
vector<pair<long long, long long>> v1;
int find(int a) {
if (a == p[a]) {
return a;
}
return p[a] = find(p[a]);
}
void unio(int a, int b) {
a = find(a);
b = find(b);
if (r[a] < r[b]) {
swap(a, b);
}
rr[r[a]]--;
r[a] += r[b];
rr[r[a]]++;
rr[r[b]]--;
r[b] = 0;
p[b] = a;
}
int main() {
long long n, q = 0, maxk = 0, maxq = 0;
cin >> n;
v.resize(n);
p.resize(n);
rr.resize(n + 1);
for (int i = 0; i < n; i++) {
p[i] = i;
cin >> v[i];
}
r.resize(n, 0);
for (int i = 0; i < n; i++) {
v1.push_back({v[i], i});
}
sort(v1.begin(), v1.end());
v2.resize(n, false);
for (int i = 0; i < n; i++) {
int j = v1[i].second;
v2[j] = true;
r[j] = 1;
rr[1]++;
q++;
if (j > 0) {
if (v2[j - 1] == true) {
unio(j, j - 1);
q--;
}
}
if (j < n - 1) {
if (v2[j + 1] == true) {
unio(j, j + 1);
q--;
}
}
if (rr[r[p[find(j)]]] == q) {
if (q > maxq) {
maxk = v1[i].first;
maxq = q;
}
}
}
cout << maxk + 1;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool dp[100010][2];
string str;
set<string> ans;
set<string>::iterator it;
int main() {
cin >> str;
int len = str.size();
for (int i = len - 1; i >= 5; i--) {
if (i + 2 == len) {
dp[i][0] = true;
ans.insert(str.substr(i, 2));
}
if (i + 3 == len) {
dp[i][1] = true;
ans.insert(str.substr(i, 3));
}
if (dp[i + 2][1] ||
(dp[i + 2][0] && str.substr(i, 2) != str.substr(i + 2, 2))) {
dp[i][0] = true;
ans.insert(str.substr(i, 2));
}
if (dp[i + 3][0] ||
(dp[i + 3][1] && str.substr(i, 3) != str.substr(i + 3, 3))) {
dp[i][1] = true;
ans.insert(str.substr(i, 3));
}
}
cout << ans.size() << endl;
for (it = ans.begin(); it != ans.end(); it++) cout << *it << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long mod = 1e9 + 7;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return 1;
return 0;
}
double getDistance(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long extended_euclidean(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = extended_euclidean(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
long long power(long long base, long long p) {
if (p == 1) return base;
if (!p) return 1ll;
long long ret = power(base, p / 2);
ret *= ret;
ret %= mod;
if (p & 1) ret *= base;
return ret % mod;
}
int main() {
int n, m, p = 0;
vector<int> v;
cin >> m >> n;
for (int i = (1); i <= (n); ++i) {
printf("1\n");
fflush(stdout);
int x;
scanf("%d", &x);
if (!x) exit(0);
if (x == 1)
v.push_back(1);
else
v.push_back(0);
}
int low = 1, high = m;
while (low + 1 < high) {
int mid = (low + high) / 2;
printf("%d\n", mid);
fflush(stdout);
int x;
scanf("%d", &x);
if (x == 0) {
exit(0);
}
if (v[p] == 0) x *= -1;
p++;
p %= n;
if (x == 1)
low = mid + 1;
else
high = mid - 1;
}
printf("%d\n", low);
fflush(stdout);
int x;
scanf("%d", &x);
if (x) {
printf("%d\n", high);
fflush(stdout);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void er(char s) {
if (s == 's')
puts("Stannis");
else
puts("Daenerys");
exit(0);
}
int main() {
int n, k;
cin >> n >> k;
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x % 2 == 0)
b++;
else
a++;
}
if (n == k) {
if (a % 2)
er('s');
else
er('d');
}
int mv = n - k;
if (mv / 2 >= a) er('d');
if (mv / 2 >= b && k % 2 == 0) er('d');
if ((mv + 1) / 2 >= b && k % 2 == 1) er('s');
if (mv % 2 == 1)
er('s');
else
er('d');
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int INF = 1e9 + 5;
const int MOD = 1e9 + 7;
int go(long long int l, long long int r, long long int need, int alphSize) {
long long int m = l + (r - l) / 2LL;
if (need < m)
return go(l, m - 1, need, alphSize - 1);
else if (need > m)
return go(m + 1, r, need, alphSize - 1);
else
return alphSize;
}
void solve() {
int n;
long long int k;
cin >> n >> k;
long long int sz = 1;
for (int i = 1; i < n; i++) sz = sz * 2LL + 1LL;
cout << go(1, sz, k, n);
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int CMXS = 30, MAXS = 200000 * 18 * 2 + 123;
int q, a[3][MAXS], nxt = 0;
bitset<CMXS> b;
int main() {
cin >> q;
for (int i = 0; i < 2; i++)
for (int j = 0; j < MAXS; j++) a[i][j] = -1;
for (int i = CMXS - 1, v = 0; (~i ? true : (a[2][v]++, false));
(~a[b[i]][v] ? v = a[b[i]][v] : v = a[b[i]][v] = ++nxt), i--)
a[2][v]++;
while (q--) {
char c;
int x;
cin >> c >> x;
if (c == '+') {
b = x;
for (int i = CMXS - 1, v = 0; (~i ? true : (a[2][v]++, false));
(~a[b[i]][v] ? v = a[b[i]][v] : v = a[b[i]][v] = ++nxt), i--)
a[2][v]++;
}
if (c == '-') {
b = x;
for (int i = CMXS - 1, v = 0; (~i ? true : (a[2][v]--, false));
v = a[b[i]][v], i--)
a[2][v]--;
}
if (c == '?') {
b = x;
bitset<CMXS> f;
for (int i = CMXS - 1, v = 0; ~i; i--)
if (~a[1 - b[i]][v] && a[2][a[1 - b[i]][v]] > 0) {
v = a[1 - b[i]][v];
f[i] = 1;
} else
v = a[b[i]][v];
cout << f.to_ulong() << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string a;
int n, i, cnt, ans = INT_MAX;
int main() {
cin >> n >> a;
for (i = 0; i < n; i++) cnt += (a[i] != (i % 2 ? '0' : '1'));
ans = min(ans, cnt);
cnt = 0;
for (i = 0; i < n; i++) cnt += (a[i] != (i % 2 ? '1' : '0'));
ans = min(ans, cnt);
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long arr1[n];
long long arr2[m];
for (int i = 0; i < n; i++) cin >> arr1[i];
for (int j = 0; j < m; j++) cin >> arr2[j];
sort(arr1, arr1 + n);
sort(arr2, arr2 + m);
long long largest[n];
for (int i = 0; i < n; i++) {
largest[i] = -1000000000000000000;
for (int j = 0; j < m; j++) {
largest[i] = max(largest[i], arr1[i] * arr2[j]);
}
}
sort(largest, largest + n);
cout << largest[n - 2] << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int K = 127;
int a[9], dp[9][K + 1], curmul[K + 1][K + 1], tempdp[9][2];
void muls(int A[K + 1][K + 1], int B[K + 1][K + 1], int siz) {
int i, j, k, C[K + 1][K + 1], lim;
long long int buf1;
lim = (1 << siz) - 1;
for (i = 0; i <= lim; i++) {
for (j = 0; j <= lim; j++) {
C[i][j] = 0;
for (k = 0; k <= lim; k++) {
buf1 = (1ll * A[i][k] * B[k][j]) % mod;
C[i][j] = (C[i][j] + buf1) % mod;
}
}
}
for (i = 0; i <= lim; i++) {
for (j = 0; j <= lim; j++) {
A[i][j] = C[i][j];
}
}
return;
}
void poweryay(int n, int ans[K + 1], int siz) {
int i, j, t1, t2, t3, t4, T[K + 1][K + 1], mulmat[K + 1][K + 1], F1[K + 1],
lim;
long long int buf1, buf2;
lim = (1 << siz) - 1;
for (i = 0; i <= lim; i++) {
for (j = 0; j <= lim; j++) {
T[i][j] = curmul[i][j];
mulmat[i][j] = (i == j) ? 1 : 0;
}
}
for (i = 0; i <= lim; i++) {
F1[i] = ans[i];
}
while (n > 0) {
if (n & 1) {
muls(mulmat, T, siz);
}
n >>= 1;
muls(T, T, siz);
}
for (i = 0; i <= lim; i++) {
buf1 = buf2 = 0;
for (j = 0; j <= lim; j++) {
buf2 = (1ll * mulmat[i][j] * F1[j]) % mod;
buf1 = (buf1 + buf2) % mod;
}
ans[i] = buf1;
}
return;
}
void getmat(int val) {
int i, j, k, t1, t2, t3, t4, allmask;
long long int finalval;
memset(curmul, 0, sizeof(curmul));
allmask = (1 << val) - 1;
for (i = 0; i <= allmask; i++) {
for (j = 0; j <= allmask; j++) {
tempdp[val][1] = 1;
tempdp[val][0] = 0;
for (k = val - 1; k >= 0; k--) {
t1 = i & (1 << k);
t2 = j & (1 << k);
if (t1 > 0 && t2 > 0) {
tempdp[k][0] = (tempdp[k + 1][1] + tempdp[k + 1][0]) % mod;
tempdp[k][1] = (tempdp[k + 1][0]) % mod;
} else {
tempdp[k][0] = (tempdp[k + 1][1] + tempdp[k + 1][0]) % mod;
tempdp[k][1] = (tempdp[k + 1][1] + tempdp[k + 1][0]) % mod;
}
}
finalval = tempdp[0][1];
curmul[j][i] = finalval;
}
}
return;
}
int main() {
int i, j, t1, t2, t3, t4, finalmask, ans;
for (i = 1; i <= 7; i++) {
scanf("%d", &a[i]);
}
dp[0][0] = 1;
finalmask = (1 << 7) - 1;
for (i = 1; i <= 7; i++) {
for (j = 0; j <= finalmask; j++) {
t1 = (1 << (i - 1)) + j;
if (t1 <= finalmask) {
dp[i][t1] = (dp[i][t1] + dp[i - 1][j]) % mod;
}
}
if (a[i] > 0) {
getmat(i);
poweryay(a[i], dp[i], i);
}
}
ans = dp[7][finalmask];
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, inf = 2e9 + 5;
int n, m, l, r, x, a[N], t[4 * N], ans[3 * N], sufMin = inf;
set<int> q[4 * N];
vector<pair<int, int> > g[N];
void dfs(int v, int l, int r) {
t[v] = inf;
if (l == r) {
return;
}
int mid = (r + l) >> 1;
dfs(v + v, l, mid);
dfs(v + v + 1, mid + 1, r);
}
void update(int v, int l, int r, int tl, int tr, int val) {
if (l > r || l > tr || tl > r) {
return;
}
if (l == r) {
if (l != tr) {
t[v] = min(t[v], abs(a[l] - val));
sufMin = min(sufMin, t[v]);
}
return;
}
int mid = (r + l) >> 1;
if (tl <= l && r <= tr) {
auto it = q[v].lower_bound(val);
if ((it == q[v].end() || abs(*it - val) >= sufMin) &&
(it == q[v].begin() || abs(*(--it) - val) >= sufMin)) {
sufMin = min(sufMin, t[v]);
return;
}
update(v + v + 1, mid + 1, r, tl, tr, val);
update(v + v, l, mid, tl, tr, val);
t[v] = min(t[v + v], t[v + v + 1]);
return;
}
update(v + v + 1, mid + 1, r, tl, tr, val);
update(v + v, l, mid, tl, tr, val);
t[v] = min(t[v + v], t[v + v + 1]);
}
int get(int v, int l, int r, int tl, int tr) {
if (l > r || l > tr || tl > r) {
return inf;
}
if (tl <= l && r <= tr) {
return t[v];
}
int mid = (r + l) >> 1;
return min(get(v + v, l, mid, tl, tr), get(v + v + 1, mid + 1, r, tl, tr));
}
void add(int v, int l, int r, int pos, int val) {
q[v].insert(val);
if (l == r) {
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
add(v + v, l, mid, pos, val);
} else {
add(v + v + 1, mid + 1, r, pos, val);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> l >> r;
g[r].push_back(make_pair(l, i));
}
dfs(1, 1, n);
for (int i = 1; i <= n; i++) {
sufMin = inf;
update(1, 1, n, 1, i, a[i]);
add(1, 1, n, i, a[i]);
for (auto to : g[i]) {
ans[to.second] = get(1, 1, n, to.first, i);
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m) {
long long ans = 1;
a %= m;
while (b) {
if (b & 1) ans = (ans * a) % m;
a = (a * a) % m;
b >>= 1;
}
return ans;
}
vector<long long> adj[100009];
bool vis[100009];
long long sz = 0;
void dfs(int i) {
vis[i] = true;
sz++;
for (auto v : adj[i]) {
if (vis[v] == false) dfs(v);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cin.tie(0);
memset(vis, false, sizeof(vis));
unsigned long long n, k, u, v, c;
cin >> n >> k;
for (long long i = 1; i < n; ++i) {
cin >> u >> v >> c;
if (c == 0) {
adj[u].push_back(v);
adj[v].push_back(u);
}
}
long long ans = (power(n, k, 1000000007) - n) % 1000000007;
for (long long i = 1; i <= n; ++i) {
if (vis[i] == false) {
sz = 0;
dfs(i);
ans += 1000000007;
ans -= power(sz, k, 1000000007);
ans += sz;
ans = ans % 1000000007;
}
}
ans = ans % 1000000007;
while (ans < 0) {
ans += 1000000007;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 5;
const long long LINF = LLONG_MAX;
int main() {
int n;
cin >> n;
int a[n];
int r1 = 0, r2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= 500000) {
r1 = max(r1, a[i] - 1);
}
if (a[i] > 500000) {
r2 = max(r2, 1000000 - a[i]);
}
}
cout << max(r1, r2) << "\n";
}
| 1 |
#include <bits/stdc++.h>
int main() {
int hours;
scanf("%d", &hours);
int active[hours];
for (int a = 0; a < hours; a++) scanf("%d", &active[a]);
int counter = 0;
for (int b = 0; b < hours; b++) {
if (active[b] == 1) counter++;
if (active[b] == 0 && active[b - 1] == 1 && active[b + 1] == 1) counter++;
}
printf("%d\n", counter);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1001000];
scanf("%s", ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const int maxn = 2048;
const int base = 29;
const int MAX_LG = 21;
const int mod = 1e9 + 7;
const int INF = 1e18;
const int maxq = 2e5 + 10;
bool e[maxn][maxn];
int n, m, k;
int Log[maxn], cnt[maxn];
int dp[maxn][maxn];
inline int calc(int a, int b) {
if (max(a, b) >= (1 << n)) return 0;
if (dp[a][b] != -1) return dp[a][b];
if (cnt[a] == 2) {
return (e[Log[a & -a]][Log[a - (a & -a)]] && a == b);
}
if (cnt[a] <= 1 || cnt[b] <= 1) return 0;
dp[a][b] = 0;
int p = Log[b & -b];
int _b = b - (1 << p);
int _a = a - (1 << p);
for (int i = 0; i < n; i++) {
int j = 1 << i;
if ((j & a) && !(j & b) && e[i][p]) {
dp[a][b] += calc(_a, _b) + calc(_a, _b + j);
}
}
return dp[a][b];
}
int res;
int32_t main() {
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++) dp[i][j] = -1;
n = in(), m = in(), k = in();
for (int i = 0; i < m; i++) {
int v = in() - 1, u = in() - 1;
e[v][u] = e[u][v] = 1;
}
for (int i = 0; i <= 10; i++) Log[1 << i] = i;
for (int i = 1; i < maxn; i++) cnt[i] = cnt[i ^ (i & -i)] + 1;
for (int mask = 1; mask < (1 << n); mask++)
if (cnt[mask] == k) res += calc((1 << n) - 1, mask);
cout << res << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 77777;
const int MAX_E2 = 1 << 18;
const int TN = 3;
const int MOD = 777777777;
typedef int mat[TN][TN];
static mat ts;
struct Elm {
mat cs;
Elm() {}
void set(int t) {
memset(cs, 0, sizeof(mat));
if (--t < 0)
for (int i = 0; i < TN; i++) cs[i][i] = 1;
else
cs[t][t] = 1;
}
void _mulmat(mat c, const mat a, const mat b) const {
for (int i = 0; i < TN; i++)
for (int j = 0; j < TN; j++) {
c[i][j] = 0;
for (int k = 0; k < TN; k++)
c[i][j] = (c[i][j] + (long long)a[i][k] * b[k][j] % MOD) % MOD;
}
}
Elm operator*(const Elm &e) const {
Elm r;
mat s;
_mulmat(s, cs, ts);
_mulmat(r.cs, s, e.cs);
return r;
}
int value() {
int val = 0;
for (int i = 0; i < TN; i++)
for (int j = 0; j < TN; j++) val = (val + cs[i][j]) % MOD;
return val;
}
};
template <typename T, const int MAX_E2>
struct SegTreeMul {
int n, e2;
T nodes[MAX_E2], uelm;
SegTreeMul() {}
void init(int _n, T _uelm) {
n = _n;
uelm = _uelm;
for (e2 = 1; e2 < n; e2 <<= 1)
;
fill(nodes, nodes + MAX_E2, uelm);
for (int j = e2 - 2; j >= 0; j--)
nodes[j] = nodes[j * 2 + 1] * nodes[j * 2 + 2];
}
T &root() { return nodes[0]; }
T &get(int i) { return nodes[e2 - 1 + i]; }
void set(int i, T v) {
int j = e2 - 1 + i;
nodes[j] = v;
while (j > 0) {
j = (j - 1) / 2;
nodes[j] = nodes[j * 2 + 1] * nodes[j * 2 + 2];
}
}
T mul_range(int r0, int r1, int k, int i0, int i1) {
if (r1 <= i0 || i1 <= r0) return uelm;
if (r0 <= i0 && i1 <= r1) return nodes[k];
int im = (i0 + i1) / 2;
if (r1 <= im) return mul_range(r0, r1, k * 2 + 1, i0, im);
if (im <= r0) return mul_range(r0, r1, k * 2 + 2, im, i1);
T v0 = mul_range(r0, r1, k * 2 + 1, i0, im);
T v1 = mul_range(r0, r1, k * 2 + 2, im, i1);
return v0 * v1;
}
T mul_range(int r0, int r1) { return mul_range(r0, r1, 0, 0, e2); }
};
SegTreeMul<Elm, MAX_E2> st;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < TN; i++)
for (int j = 0; j < TN; j++) scanf("%d", &ts[i][j]);
Elm uelm;
uelm.set(0);
st.init(n, uelm);
while (m--) {
int v, t;
scanf("%d%d", &v, &t);
v--;
Elm e;
e.set(t);
st.set(v, e);
printf("%d\n", st.mul_range(0, n).value());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
inline void in(const char *t) {}
template <typename Head, typename... Tail>
inline void in(const char *t, Head &H, Tail &...T) {
scanf(t, &H);
in(t, T...);
}
const int OO = 0x3fffffff, N = 1e5 + 7, MOD = 1000000007;
int n;
int fre[30];
void test(int T) {
in("%d", n);
;
for (int i = 0, a; i < n; ++i) {
in("%d", a);
;
fre[a + 10]++;
}
long long ans = fre[0 + 10] * 1LL * (fre[0 + 10] - 1) / 2;
for (int i = 1; i < 11; ++i) {
ans += fre[i + 10] * 1LL * fre[-1 * i + 10];
}
printf("%I64d\n", ans);
}
int main() {
int tc;
tc = 1;
for (int i = 0; i < tc; ++i) test(i);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> sqr[11];
int main() {
string s;
cin >> s;
vector<int> a(256, 0);
for (int i = 0; i < s.length(); i++) {
a[s[i]]++;
}
int c = 0, l = 0;
for (int i = 0; i < 256; i++) {
if (a[i] != 0) {
l++;
if (a[i] == 1) c = 1;
}
}
if (l == 1 || (l == 2 && c == 1) || (l == s.length() && l % 2 == 1) || l > 4)
cout << "NO";
else
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n, m, a, b, c, k, temp, x, y;
const int MAXN = 1e5 + 11, mod = 1e9 + 7;
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) ? b : a); }
vector<int> read(int n) {
vector<int> v(n);
for (int i = 0; i < v.size(); i++) cin >> v[i];
return v;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int fun(vector<int> v, int bit) {
if (v.size() <= 1) return v.size();
vector<int> v1, v2;
for (auto x : v)
if ((1 << bit) & x)
v1.push_back(x);
else
v2.push_back(x);
if (v1.size() && v2.size())
return max(1 + fun(v1, bit - 1), 1 + fun(v2, bit - 1));
if (v1.size()) return fun(v1, bit - 1);
if (v2.size()) return fun(v2, bit - 1);
return 0;
}
void sol(void) {
cin >> n;
vector<int> v = read(n);
cout << n - fun(v, 30);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int test = 1;
while (test--) sol();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> edge[N];
int n, sz[N];
double A[N];
void dfs(int x) {
for (int i = 0; i < edge[x].size(); i++) {
int k = edge[x][i];
dfs(k);
sz[x] += sz[k];
}
}
void dfs_ans(int x) {
for (int i = 0; i < edge[x].size(); i++) {
int k = edge[x][i];
A[k] = A[x] + 1.0 + (sz[x] - sz[k] - 1) / 2.0;
dfs_ans(k);
}
}
int main() {
int x;
memset(A, 0, sizeof(A));
scanf("%d", &n);
for (int i = 1; i <= n; i++) sz[i] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
edge[x].push_back(i);
}
A[1] = 1;
dfs(1);
dfs_ans(1);
for (int i = 1; i <= n; i++) printf("%lf ", A[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
list<int> a[10001];
int n, m, val, maxi, visited[10001], dist[10001];
list<int>::iterator it;
cin >> n >> m;
if (n == m)
cout << "0";
else {
for (int i = 1; i <= 10000; ++i) {
if (i - 1 <= 10000) a[i].push_back(i - 1);
if (i * 2 <= 10000) a[i].push_back(i * 2);
}
memset(visited, 0, sizeof(visited));
for (int i = 0; i <= 10000; ++i) dist[i] = INT_MAX;
dist[n] = 0;
for (int i = 0; i < 10000; ++i) {
maxi = INT_MAX;
for (int j = 0; j <= 10000; ++j) {
if (!visited[j] && dist[j] < maxi) {
val = j;
maxi = dist[j];
}
}
visited[val] = 1;
if (val == m) break;
for (it = a[val].begin(); it != a[val].end(); ++it) {
if (!visited[*it] && dist[*it] > dist[val] + 1)
dist[*it] = dist[val] + 1;
}
}
cout << dist[m];
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (int)1e9 + 123;
const long long infl = (long long)1e18 + 123;
const double eps = 1e-10;
const int MAX_N = (int)3e5 + 123;
int n;
int powerOfTwo[60], bad[60], endsAt[60], needToBeDeleted[60];
bool can(int need) {
int left = need;
for (int i = 59, del = 0; i >= 0; i--) {
endsAt[i] = min(left, powerOfTwo[i] - del);
needToBeDeleted[i] = bad[i] + powerOfTwo[i] - del - endsAt[i];
left -= endsAt[i];
del += endsAt[i];
}
for (int i = 59; i >= 0; i--) {
for (int j = 59; j >= i; j--) {
int canDelete = min(needToBeDeleted[i], endsAt[j]);
endsAt[j] -= canDelete, needToBeDeleted[i] -= canDelete;
}
if (needToBeDeleted[i] > 0) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
int ptr = 0, bad = 0;
while (x) {
ptr++;
if (x > 1 && x % 2 == 1) bad = 1;
x /= 2;
}
if (bad)
::bad[ptr - 1]++;
else
powerOfTwo[ptr - 1]++;
}
int atLeast = powerOfTwo[0];
for (int i = 1; i < 60; i++) {
if (powerOfTwo[i] > atLeast) {
bad[i] += powerOfTwo[i] - atLeast;
powerOfTwo[i] = atLeast;
}
atLeast = powerOfTwo[i];
}
bool flag = 0;
for (int i = 1; i <= powerOfTwo[0]; i++) {
if (can(i)) {
printf("%d ", i);
flag = 1;
}
}
if (!flag) puts("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
long long n, m, h;
long long a[1111];
long long S = 0;
long long all, ex, dif;
double ans;
long long X[1111], Y[1111];
long long C(long long x, long long y) {
if (x < y) return 0;
if (x == y) return 1;
long long i, j, k, t, tt, ttt;
long long max, min;
k = x - y;
long long left = 1;
if (x - y > y) {
max = x - y;
min = y;
} else {
max = y;
min = x - y;
}
for (i = 1; i <= x; i++) {
X[i] = i;
}
for (i = 1; i <= min; i++) {
Y[i] = i;
}
for (i = 1; i <= max; i++) {
X[i] = 1;
}
for (i = 2; i <= min; i++) {
tt = i;
for (j = max + 1; j <= x; j++) {
t = 0;
if (X[j] % i == 0) {
X[j] /= i;
t++;
tt = 0;
break;
}
if (t != 0) break;
}
if (tt != 0) {
left *= tt;
}
}
long long re = 1;
for (i = max + 1; i <= x; i++) {
re *= X[i];
if (re >= left) {
if (re % left == 0) {
re /= left;
left = 1;
}
}
}
return re;
}
int main() {
long long i, j, k;
long long p, q, r;
long long t, tt, ttt;
long long A, B, P;
scanf("%I64d %I64d %I64d", &n, &m, &h);
h--;
for (i = 0; i < m; i++) {
scanf("%I64d", &a[i]);
S += a[i];
}
if (S < n) {
printf("-1.0");
scanf(" ");
return 0;
}
if (n == 1) {
printf("0");
scanf(" ");
return 0;
}
A = S - 1;
B = n - 1;
P = S - a[h];
p = S - a[h];
double ANS = 1;
for (i = A - B + 1, j = P - B + 1; i <= A, j <= P; i++, j++) {
ANS = ANS * (((double)(j)) / ((double)(i)));
}
printf("%.8lf", 1 - ANS);
scanf(" ");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename G1, typename G2 = G1, typename G3 = G1>
struct triple {
G1 first;
G2 second;
G3 T;
};
const long long mod = 1e9 + 7;
long long sum(long long a, long long b) {
a += b;
if (a >= b) a -= mod;
if (a < 0) a += mod;
return a;
}
struct st {
int n;
set<pair<long long, long long>> s;
long long t = 0;
st(int _n) : n(_n) { s.insert({n, n + 1}); }
void upd(pair<long long, long long> x) {
t = sum(t, ((*s.begin()).first - x.first) * x.second % mod);
s.insert(x);
}
void upd(long long l, long long m) {
auto it = s.lower_bound({l, 0});
pair<long long, long long> last = {l, 0};
if ((*it).first > l) {
--it;
last.second = (*it).second;
++it;
}
if (last.second >= m || ((*it).first == l && (*it).second >= m)) return;
vector<pair<long long, long long>> del;
while ((*it).second < m) {
del.push_back(*it);
t = sum(t, ((*it).first - last.first) * (m - last.second) % mod);
last = *it;
++it;
}
t = sum(t, ((*it).first - last.first) * (m - last.second) % mod);
for (auto i : del) s.erase(i);
s.insert({l, m});
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, l;
cin >> n >> k >> l;
vector<triple<long long>> v(n);
for (auto &i : v) cin >> i.first >> i.second >> i.T, --i.T;
sort(v.begin(), v.end(), [](triple<long long> x, triple<long long> y) {
return x.first < y.first;
});
vector<multiset<long long>> t(k);
long long ans = 0;
long long p = 0, last = -1;
while (p < n) {
for (int i = 0; i < k; i++) t[i].clear();
vector<pair<long long, long long>> w;
for (int i = p; i < n; i++) {
t[v[i].T].insert(v[i].second);
w.push_back({v[i].second, v[i].T});
}
for (int i = 0; i < k; i++) t[i].insert(l);
sort(w.begin(), w.end());
multiset<long long> temp;
vector<long long> ex(k, l + 1);
st s(l);
for (int i = 0; i < k; i++) temp.insert(l + 1);
long long lp = l + 1;
for (int i = w.size() - 1, j = i; i >= 0; i = j) {
for (; j >= 0 && w[j].first == w[i].first; j--) {
temp.erase(temp.find(ex[w[j].second]));
ex[w[j].second] = w[j].first + 1;
temp.insert(w[j].first + 1);
}
if (*temp.rbegin() != lp) {
s.upd({w[i].first + 1, lp});
lp = *temp.rbegin();
}
}
if ((*s.s.begin()).first != 0) s.upd({0, lp});
long long lx = l;
for (int i = n - 1, j = i; i >= p; i = j) {
ans = sum(ans, (v[p].first - last) * (lx - v[i].first) % mod *
((l * (l + 1) - s.t) % mod) % mod);
lx = v[i].first;
for (; j >= p && v[j].first == v[i].first; j--) {
long long ri = v[j].second;
t[v[j].T].erase(t[v[j].T].find(ri));
auto it = t[v[j].T].lower_bound(ri);
long long m = (*it) + 1;
long long li = 0;
if (it != t[v[j].T].begin()) {
--it;
li = *it + 1;
}
s.upd(li, m);
}
}
last = v[p].first;
int id = p;
for (; id < n && v[id].first == v[p].first; ++id)
;
p = id;
}
cout << ans << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
a.push_back(temp);
}
int k = 0;
for (int i = 1; i < n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
a[i + 1] = 0;
k++;
}
}
cout << k;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> mp;
bool sou(int x);
long long ge[100005], a[100005][16], b[100005][16], A[16], B[16];
long long ansa[16], ansb[16];
bool mj(int x, int y, int z) {
if (y == 0) {
if (z == 0 || z == x) return false;
if (x - z < z) return false;
if (sou(z) && sou(x - z)) {
ge[x] = ge[z] + ge[x - z];
for (int i = 1; i <= ge[z]; i++) a[x][i] = a[z][i], b[x][i] = b[z][i];
for (int i = 1; i <= ge[x - z]; i++)
a[x][i + ge[z]] = a[x - z][i], b[x][i + ge[z]] = b[x - z][i];
return true;
}
return false;
}
int k = y & (-y);
if (mj(x, y - k, z + k)) return true;
if (mj(x, y - k, z)) return true;
}
bool sou(int x) {
if (ge[x] > 0) {
return true;
}
if (ge[x] == -1) return false;
bool bo = mj(x, x, 0);
if (!bo) ge[x] = -1;
return bo;
}
int n, k[20];
long long num[20][5005];
long long Sum, sum[20];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &k[i]);
for (int j = 1; j <= k[i]; j++) {
scanf("%I64d", &num[i][j]);
Sum += num[i][j];
sum[i] += num[i][j];
mp[num[i][j]] = i;
}
}
if (Sum % n != 0) {
printf("No");
} else {
Sum /= n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k[i]; j++) {
int ch = 0;
long long w = num[i][j];
bool bo = true;
int tot = 0;
while (bo) {
if (mp[w] == 0) {
bo = false;
break;
}
if (ch & (1 << (mp[w] - 1))) {
bo = false;
break;
}
B[++tot] = mp[w];
ch |= (1 << (mp[w] - 1));
w = Sum - (sum[mp[w]] - w);
A[tot] = w;
if (w == num[i][j]) {
break;
}
}
if (bo) {
ge[ch] = tot;
for (int i = 1; i <= tot; i++) {
a[ch][i] = A[i], b[ch][i] = B[i];
}
}
}
}
if (sou((1 << n) - 1)) {
printf("Yes\n");
for (int i = n; i >= 1; i--)
ansa[mp[a[(1 << n) - 1][i]]] = a[(1 << n) - 1][i],
ansb[mp[a[(1 << n) - 1][i]]] = b[(1 << n) - 1][i];
for (int i = 1; i <= n; i++) printf("%I64d %I64d\n", ansa[i], ansb[i]);
} else {
printf("No\n");
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void freac() {}
const int DX[] = {+1, 0, -1, 0, +1, +1, -1, -1};
const int DY[] = {0, +1, 0, -1, +1, -1, +1, -1};
const int INF = (int)1e9 + 123;
const long long INFL = (long long)1e18 + 123;
const double EPS = 1e-9;
int main() {
freac();
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
for (int i = 0; i < n; i++)
sum = (sum + (long long)a[i] * a[n - 1 - i]) % 10007;
cout << sum << endl;
return false;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long G(long long a, long long b) {
if (b == 0) return a;
return G(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
int m, n;
cin >> m >> n;
cout << min(m, n) + 1 << endl;
for (int i = 0; i < min(m, n) + 1; i++)
cout << min(m, n) - i << " " << i << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100001], b[100001];
cin >> a >> b;
int i;
int t = 0;
for (i = 0; a[i]; i++) {
if (a[i] != b[i]) {
t++;
}
}
if (t % 2) {
cout << "impossible";
return 0;
}
for (i = 0; a[i]; i++) {
if (a[i] == b[i]) {
cout << a[i];
} else {
if (t % 2) {
cout << a[i];
} else {
cout << b[i];
}
t--;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], b[100005];
int da[100005], db[100005];
int is_eqal(int *a, int *b, int sz) {
sort(a + 1, a + 1 + sz);
sort(b + 1, b + 1 + sz);
for (int i = 1; i <= sz; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
for (int i = 1; i < n; i++) {
da[i] = a[i + 1] - a[i];
}
for (int i = 1; i < n; i++) {
db[i] = b[i + 1] - b[i];
}
if (a[1] != b[1] || a[n] != b[n]) {
printf("No\n");
} else {
if (is_eqal(da, db, n - 1))
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int n, m;
int r1, c1, r2, c2;
char a[1 << 9][1 << 9];
int u[1 << 9][1 << 9];
bool bound(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int go(int r1, int c1, int r2, int c2) {
if (r1 == r2 && c1 == c2) return 1;
u[r1][c1] = 1;
for (int i = 0; i < 4; ++i) {
int tor = r1 + dx[i];
int toc = c1 + dy[i];
if (!bound(tor, toc) || u[tor][toc]) continue;
if (a[tor][toc] == 'X' && (tor != r2 || toc != c2)) continue;
if (go(tor, toc, r2, c2)) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", a[i]);
scanf("%d%d", &r1, &c1);
scanf("%d%d", &r2, &c2);
r1--, c1--;
r2--, c2--;
int cnt = 0;
for (int i = 0; i < 4; ++i) {
int tor = r2 + dx[i];
int toc = c2 + dy[i];
cnt += bound(tor, toc) && (a[tor][toc] == '.' || tor == r1 && toc == c1);
}
if (a[r2][c2] == '.' && cnt < 2) {
printf("NO\n");
return 0;
}
if (r1 == r2 && c1 == c2) {
if (cnt == 0)
printf("NO\n");
else
printf("YES\n");
return 0;
}
if (go(r1, c1, r2, c2))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double slope(pair<long long int, long long int> A,
pair<long long int, long long int> B) {
double ret = B.second - A.second + 0.0;
ret /= (B.first - A.first);
return ret;
}
long long cross(pair<long long int, long long int> A,
pair<long long int, long long int> B,
pair<long long int, long long int> C) {
return (B.first - A.first) * (C.second - A.second) -
(B.second - A.second) * (C.first - A.first);
}
void convex_hull(vector<pair<long long int, long long int> > pts,
vector<pair<long long int, long long int> >& hull) {
hull.clear();
sort(pts.begin(), pts.end());
for (long long int i = 0; i < (long long int)pts.size(); i++) {
while ((long long int)hull.size() >= 2 &&
cross(hull[(long long int)hull.size() - 2], hull.back(), pts[i]) <=
0)
hull.pop_back();
hull.push_back(pts[i]);
}
int s = (long long int)hull.size();
for (int i = pts.size() - 2; i >= 0; i--) {
while ((long long int)hull.size() >= s + 1 &&
cross(hull[(long long int)hull.size() - 2], hull.back(), pts[i]) <=
0)
hull.pop_back();
hull.push_back(pts[i]);
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
vector<pair<long long int, long long int> > hull, pts;
long long n;
cin >> n;
for (long long int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
pts.push_back({a, b - a * a});
}
convex_hull(pts, hull);
auto mx = hull[0], mn = hull[0];
long long mxi = 0, mni = 0;
for (long long int i = 0; i < hull.size(); i++) {
if (mx.first < hull[i].first) {
mx = hull[i];
mxi = i;
}
if (mn.first > hull[i].first) {
mn = hull[i];
mni = i;
}
}
set<double> s;
long long nn = hull.size();
swap(mni, mxi);
while (mni != mxi) {
if (hull[mni].first == hull[(mni + 1) % nn].first) {
mni = (mni + 1) % nn;
continue;
}
s.insert(slope(hull[mni], hull[(mni + 1) % nn]));
mni = (mni + 1) % nn;
}
cout << s.size() << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, V;
cin >> n >> V;
int a[n], b[n];
double x = 1000;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> b[i];
x = (x < ((b[i] * 1.0) / a[i]) ? x : ((b[i] * 1.0) / a[i]));
}
double v = 0;
for (int i = 0; i < n; i++) v += a[i] * x;
cout << (v < V ? v : V);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300005];
int cnt[2];
int color[300005];
int power2[300005];
int mo = 998244353;
int fg;
void dfs(int id, int c) {
color[id] = c;
cnt[c] += 1;
for (int i = 0; i < v[id].size(); i++) {
if (color[v[id][i]] == -1) {
dfs(v[id][i], 1 - c);
}
if (color[id] == color[v[id][i]]) {
fg = 1;
}
}
}
int main() {
power2[0] = 1;
for (int i = 1; i < 300005; i++) {
power2[i] = (2 * power2[i - 1]) % mo;
}
int t;
cin >> t;
while (t) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) v[i].clear();
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
--a;
--b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 0; i < n; i++) {
color[i] = -1;
}
long long int ans = 1;
for (int i = 0; i < n; i++) {
if (color[i] != -1) continue;
fg = 0;
cnt[0] = 0;
cnt[1] = 0;
dfs(i, 0);
if (fg) {
break;
}
ans =
(ans * (((long long int)power2[cnt[0]] + power2[cnt[1]]) % mo)) % mo;
}
if (fg) {
cout << "0" << endl;
} else {
cout << ans << endl;
}
t--;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const long long maxn = 112345;
long long n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
int t = 1;
while (t--) {
long long n;
cin >> n;
long long x = (long long)sqrt(n);
long long ans = 0;
if (x * x == n) {
ans = 2 * x;
} else if (x * x + x >= n) {
ans = 2 * x + 1;
} else if (x * x + 2 * x + 1 >= n) {
ans = 2 * x + 2;
}
cout << ans;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 5005;
const int MOD = 1000000007;
int N, A, B, K;
int dp[SIZE][SIZE];
void slv(int x, int l, int r, int d) {
dp[x][l] += d;
dp[x][l] %= MOD;
dp[x][r] -= d;
dp[x][r] = (dp[x][r] + MOD) % MOD;
}
int main() {
scanf("%d %d %d %d", &N, &A, &B, &K);
dp[0][A] = 1;
for (int i = 0; i < K; i++) {
for (int j = 1; j <= N; j++) {
if (j == B) continue;
int temp = abs(j - B) - 1;
slv(i + 1, max(j - temp, 1), j, dp[i][j]);
slv(i + 1, j + 1, min(j + temp + 1, N + 1), dp[i][j]);
}
int cnt = 0;
for (int j = 1; j <= N; j++) {
cnt += dp[i + 1][j];
cnt %= MOD;
dp[i + 1][j] = cnt;
}
}
int res = 0;
for (int i = 1; i <= N; i++) {
res += dp[K][i];
res %= MOD;
}
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
double ans = 1;
cin >> n;
for (int i = n, j = 2; i > n - 5; i--, j++) {
ans *= i * i;
if (j <= 5) ans /= j;
}
cout << (long long)ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1ll << 60, N = 30010;
struct node {
long long v;
int id;
} a[N], b[N];
int n, q, Pa[N], Pb[N], F[N];
long long f[N], w1[N], w2[N], w3[N];
inline bool cmp(node a, node b) { return a.v < b.v; }
inline void calc(int i) {
w1[i] = w2[i] = w3[i] = -inf;
if (i >= 1 && F[i] != i) w1[i] = a[i].v * b[i].v;
if (i >= 2 && F[i] != i - 1 && F[i - 1] != i)
w2[i] = a[i].v * b[i - 1].v + a[i - 1].v * b[i].v;
if (i >= 3) {
if (F[i] != i - 2 && F[i - 1] != i && F[i - 2] != i - 1)
w3[i] =
a[i].v * b[i - 2].v + a[i - 1].v * b[i].v + a[i - 2].v * b[i - 1].v;
if (F[i] != i - 1 && F[i - 1] != i - 2 && F[i - 2] != i)
w3[i] = max(w3[i], a[i].v * b[i - 1].v + a[i - 1].v * b[i - 2].v +
a[i - 2].v * b[i].v);
}
}
int main() {
register int i, j;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++) scanf("%lld", &a[i].v), a[i].id = i;
for (i = 1; i <= n; i++) scanf("%lld", &b[i].v), b[i].id = i;
sort(a + 1, a + 1 + n, cmp), sort(b + 1, b + 1 + n, cmp);
for (i = 1; i <= n; i++) Pa[a[i].id] = i, Pb[b[i].id] = i;
for (i = 1; i <= n; i++) F[i] = Pb[a[i].id];
for (i = 1; i <= n; i++) calc(i);
int x, y;
for (j = 1; j <= q; j++) {
scanf("%d%d", &x, &y);
x = Pa[x], y = Pa[y], swap(F[x], F[y]);
for (i = max(1, x - 5); i <= min(n, x + 5); i++) calc(i);
for (i = max(1, y - 5); i <= min(n, y + 5); i++) calc(i);
f[0] = 0;
for (i = 1; i <= n; i++) {
if (i >= 1) f[i] = f[i - 1] + w1[i];
if (i >= 2) f[i] = max(f[i], f[i - 2] + w2[i]);
if (i >= 3) f[i] = max(f[i], f[i - 3] + w3[i]);
}
printf("%lld\n", f[n]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a;
cin >> b;
int i = 1;
while (a >= 0 && b >= 0) {
if (i % 2 == 1)
a -= i;
else
b -= i;
i++;
}
if (a < 0)
cout << "Vladik" << endl;
else
cout << "Valera" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int k = 0; k < t; k++) {
int n, flagp = 0, flagn = 0, min, max;
cin >> n;
long long int arr[n];
vector<long long int> v;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] < 0) {
flagn = 1;
} else {
flagp = 1;
}
}
int i = 0;
while (i < n) {
max = 0, min = 0;
if (arr[i] > 0) {
max = arr[i];
i += 1;
for (;;) {
if (i >= n) break;
if (arr[i] < 0)
break;
else {
if (arr[i] > max) max = arr[i];
}
i += 1;
}
v.push_back(max);
} else if (arr[i] < 0) {
min = arr[i];
i += 1;
for (;;) {
if (i >= n) break;
if (arr[i] > 0)
break;
else {
if (min < arr[i]) min = arr[i];
}
i += 1;
}
v.push_back(min);
}
}
int s = v.size();
long long int sum = 0;
for (int i = 0; i < s; i++) {
sum += v[i];
}
cout << sum;
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int long long t, n, i, l, r, m, k, cnt, ans, sum;
multiset<int long long> me, my[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t) {
t--;
cin >> n;
for (i = 1; i <= n; i++) {
int x, q;
cin >> x >> q;
my[x].insert(q);
}
cnt = my[0].size();
sum = 0;
my[0].clear();
ans = 0;
l = 0;
while (l <= cnt) {
cnt += my[l].size();
my[l].clear();
l++;
}
for (i = n; i >= l; i--) {
int x = my[i].size();
sum += x;
while (!my[i].empty()) {
me.insert(*my[i].begin());
my[i].erase(my[i].begin());
}
while (i > n - sum) {
if (me.empty()) {
cout << -1;
return 0;
}
ans += *me.begin();
sum--;
cnt++;
me.erase(me.begin());
while (l <= cnt) {
cnt += my[l].size();
my[l].clear();
l++;
}
}
}
for (i = 0; i < n; i++) my[i].clear();
cout << ans << endl;
me.clear();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long prefix[100005];
int main() {
std::ios_base::sync_with_stdio(false);
long long n, i, j, k;
cin >> n;
long long prefixsum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
prefix[i] += prefix[i - 1];
prefixsum += a[i];
}
long long maxsum = INT_MIN;
long long sum = 0;
for (i = 0; i < n; i++) {
sum += a[i];
if (sum < 0) sum = 0;
maxsum = max(maxsum, sum);
}
cout << 2 * maxsum - prefixsum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int a[155], b[155], d[155], ord[155];
bool cmpEdge(int u, int v) { return d[u] < d[v]; }
struct matrix {
int row, col;
bitset<155> c[155];
matrix(int _row = 0, int _col = 0, bool isU = false) {
row = _row, col = _col;
for (int i = 0; i <= row; ++i)
for (int j = 0; j <= col; ++j) c[i][j] = 0;
if (isU)
for (int i = 1; i <= row; ++i) c[i][i] = 1;
}
matrix operator*(const matrix &t) {
matrix res(row, t.col);
for (int i = 1; i <= row; ++i)
for (int j = 1; j <= col; ++j)
if (c[i][j]) res.c[i] |= t.c[j];
return res;
}
};
matrix matFpm(matrix x, int y) {
matrix res(n, n, true);
while (y) {
if (y & 1) res = x * res;
x = x * x, y >>= 1;
}
return res;
}
int dist[155];
int solve(matrix str, matrix g) {
queue<int> que;
for (int i = 1; i <= n; ++i) {
if (str.c[1][i]) {
dist[i] = 0;
que.push(i);
} else {
dist[i] = 1000050000;
}
}
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v = 1; v <= n; ++v)
if (g.c[u][v] && dist[v] > dist[u] + 1) {
dist[v] = dist[u] + 1;
que.push(v);
}
}
return dist[n];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d %d", &a[i], &b[i], &d[i]);
ord[i] = i;
}
sort(ord + 1, ord + m + 1, cmpEdge);
ans = 1000050000;
matrix f(n, n, true), g(n, n, false), s(1, n, true);
for (int i = 1; i <= m; ++i) {
f = f * matFpm(g, d[ord[i]] - d[ord[i - 1]]);
g.c[a[ord[i]]][b[ord[i]]] = 1;
ans = min(ans, d[ord[i]] + solve(s * f, g));
}
if (ans < 1000050000) {
printf("%d\n", ans);
} else {
puts("Impossible");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int fact(int n);
int ncr(int n) { return (n * (n - 1)) / 2; }
int main() {
int n;
cin >> n;
int fr[26] = {0};
for (int i = 0; i < n; i++) {
string temp;
cin >> temp;
fr[int(temp[0]) - 97]++;
}
int count = 0;
for (int i = 0; i < 26; i++) {
if (fr[i] > 2) {
int x = (fr[i] / 2) + (fr[i] % 2);
int y = fr[i] - x;
count += ncr(x) + ncr(y);
}
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int X[100666], Y[100666];
int ind[100666];
int result[100666];
bool comp(int i1, int i2) {
if (X[i1] == X[i2]) return Y[i1] > Y[i2];
return X[i1] < X[i2];
}
int main() {
int n, m, i;
cin >> n >> m;
for (i = 1; i <= m; ++i) {
cin >> X[i] >> Y[i];
ind[i] = i;
}
for (int e = 1; e <= 8; ++e) {
sort(ind + 1, ind + m + 1, comp);
for (i = 1; i <= m;) {
int j = i;
while (j <= m && X[ind[i]] == X[ind[j]]) ++j;
for (int t = i; t < j - 1; ++t) ++result[ind[t]];
i = j;
}
for (i = 1; i <= m; ++i) {
int v1 = X[i];
int v2 = Y[i];
X[i] = v1 - v2;
Y[i] = v1 + v2;
}
}
for (i = 0; i <= 8; ++i) {
int nr = 0;
for (int j = 1; j <= m; ++j)
if (result[j] == i) ++nr;
cout << nr << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int S(int n, double w, double m) {
double q, c = 0, z;
int i;
q = (double)n * w / m;
for (i = 0; i < n; i++) {
z = w;
if (z >= q - c) {
z -= q - c;
if (z > q + 1e-8) return 0;
c = z;
if (c + 1e-8 > q) c = 0;
} else {
c += z;
}
}
return 1;
}
int SS(int n, double w, double m) {
double q, c = 0, z;
int i;
q = (double)n * w / m;
for (i = 0; i < n; i++) {
z = w;
if (z >= q - c) {
z -= q - c;
printf("%d %.8lf\n", i + 1, q - c);
c = z;
if (c > 1e-8) {
printf("%d %.8lf ", i + 1, c);
if (c + 1e-8 > q) {
c = 0;
puts("");
}
}
} else {
c += z;
printf("%d %.8lf ", i + 1, z);
}
}
return 1;
}
int main() {
double w, m;
int i, n;
scanf("%d%lf%lf", &n, &w, &m);
if (S(n, w, m)) {
puts("YES");
SS(n, w, m);
} else
puts("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
inline int read() {
int x = 0, o = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int n, q, t;
int f[100050];
int a[550], so[550], fa[550];
int main() {
n = read(), q = read(), t = read();
for (register int i = 1; i <= n; i++) a[i] = read();
for (register int i = 1; i <= q; i++) {
int v, x;
v = read(), x = read();
so[x]++;
fa[v] = x;
}
for (register int i = 1; i <= q; i++) {
int pos = 0;
for (register int j = 1; j <= n; j++) {
if ((fa[j]) && (!so[j])) {
pos = j;
break;
}
}
if (!pos) {
puts("0");
return 0;
}
int pre = fa[pos];
fa[pos] = 0;
so[pre]--;
t -= a[pos];
a[pre] += a[pos];
if (t < 0) {
puts("0");
return 0;
}
}
f[0] = 1;
for (register int i = 1; i <= n; i++) {
for (register int j = a[i]; j <= t; j++) f[j] = (f[j] + f[j - a[i]]) % mod;
}
cout << f[t] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
long long cnt[9 * maxn];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int a;
string second;
cin >> a >> second;
vector<int> v;
for (auto i : second) v.push_back(i - '0');
int n = v.size();
for (int i = 0; i < n; ++i) {
int tmp = 0;
for (int j = i; j < n; ++j) {
tmp += v[j];
++cnt[tmp];
}
}
long long ans = 0;
for (int i = 1; i * i <= a; ++i) {
if (a % i) continue;
if (i > 9 * maxn || a / i > 9 * maxn) continue;
ans += (cnt[i] * cnt[a / i]);
if (i != a / i) ans += (cnt[i] * cnt[a / i]);
}
if (a) return cout << ans, 0;
ans = cnt[0] * cnt[0];
for (int i = 1; i <= 9 * n; ++i) ans += (2 * cnt[0] * cnt[i]);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const long long mx_error = 15 * 1e5;
long long px = 0, py = 0;
bool try_it(long long dx, long long dy) {
long long n_x = px + dx;
long long n_y = py + dy;
long long n_x_neg = px - dx;
long long n_y_neg = py - dy;
long long er = n_x * n_x + n_y * n_y;
long long er_neg = n_x_neg * n_x_neg + n_y_neg * n_y_neg;
if (er > er_neg) return false;
return true;
}
struct delta {
int idx;
long long dx, dy;
};
bool cmp(delta a, delta b) { return a.dx > b.dx; }
int ans[100009];
int main() {
int n;
scanf("%d", &n);
vector<delta> a(n);
for (int i = 0; i < n; i++) {
int dx, dy;
scanf("%d %d", &dx, &dy);
a[i] = {i, dx, dy};
}
bool done = false;
while (!done) {
px = 0, py = 0;
random_shuffle(a.begin(), a.end());
done = true;
for (int i = 0; i < n; i++) {
long long dx, dy;
dx = a[i].dx;
dy = a[i].dy;
int res = 1;
if (!try_it(dx, dy)) res = -1;
px += 1LL * res * dx;
py += 1LL * res * dy;
ans[a[i].idx] = res;
}
if (px > mx_error || py > mx_error ||
px * px + py * py > mx_error * mx_error)
done = false;
}
for (int i = 0; i < n; i++) printf("%d%c", ans[i], " \n"[i == n - 1]);
cerr << "final:" << px << ' ' << py << '\n';
cerr << "final error = " << px * px + py * py << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, a[5000], cnt;
int *F[4010][4010][2];
inline int solve(int l, int r, int k, int tp) {
if (r - l + 1 < k) return 0;
if (F[l][r][tp] == NULL) {
F[l][r][tp] = new int[90];
for (int i = 0; i < 90; i++) F[l][r][tp][i] = -1;
}
if (F[l][r][tp][k] != -1) return F[l][r][tp][k];
int ret = 0;
if (tp == 1) {
if (r - l + 1 >= k)
ret = solve(l + k, r, k, tp ^ 1) + (a[l + k - 1] - a[l - 1]);
if (r - l + 1 >= k + 1) {
int s = solve(l + k + 1, r, k + 1, tp ^ 1) + (a[l + k] - a[l - 1]);
if (s > ret) ret = s;
}
} else {
if (r - l + 1 >= k) ret = solve(l, r - k, k, tp ^ 1) - (a[r] - a[r - k]);
if (r - l + 1 >= k + 1) {
int s = solve(l, r - k - 1, k + 1, tp ^ 1) - (a[r] - a[r - k - 1]);
if (s < ret) ret = s;
}
}
F[l][r][tp][k] = ret;
return ret;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = a[i - 1] + read();
printf("%d\n", solve(1, n, 1, 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<int> S;
void dfs(int Cur, int dgt, int x, int y) {
if (dgt == 11) return;
if (Cur > 0) S.insert(Cur);
dfs(Cur * 10 + x, dgt + 1, x, y);
dfs(Cur * 10 + y, dgt + 1, x, y);
return;
}
int main() {
int n, Ans = 0;
cin >> n;
S.insert(1e9);
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
dfs(0, 1, i, j);
}
}
for (auto x : S) {
if (x > n)
break;
else
Ans++;
}
cout << Ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
int b[a];
for (int k = 0; k < a; k++) cin >> b[k];
sort(b, b + a);
for (int k = 0; k < a / 2; k++) cout << b[k] << " " << b[a - k - 1] << " ";
if (a % 2 == 1) {
cout << b[(a - 1) / 2];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
long long ans = 0;
for (int i = 2; i < n; i++) {
for (int j = 2;; j++) {
if (i * j <= n)
ans += j * 4;
else
break;
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int n, m;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long ans = 0;
long long phi(long long n) {
long long res = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) res = res / i * (i - 1);
while (n % i == 0) n /= i;
}
if (n > 1) res = res / n * (n - 1);
return res;
}
void solve() {
long long a, m, d;
scanf("%lld%lld", &a, &m);
d = gcd(a, m);
a /= d;
m /= d;
ans = phi(m);
cout << ans << endl;
}
int main() {
int T;
scanf("%d", &T);
for (int i = 1; i <= T; i++) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000];
int main() {
int n, l, ans = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
int zz = 0;
while (a[0] != a[n - 1]) {
l = a[0];
a[0] = 1001;
for (int i = 1; i < n; ++i) {
if (a[i] > l) {
l = a[i];
ans++;
a[i] = 1001;
zz++;
}
}
if (n < 1) break;
sort(a, a + n);
n = n - zz - 1;
zz = 0;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int formNumber, i, sum = 0;
cin >> formNumber;
int form[formNumber];
for (int i = 0; i < formNumber; i++) cin >> form[i];
for (i = 0; i < formNumber; i++) {
for (int k = 0; k < formNumber; k++) {
if (i == k) continue;
sum = form[i] + form[k];
for (int j = 0; j < formNumber; j++) {
if (i == j || j == k) continue;
if (sum == form[j]) {
cout << j + 1 << " " << i + 1 << " " << k + 1;
sum = -1;
break;
}
}
if (sum == -1) break;
}
if (sum == -1) break;
}
if (i == formNumber) cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 7;
string alp = "abcdefghijklmnopqrstuvwxyz";
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long test = 1;
while (test--) {
long long r, g, b, ans1 = 0;
long long a[3] = {};
cin >> r >> g >> b;
ans1 += r / 3 + g / 3 + b / 3 + min({r % 3, g % 3, b % 3});
a[r % 3]++;
a[g % 3]++;
a[b % 3]++;
if (a[2] == 2 && a[0] == 1 && r != 0 && b != 0 && g != 0) {
ans1++;
}
cout << ans1;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int h = 1, l = n;
while (h <= l) {
if (h < l) {
for (int i = 1; i <= m; i++) {
printf("%d %d\n", h, i);
printf("%d %d\n", l, m + 1 - i);
}
} else {
int le = 1, ri = m;
while (le <= ri) {
if (le < ri) {
printf("%d %d\n", h, le);
printf("%d %d\n", l, ri);
} else {
printf("%d %d\n", h, le);
}
le++, ri--;
}
}
l--, h++;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[22], c[22];
int n, k, t;
struct node {
int state;
int val;
int lst;
int now;
node(int a = 0, int b = 0, int c = 0, int d = 0) {
state = a, val = b, lst = c, now = d;
}
void spread(priority_queue<node> &pq) {
if (now == n) return;
for (int i = 0; i < v[now].size(); i++) {
int j = v[now][i];
if ((1 << j) & state) continue;
pq.push(node((1 << j) | state, val + c[now][i], 1, now + 1));
}
pq.push(node(state, val, 0, now + 1));
}
};
bool operator<(node a, node b) { return a.val > b.val; }
priority_queue<node> pq;
int main() {
scanf("%d%d%d", &n, &k, &t);
while (k--) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
x--, y--;
v[x].push_back(y);
c[x].push_back(w);
}
pq.push(node(0, 0, 1, 0));
while (1) {
node nr = pq.top();
pq.pop();
nr.spread(pq);
t -= nr.lst;
if (t == 0) {
printf("%d\n", nr.val);
return 0;
}
}
puts("CYKA BLYAT!");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 1000 * 100 + 5;
set<long long> ad[mx];
long long sz[mx], ans[mx];
void dfs(long long v, long long par) {
sz[v] = 1;
for (auto u : ad[v])
if (u != par) {
dfs(u, v);
sz[v] += sz[u];
}
return;
}
long long find_centroid(long long v, long long par, long long siz) {
for (auto u : ad[v])
if (u != par && sz[u] > siz / 2) return find_centroid(u, v, siz);
return v;
}
void give_char(long long v, long long siz, long long c) {
dfs(v, -1);
long long cent = find_centroid(v, -1, siz);
ans[cent] = c;
for (auto u : ad[cent]) {
ad[u].erase(cent);
give_char(u, sz[u], c + 1);
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, u, v;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v;
u--, v--;
ad[u].insert(v);
ad[v].insert(u);
}
give_char(0, n, 0);
for (long long i = 0; i < n; i++) cout << char(ans[i] + 65) << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:2000000")
long long fact[100005], ofact[100005], p = 998244353, root, sz = 262144, obroot,
logs = 18, obrt[100005];
vector<long long> rev_pow, orev_pow, pow1, opow, revmas;
long long bp(long long a, long long b) {
{
if (b == 0) {
return 1;
} else if (b % 2 == 0) {
long long aq = bp(a, b / 2);
return (aq * aq) % p;
} else {
long long aq = bp(a, b - 1);
return (aq * a) % p;
}
}
}
long long obr(long long x) { return bp(x, p - 2); }
void mlt1(vector<long long> &v1, vector<long long> &v2, vector<long long> &v3) {
for (int j = 0; j < sz; j++) {
v3[j] = v1[j] * v2[j];
v3[j] %= p;
}
}
long long rev(long long j) {
long long y = 0, cur = j;
for (int h = 0; h < logs; h++) {
long long x = cur % 2;
y += (x << logs - 1 - h);
cur /= 2;
}
return y;
}
void b_reverse(vector<long long> &v1) {
vector<long long> used;
used.resize(sz);
for (int j = 0; j < sz; j++) {
long long x;
if (1 - used[j] > 0) {
x = v1[j];
v1[j] = v1[revmas[j]];
v1[rev(j)] = x;
used[j] = 1;
used[rev(j)] = 1;
}
}
}
long long transf(long long g, long long j) {
long long h = g - ((g >> j) << j);
return h;
}
void fft(vector<long long> &v1) {
vector<long long> v2;
v2.resize(sz);
for (int j = 0; j < logs; j++) {
if (1 - j % 2 > 0) {
long long blc = 1 << (j + 1);
for (int h = 0; h < sz / blc; h++) {
for (int g = 0; g < blc; g++) {
v2[h * blc + g] =
v1[h * blc + (g >> 1)] +
v1[h * blc + (g >> 1) + (blc >> 1)] * rev_pow[transf(g, j + 1)];
v2[h * blc + g] %= p;
}
}
}
if (j % 2 > 0) {
long long blc = 1 << (j + 1);
for (int h = 0; h < sz / blc; h++) {
for (int g = 0; g < blc; g++) {
v1[h * blc + g] =
v2[h * blc + (g >> 1)] +
v2[h * blc + (g >> 1) + (blc >> 1)] * rev_pow[transf(g, j + 1)];
v1[h * blc + g] %= p;
}
}
}
}
}
void dft(vector<long long> &v1) {
vector<long long> v2;
long long osz = obr(sz);
v2.resize(sz);
for (int j = 0; j < logs; j++) {
if (1 - j % 2 > 0) {
long long blc = 1 << (j + 1);
for (int h = 0; h < sz / blc; h++) {
for (int g = 0; g < blc; g++) {
v2[h * blc + g] =
v1[h * blc + (g >> 1)] +
v1[h * blc + (g >> 1) + (blc >> 1)] * orev_pow[transf(g, j + 1)];
v2[h * blc + g] %= p;
}
}
}
if (j % 2 > 0) {
long long blc = 1 << (j + 1);
for (int h = 0; h < sz / blc; h++) {
for (int g = 0; g < blc; g++) {
v1[h * blc + g] =
v2[h * blc + (g >> 1)] +
v2[h * blc + (g >> 1) + (blc >> 1)] * orev_pow[transf(g, j + 1)];
v1[h * blc + g] %= p;
}
}
}
}
for (int j = 0; j < sz; j++) {
v1[j] *= osz;
v1[j] %= p;
}
}
void mlt(vector<long long> &v1, vector<long long> &v2, vector<long long> &v3,
long long oo) {
v1.resize(sz);
v2.resize(sz);
v3.resize(sz);
b_reverse(v1);
b_reverse(v2);
fft(v1);
fft(v2);
mlt1(v1, v2, v3);
dft(v3);
b_reverse(v3);
v3.resize(oo);
}
void umn(vector<long long> &v) {
int x = v.size();
for (int j = 0; j < x; j++) {
v[j] *= fact[j];
v[j] %= p;
}
}
void umn1(vector<long long> &v) {
int x = v.size();
for (int j = 0; j < x; j++) {
v[j] *= ofact[j];
v[j] %= p;
}
}
void mn(vector<long long> &v) {
int x = v.size();
for (int j = 0; j < x; j++) {
if (j % 2 > 0) {
v[j] = p - v[j];
}
}
}
void encode(vector<long long> &v) {
vector<long long> v1 = v, v2, v3;
umn(v1);
reverse(v1.begin(), v1.end());
int x = v.size();
v2.resize(x);
for (int j = 0; j < x; j++) {
v2[j] = ofact[j];
}
mlt(v1, v2, v3, x);
reverse(v3.begin(), v3.end());
umn1(v3);
for (int j = 0; j < x; j++) {
v[j] = v3[j];
}
}
void decode(vector<long long> &v) {
vector<long long> v1 = v, v2, v3;
umn(v1);
mn(v1);
reverse(v1.begin(), v1.end());
int x = v.size();
v2.resize(x);
for (int j = 0; j < x; j++) {
v2[j] = ofact[j];
}
mlt(v1, v2, v3, x);
reverse(v3.begin(), v3.end());
umn1(v3);
mn(v3);
for (int j = 0; j < x; j++) {
v[j] = v3[j];
}
}
void oper(vector<long long> &v, long long m) {
long long n = v.size(), m1 = m % (p - 1);
for (int j = 0; j < n; j++) {
long long x = bp(j + 1, p - 1 - m1);
v[j] *= x;
v[j] %= p;
}
}
void calc() {
fact[0] = 1;
ofact[0] = 1;
for (int j = 1; j < 100001; j++) {
if (2 - j > 0) {
obrt[1] = 1;
}
if (j - 1 > 0) {
obrt[j] = (p - (p / j) * obrt[p % j] % p) % p;
}
fact[j] = fact[j - 1] * j;
fact[j] %= p;
ofact[j] = ofact[j - 1] * obrt[j];
ofact[j] %= p;
}
}
void clc() {
revmas.resize(sz);
vector<long long> rm;
rm.resize(sz);
for (int j = 0; j < logs; j++) {
if (1 - j % 2 > 0) {
for (int h = 0; h < (1 << (j + 1)); h++) {
rm[h] = revmas[h / 2] + ((h % 2) << j);
}
}
if (j % 2 > 0) {
for (int h = 0; h < (1 << (j + 1)); h++) {
revmas[h] = rm[h / 2] + ((h % 2) << j);
}
}
}
}
void pow_calcs() {
rev_pow.resize(sz);
orev_pow.resize(sz);
pow1.resize(sz);
opow.resize(sz);
pow1[0] = 1;
opow[0] = 1;
for (int j = 1; j < sz; j++) {
pow1[j] = pow1[j - 1] * root;
pow1[j] %= p;
opow[j] = opow[j - 1] * obroot;
opow[j] %= p;
}
for (int j = 0; j < sz; j++) {
rev_pow[j] = pow1[revmas[j]];
orev_pow[j] = opow[revmas[j]];
}
}
int main() {
root = bp(5, 32 * 119);
obroot = obr(root);
clc();
pow_calcs();
long long n, m;
vector<long long> v;
cin >> n;
cin >> m;
for (int j = 0; j < n + 1; j++) {
long long x;
cin >> x;
v.push_back(x);
}
calc();
encode(v);
oper(v, m);
decode(v);
for (int j = 0; j < n + 1; j++) {
cout << v[j] % p << ' ';
}
return 0;
}
| 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.