solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 15], *p1 = buf, *p2 = buf;
inline long long read() {
char ch;
bool flag = 0;
long long res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 15, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 15, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10ll + ch - '0')
;
(flag) && (res = -res);
return res;
}
inline void write(long long x) {
if (x < 0) x = ~x + 1ll, putchar('-');
if (x > 9) write(x / 10ll);
putchar(x % 10ll + '0');
}
unordered_map<long long, long long> mp[26];
int n, K, K1;
long long ans = 0;
long long S;
long long fac[50];
long long a[50];
void dfs(int x, int mx, int k, long long s, int t) {
if (k > K1 || s > S) return;
if (x == mx + 1) {
if (t == 1)
mp[k][s]++;
else
for (register int i = (0); i <= (K - k); i++) ans += mp[i][S - s];
return;
}
if (a[x] < 20) dfs(x + 1, mx, k + 1, s + fac[x], t);
dfs(x + 1, mx, k, s, t);
dfs(x + 1, mx, k, s + a[x], t);
}
void solve() {
n = read();
K = read(), S = read();
for (register int i = (1); i <= (n); i++) a[i] = read();
for (register int i = (1); i <= (n); i++) {
if (a[i] >= 20) continue;
fac[i] = 1;
for (long long j = 1; j <= a[i]; j++) fac[i] = fac[i] * j;
}
K1 = K;
dfs(1, n / 2, 0, 0, 1);
dfs(n / 2 + 1, n, 0, 0, -1);
cout << ans;
}
int main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
int mid = ceil(n * 1.0 / 2);
int a[101];
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = -1; j <= 1; j += 2) {
int num = 0;
for (int i = 0; i < n; i++) {
if (a[i] / j > 0) num++;
if (num >= mid) {
cout << j << endl;
return 0;
}
}
}
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
struct res {
ll a, b;
vector<pair<ll, ll>> out;
};
res test(ll a, ll b, ll i, res r) {
if (r.out[i].first > r.out[i].second) {
r.out[i].second += min(r.out[i].first - 2, b);
b -= r.out[i].second;
ll c = min(a, b);
r.out[i].first += c;
r.out[i].second += c;
a -= c;
b -= c;
} else {
r.out[i].first += min(r.out[i].second - 2, a);
a -= r.out[i].first;
ll c = min(a, b);
r.out[i].first += c;
r.out[i].second += c;
a -= c;
b -= c;
}
for (ll j = 0; j < (int)(r.out).size(); j++) {
if (j != i) {
if (r.out[j].first > r.out[j].second) {
r.out[j].second += min(r.out[j].first - 2, b);
b -= r.out[j].second;
} else {
r.out[j].first += min(r.out[j].second - 2, a);
a -= r.out[j].first;
}
}
}
if (a != 0 || b != 0) return {-1, -1, {}};
return r;
}
res check(ll a, ll b, ll bits) {
res r = {0, 0, {}};
for (ll i = 0; i < 5 && r.a < 3 && r.b < 3; i++) {
if (((bits >> i) & 1) == 0) {
r.a++;
if (a >= 25 && i < 4) {
a -= 25;
r.out.push_back({25, 0});
} else if (a >= 15 && i == 4) {
a -= 15;
r.out.push_back({15, 0});
} else {
return {-1, -1, {}};
}
} else {
r.b++;
if (b >= 25 && i < 4) {
b -= 25;
r.out.push_back({0, 25});
} else if (b >= 15 && i == 4) {
b -= 15;
r.out.push_back({0, 15});
} else {
return {-1, -1, {}};
}
}
}
for (ll i = 0; i < (int)(r.out).size(); i++) {
res rr = test(a, b, i, r);
if (rr.a >= 0) return rr;
}
return {-1, -1, {}};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ll m;
cin >> m;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
res r = {-1, -1, {}};
for (ll j = 0; j < (1 << 5); j++) {
res rr = check(a, b, j);
if (rr.a >= 0 && (r.a < 0 || (r.a - r.b) < (rr.a - rr.b))) {
r = rr;
}
}
if (r.a < 0) {
cout << "Impossible" << endl;
} else {
cout << r.a << ":" << r.b << endl;
for (auto e : r.out) {
cout << e.first << ":" << e.second << " ";
}
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void yes() {
cout << "Yes"
<< "\n";
}
void no() {
cout << "No"
<< "\n";
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
vector<vector<long long>> calc_stirling_2(int n) {
vector<vector<long long>> res(n + 1, vector<long long>(n + 1));
res[0][0] = 1;
for (int i = (1); i < (n + 1); ++i) {
for (int j = (1); j < (n + 1); ++j) {
res[i][j] = res[i - 1][j - 1] + j * res[i - 1][j];
res[i][j] %= MOD;
}
}
return res;
}
vector<long long> calc_bell(int n) {
auto st = calc_stirling_2(n);
vector<long long> res(n + 1);
for (int i = (0); i < (n + 1); ++i) {
for (int j = (0); j < (n + 1); ++j) {
res[i] += st[i][j];
res[i] %= MOD;
}
}
return res;
}
const string inv(string s) {
for (int i = (0); i < (s.size()); ++i) {
s[i] = s[i] == '1' ? '0' : '1';
}
return s;
}
int main() {
int n, m;
cin >> m >> n;
vector<bitset<1000>> v;
for (int i = (0); i < (n); ++i) {
string s;
cin >> s;
v.push_back(bitset<1000>{s});
v.push_back(bitset<1000>{inv(s)});
}
n *= 2;
vector<bitset<1000>> minc(m, bitset<1000>{string(1000, '1')});
for (int i = (0); i < (m); ++i) {
for (int j = (0); j < (n); ++j) {
if (v[j].test(i)) {
minc[i] &= v[j];
}
}
}
unordered_set<bitset<1000>> minc_hash = {minc.begin(), minc.end()};
auto bell = calc_bell(m);
long long res = 1;
for (const auto &mask : minc_hash) {
res *= bell[mask.count()];
res %= MOD;
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char s[15];
int ans, len, c;
while (~scanf("%s", s)) {
c = 1;
ans = 0;
len = strlen(s);
ans += s[0] - '0' + (len - 1) * 9 - 1;
for (int i = len - 1; i > 0; i--) {
s[i] += c;
c = (s[i] - '0') / 10;
s[i] = (s[i] - '0') % 10 + '0';
ans += s[i] - '0';
}
printf("%d\n", ans + c);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int convert(string s, int base) {
stringstream str;
int x, sum = 0;
for (int i = 0; i < s.length(); i++) {
x = 0;
str << s[i];
str >> x;
sum = sum * base;
sum = sum + x;
str.clear();
}
return sum;
}
int main() {
string s1, s2;
stringstream ss;
int c, b, n;
cin >> s1 >> s2;
int mx = 0, x, z, v, y, m = 0;
for (int i = 0; i < s1.length(); i++) {
ss << s1[i];
ss >> x;
if (x > mx) mx = x;
ss.clear();
}
for (int i = 0; i < s2.length(); i++) {
ss << s2[i];
ss >> x;
if (x > mx) mx = x;
ss.clear();
}
c = convert(s1, mx + 1);
b = convert(s2, mx + 1);
n = c + b;
while (n) {
n = n / (mx + 1);
m++;
}
cout << m;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MAXN = 2e5 + 300;
const long long MINN = 1e3 + 20;
int gcd(int a, int b) { return (b ? gcd(b, a % b) : a); }
int mod(int n) {
while (n < 0) n += MOD;
return n % MOD;
}
long long par[MAXN], segment_par[MAXN];
void Bulid() {
for (int i = 0; i < MAXN; i++) par[i] = i;
}
void Segment() {
for (int i = 0; i < MAXN; i++) segment_par[i] = i;
}
long long Find(long long v) {
if (v == par[v]) return v;
return par[v] = Find(par[v]);
}
long long Find_Seg(long long v) {
if (v == segment_par[v]) return v;
return segment_par[v] = Find_Seg(segment_par[v]);
}
void Merge(long long u, long long v) {
u = Find(u);
v = Find(v);
if (rand() % 2)
par[u] = v;
else
par[v] = u;
}
void Merge_Seg(long long l, long long r) {
long long v = l;
while (v < r) {
Merge(v, v + 1);
segment_par[v] = v + 1;
v = Find_Seg(v);
}
}
bool check(long long u, long long v) {
u = Find(u);
v = Find(v);
return (u == v);
}
void solve(long long t, long long x, long long y) {
if (t == 1) Merge(x, y);
if (t == 2) Merge_Seg(x, y);
if (t == 3) {
if (check(x, y))
printf("YES\n");
else
printf("NO\n");
}
}
int main() {
Bulid();
Segment();
long long n, q, t, x, y;
scanf("%lld%lld", &n, &q);
while (q--) {
scanf("%lld%lld%lld", &t, &x, &y);
solve(t, x, y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)2e5 + 7;
const long long inf = (long long)1e18;
const int infint = (int)2e9;
int l[MAXN], r[MAXN], visited[MAXN];
vector<int> v[MAXN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
int j = i;
while (l[j] != 0) j = l[j];
while (true) {
v[ans].push_back(j);
visited[j] = 1;
if (r[j] == 0)
break;
else
j = r[j];
}
ans++;
}
}
for (int i = 0; i < ans - 1; i++) {
r[v[i].back()] = v[i + 1][0];
l[v[i + 1][0]] = v[i].back();
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int co=0;
for(int i=0; i<n; i++)
{
int a;
cin>>a;
if(a%4==0)co+=2;
else if(a%2==0)co++;
}
if(co>=n/2*2)
{
cout<<"Yes\n";
}
else
{
cout<<"No\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const long long INF = 2 * 1e18;
const long double PI = 3.14159265358979323846;
vector<long long> ed[100005];
long long dist[100005][5], sz[100005];
void dfs1(long long n, long long p, long long x) {
for (long long i = 0; i < ed[n].size(); i++) {
if (ed[n][i] == p) continue;
dist[ed[n][i]][x] = dist[n][x] + 1;
dfs1(ed[n][i], n, x);
}
}
void dfs2(long long n, long long p) {
long long cnt = 0;
for (long long i = 0; i < ed[n].size(); i++) {
if (ed[n][i] != p) {
dist[ed[n][i]][2] = dist[n][2] + 1;
cnt++;
dfs2(ed[n][i], n);
}
}
sz[n] = cnt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, pos = -1;
bool x = 0;
cin >> n >> k;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
ed[u].push_back(v);
ed[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
if (ed[i].size() == 1) {
dfs1(i, -1, 0);
break;
}
}
for (long long i = 1; i <= n; i++) {
if (dist[i][0] == 2 * k) {
pos = i;
x = 1;
}
if (dist[i][0] > 2 * k) {
cout << "No";
return 0;
}
}
if (!x) {
cout << "No";
return 0;
}
dfs1(pos, -1, 1);
x = 0;
for (long long i = 1; i <= n; i++) {
if (dist[i][0] == k && dist[i][1] == k) {
dfs2(i, -1);
x = 1;
break;
}
}
if (!x) {
cout << "No";
return 0;
}
x = 0;
for (long long i = 1; i <= n; i++) {
if (dist[i][2] == k) {
if (ed[i].size() != 1) x = 1;
} else {
if (sz[i] < 3) x = 1;
}
}
if (!x)
cout << "Yes";
else
cout << "No";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(30);
int S;
pair<int, int> A[3];
double O[3];
cin >> S;
for (int i = 0; i < 3; ++i) {
int a;
cin >> a;
A[i] = {a, i};
}
sort(A, A + 3);
if (A[2].first == 0)
O[0] = O[1] = O[2] = 0.0;
else if (A[1].first == 0)
O[A[0].second] = O[A[1].second] = 0.0, O[A[2].second] = S;
else if (A[0].first == 0) {
O[A[0].second] = 0.0;
double a = A[1].first, b = A[2].first, W = a + b;
O[A[1].second] = a * S / W;
O[A[2].second] = b * S / W;
} else {
double a = A[0].first, b = A[1].first, c = A[2].first, W = a + b + c;
O[A[0].second] = a * S / W;
O[A[1].second] = b * S / W;
O[A[2].second] = c * S / W;
}
cout << O[0] << ' ' << O[1] << ' ' << O[2] << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long INF = (long long)1e20;
int iINF = (int)1e20;
long long mod = (long long)1e9 + 7;
long long dp[50][50][50][50];
void get(long long x1, long long y1, long long x2, long long y2) {
if (dp[x1][y1][x2][y2] != INF) {
return;
}
dp[x1][y1][x2][y2] = max(x2 - x1 + 1, y2 - y1 + 1);
for (int d = x1; d < x2; ++d) {
get(x1, y1, d, y2);
get(d + 1, y1, x2, y2);
dp[x1][y1][x2][y2] =
min(dp[x1][y1][x2][y2], dp[x1][y1][d][y2] + dp[d + 1][y1][x2][y2]);
}
for (int d = y1; d < y2; ++d) {
get(x1, y1, x2, d);
get(x1, d + 1, x2, y2);
dp[x1][y1][x2][y2] =
min(dp[x1][y1][x2][y2], dp[x1][y1][x2][d] + dp[x1][d + 1][x2][y2]);
}
}
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
for (int l = 0; l < n; ++l) {
dp[i][j][k][l] = INF;
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
char c;
cin >> c;
if (c == '#') {
dp[i][j][i][j] = 1;
} else {
dp[i][j][i][j] = 0;
}
}
}
get(0, 0, n - 1, n - 1);
cout << dp[0][0][n - 1][n - 1];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp1[100010], dp2[100010], a[100010], f[100010], r[100010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, n, mx;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
f[1] = -a[1];
dp1[1] = max(a[1], f[1]);
for (i = 2; i <= n; i++) {
f[i] = f[i - 1] - a[i];
dp1[i] = max(f[i], dp1[i - 1] + a[i]);
}
r[n] = -a[n];
dp2[n] = max(r[n], a[n]);
for (i = n - 1; i > 0; i--) {
r[i] = r[i + 1] - a[i];
dp2[i] = max(r[i], dp2[i + 1] + a[i]);
}
mx = -1e18;
for (i = 0; i <= n; i++) mx = max(mx, dp1[i] + dp2[i + 1]);
cout << mx << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
const int inf = 0x3f3f3f3f;
int n, m, cnt = -1, p[maxn], dep[maxn], cur[maxn], s, t, zx[maxn], zy[maxn],
cntx, cnty;
struct kkk {
int lx, ly, rx, ry;
} a[maxn];
struct node {
int v, next, cap, flow;
} e[maxn * 10];
void add(int u, int v, int cap, int flow) {
cnt++;
e[cnt].v = v;
e[cnt].next = p[u];
e[cnt].cap = cap;
e[cnt].flow = flow;
p[u] = cnt;
}
bool bfs() {
queue<int> q;
memset(dep, -1, sizeof(dep));
q.push(s);
dep[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = p[u]; i != -1; i = e[i].next) {
if (e[i].cap - e[i].flow > 0 && dep[e[i].v] == -1) {
dep[e[i].v] = dep[u] + 1;
q.push(e[i].v);
}
}
}
if (dep[t] == -1) return false;
return true;
}
int dfs(int u, int maxflow) {
if (u == t || maxflow == 0) return maxflow;
int flow = 0;
for (int &i = cur[u]; i != -1; i = e[i].next) {
if (dep[e[i].v] == dep[u] + 1 && e[i].cap > e[i].flow) {
int fl = dfs(e[i].v, min(maxflow, e[i].cap - e[i].flow));
maxflow -= fl;
flow += fl;
e[i].flow += fl;
e[i ^ 1].flow -= fl;
if (maxflow == 0) break;
}
}
return flow;
}
int dinic() {
int ans = 0;
while (bfs()) {
for (int i = s; i <= t; i++) {
cur[i] = p[i];
}
ans += dfs(s, inf);
}
return ans;
}
int main() {
memset(p, -1, sizeof(p));
int n, m;
cin >> n >> m;
s = 0, t = 201;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &a[i].lx, &a[i].ly, &a[i].rx, &a[i].ry);
a[i].lx--;
a[i].ly--;
zx[++cntx] = a[i].lx;
zx[++cntx] = a[i].rx;
zy[++cnty] = a[i].ly;
zy[++cnty] = a[i].ry;
}
sort(zx + 1, zx + cntx + 1);
sort(zy + 1, zy + cnty + 1);
cntx = unique(zx + 1, zx + cntx + 1) - zx - 1;
cnty = unique(zy + 1, zy + cnty + 1) - zy - 1;
for (int i = 2; i <= cntx; i++) {
for (int j = 2; j <= cnty; j++) {
for (int k = 1; k <= m; k++) {
if (a[k].lx <= zx[i - 1] && a[k].rx >= zx[i] && a[k].ly <= zy[j - 1] &&
a[k].ry >= zy[j]) {
add(i, j + 100, inf, 0);
add(j + 100, i, 0, 0);
break;
}
}
}
}
for (int i = 2; i <= cntx; i++)
add(s, i, zx[i] - zx[i - 1], 0), add(i, s, 0, 0);
for (int i = 2; i <= cnty; i++)
add(i + 100, t, zy[i] - zy[i - 1], 0), add(t, i + 100, 0, 0);
cout << dinic();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
const int ALPHA = 26;
int n = (int)s.size();
vector<vector<int>> all(ALPHA);
vector<int> a(n);
for (int i = 0; i < n; i++) {
a[i] = (int)(s[i] - 'a');
all[(int)(s[i] - 'a')].push_back(i);
}
long long ans = 0;
for (int i = 0; i < ALPHA; i++) {
ans = max(ans, (long long)all[i].size());
}
for (int i = 0; i < ALPHA; i++) {
for (int j = 0; j < ALPHA; j++) {
long long cur = 0;
int cc = 0;
for (int k = 0; k < n; k++) {
if (a[k] == j) {
cur += cc;
}
if (a[k] == i) {
cc += 1;
}
}
ans = max(ans, cur);
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, K = 1000005;
int a[N], vis[K];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, k, d;
scanf("%d %d %d", &n, &k, &d);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
vis[a[i]] = 0;
}
int typ = 0;
for (int i = 1; i <= d; i++) {
if (!vis[a[i]]) typ++;
vis[a[i]]++;
}
int Min = typ;
for (int i = d + 1; i <= n; i++) {
vis[a[i - d]]--;
if (!vis[a[i - d]]) typ--;
if (!vis[a[i]]) typ++;
vis[a[i]]++;
Min = min(Min, typ);
}
printf("%d\n", Min);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[17], n;
int find(int lo, int hi) {
for (int i = lo; i < hi; i++)
if (arr[i] > arr[i + 1])
return max(find(lo, ((lo + hi) / 2)), find(((lo + hi) / 2) + 1, hi));
return hi - lo + 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; cin >> arr[i], i++)
;
cout << find(0, n - 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
bool dbg = 0;
clock_t start_time = clock();
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
void upmax(T& x, T y) {
x = max(x, y);
}
template <typename T>
bool upmin(T& x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 2e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-6;
const int maxn = (int)4e6 + 12, base = 1e9 + 7;
const long long llinf = 2e18 + 5;
const double PI = acos(-1.0);
const int mod = 998244353;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % mod;
} else {
return (1LL * binpow(n, second - 1) * n) % mod;
}
}
int h, g, n, m;
int a[maxn];
vector<int> order;
vector<int> path;
void find_path(int v) {
int l = v << 1;
int r = v << 1 | 1;
path.push_back(v);
if (a[l] == 0 && a[r] == 0) {
return;
} else if (a[l] > a[r]) {
find_path(l);
} else {
find_path(r);
}
}
void dfs(int v) {
while (a[v] > 0) {
path.clear();
find_path(v);
if (path.back() <= m) {
break;
} else {
order.push_back(v);
for (int i = 0; i + 1 < path.size(); i++) {
a[path[i]] = a[path[i + 1]];
}
a[path.back()] = 0;
}
}
if (a[v << 1]) dfs(v << 1);
if (a[v << 1 | 1]) dfs(v << 1 | 1);
}
void solve() {
cin >> h >> g;
n = (1 << h) - 1;
m = (1 << g) - 1;
for (int i = 1; i <= 2 * n + 10; i++) {
a[i] = 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
order.clear();
dfs(1);
long long ans = 0;
for (int i = 1; i <= m; i++) {
ans += a[i];
}
cout << ans << "\n";
for (int ind : order) {
cout << ind << ' ';
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
string s;
set<int> a, b;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'D') {
a.insert(i + 1);
} else {
b.insert(i + 1);
}
}
while (!a.empty() && !b.empty()) {
int x = *a.begin();
int y = *b.begin();
a.erase(a.begin());
b.erase(b.begin());
if (x < y) {
a.insert(x + n);
} else {
b.insert(y + n);
}
}
puts(a.empty() ? "R" : "D");
return 0;
}
| 3 |
#include <bits/stdc++.h>
typedef long long LL;
LL A, B, N;
int main() {
std :: cin >> N >> A >> B;
if(A * B < N || A + B - 1 > N) return puts("-1"), 0;
while(N) {
int x = std :: min(N - B + 1, A);
for(LL i = N - x + 1; i <= N; i++) printf("%lld ", i);
N -= x; B--;
}
std :: cout << std :: endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
long long dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long expo(long long n, long long m, long long p) {
long long r = 1;
n = n % p;
while (m > 0) {
if (m % 2) r = (r * n) % p;
n = (n * n) % p;
m = m / 2;
}
return r % p;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long> z_function(string s) {
long long n = (long long)s.length();
vector<long long> z(n);
for (long long i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
const long long N = 3005;
long long a[N], b[N], c[N];
long long n;
long long dp[N][10];
long long solve(long long i, long long p) {
long long ans = 0;
if (dp[i][p] != -1) return dp[i][p];
if (i == n - 1) {
if (p == 1) {
ans = b[i];
} else
ans = a[i];
} else if (i == 0) {
ans = max(a[i] + solve(i + 1, 1), b[i] + solve(i + 1, 0));
} else {
if (p == 0) {
ans = max(a[i] + solve(i + 1, 1), b[i] + solve(i + 1, 0));
} else {
ans = max(c[i] + solve(i + 1, 0), b[i] + solve(i + 1, 1));
}
}
dp[i][p] = ans;
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
memset(dp, -1, sizeof(dp));
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
for (long long i = 0; i < n; i++) {
cin >> c[i];
}
cout << solve(0, 0) << '\n';
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
long long n,f,m,tt,ans,c,sum,w,k,a[900000],x,y,i;
string s;
int main(){
tt=1;
cin>>tt;
while(tt--)
{
ans=x=y=0;
cin>>s;
n=s.size();
for(i=0;i<n;i++){
if(s[i]=='(')x++;
else if(s[i]=='[')y++;
else if(s[i]==')'&&x)x--,ans++;
else if(s[i]==']'&&y)y--,ans++;
}
cout<<ans;
cout<<'\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A[1000000];
int n;
cin>>n;
for (int i=0;i<n;i++){
cin>>A[i];
}
int q,k,sum=0;
cin >>q;
for (int i=0;i<q;i++){
cin>>k;
if(*lower_bound(A,A+n,k)==k) sum++;
}
cout<<sum<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
vector<int> arr;
int get(vector<int> arr) {
int n = arr.size();
int last = 0;
vector<int> even;
vector<int> odd;
int ce = (n - 1) / 2, co = (n - 2) / 2;
int li = -1;
int ans = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] != 0) {
int x = arr[i] % 2;
if (x == 0) {
x = 2;
if (i != 0 && i != n - 1) {
co--;
}
} else {
if (i != 0 && i != n - 1) {
ce--;
}
}
if (x & last) {
if (x == 1) {
even.push_back(i - li - 1);
} else {
odd.push_back(i - li - 1);
}
ans++;
}
ans++;
last = x;
li = i;
}
}
ans--;
if (co + ce == n - 2) {
if (n == 3) {
return 0;
} else {
return 1;
}
}
sort(even.begin(), even.end());
for (auto elem : even) {
if (ce >= elem) {
ce -= elem;
ans -= 2;
}
}
sort(odd.begin(), odd.end());
for (auto elem : odd) {
if (co >= elem) {
co -= elem;
ans -= 2;
}
}
return ans;
}
int main() {
int n;
cin >> n;
arr.resize(n + 2);
for (int i = 0; i < n; ++i) {
cin >> arr[i + 1];
}
int ans = 1e9;
for (int i = 1; i < 3; ++i) {
for (int j = 1; j < 3; ++j) {
arr[0] = i;
arr[n + 1] = j;
ans = min(ans, get(arr));
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int fix[1000020], n, l, k, i;
int main() {
scanf("%d", &n);
printf("%d\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &l);
fix[l] = 1;
if (fix[1000001 - l]) k++;
}
for (i = 1; i <= 1000000; i++) {
if (k > 0 && !fix[i] && !fix[1000001 - i])
k--, printf("%d %d ", i, 1000001 - i);
if (fix[i] && !fix[1000001 - i]) printf("%d ", 1000001 - i);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 500;
int N;
char s[Maxn + 5][Maxn + 5];
bool Check(int x, int y) {
return s[x][y] == 'X' && s[x - 1][y - 1] == 'X' && s[x - 1][y + 1] == 'X' &&
s[x + 1][y - 1] == 'X' && s[x + 1][y + 1] == 'X';
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%s", s[i]);
int ans = 0;
for (int i = 2; i < N; i++)
for (int j = 2; j < N; j++)
if (Check(i - 1, j - 1)) ans++;
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> paso(pair<int, int> pos, char dir) {
if (dir == 'U')
pos.first++;
else if (dir == 'D')
pos.first--;
else if (dir == 'R')
pos.second++;
else
pos.second--;
return pos;
}
int main() {
pair<int, int> fin, pos, bl = pair<int, int>(0, 0);
int K;
int a, b;
string S;
cin >> fin.second >> fin.first >> S;
for (int i = 0; i < S.size(); i++) {
bl = paso(bl, S[i]);
}
for (int w = 0; w < S.size(); w++) {
pair<int, int> rd = pair<int, int>(0, 0);
for (int i = 0; i < w; i++) {
rd = paso(rd, S[i]);
}
rd.first = fin.first - rd.first;
rd.second = fin.second - rd.second;
K = min((bl.first != 0) ? rd.first / bl.first : (1 << 30),
(bl.second != 0) ? rd.second / bl.second : (1 << 30));
K %= (1 << 30);
if (K < 0) {
continue;
}
pos = pair<int, int>(K * bl.first, K * bl.second);
if (pos == rd) {
printf("Yes\n");
return 0;
}
}
printf("No\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
int anc[100100][20];
int dep[100100];
int l[100100], r[100100];
vector<int> v[100100], u[100100];
void dfs(int x) {
l[x] = ++tot;
u[dep[x]].push_back(tot);
for (auto y : v[x]) {
dep[y] = dep[x] + 1;
dfs(y);
}
r[x] = tot;
}
int query(int x, int p) {
int d = dep[x];
if (p >= d) return 0;
for (int i = 19; i >= 0; i--) {
if (p >= (1 << i)) {
p = p - (1 << i);
x = anc[x][i];
}
}
int up = upper_bound(u[d].begin(), u[d].end(), r[x]) - u[d].begin();
int lo = lower_bound(u[d].begin(), u[d].end(), l[x]) - u[d].begin();
return up - lo - 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
anc[i][0] = x;
v[x].push_back(i);
}
dfs(0);
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= n; i++) {
int last = anc[i][j - 1];
anc[i][j] = anc[last][j - 1];
}
}
cin >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
int ans = query(x, y);
cout << ans << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace ufs {
int fa[100005];
void makeset(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int findset(int u) {
if (fa[u] == u) return fa[u];
return fa[u] = findset(fa[u]);
}
void unionset(int a, int b) {
int u = findset(a);
int v = findset(b);
fa[u] = v;
}
} // namespace ufs
using namespace ufs;
struct node {
int e;
int c;
};
int n, m;
int ans1, ans2;
int mem1[100005], mem2[100005], used[100005];
bool vis[100005];
vector<int> bel[100005];
vector<node> g[100005];
void init(int st) {
for (int i = 0; i < bel[st].size(); i++) used[bel[st][i]] = -1;
}
bool dfs(int u, int col) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].e;
int edge_col = (g[u][i].c ^ used[u]);
if (edge_col == col) {
if (used[v] == 1) return 0;
if (used[v] == -1) {
used[v] = 0;
if (dfs(v, col) == 0) return 0;
}
} else {
if (used[v] == 0) return 0;
if (used[v] == -1) {
used[v] = 1;
if (dfs(v, col) == 0) return 0;
}
}
}
return 1;
}
void update1(int st, int &ans) {
int tot = 0;
for (int i = 0; i < bel[st].size(); i++)
if (used[bel[st][i]] == 1) tot++;
if (tot < ans) {
ans = tot;
for (int i = 0; i < bel[st].size(); i++)
mem1[bel[st][i]] = used[bel[st][i]];
}
}
void update2(int st, int &ans) {
int tot = 0;
for (int i = 0; i < bel[st].size(); i++)
if (used[bel[st][i]] == 1) tot++;
if (tot < ans) {
ans = tot;
for (int i = 0; i < bel[st].size(); i++)
mem2[bel[st][i]] = used[bel[st][i]];
}
}
bool check1(int st) {
int ans = (1 << 30);
init(st);
used[st] = 1;
if (dfs(st, 1)) update1(st, ans);
init(st);
used[st] = 0;
if (dfs(st, 1)) update1(st, ans);
if (ans == (1 << 30)) return 1;
ans1 += ans;
return 0;
}
bool check2(int st) {
int ans = (1 << 30);
init(st);
used[st] = 1;
if (dfs(st, 0)) update2(st, ans);
init(st);
used[st] = 0;
if (dfs(st, 0)) update2(st, ans);
if (ans == (1 << 30)) return 1;
ans2 += ans;
return 0;
}
int main() {
cin >> n >> m;
makeset(n);
for (int i = 1; i <= m; i++) {
int u, v;
char c;
cin >> u >> v >> c;
g[u].push_back((node){v, c == 'B' ? 1 : 0});
g[v].push_back((node){u, c == 'B' ? 1 : 0});
unionset(u, v);
}
for (int i = 1; i <= n; i++) bel[findset(i)].push_back(i);
for (int i = 1; i <= n; i++)
if (vis[findset(i)] == 0) {
vis[findset(i)] = 1;
if (check1(findset(i))) {
ans1 = (1 << 30);
break;
}
}
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= n; i++)
if (vis[findset(i)] == 0) {
vis[findset(i)] = 1;
if (check2(findset(i))) {
ans2 = (1 << 30);
break;
}
}
if (ans1 == (1 << 30) && ans2 == (1 << 30))
cout << "-1";
else {
if (ans1 > ans2) {
ans1 = ans2;
for (int i = 1; i <= n; i++) mem1[i] = mem2[i];
}
cout << ans1 << endl;
for (int i = 1; i <= n; i++)
if (mem1[i] == 1) cout << i << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 100;
int trie[maxn][2], nxt = 1, ans, cnt[maxn], cnt2[maxn];
void add(int num) {
int u = 0;
cnt[u]++;
for (int j = 29; j >= 0; j--) {
int bit = num & (1 << j);
bit = (bit > 0 ? 1 : 0);
if (trie[u][bit] == 0) {
trie[u][bit] = nxt++;
}
u = trie[u][bit];
cnt[u]++;
}
}
void go(int node) {
int l = trie[node][0], r = trie[node][1];
if (cnt[node] == 2) {
cnt2[node] = 1;
return;
}
if (l != 0) {
go(l);
cnt2[node] += cnt2[l];
}
if (r != 0) {
go(r);
cnt2[node] += cnt2[r];
}
if (cnt[node] - cnt2[node] == 2) {
cnt2[node]++;
}
}
void go1(int node, int val) {
int l = trie[node][0], r = trie[node][1];
int tot = 0;
if (l != 0) {
tot += cnt2[l];
}
if (r != 0) {
tot += cnt2[r];
}
if (cnt2[node] != tot) {
val++;
}
ans = max(ans, val);
if (l != 0) {
go1(l, val);
}
if (r != 0) {
go1(r, val);
}
if (cnt2[node] != tot) {
val--;
}
}
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
add(a[i]);
}
go(0);
go1(0, 0);
cout << cnt2[0] - ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxn = 1e6 + 3;
vector<pair<int, int> > G[maxn];
int pre[maxn], fa[maxn][19], dep[maxn], mx[maxn][19], ans[maxn];
struct no {
int id, u, v, w;
} a[maxn];
bool cmp(no a, no b) { return a.w < b.w; }
int ffind(int x) {
if (pre[x] == x) return x;
pre[x] = ffind(pre[x]);
return pre[x];
}
void dfs(int u, int p) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
if (p == v) continue;
dep[v] = dep[u] + 1;
fa[v][0] = u;
mx[v][0] = G[u][i].second;
dfs(v, u);
}
}
int lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int i = 0; i < 18; i++)
if ((dep[v] - dep[u]) & (1 << i)) v = fa[v][i];
if (u == v) return u;
for (int i = 17; i >= 0; i--)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
int ask(int u, int st) {
int ret = 0;
for (int i = 0; i < 18; i++)
if (st & (1 << i)) ret = max(ret, mx[u][i]), u = fa[u][i];
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
a[i].id = i;
scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
}
for (int i = 1; i <= n; i++) pre[i] = i;
sort(a, a + m, cmp);
for (int i = 0; i < m; i++) {
int u = ffind(a[i].u), v = ffind(a[i].v);
if (u != v) {
pre[u] = v;
ans[a[i].id] = -1;
G[a[i].u].push_back({a[i].v, a[i].w});
G[a[i].v].push_back({a[i].u, a[i].w});
}
}
dep[1] = 1;
dfs(1, 0);
for (int i = 1; i < 18; i++)
for (int j = 1; j <= n; j++) {
fa[j][i] = fa[fa[j][i - 1]][i - 1];
mx[j][i] = max(mx[j][i - 1], mx[fa[j][i - 1]][i - 1]);
}
for (int i = 0; i < m; i++)
if (ans[a[i].id] != -1) {
int u = a[i].u, v = a[i].v, w = lca(u, v);
ans[a[i].id] = max(ask(u, dep[u] - dep[w]), ask(v, dep[v] - dep[w]));
}
for (int i = 0; i < m; i++) {
if (ans[i] != -1) printf("%d ", ans[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> w(1007);
int sttoi(string a) {
int k = 0, i = 1;
while (a.length()) {
k += (a[a.length() - 1] - '0') * i;
i *= 10;
a.pop_back();
}
return k;
}
string itos(int a) {
string b = "";
while (a) {
b += a % 10 + '0';
a /= 10;
}
reverse(b.begin(), b.end());
return b;
}
vector<int> uniqvint(vector<int> v) {
sort(v.begin(), v.end());
std::vector<int>::iterator it;
it = std::unique(v.begin(), v.end());
v.resize(std::distance(v.begin(), it));
return v;
}
vector<string> uniqvstr(vector<string> v) {
sort(v.begin(), v.end());
std::vector<string>::iterator it;
it = std::unique(v.begin(), v.end());
v.resize(std::distance(v.begin(), it));
return v;
}
int main() {
string s;
cin >> s;
vector<string> l(s.length());
for (int i = 0, j = 0; i < s.length(); i++)
if (s[i] == ',') {
j++;
} else {
l[j] += s[i];
}
uniqvstr(l);
vector<int> v(0);
for (int i = 0; i < l.size(); i++) {
v.push_back(sttoi(l[i]));
}
for (int i = 0; i < v.size(); i++) {
w[v[i]] = v[i];
}
string p = "";
for (int i = 1; i < w.size() - 1; i++) {
if (w[i - 1] == 0 && w[i] != 0 && w[i + 1] != 0) {
p += (itos(w[i])), p += '-';
} else if (w[i + 1] == 0 && w[i] != 0 && w[i - 1] != 0) {
p += (itos(w[i])), p += ',';
} else if (w[i - 1] == 0 && w[i] != 0 && w[i + 1] == 0) {
p += (itos(w[i])), p += ',';
}
}
for (int i = 0; i < p.length() - 1; i++) {
cout << p[i];
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, B, a[100005], pos[100005], bel[100005], lst[100005], f[100005],
cnt[100005];
int delta[450], ans[450], sum[450][100005];
void Update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delta[t] <= m) ans[t] = (ans[t] - f[u] + 998244353) % 998244353;
cnt[u] += v;
sum[t][cnt[u]] = (sum[t][cnt[u]] + f[u]) % 998244353;
if (cnt[u] + delta[t] <= m) ans[t] = (ans[t] + f[u]) % 998244353;
}
void Add(int u, int v, int w) {
if (u > v) return;
int p = bel[u], q = bel[v];
if (p + 1 >= q) {
for (int i = u; i <= v; i++) Update(i, w);
return;
}
for (int i = u; bel[i] == p; i++) Update(i, w);
for (int i = v; bel[i] == q; i--) Update(i, w);
for (int i = p + 1; i < q; i++) {
if (w > 0)
if (m - delta[i] >= 0)
ans[i] = (ans[i] - sum[i][m - delta[i]] + 998244353) % 998244353;
delta[i] += w;
if (w < 0)
if (m - delta[i] >= 0)
ans[i] = (ans[i] + sum[i][m - delta[i]]) % 998244353;
}
}
int main() {
scanf("%d%d", &n, &m);
B = sqrt(n);
bel[0] = 1;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), bel[i] = i / B + 1;
f[0] = sum[1][0] = ans[1] = 1;
for (int i = 1; i <= n; i++) {
lst[i] = pos[a[i]];
Add(lst[lst[i]], lst[i] - 1, -1);
Add(lst[i], i - 1, 1);
int j = i - 1;
for (int j = i - 1; j >= 0 && bel[i] == bel[j]; j--)
if (cnt[j] + delta[bel[i]] <= m) f[i] = (f[i] + f[j]) % 998244353;
for (int j = bel[i] - 1; j; j--) f[i] = (f[i] + ans[j]) % 998244353;
sum[bel[i]][0] = (sum[bel[i]][0] + f[i]) % 998244353;
if (delta[bel[i]] <= m) ans[bel[i]] = (ans[bel[i]] + f[i]) % 998244353;
pos[a[i]] = i;
}
printf("%d", f[n]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int gans = 0, gflag = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
gflag |= (ch == '-');
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
gans = (gans << 1) + (gans << 3) + ch - '0';
ch = getchar();
}
return gflag ? -gans : gans;
}
inline pair<int, int> readpr() {
int x = read();
return make_pair(x, read());
}
inline void write(int x) {
if (x > 9) {
write(x / 10);
}
putchar(x % 10 ^ 48);
}
inline void writenum(int x, char ch) {
if (x < 0) {
putchar('-');
x = -x;
}
write(x);
putchar(ch);
}
inline void writechar(char x, char ch) {
putchar(x);
putchar(ch);
}
inline int Min(int x, int y) { return x < y ? x : y; }
inline int Max(int x, int y) { return x > y ? x : y; }
inline int Abs(int x) { return x > 0 ? x : -x; }
const int Mx = 1e5;
struct Node {
int x, y;
} st[Mx + 5];
int n, tot, num, top, ans, q[Mx + 5], rd[Mx + 5], cd[Mx + 5], dn[Mx + 5],
lw[Mx + 5], vs[Mx + 5], bl[Mx + 5], db[Mx + 5];
vector<int> vec[Mx + 5], vct[Mx + 5];
inline void Trj(int x) {
dn[x] = lw[x] = ++tot;
q[++top] = x;
vs[x] = 1;
for (int to : vec[x]) {
if (!dn[to]) {
Trj(to);
lw[x] = Min(lw[x], lw[to]);
} else {
if (vs[to]) {
lw[x] = Min(lw[x], dn[to]);
}
}
}
int to;
if (dn[x] == lw[x]) {
num++;
do {
to = q[top--];
db[num] = to;
bl[to] = num;
vs[to] = 0;
} while (to ^ x);
}
}
inline void DFS(int x) {
vs[x] = 1;
if (!cd[x]) {
q[++top] = x;
return;
}
for (int to : vct[x]) {
if (vs[to]) {
continue;
}
DFS(to);
}
}
signed main() {
int i, fst = 1;
n = read();
for (i = 1; i <= n; i++) {
vec[i].emplace_back(read());
}
for (i = 1; i <= n; i++) {
if (!dn[i]) {
Trj(i);
}
}
for (i = 1; i <= n; i++) {
for (int to : vec[i]) {
if (bl[i] == bl[to]) {
continue;
}
vct[bl[to]].emplace_back(bl[i]);
rd[bl[i]]++;
cd[bl[to]]++;
}
}
for (i = 1; i <= num; i++) {
if (!rd[i]) {
fst = (!fst ? i : fst);
while (top) {
st[++ans] = (Node){db[i], db[q[top--]]};
}
DFS(i);
}
}
while (top) {
st[++ans] = (Node){db[fst], db[q[top--]]};
}
if (num == 1) {
writenum(0, '\n');
return 0;
}
writenum(ans, '\n');
for (i = 1; i <= ans; i++) {
writenum(st[i].x, ' ');
writenum(st[i].y, '\n');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, p[100001], i, j, h, f1, f2;
vector<pair<int, int> > v;
bool used[100001];
void dfs(int x, int y, int g) {
if (used[y]) {
if (g % 2 == 1) {
printf("NO\n");
exit(0);
}
return;
}
used[x] = used[y] = true;
v.push_back({x, y});
dfs(p[x], p[y], g + 1);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &p[i]);
if (p[i] == i) f1 = i;
if (p[p[i]] == i) f2 = i;
}
if (f1) {
printf("YES\n");
for (i = 1; i <= n; i++) {
if (i != f1) printf("%d %d\n", f1, i);
}
} else if (f2) {
v.push_back({f2, p[f2]});
used[f2] = used[p[f2]] = true;
for (i = 1; i <= n; i++) {
if (!used[i]) {
dfs(f2, i, 0);
}
}
printf("YES\n");
for (i = 0; i < v.size(); i++) printf("%d %d\n", v[i].first, v[i].second);
} else
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n;
std::cin >> n;
std::vector<bool> col(6 * n);
for (int i = 0; i < 3 * n; ++i) {
int x;
std::cin >> x;
--x;
col[x] = true;
}
std::vector<int> sta;
std::vector<std::vector<int>> tmp(6 * n);
std::vector<std::tuple<int, int, int>> tp;
std::vector<bool> bel;
std::vector<std::vector<int>> E(2 * n);
for (int i = 0; i < 6 * n; ++i) {
sta.push_back(i);
if ((int)sta.size() >= 3) {
auto c = std::prev(sta.end()), b = std::prev(c), a = std::prev(b);
if (col[*a] == col[*b] && col[*b] == col[*c]) {
int u = tp.size();
tp.emplace_back(*a, *b, *c);
bel.push_back(col[*a]);
if (a != sta.begin()) {
tmp[*std::prev(a)].push_back(u);
}
E[u].insert(E[u].end(), tmp[*a].begin(), tmp[*a].end());
E[u].insert(E[u].end(), tmp[*b].begin(), tmp[*b].end());
sta.pop_back(), sta.pop_back(), sta.pop_back();
}
}
}
std::vector<int> fa(2 * n, -1), deg(2 * n, 0);
for (int u = 0; u < 2 * n; ++u) {
for (int v : E[u]) {
fa[v] = u;
}
deg[u] = E[u].size();
}
int cnt = 0;
for (int u = 0; u < 2 * n; ++u) {
if (fa[u] == -1 && !bel[u]) {
++cnt;
}
}
int p = -1;
std::array<std::queue<int>, 2> Q;
for (int u = 0; u < 2 * n; ++u) {
if (!deg[u]) {
Q[bel[u]].push(u);
}
}
std::vector<std::tuple<int, int, int>> ans;
int c = 0;
for (int i = 0; i < 2 * n - 1; ++i) {
c ^= 1;
while (1) {
int u = Q[c].front();
Q[c].pop();
if (fa[u] == -1 && !bel[u]) {
if (cnt == 1) {
p = u;
continue;
}
--cnt;
}
ans.emplace_back(tp[u]);
if (fa[u] != -1) {
--deg[fa[u]];
if (!deg[fa[u]]) {
Q[bel[fa[u]]].push(fa[u]);
}
}
break;
}
}
if (p == -1) {
c ^= 1;
p = Q[c].front();
}
ans.emplace_back(tp[p]);
for (auto [x, y, z] : ans) {
std::cout << x + 1 << " " << y + 1 << " " << z + 1 << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, n;
cin >> T;
long long int k, res[T];
for (int i = 0; i < T; i++) {
cin >> n >> k;
long long int a[n];
for (int j = 0; j < n; j++) {
cin >> a[j];
}
sort(a, a + n);
if ((a[n - 1] - k) <= (a[0] + k) && (a[0] + k) <= (a[n - 1] + k)) {
res[i] = a[0] + k;
} else
res[i] = -1;
}
for (int i = 0; i < T; i++) cout << res[i] << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1000000007;
template <class T>
T bigmod(T b, T p, T m) {
if (p == 0) return 1;
T res = bigmod(b, p / 2, m);
res = (res * res) % m;
if (p % 2 == 1) res = (res * b) % m;
return res;
}
template <class T>
T gcd(T x, T y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long i, l = s.size(), f = 0;
for (i = 1; i < l; i++) {
if (s[i] == '.') {
if ((i - f) > k)
break;
else
f = i;
}
}
if (f == l - 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 35100, maxk = 55;
const int maxp = maxn * 16 * 2 * 2;
int tot, n, k;
int f[maxk][maxn];
int tr[maxp], ls[maxp], rs[maxp];
int a[maxn], w[maxn], rt[maxn];
pair<pair<int, int>, int> sta[maxn];
int insert(int rt, int l, int r, int x, int v) {
int t = ++tot;
tr[t] = tr[rt], ls[t] = ls[rt], rs[t] = rs[rt];
if (l == r) {
tr[t] += v;
return t;
}
int mid = (l + r) >> 1;
if (x <= mid)
ls[t] = insert(ls[rt], l, mid, x, v);
else
rs[t] = insert(rs[rt], mid + 1, r, x, v);
tr[t] = tr[ls[t]] + tr[rs[t]];
return t;
}
int ask(int t, int l, int r, int w) {
if (!t) return 0;
if (w <= l) return tr[t];
int mid = (l + r) >> 1;
if (w <= mid)
return ask(ls[t], l, mid, w) + ask(rs[t], mid + 1, r, w);
else
return ask(rs[t], mid + 1, r, w);
}
inline int calc(int i, int l, int r) {
return f[i - 1][l] + ask(rt[r], 1, n, l + 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) {
rt[i] = insert(rt[i - 1], 1, n, i, 1);
if (w[a[i]]) rt[i] = insert(rt[i], 1, n, w[a[i]], -1);
w[a[i]] = i;
}
for (int i = 1; i <= k; ++i) {
sta[1] = make_pair(make_pair(1, n), 0);
int l = 1, r = 1;
for (int j = 1; j <= n; ++j) {
f[i][j] = calc(i, sta[l].second, j);
if (sta[l].first.first == j) sta[l].first.first++;
if (sta[l].first.first > sta[l].first.second) ++l;
if (j == n) continue;
if (l > r) {
sta[++r] = make_pair(make_pair(j + 1, n), j);
continue;
}
if (calc(i, j, n) <= calc(i, sta[r].second, n)) continue;
while (l <= r && calc(i, sta[r].second, sta[r].first.first) <=
calc(i, j, sta[r].first.first))
--r;
if (l > r)
sta[++r] = make_pair(make_pair(j + 1, n), j);
else {
int lt = sta[r].first.first, rt = sta[r].first.second + 1;
while (lt + 1 < rt) {
int d = (lt + rt) >> 1;
if (calc(i, sta[r].second, d) > calc(i, j, d))
lt = d;
else
rt = d;
}
sta[r].first.second = lt;
sta[++r] = make_pair(make_pair(rt, n), j);
}
}
}
printf("%d\n", f[k][n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 20;
int n, dis[maxn], k;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> vec;
for (int i = 0, a; i < k; i++) {
cin >> a;
vec.push_back(a - n);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
queue<int> q;
for (int i : vec) q.push(i + 1000), dis[i + 1000] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int u : vec)
if (x + u >= 0 && x + u <= 1000 && dis[x + u] == 0)
dis[x + u] = dis[x] + 1, q.push(x + u);
}
if (dis[1000] == 0) return cout << -1 << endl, 0;
cout << dis[1000] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
inline long long sum(long long x, long long y, long long cnt) {
return cnt * (x + y) / 2LL;
}
long long n, m;
long long bSearch(int x, int y) {
long long ans = -1, ini = x;
while (x <= y) {
long long mit = (x + y) / 2;
long long cnt = mit - ini + 1;
if (sum(ini, mit, cnt) > m) {
y = mit - 1;
} else if (sum(ini, mit, cnt) <= m) {
ans = mit;
x = mit + 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];
arr.push_back(0);
arr.push_back((long long)1e9 + 1);
sort((arr).begin(), (arr).end());
vector<long long> ans;
long long k = 0;
for (long long i = 1; i <= n + 1; i++) {
long long x = arr[i - 1], y = arr[i];
x++;
y--;
if (x > y) continue;
long long cnt = y - x + 1;
if (sum(x, y, cnt) <= m) {
m -= sum(x, y, cnt);
k += cnt;
for (long long j = x; j <= y; j++) ans.push_back(j);
} else if (x <= m) {
long long tmp = bSearch(x, y);
k += tmp - x + 1;
for (long long j = x; j <= tmp; j++) ans.push_back(j);
break;
} else
break;
}
cout << k << "\n";
for (auto x : ans) cout << x << " ";
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll fi[1010], dp[1010];
ll modpow(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
dp[n] = 1;
for (int i = 1; i <= n; i++) dp[n] = dp[n] * i % MOD;
fi[n] = modpow(dp[n], MOD - 2);
for (int i = n; i > 0; i--) fi[i - 1] = fi[i] * i % MOD;
for (int i = a; i <= b; i++) {
for (int j = 0; j <= n; j++) {
for (int k = c; k <= d; k++) {
if (j + i * k > n) break;
(dp[j] += dp[j + i * k] * modpow(fi[i], k) % MOD * fi[k] % MOD) %= MOD;
}
}
}
cout << dp[0] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, f = 0;
cin >> n;
long long i = 2;
while (i * i < n) {
if (n % i == 0) {
f = 1;
break;
}
i++;
}
n = n / i;
if (n > i && f) {
f = 0;
long long j = i + 1;
while (j * j < n) {
if (n % j == 0) {
f = 1;
break;
}
j++;
}
n /= j;
if (f && n > j) cout << "YES\n" << i << " " << j << " " << n << "\n";
}
if (f == 0) cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool g[128][128];
int p[128];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a][b] = g[b][a] = true;
}
int ans = -1;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++)
if (g[i][j] && g[j][k] && g[i][k]) {
int c = p[i] + p[j] + p[k];
if (ans == -1 || c < ans) ans = c;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int INFINITE = 0x3f3f3f3f;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
typedef vector<int> VI;
typedef vector<VI> VII;
typedef vector<string> VS;
VII nums;
VI order;
int main() {
int n, k;
cin >> n >> k;
order.resize(k);
nums.resize(n);
for (int i = (int)(1); i < (int)(k + 1); i++) order[i - 1] = i;
for (int i = (int)(0); i < (int)(n); i++) {
string s;
cin >> s;
for (int j = (int)(0); j < (int)(s.size()); j++)
nums[i].push_back(s[j] - '0');
}
int res = INT_MAX;
do {
int minm = INT_MAX, maxm = -INT_MAX;
for (int i = (int)(0); i < (int)(n); i++) {
int num = 0;
for (int j = (int)(0); j < (int)(order.size()); j++)
num = num * 10 + nums[i][order[j] - 1];
checkmax(maxm, num);
checkmin(minm, num);
}
checkmin(res, (maxm - minm));
} while (next_permutation((order).begin(), (order).end()));
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void prepare() {}
bool solve() {
int n, m, k, x, y, i;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
if (x - 1 < 5 || n - x < 5 || y - 1 < 5 || m - y < 5) return true;
}
return false;
}
int main() {
prepare();
printf(solve() ? "YES\n" : "NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string name1[200];
string name2[200];
vector<pair<int, int> > a[200];
map<string, int> ind1;
map<string, int> ind2;
vector<pair<int, int> > aa;
map<pair<int, int>, int> d[200];
char s[10000];
int main() {
int i, j, k, m, n, q, o, p, b1, x;
string s1, s2, ss;
scanf("%d", &k);
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
ind1.clear();
for (i = 0; i < n; i++) {
scanf("%s", s);
name1[i] = s;
ind1[s] = i;
}
gets(s);
ind2.clear();
for (i = 0; i < m; i++) {
gets(s);
ss = s;
p = ss.find_first_of(':');
name2[i] = ss.substr(0, p);
ind2[name2[i]] = i;
ss.erase(0, p + 2);
ss += ", ";
aa.clear();
while (ss != "") {
p = ss.find_first_of(' ');
s1 = ss.substr(0, p);
ss.erase(0, p + 1);
p = ss.find_first_of(',');
s2 = ss.substr(0, p);
ss.erase(0, p + 2);
aa.push_back(make_pair(ind1[s1], atoi(s2.c_str())));
}
a[i] = aa;
}
for (i = 0; i < k; i++) d[i].clear();
for (i = 0; i < q; i++) {
scanf("%d", &x);
x--;
scanf("%s", s);
d[x][make_pair(0, ind1[s])]++;
for (j = 0; j < m; j++) {
b1 = 1;
for (o = 0; o < a[j].size(); o++)
if (d[x][make_pair(0, a[j][o].first)] < a[j][o].second) b1 = 0;
if (b1 == 1) {
for (o = 0; o < a[j].size(); o++)
d[x][make_pair(0, a[j][o].first)] -= a[j][o].second;
d[x][make_pair(1, j)]++;
}
}
}
for (i = 0; i < k; i++) {
vector<pair<string, int> > ans;
ans.clear();
for (map<pair<int, int>, int>::iterator it = d[i].begin(); it != d[i].end();
it++) {
if (it->second != 0) {
if (it->first.first == 0)
ans.push_back(make_pair(name1[it->first.second], it->second));
else
ans.push_back(make_pair(name2[it->first.second], it->second));
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (j = 0; j < ans.size(); j++)
printf("%s %d\n", ans[j].first.c_str(), ans[j].second);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> a[100005];
int ans[100005];
void dfs(int no,int father){
for (int i=0;i<a[no].size();i++){
int u=a[no][i].first;
int w=a[no][i].second%2;
if(u!=father){
ans[u]=ans[no]^w;
dfs(u,no);
}
}
}
int main(){
int n;
cin>>n;
for (int i=1;i<n;i++){
int u,v,c;
cin>>u>>v>>c;
a[u].push_back({v,c});
a[v].push_back({u,c});
}
dfs(1,-1);
for(int i=1;i<=n;i++) cout<<ans[i]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long int f(long long int idx) { return 0; }
inline long long int g(long long int val, long long int key,
long long int ret) {
return (val <= key) ? ret : ret - 1;
}
inline long long int lowbound(long long int l, long long int r,
long long int key) {
long long int mid, val;
while (l < r) {
mid = (l + r) >> 1;
val = f(mid);
if (key > val) {
l = mid + 1;
} else {
r = mid;
}
}
return g(f(l), key, l);
}
bitset<1000001> ok;
inline void seive() {
ok.set();
for (int i = 2; i * i < 1000001; i++)
if (ok[i])
for (int j = i << 1; j < 1000001; j += i) ok.reset(j);
}
long long int phi[1000001];
inline void totient() {
for (int i = int(1); i < int(1000001); i++) phi[i] = (i & 1) ? i : i / 2;
for (long long int i = 3; i < 1000001; i += 2)
if (phi[i] == i)
for (long long int j = i; j < 1000001; j += i) phi[j] -= phi[j] / i;
}
inline long long int EXP(long long int a, long long int b, long long int mod) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
inline long long int Poww(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
inline long long int inv(long long int x, long long int mod) {
return EXP(x, mod - 2, mod);
}
inline long long int anyinv(long long int a, long long int mod) {
return (ok[mod]) ? EXP(a, mod - 2, mod) : EXP(a, phi[mod] - 1, mod);
}
long long int fact[1000001];
inline void Fact() {
fact[0] = 1;
for (int i = int(1); i < int(1000001); i++)
fact[i] = (i * fact[i - 1]) % 1000000007;
}
inline long long int comb(long long int a, long long int b) {
if (a < b) return 0;
return (((fact[a] * inv(fact[b], 1000000007)) % 1000000007) *
inv(fact[a - b], 1000000007)) %
1000000007;
}
long long int C[1001][1001];
inline void COMB() {
for (int i = int(0); i < int(1001); i++) {
C[i][0] = C[i][i] = 1;
for (int j = int(1); j <= int(i >> 1); j++)
C[i][j] = C[i][i - j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
}
int n;
int a, b[1000001], ans[1000001], res, k;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = int(1); i <= int(n); i++) {
cin >> a;
cin >> b[a];
k = max(k, a);
}
if (b[0]) ans[0] = res = 1;
for (int i = int(1); i <= int(k); i++) {
if (b[i] >= i)
ans[i] = 1;
else if (b[i])
ans[i] = ans[i - b[i] - 1] + 1;
else
ans[i] = ans[i - 1];
res = max(res, ans[i]);
}
cout << n - res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int kcz = 1000000007;
const int maxn = 500005;
const int maxlogn = 21;
int n, logn, x[maxn], tot, he[maxn], ne[maxn << 1], to[maxn << 1],
pre[maxn << 1], suf[maxn << 1], st[maxn], en[maxn];
int tofa[maxn], fa[maxlogn][maxn], dep[maxn], f[maxn << 1];
long long fac[maxn];
int father(int x) { return (f[x] == x) ? x : (f[x] = father(f[x])); }
inline void add_edge(int u, int v) {
to[tot] = v, ne[tot] = he[u], pre[tot] = suf[tot] = -1, f[tot] = tot,
he[u] = tot++;
}
void dfs(int u) {
int i;
for (i = he[u]; ~i; i = ne[i])
if (to[i] != fa[0][u])
tofa[to[i]] = i ^ 1, fa[0][to[i]] = u, dep[to[i]] = dep[u] + 1,
dfs(to[i]);
}
inline int nex(int u, int v) {
int i;
for (i = logn; i >= 0; i--)
if (dep[v] - (1 << i) > dep[u]) v = fa[i][v];
if (fa[0][v] == u) return tofa[v] ^ 1;
return tofa[u];
}
void solve(int u, int s, int v) {
if (s != -1) s ^= 1;
if (s == -1 && u == v) throw 0xdead;
if (u == v) {
if (en[u] != -1 || suf[s] != -1) throw 0xdead;
en[u] = s;
return;
}
int t = nex(u, v);
if (s == -1) {
if (st[u] != -1 || pre[t] != -1) throw 0xdead;
st[u] = t;
} else {
if (en[u] == s || suf[s] != -1 || st[u] == t || pre[t] != -1) throw 0xdead;
if (father(s) == father(t)) throw 0xdead;
suf[s] = t, pre[t] = s, f[f[s]] = f[t];
}
solve(to[t], t, v);
}
int main() {
int i, cnt, u, v;
long long ans;
scanf("%d", &n);
for (i = 1, tot = 0; i <= n; i++) he[i] = -1, st[i] = en[i] = -1;
for (i = 1; i < n; i++) scanf("%d%d", &u, &v), add_edge(u, v), add_edge(v, u);
tot = 0, tofa[1] = -1, fa[0][1] = 0, dep[1] = 0, dfs(1);
for (logn = 0; (1 << logn) < n; logn++)
;
for (i = 1; i <= logn; i++)
for (u = 0; u <= n; u++) fa[i][u] = fa[i - 1][fa[i - 1][u]];
try {
for (i = 1; i <= n; i++) {
scanf("%d", &u);
if (u) solve(i, -1, u);
}
for (fac[0] = 1, i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % kcz;
ans = 1;
for (u = 1; u <= n; u++) {
if (st[u] != -1 && en[u] != -1) {
cnt = 0;
for (i = st[u]; ~suf[i]; i = suf[i]) cnt++;
cnt++;
if (i == en[u]) {
for (i = he[u]; ~i; i = ne[i]) cnt--;
if (cnt) throw 0xdead;
continue;
}
}
cnt = 0;
for (i = he[u]; ~i; i = ne[i])
if (pre[i] == -1 && st[u] != i) cnt++;
if (en[u] != -1) cnt--;
(ans *= fac[cnt]) %= kcz;
}
printf("%lld\n", ans);
} catch (int) {
printf("0\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, arr[N], ans[N];
vector<pair<int, int> > v;
pair<int, int> seg[4 * N];
pair<int, int> build(int s, int e, int idx) {
if (s == e)
return seg[idx] = make_pair(v[s].first - (s == 0 ? 0 : v[s - 1].first), s);
return seg[idx] = max(build(s, (s + e) / 2, idx * 2),
build((s + e) / 2 + 1, e, idx * 2 + 1));
}
pair<int, int> getmax(int s, int e, int idx, int l, int r) {
if (s > r || e < l) return make_pair(-1234, 0);
if (s >= l && e <= r) return seg[idx];
return max(getmax(s, (s + e) / 2, idx * 2, l, r),
getmax((s + e) / 2 + 1, e, idx * 2 + 1, l, r));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
v.push_back(make_pair(arr[i], i));
}
sort(v.begin(), v.end());
build(0, n - 1, 1);
int mx = 0;
int mx2 = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
int k = (max(i, j) + 1) / 2;
if (k > (n - (i + j))) k = n - (i + j);
if (k * 2 < j || k * 2 < i) continue;
if (i * 2 < j || i * 2 < k) continue;
if (j * 2 < i || j * 2 < k) continue;
mx = max(mx, v[n - i].first - v[n - i - 1].first);
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
int k = (max(i, j) + 1) / 2;
if (k > (n - (i + j))) k = n - (i + j);
if (k * 2 < j || k * 2 < i) continue;
if (i * 2 < j || i * 2 < k) continue;
if (j * 2 < i || j * 2 < k) continue;
int cur = v[n - i].first - v[n - i - 1].first;
if (cur != mx) continue;
mx2 = max(mx2, v[n - i - j].first - v[n - i - j - 1].first);
}
}
int idx1 = 0, idx2 = 0, idx3 = 0;
int mx3 = -1;
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
int k = (max(i, j) + 1) / 2;
if (k > (n - (i + j))) k = n - (i + j);
if (k * 2 < j || k * 2 < i) continue;
if (i * 2 < j || i * 2 < k) continue;
if (j * 2 < i || j * 2 < k) continue;
int cur = v[n - i].first - v[n - i - 1].first;
if (cur != mx) continue;
int cur2 = (v[n - i - j].first - v[n - i - j - 1].first);
if (cur2 != mx2) continue;
int mnk = (max(i, j) + 1) / 2;
int mxk = min(i, j) * 2;
if (mxk > (n - (i + j))) mxk = (n - (i + j));
pair<int, int> cur3 =
getmax(0, n - 1, 1, n - i - j - mxk, n - i - j - mnk);
if (cur3.first > mx3) {
mx3 = cur3.first;
idx1 = i;
idx2 = j;
idx3 = cur3.second;
}
}
}
for (int i = 0; i < idx1; i++) {
ans[v.back().second] = 1;
v.pop_back();
}
for (int i = 0; i < idx2; i++) {
ans[v.back().second] = 2;
v.pop_back();
}
for (int i = 0; i < idx3; i++) ans[v[i].second] = -1;
for (int i = idx3; i < v.size(); i++) ans[v[i].second] = 3;
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long MXN = 5e1 + 5, md = 1e9 + 7, inf = 1e9, zero = 0;
using namespace std;
long long n;
long long dp[MXN][MXN][MXN];
long long game(long long x, long long y, long long k) {
if (dp[x][y][k] || x * y == k || !k) return dp[x][y][k];
long long res = 1e12;
for (long long i = 1; i * 2 <= x; i++)
for (long long j = 0; j <= k; j++)
res = min(res, y * y + game(i, y, k - j) + game(x - i, y, j));
for (long long i = 1; i * 2 <= y; i++)
for (long long j = 0; j <= k; j++)
res = min(res, x * x + game(x, y - i, k - j) + game(x, i, j));
dp[x][y][k] = res;
return res;
}
int main() {
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long x, y, k;
cin >> x >> y >> k;
cout << game(x, y, k) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long g[600][600];
int tle[600], ac[600], re[600];
int n;
int nx, ny;
long long linker[600], lx[600], ly[600];
long long slack[600];
bool visx[600], visy[600];
bool dfs(int x) {
visx[x] = true;
for (int y = 0; y < ny; y++) {
if (visy[y]) continue;
int tmp = lx[x] + ly[y] - g[x][y];
if (tmp == 0) {
visy[y] = true;
if (linker[y] == -1 || dfs(linker[y])) {
linker[y] = x;
return true;
}
} else if (slack[y] > tmp)
slack[y] = tmp;
}
return false;
}
long long KM() {
memset(linker, -1, sizeof(linker));
memset(ly, 0, sizeof(ly));
for (int i = 0; i < nx; i++) {
lx[i] = -INF;
for (int j = 0; j < ny; j++)
if (g[i][j] > lx[i]) lx[i] = g[i][j];
}
for (int x = 0; x < nx; x++) {
for (int i = 0; i < ny; i++) slack[i] = INF;
while (true) {
memset(visx, false, sizeof(visx));
memset(visy, false, sizeof(visy));
if (dfs(x)) break;
int d = INF;
for (int i = 0; i < ny; i++) {
if (!visy[i] && d > slack[i]) d = slack[i];
}
for (int i = 0; i < nx; i++)
if (visx[i]) lx[i] -= d;
for (int i = 0; i < ny; i++) {
if (visy[i])
ly[i] += d;
else
slack[i] -= d;
}
}
}
long long res = 0;
for (int i = 0; i < ny; i++) {
if (linker[i] != -1) res += g[linker[i]][i];
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &tle[i], &ac[i], &re[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = max(tle[i] - 1ll * ac[i] * (min(re[i], j)), 0ll);
}
}
long long res = 0;
nx = ny = n;
res = KM();
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000100;
int go[N][26], par[N], val[N], endpos[N];
int root = 1, last = 1, tot = 1;
inline void newn(int &x, int v, int *g, int f) {
x = ++tot, val[x] = v, par[x] = f;
if (g)
for (int i = 0, nn = int(26); i < nn; ++i) go[x][i] = g[i];
}
inline void insert(int x) {
int np;
newn(np, val[last] + 1, NULL, 0);
endpos[np] = 1;
int p = last;
last = np;
while (p && go[p][x] == 0) go[p][x] = np, p = par[p];
if (!p)
par[np] = root;
else {
int q = go[p][x];
if (val[q] == val[p] + 1)
par[np] = q;
else {
int nq;
newn(nq, val[p] + 1, go[q], par[q]);
while (p && go[p][x] == q) go[p][x] = nq, p = par[p];
par[q] = par[np] = nq;
}
}
}
inline void query(string &s, int len) {
int u = root, l = 0, x, ans = 0;
static bitset<N> vis;
vis.reset();
for (int i = 0, nn = int(s.length()); i < nn; ++i) {
x = s[i] - 'a';
while (u && !go[u][x]) u = par[u], l = val[u];
if (!u) u = root, l = 0;
if (go[u][x]) u = go[u][x], ++l;
while (u && val[par[u]] >= len) u = par[u], l = val[u];
if (l >= len && !vis[u]) vis.set(u), ans += endpos[u];
}
printf("%d\n", ans);
}
int main() {
ios ::sync_with_stdio(false);
string s;
cin >> s;
for (int i = 0, nn = int(s.length()); i < nn; ++i) insert(s[i] - 'a');
static int ss[N / 2], ord[N];
for (int i = 1, nn = int(tot); i <= nn; ++i) ++ss[val[i]];
for (int i = 1, nn = int(val[last]); i <= nn; ++i) ss[i] += ss[i - 1];
for (int i = 1, nn = int(tot); i <= nn; ++i) ord[ss[val[i]]--] = i;
for (int i = tot, nn = int(1); i >= nn; --i) {
int x = ord[i];
endpos[par[x]] += endpos[x];
}
int n;
cin >> n;
while (n--) {
cin >> s;
int l = s.length();
for (int i = 0, nn = int(l - 1); i < nn; ++i) s += s[i];
query(s, l);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using db = double;
const ll mod = 1E9 + 7;
int n, m;
ll a[1 << 20];
void fwt(ll *a, int n, int op = 1) {
for (int i = 1; i < n; i *= 2)
for (int j = 0; j < n; j += i * 2)
for (int k = 0; k < i; ++k) {
ll x = a[j + k], y = a[j + k + i];
a[j + k] = x + y, a[j + k + i] = x - y;
if (op == -1) a[j + k] /= 2, a[j + k + i] /= 2;
}
}
char s[(1 << 20) + 6];
int main() {
cin >> m;
n = 1 << m;
scanf("%s", s);
for (int i = 0; i < n; ++i) a[i] = s[i] - '0';
fwt(a, n);
for (int i = 0; i < n; ++i) a[i] *= a[i];
fwt(a, n, -1);
ll ans = 0;
for (int i = 0; i < n; ++i)
(ans += a[i] << (m - __builtin_popcount(i))) %= mod;
cout << ans * 3 % mod << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void achange(int a[], int i, int r, int x) {
while (i <= r) {
a[i] = x;
i++;
}
}
void change(int a[], int i, int r, int x) {
while (i <= r) {
if (a[i] > x) a[i] = x;
i++;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, h, m, i, x, d, sum = 0, l, r;
cin >> n >> h >> m;
int a[n + 1];
achange(a, 1, n, h);
for (i = 0; i < m; i++) {
cin >> l >> r >> x;
change(a, l, r, x);
}
for (i = 1; i <= n; i++) {
sum = sum + a[i] * a[i];
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, ara[104];
cin >> n;
for (int i = 0; i < n; i++) cin >> ara[i];
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = i; j >= 0; j--)
if (!ara[j]) sum++;
for (int j = i; j < n; j++) sum += ara[j];
ans = max(sum, ans);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
while (n--) {
int x1, x2, y1, y2;
cin >> x1 >> x2 >> y1 >> y2;
sum += (abs(x1 - y1) + 1) * (abs(x2 - y2) + 1);
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l;
int ans = 1;
int p = 0;
cin >> c >> v0 >> v1 >> a >> l;
p = v0;
while (p < c) {
ans++;
p -= l;
if (v0 + a * (ans - 1) > v1)
p += v1;
else
p += v0 + a * (ans - 1);
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int t;
cin >> n >> t;
if (t == 10 && n == 1) return cout << -1, 0;
string s;
if (t == 10)
s += "10", n -= 2;
else
s += (char)(t + 48), n--;
while (n--) s += "0";
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[105][105], s1[3], s2[3];
int i, j, m, n, c;
cin >> m >> n;
getchar();
c = 0;
for (i = 0; i < m; i++)
for (j = 0; j < n; j++) {
cin >> a[i][j];
if (a[i][j] == '*') {
s1[c] = i;
s2[c++] = j;
}
}
sort(s1, s1 + 3);
sort(s2, s2 + 3);
i = s1[0] == s1[1] ? s1[2] : s1[0];
j = s2[0] == s2[1] ? s2[2] : s2[0];
printf("%d %d\n", i + 1, j + 1);
}
| 1 |
#include <stdio.h>
char c[13][13];
void saiki(int x, int y){
c[x][y] = '0';
if(x > 0){
if(c[x - 1][y] == '1'){
saiki(x - 1, y);
}
}
if(x < 11){
if(c[x + 1][y] == '1'){
saiki(x + 1, y);
}
}
if(y > 0){
if(c[x][y - 1] == '1'){
saiki(x, y - 1);
}
}
if(y < 11){
if(c[x][y + 1] == '1'){
saiki(x, y + 1);
}
}
}
int main(void)
{
int ans;
while(scanf("%s", c[0]) != EOF){
for(int i = 1; i < 12; i++){
scanf("%s", c[i]);
}
ans = 0;
for(int i = 0; i < 12; i++){
for(int j = 0; j < 12; j++){
if(c[i][j] == '1'){
ans++;
saiki(i, j);
}
}
}
printf("%d\n",ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(0);
int t = 1;
while (t--) solve();
return 0;
}
int n, m;
string s[60];
bool been[60][60];
void dfs(int x, int y) {
if (been[x][y]) return;
been[x][y] = true;
if (x > 0 && s[x - 1][y] == '#') dfs(x - 1, y);
if (x < n - 1 && s[x + 1][y] == '#') dfs(x + 1, y);
if (y > 0 && s[x][y - 1] == '#') dfs(x, y - 1);
if (y < m - 1 && s[x][y + 1] == '#') dfs(x, y + 1);
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '#') cnt++;
if (cnt < 3) {
cout << "-1";
return;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '#') {
s[i][j] = '.';
memset(been, false, sizeof been);
for (int w = 0; w < n; w++) {
bool flag = true;
for (int k = 0; k < m; k++)
if (s[w][k] == '#') {
dfs(w, k);
flag = false;
break;
}
if (!flag) break;
}
bool f = true;
for (int w = 0; w < n; w++)
for (int k = 0; k < m; k++)
if (s[w][k] == '#' && !been[w][k]) {
f = false;
break;
}
if (!f) {
cout << "1";
return;
}
s[i][j] = '#';
}
cout << "2";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void cmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void cmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
int len(const T &c) {
return (int)c.size();
}
template <class T>
int len(char c[]) {
return (int)strlen(c);
}
string itos(long n) {
string s;
while (n) {
s += (n % 10 + 48);
n /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long stoi(string s) {
long n = 0;
for (int i(0), _n(len(s)); i < _n; ++i) n = n * 10 + (s[i] - 48);
return n;
}
int main() {
long n, m, a, b, ar[1000], c;
cin >> n >> m;
for (int i(1), _n(n); i <= _n; ++i) {
cin >> ar[i];
}
double res = 0;
for (int i(0), _n(m); i < _n; ++i) {
cin >> a >> b >> c;
cmax(res, (double)(ar[a] + ar[b]) / (double)c);
}
cout.precision(10);
cout << res;
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<algorithm>
#define to first
#define cnt first
#define cost second
#define MAX_N 100001
#define MOD 10007
using namespace std;
typedef pair<int,int> P;
vector<P>G[MAX_N];
bool vis[MAX_N];
P dfs(int n,P x){
vis[n]=true;
for(int i=0;i<G[n].size();i++){
P e=G[n][i];
if(x.cost<e.cost)x.cost=e.cost,x.cnt=1;
else if(x.cost==e.cost)x.cnt++;
if(!vis[e.to])x=dfs(e.to,x);
}
return x;
}
int main(void){
int n,b,fb;
while(cin >> n,n){
for(int i=0;i<MAX_N;i++)G[i].clear();
for(int i=0;i<n;i++){
for(int j=0;j<2;j++){
cin >> b >> fb;
G[i].push_back(make_pair(b,fb));
}
}
fill(vis,vis+MAX_N,false);
int ans=1;
for(int i=0;i<n;i++){
if(!vis[i]){
P x(0,0);
x=dfs(i,x);
ans=ans%MOD*x.cnt/2%MOD;
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000005;
const int maxt = (1 << 20) + 5;
int all[maxt], dp[2][maxt];
int best[30], a[30][30];
int mask[30][30], cost[30][30];
char str[30][30];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", str[i]), best[i] = inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &a[i][j]), best[i] = min(best[i], a[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
bool ok = true;
for (int k = 0; k < n; k++)
if (k != i && str[i][j] == str[k][j]) ok = false;
if (ok) best[i] = 0;
}
}
for (int j = 0; j < m; j++) {
for (int c = 0; c < 26; c++) {
mask[j][c] = 0;
cost[j][c] = 0;
int maxc = 0, cnt = 0;
for (int i = 0; i < n; i++)
if (str[i][j] - 'a' == c) {
mask[j][c] |= 1 << i;
cost[j][c] += a[i][j];
maxc = max(maxc, a[i][j]);
cnt++;
}
cost[j][c] -= maxc;
if (cnt < 2) mask[j][c] = -1;
}
}
for (int i = 0; i < 1 << n; i++) dp[0][i] = dp[1][i] = inf;
int nw = 0, ls = 1;
dp[nw][0] = 0;
for (int j = 0; j < m; j++)
for (int c = 0; c < 26; c++)
if (mask[j][c] != -1) {
swap(nw, ls);
memcpy(dp[nw], dp[ls], sizeof dp[ls]);
for (int i = 0; i < 1 << n; i++) {
dp[nw][i | mask[j][c]] =
min(dp[nw][i | mask[j][c]], dp[ls][i] + cost[j][c]);
}
}
for (int i = 0; i < 1 << n; i++) {
all[i] = 0;
for (int j = 0; j < n; j++)
if ((i >> j) & 1)
;
else
all[i] += best[j];
}
int ans = inf;
for (int i = 0; i < 1 << n; i++) ans = min(ans, all[i] + dp[nw][i]);
printf("%d\n", ans);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5;
int n,l,a[N],b[N];
ll sum1[N],sum2[N];
int main()
{
scanf("%d%d",&l,&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]),b[n-i+1]=l-a[i];
for(int i=1;i<=n;i++) sum1[i]=sum1[i-1]+a[i]*2,sum2[i]=sum2[i-1]+b[i]*2;
ll ans=0;
for(int i=1;i<=n;i++)
{
int t=n-i;
ll res=sum1[i+t/2]-sum1[i-1]+sum2[t/2+t%2];
if(t&1) res-=b[t/2+t%2];
else res-=a[i+t/2];
ans=max(ans,res);
res=sum2[i+t/2]-sum2[i-1]+sum1[t/2+t%2];
if(t&1) res-=a[t/2+t%2];
else res-=b[i+t/2];
ans=max(ans,res);
}
printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2, typename T3>
struct pair3 {
T1 first;
T2 second;
T3 third;
};
template <typename T1, typename T2, typename T3, typename T4>
struct pair4 {
T1 first;
T2 second;
T3 third;
T4 fourth;
};
const long long MOD = 1000000007;
const long double PI = acos(-1.0);
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n;
vector<long long> ar(n);
for (long long i = 0; i < n; ++i) {
cin >> ar[i];
}
vector<vector<long long>> ans(n + 1);
for (long long len = 1; len <= n; ++len) {
vector<long long> temp;
long long mx = -1, mn = INT_MAX;
multiset<long long> st;
auto del = [&](long long val) {
auto it = temp.end();
--it;
while (1) {
if (*it == val) {
temp.erase(it);
break;
}
it -= 1;
}
};
for (long long start = 0; start < n; ++start) {
if (temp.size() < len) {
temp.push_back(ar[start]);
st.insert(ar[start]);
} else {
if (ar[start] > *st.begin()) {
del(*st.begin());
st.erase(st.begin());
st.insert(ar[start]);
temp.push_back(ar[start]);
}
}
ans[len] = temp;
}
}
cin >> m;
long long l, idx;
while (m--) {
cin >> l >> idx;
cout << ans[l][idx - 1] << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int v[n],c[n];
for(int i=0;i<n;++i)
cin>>v[i];
for(int i=0;i<n;++i)
cin>>c[i];
int ans=0;
for(int i=0;i<n;++i)
if(v[i]>c[i])
ans+=(v[i]-c[i]);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int c = 1, now = 10, used[128] = {}, nz = 0;
int main(void) {
scanf("%s", s);
for (int i = 0; s[i]; i++)
if (s[i] >= 'A' && s[i] <= 'J') {
if (used[(int)s[i]]) continue;
used[(int)s[i]] = 1;
if (i == 0)
c *= 9;
else
c *= now;
now--;
} else if (s[i] == '?') {
if (i == 0)
c *= 9;
else
nz++;
}
printf("%d", c);
for (int i = 0; i < nz; i++) printf("0");
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char map[110];
int pos[3][2], ans[2], all[2] = {0, 0};
int i, j, n, m, k = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", map);
for (j = 0; j < m; j++) {
if (map[j] == '*') {
all[0] += i + 1;
pos[k][0] = i + 1;
pos[k][1] = j + 1;
all[1] += j + 1;
k++;
}
}
}
int flag = 0;
for (i = 0; i < 3 && !flag; i++) {
for (j = 0; j < 3 && !flag; j++) {
if (pos[i][0] != pos[j][0] && pos[j][1] != pos[i][1]) {
ans[0] = 2 * (pos[i][0] + pos[j][0]) - all[0];
ans[1] = 2 * (pos[i][1] + pos[j][1]) - all[1];
flag = 1;
}
}
}
printf("%d %d\n", ans[0], ans[1]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ans, sum1[500005], sum2[500005], f1[500005], f2[500005], H1, H2, p;
int R, L, D, U, n, X, Y, i;
char s[500005];
const int MOD = 1000000007;
int main() {
scanf("%d%d%d", &n, &X, &Y);
scanf("%s", s + 1);
U = 1;
D = X;
L = 1;
R = Y;
for (i = 1; i <= n; i++) {
ans = (ans + 1ll * (R - L + 1) * (D - U + 1)) % MOD;
if (s[i] == 'L') L--, R--;
if (s[i] == 'R') L++, R++;
if (s[i] == 'U') U--, D--;
if (s[i] == 'D') U++, D++;
L = max(L, 1);
U = max(U, 1);
R = min(R, Y);
D = min(D, X);
L = min(L, Y + 1);
U = min(U, X + 1);
R = max(R, 0);
D = max(D, 0);
}
f1[0] = (R - L + 1);
f2[0] = (D - U + 1);
if (!f1[0] || !f2[0]) {
cout << ans;
return 0;
}
for (i = 1; i <= n; i++) {
if (s[i] == 'L') L--, R--;
if (s[i] == 'R') L++, R++;
if (s[i] == 'U') U--, D--;
if (s[i] == 'D') U++, D++;
L = max(L, 1);
U = max(U, 1);
R = min(R, Y);
D = min(D, X);
L = min(L, Y + 1);
U = min(U, X + 1);
R = max(R, 0);
D = max(D, 0);
f1[i] = (R - L + 1);
f2[i] = (D - U + 1);
}
H1 = f1[0] - f1[n];
H2 = f2[0] - f2[n];
if (!H1 && !H2) {
puts("-1");
return 0;
}
for (i = 1; i <= 500000; i++)
sum1[i] = (sum1[i - 1] + i) % MOD,
sum2[i] = (sum2[i - 1] + 1ll * i * i) % MOD;
for (i = 0; i < n; i++) {
if (H1 == 0)
p = f2[i] / H2;
else if (H2 == 0)
p = f1[i] / H1;
else
p = min(f2[i] / H2, f1[i] / H1);
ans = (ans + p * f1[i] % MOD * f2[i] -
(f1[i] * H2 + f2[i] * H1) % MOD * sum1[p - 1] +
H1 * H2 % MOD * sum2[p - 1]) %
MOD;
f1[i] -= p * H1;
f2[i] -= p * H2;
ans = (ans + f1[i] * f2[i]) % MOD;
}
cout << (ans + MOD) % MOD;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const int MAXM = 100000;
const int MAXSIZE = 1048576;
int n, m;
int tab[MAXM + 3];
char r[MAXM + 3];
int ans[MAXSIZE + 3], dp[2][23][MAXSIZE];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", r + 1);
for (int j = 1; j <= m; j++) tab[j] = (tab[j] << 1) + (r[j] - '0');
}
for (int i = 1; i <= m; i++) dp[0][0][tab[i]]++;
for (int t = 1; t <= n; t++)
for (int first = ((1 << n) - 1); first >= 0; first--)
dp[0][t][first] = dp[0][t - 1][first];
for (int k = 1; k <= n; k++) {
for (int first = ((1 << n) - 1); first >= 0; first--)
dp[k & 1][0][first] = 0;
for (int t = 1; t <= n; t++)
for (int first = ((1 << n) - 1); first >= 0; first--)
dp[k & 1][t][first] = dp[k & 1][t - 1][first] +
dp[(k + 1) & 1][t - 1][first ^ (1 << (t - 1))];
for (int first = ((1 << n) - 1); first >= 0; first--)
ans[first] += dp[k & 1][n][first] * min(k, n - k);
}
int res = n * m;
for (int first = ((1 << n) - 1); first >= 0; first--)
res = min(res, ans[first]);
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long p, tmp1, tmp2;
cin >> n >> p;
pair<long, long> a[n];
vector<long double> dp(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
for (int i = 0; i < n; i++) {
tmp1 = a[i].second / p;
tmp2 = tmp1 - (a[i].first - 1) / p;
dp[i] = (long double)tmp2 / (a[i].second - a[i].first + 1);
}
long double ans = 0;
for (int i = 0; i < n; i++) {
ans += 1000 * (dp[i] + dp[(i + 1) % n] - dp[i] * dp[(i + 1) % n]) +
1000 * (dp[i] + dp[(i + n - 1) % n] - dp[i] * dp[(i + n - 1) % n]);
;
}
printf("%.7f\n", (double)ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
vector<pair<int, int> > pnt(2 * n);
int a, b;
for (int i = 0; i < 2 * n; i += 2) {
scanf("%d%d", &a, &b);
pnt[i] = make_pair(a, 0);
pnt[i + 1] = make_pair(b, 1);
}
sort(pnt.begin(), pnt.end());
vector<int> good;
vector<pair<int, int> > ans;
int bal = 0;
for (int i = 0; i < 2 * n; ++i) {
if (pnt[i].second) {
--bal;
if (bal == m - 1) {
good.push_back(pnt[i].first);
}
} else {
++bal;
if (bal == m) {
good.push_back(pnt[i].first);
}
}
}
printf("%d\n", good.size() / 2);
for (int i = 0; i < int(good.size()); i += 2) {
printf("%d %d\n", good[i], good[i + 1]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = sqrt(n);
for (int i = 0; i < n; i += m) {
for (int j = min(n, i + m) - 1; j >= i; j--) {
cout << (j + 1) << " ";
}
}
return 0;
}
| 3 |
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#include <set>
#define MAXN 200005
#define P 998244353
#define INF 0x3f3f3f3f
#define rint register int
#define LL long long
#define LD long double
using namespace std;
int n, cnt, head[MAXN], ans[MAXN], mv[MAXN];
map<int, int> mp[MAXN];
struct Edge {int next, to;} edge[MAXN*2];
void addedge(int from, int to)
{
edge[++cnt].next=head[from];
edge[cnt].to=to;
head[from]=cnt;
}
int cal(int x, int fa, int val)
{
if(mp[x].count(val)) return mp[x][val];
int temp=0;
for(rint i=head[x]; i; i=edge[i].next)
{
int to=edge[i].to;
if(to==fa || to>=val) continue;
temp+=cal(to, x, val)+1;
}
mp[x][val]=temp;
return temp;
}
void dfs(int x, int fa)
{
for(rint i=head[x]; i; i=edge[i].next)
{
int to=edge[i].to;
if(to==fa) continue;
ans[to]=ans[x];
mv[to]=max(mv[x], x);
if(to>mv[x]) ans[to]+=cal(to, x, mv[to])+1;
else ans[to]+=cal(to, x, mv[to])-cal(to, x, mv[x]);
dfs(to, x);
}
}
int main()
{
scanf("%d", &n);
for(rint i=1, x, y; i<n; ++i)
{
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
dfs(1, 0);
for(rint i=2; i<=n; ++i) printf("%d ", ans[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int a1;
cin >> a1;
cout << 1 << " " << (a1 - 1);
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int bfs(string a, int n, int k) {
queue<string> q;
map<string, int> m;
m[a] = 1;
q.push(a);
int count = a.length();
int ans = 1;
while (!q.empty()) {
string s = q.front();
q.pop();
int x = 0;
while (x < s.length()) {
string curr = "";
for (int i = 0; i < s.length(); i++) {
if (i != x) curr += s[i];
}
if (m.find(curr) == m.end()) {
q.push(curr);
m[curr] = 1;
count += curr.length();
ans++;
if (ans == k) return n * k - count;
}
x++;
}
}
return -1;
}
int main() {
int n, k;
cin >> n >> k;
string a;
cin >> a;
if (k == 1)
cout << 0 << endl;
else
cout << bfs(a, n, k);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[200005], b, b1;
set<int> c1;
int n, k, p, f[200005], x[200005], c[200005], c2[200005];
int getdeepth(int i) {
for (vector<int>::iterator j = a[i].begin(); j != a[i].end(); j++)
if ((*j) != f[i]) {
f[*j] = i;
int x = getdeepth(*j);
c[i] += c[*j];
if (c[*j] >= k) return x;
}
return i;
}
int getdeepth1(int i) {
for (vector<int>::iterator j = a[i].begin(); j != a[i].end(); j++)
if ((*j) != f[i]) {
getdeepth1(*j);
}
if (!c2[i]) return i;
if (b.size() < k && c2[i])
b.push_back(i), c1.erase(i);
else
b1.push_back(i), c1.erase(i);
return i;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> n >> k;
for (int i = 1, j, l; i < n; i++) {
cin >> j >> l;
a[j].push_back(l);
a[l].push_back(j);
}
for (int i = 1, j; i <= 2 * k; i++) {
cin >> j;
c[j] = c2[j] = 1;
c1.insert(j);
}
p = getdeepth(1);
getdeepth1(p);
for (set<int>::iterator i = c1.begin(); i != c1.end(); i++) b1.push_back(*i);
cout << 1 << endl << p << endl;
for (int i = 0; i < k; i++) cout << b[i] << ' ' << b1[i] << ' ' << p << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1200;
int a[maxn];
int n, m, k, x, y;
int t[maxn], c[maxn];
int numb[3111114];
int main() {
cin >> n;
int maxSize = 0;
int siz = 0;
for (int i = 0; i < n; i++) {
cin >> t[i] >> c[i];
numb[t[i] + 1] += c[i];
}
int last = 0;
for (int i = 1; i <= 3111111; i++) {
maxSize = max(maxSize, numb[i]);
if (numb[i]) {
numb[i]--;
last = i;
numb[i + 1] += numb[i];
}
}
if (numb[3111112]) {
maxSize = max(maxSize, numb[3111112]);
last = 3111111 + numb[3111111];
}
cout << last << " " << maxSize << endl;
}
| 1 |
#include <bits/stdc++.h>
int nums[(100000)] = {0};
int dp[(100000)] = {0};
int N;
int max(int a, int b) { return a > b ? a : b; }
int solve() {
dp[0] = 1;
int m = 1;
for (int i = 1; i < N; i++) {
if (nums[i] > nums[i - 1]) {
dp[i] = dp[i - 1] + 1;
} else {
dp[i] = 1;
}
m = max(m, dp[i]);
}
return m;
}
int main() {
scanf("%d ", &N);
for (int k = 0; k < N; k++) {
scanf("%d ", &nums[k]);
}
printf("%d\n", solve());
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long fs(long n, long a, long b, long m) {
long r = 0;
while(m) {
r += a / m * n * (n - 1) / 2 + b / m * n;
a %= m;
b %= m;
b += a * n;
n = b / m;
b -= m * n;
swap(a, m);
}
return r;
}
int main() {
int t;
cin >> t;
for(int i = 0; i < t; i++) {
int n, m, a, b;
cin >> n >> m >> a >> b;
cout << fs(n, a, b, m) << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
ll const maxn = 2e5 + 10;
using namespace std;
ll a[maxn];
ll b[maxn];
int main(void) {
ll n, m;
set<int> s;
int i;
cin >> n >> m;
int cnt = n / m;
ll ans = 0;
for (i = 0; i < m; i++) s.insert(i);
for (i = 0; i < n; i++) {
cin >> a[i];
int r = a[i] % m;
if (r <= *s.rbegin())
r = *s.lower_bound(r);
else
r = *s.begin();
b[r]++;
if (b[r] == cnt) s.erase(r);
ans += (r - a[i] % m + m) % m;
a[i] += (r - a[i] % m + m) % m;
}
cout << ans << '\n';
for (i = 0; i < n; i++) cout << (i != 0 ? " " : "") << a[i];
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double cockno, timen, cockpert, timeb;
cin >> cockno >> timen >> cockpert >> timeb;
int times = (cockno / cockpert) + .99999;
if ((times * timen) > timen + timeb)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (c < 48) c == '-' && (f = -1), c = getchar();
while (c > 47) x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int MAXN = 2005;
int G[MAXN][MAXN], dfn[MAXN];
int st[MAXN], vis[MAXN], low[MAXN];
int n, t, sz, top, dft;
inline void tarjan(int x) {
vis[st[++top] = x] = 1;
dfn[x] = low[x] = ++dft;
for (int i = 1; i <= n; ++i)
if (G[x][i]) {
if (!dfn[i])
tarjan(i), low[x] = min(low[x], low[i]);
else if (vis[i])
low[x] = min(low[x], dfn[i]);
}
if (dfn[x] == low[x] && (sz = 0, 1))
while (t ^ x) vis[t = st[top--]] = 0, ++sz;
}
int main(int argc, char const *argv[]) {
n = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) G[i][j] = read() > 0;
tarjan(1);
puts(sz == n ? "YES" : "NO");
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
void print(int x,int y)
{
printf("%d %d\n",x,y);
}
int n;
int main()
{
scanf("%d",&n);
int m=1;
while(m<n)m<<=1;
if(n<3||m==n){printf("No\n");return 0;}
printf("Yes\n");
print(n+1,n+2);
print(n+2,n+3);
print(n+3,1);
print(1,2);
print(2,3);
for(int i=4;i<n;i+=2)
{
print(1,i);
print(i,n+i+1);
print(1,i+1);
print(i+1,i+n);
}
if(n%2==0)
{
for(int i=2;i<n;i++)
if((n^i^1)<n)
{
print(n^i^1,n);
print(i,2*n);
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
typedef long long ll;
const int N = 100054;
int n;
std::priority_queue <ll> L;
std::priority_queue <ll, std::vector <ll>, std::greater <ll> > R;
ll OL, OR; // offset
int main() {
int i, l, r, dis, la = -1; ll x, y, ans = 0;
scanf("%d%d%d", &n, &l, &r), la = r - l;
L.emplace(l), R.emplace(l);
for (i = 1; i < n; ++i, la = dis) {
scanf("%d%d", &l, &r), dis = r - l, OL -= dis, OR += la;
x = L.top() + OL, y = R.top() + OR;
if (x > l) ans += x - l, R.push(x - OR), L.pop(), L.emplace(l - OL), L.emplace(l - OL);
else if (y < l) ans += l - y, L.push(y - OL), R.pop(), R.emplace(l - OR), R.emplace(l - OR);
else L.emplace(l - OL), R.emplace(l - OR);
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int map[6][6];
int m;
bool input() {
if (scanf("%d", &m) == 1) {
int u, v;
memset(map, 0, sizeof(map));
while (m--) {
scanf("%d%d", &u, &v);
map[u][v] = map[v][u] = 1;
}
return true;
} else
return false;
}
void deal() {
int i, j, ac, uc, max = 0, max2 = 0;
for (i = 1; i <= 5; i++) {
ac = uc = 0;
for (j = 1; j <= 5; j++) {
if (map[i][j]) ac++;
if (i != j && map[i][j] == 0) uc++;
}
if (max < ac) max = ac;
if (max2 < uc) max2 = uc;
}
if (max >= 3 || max2 >= 3)
puts("WIN");
else
puts("FAIL");
}
int main(void) {
while (input()) {
deal();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char s[2000][40];
char s1[40];
int a[2000], a1, count = 0;
;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> s1 >> a1;
bool b = false;
for (int j = 0; j < count; j++)
if (strcmp(s[j], s1) == 0) {
b = true;
if (a1 > a[j]) a[j] = a1;
break;
}
if (b == false) {
strcpy(s[count], s1);
a[count++] = a1;
}
}
int less[2000];
for (int i = 0; i < count; i++) less[i] = 1;
for (int i = 0; i < count - 1; i++)
for (int j = i + 1; j < count; j++)
if (a[i] > a[j])
less[i]++;
else if (a[i] != a[j])
less[j]++;
else {
less[j]++;
less[i]++;
}
printf("%d\n", count);
for (int i = 0; i < count; i++) {
printf("%s ", s[i]);
if (less[i] < count / 2 + count % 2)
printf("noob\n");
else if (less[i] < (count * 4 / 5) + ((4 * count % 5) ? 1 : 0))
printf("random\n");
else if (less[i] < (9 * count / 10) + ((9 * count % 10) ? 1 : 0))
printf("average\n");
else if (less[i] < (99 * count / 100) + ((99 * count % 100) ? 1 : 0))
printf("hardcore\n");
else
printf("pro\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = (1 << 20) + 5;
constexpr int MOD = 1e9 - 7;
int f[2000], g[2000];
set<int> s;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int n, m, c, x;
memset(f, 0x7f, sizeof f);
cin >> n >> m >> c;
int i = 0, j = 0;
while (cin >> x) {
if (2 * x > c) {
int p = lower_bound(g, g + n, x) - g - 1;
g[p] = x;
printf("%d\n", p + 1);
} else {
int p = upper_bound(f, f + n, x) - f;
f[p] = x;
printf("%d\n", p + 1);
}
fflush(stdout);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l = 0;
cin >> n >> m;
int a[n];
for (int k = 0; k < n; k++) cin >> a[k];
for (int k = 0; k < n - 1; k++) {
l += max(m - a[k] - a[k + 1], 0);
a[k + 1] += max(m - a[k] - a[k + 1], 0);
}
cout << l << endl;
for (int k = 0; k < n; k++) cout << a[k] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, x, y, edge[100001];
vector<long long> v[100001];
map<pair<long long, long long>, long long> mp;
cin >> n;
memset(edge, -1, sizeof(edge));
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
mp[{x, y}] = i;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++)
if (v[i].size() > 2) break;
if (i > n) {
for (i = 0; i < n - 1; i++) cout << i << "\n";
return 0;
}
for (j = 0; j < 3; j++) {
if (mp.find({v[i][j], i}) != mp.end()) {
edge[mp[{v[i][j], i}]] = j;
} else
edge[mp[{i, v[i][j]}]] = j;
}
x = 3;
for (i = 0; i < n - 1; i++) {
if (edge[i] == -1) {
cout << x << "\n";
x++;
} else
cout << edge[i] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int K = 21, N = 1 << K;
struct cmp {
double x, y;
cmp(double _x = 0, double _y = 0) : x(_x), y(_y) {}
};
inline cmp operator+(cmp a, cmp b) { return cmp(a.x + b.x, a.y + b.y); }
inline cmp operator-(cmp a, cmp b) { return cmp(a.x - b.x, a.y - b.y); }
inline cmp operator*(cmp a, cmp b) {
return cmp(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
}
inline cmp conj(cmp a) { return cmp(a.x, -a.y); }
string n;
int p, ans;
cmp poW[N], f[N];
int rev[N], nd, num[N], td, tgt[N];
void init() {
poW[0] = cmp(1, 0);
double a1 = 8 * atan(1) / N;
for (int i = 1; i < N; i++) {
double a = a1 * i;
poW[i] = cmp(cos(a), sin(a));
rev[i] = (i & 1) << K - 1 | rev[i >> 1] >> 1;
}
}
void mul(int x) {
int car = 0;
for (int i = 0; i < nd; i++) {
car += num[i] * x;
num[i] = car % 10;
car /= 10;
}
while (car) {
num[nd++] = car % 10;
car /= 10;
}
}
void div(int x) {
int rem = 0;
for (int i = nd - 1; i >= 0; i--) {
rem = rem * 10 + num[i];
num[i] = rem / x;
rem %= x;
}
assert(rem == 0);
while (nd && !num[nd - 1]) {
nd--;
}
}
void fft(int k) {
int n = 1 << k, sh = K - k;
for (int i = 0; i < n; i++) {
int j = rev[i] >> sh;
if (i < j) swap(f[i], f[j]);
}
for (int k = 1, sh = K - 1; k < n; k <<= 1, sh--) {
for (int i = 0; i < n; i += k << 1) {
for (int j = 0; j < k; j++) {
int l = i + j, r = l + k;
cmp z = f[r] * poW[j << sh];
f[r] = f[l] - z;
f[l] = f[l] + z;
}
}
}
}
void pow3(int x) {
nd = num[0] = 1;
for (int k = 0, n = 1, b = K; b >= 0; b--) {
for (nd <<= 1; n < nd; k++, n <<= 1)
;
for (int i = 0; i < n; i++) {
f[i] = cmp(num[i], 0);
}
fft(k);
for (int i = 0; i < n; i++) {
f[i] = f[i] * f[i];
f[i].y = -f[i].y;
}
fft(k);
for (int i = 0; i < n; i++) {
num[i] = f[i].x / n + 0.5;
}
for (; nd && !num[nd - 1]; nd--)
;
mul(1);
if (x >> b & 1) mul(3);
}
}
bool small() {
for (int i = max(nd, td) - 1; i >= 0; i--) {
if (num[i] < tgt[i]) return true;
if (num[i] > tgt[i]) return false;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
cin >> n;
if (n == "1") {
cout << 1 << '\n';
return 0;
}
td = n.length();
for (int i = 0; i < td; i++) {
tgt[i] = n[td - 1 - i] - '0';
}
pow3(p = max(td / log10(3.0L) - 3.5L, 0.0L));
ans = p * 3;
while (small()) {
if (ans <= 3) {
num[0] = ans + 1;
} else if (ans % 3 == 0) {
div(3);
mul(4);
} else {
div(2);
mul(3);
}
ans++;
}
cout << ans << '\n';
}
| 4 |
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <set>
#include <string>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 50;
int solve();
ll gcd(ll p, ll q) {
if (q == 0) { return p; }
return gcd(q, p%q);
}
int main(void) {
while (solve()) {}
return 0;
}
int solve() {
int n;
cin >> n;
if (!n) { return 0; }
vector< string > s(n);
vector< string > code(n);
set<char> b = { 'a', 'i', 'u', 'e', 'o' };
int maxlen = 0;
// 入力を受け取る
for (auto &str : s)
cin >> str;
// tdn表記
for (int i = 0; i < n; i++) {
code[i] += s[i][0];
for (int j = 1; j < s[i].length(); j++) {
if (b.find(s[i][j - 1]) != b.end())
code[i] += s[i][j];
}
}
for (auto c : code) { maxlen = max(maxlen, static_cast<int>(c.length())); }
for (auto &c : code) {
int d = maxlen - static_cast<int>(c.length());
for (int i = 0; i < d+1; i++) {
c += '*';
}
}
//for (auto c : code) { cout << c << endl; }
int ans = -1;
for (int i = 1; i < maxlen + 1; i++) {
if (ans > 0) { break; }
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
int jlen =i;
int klen =i;
//cout << code[j].substr(0, jlen) << " / " << code[k].substr(0, klen) << endl;
if (code[j].substr(0, jlen) == code[k].substr(0, klen)) {
j = n + 200; break;
}
}
if (j == n - 1) { ans = i; }
}
}
cout << ans << endl;
return 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long c[100007];
int main() {
long long n, i, j, ans = 0;
long long a[100007], b[100007];
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (i = 1, j = 1; i <= n && j <= n;) {
if (a[i] == b[j]) {
c[a[i]] = 5;
i++, j++;
} else {
if (c[a[i]] == 5) {
i++;
continue;
} else {
c[b[j]] = 5;
j++;
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
bool vis[100005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
vis[a[i]] = 1;
}
int now = 15;
for (int i = 1; i <= 90; i++) {
if (vis[i])
now = 15;
else
now--;
if (now == 0) {
cout << i << "\n";
return 0;
}
}
cout << "90\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, g, r, a[10005], dist[11111111];
int cn(int i, int j) { return i * (g + 1) + j; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) scanf("%d", &a[i]);
sort(a, a + m);
scanf("%d%d", &g, &r);
for (int i = 0; i < m; i++) {
for (int j = 0; j <= g; j++) dist[cn(i, j)] = 1e9;
}
deque<pair<int, int> > s;
s.push_back({0, 0});
dist[0] = 0;
int ans = 1e9;
vector<pair<int, int> > v;
while (!s.empty()) {
auto node = s.front();
s.pop_front();
int i = node.second / (g + 1), j = node.second % (g + 1);
if (i == m - 1) ans = min(ans, node.first * (g + r) + j);
if (dist[node.second] < node.first) continue;
v.clear();
if (i && j + a[i] - a[i - 1] <= g)
v.push_back({cn(i - 1, j + a[i] - a[i - 1]), 0});
if (i != m - 1 && j + a[i + 1] - a[i] <= g)
v.push_back({cn(i + 1, j + a[i + 1] - a[i]), 0});
if (j == g) v.push_back({cn(i, 0), 1});
for (auto u : v) {
if (node.first + u.second < dist[u.first]) {
dist[u.first] = node.first + u.second;
if (u.second)
s.push_back({dist[u.first], u.first});
else
s.push_front({dist[u.first], u.first});
}
}
}
if (ans == 1e9) ans = -1;
printf("%d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string st[10];
int main() {
for (int i = 0; i < 8; i++) cin >> st[i];
int mina = 8;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (st[i][j] == 'W') {
bool bisa = 1;
int sum = 0;
int x = i;
while (bisa && x > 0) {
if (st[x - 1][j] != '.')
bisa = 0;
else {
x--;
sum++;
}
}
if (bisa) mina = min(mina, sum);
}
}
}
int minb = 8;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (st[i][j] == 'B') {
bool bisa = 1;
int sum = 0;
int x = i;
while (bisa && x < 7) {
if (st[x + 1][j] != '.')
bisa = 0;
else {
x++;
sum++;
}
}
if (bisa) minb = min(minb, sum);
}
}
}
if (mina <= minb)
cout << "A";
else
cout << "B";
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
double a, b;
int equal(double a, double b) {
if (fabs(a - b) < 1e-12)
return 1;
else
return 0;
}
int main() {
int i, j, T;
scanf("%d", &T);
while (T--) {
scanf("%lf%lf", &a, &b);
if (a == 0 && b == 0) {
printf("%lf\n", 1.0);
} else if (b == 0) {
printf("%lf\n", 1.0);
} else if (a == 0) {
printf("%lf\n", 0.5);
} else if (a < b * 4) {
double y = a / 4.0;
double ds = y * a / 2.0;
printf("%lf\n", (ds + b * a) / (2 * b * a));
} else {
double x = b * 4;
double ds = x * b / 2;
printf("%lf\n", 1 - ds / (2 * b * a));
}
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.