solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 2000000000;
long long INFF = 8000000000000000000LL;
double PI = acos(-1);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
inline string IntToString(int a) {
char x[100];
sprintf(x, "%d", a);
string s = x;
return s;
}
inline int StringToInt(string a) {
char x[100];
int res;
strcpy(x, a.c_str());
sscanf(x, "%d", &res);
return res;
}
inline string GetString(void) {
char x[1000005];
scanf("%s", x);
string s = x;
return s;
}
inline string uppercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); ++(i))
if (s[i] >= 'a' && s[i] <= 'z') s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); ++(i))
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] - 'A' + 'a';
return s;
}
inline void OPEN(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
vector<int> angka;
int n, data[2005];
long long dewa[2005];
long long MOD = 1000000007;
bool sudah[2005];
int to[2005];
int conn;
int pisah;
long long risan;
long long C[2005][2005];
int main() {
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); ++(i)) {
scanf("%d", &data[i]);
to[i] = data[i];
}
for (int(i) = (0); (i) <= (n); ++(i)) {
C[i][0] = C[i][i] = 1;
for (int(j) = (1); (j) <= (i - 1); ++(j))
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
dewa[1] = 0;
dewa[2] = 1;
dewa[0] = 1;
for (int(i) = (3); (i) <= (n); ++(i)) {
dewa[i] = (i - 1) * (dewa[i - 1] + dewa[i - 2]);
dewa[i] %= MOD;
}
memset(sudah, 0, sizeof(sudah));
for (int(i) = (1); (i) <= (n); ++(i)) {
if (to[i] == -1) continue;
int x = i;
while (x != -1) {
if (sudah[x]) goto hell;
sudah[x] = 1;
x = to[x];
if (x == i) goto hell;
}
++conn;
hell:;
}
for (int(i) = (1); (i) <= (n); ++(i))
if (!sudah[i]) ++pisah;
for (int(i) = (0); (i) <= (conn); ++(i)) {
long long pos = (C[conn][i] * dewa[i + pisah]) % MOD;
risan = (risan + pos) % MOD;
}
printf("%d\n", (int)risan);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int used[2300];
vector<pair<long long int, long long int> > q, uz1, uz2;
long long int uzaklik(long long int a, long long int b, long long int c,
long long int d) {
return abs(a - c) * abs(a - c) + abs(b - d) * abs(b - d);
}
int main() {
long long int N, x11, y11, x22, y22, x, y;
cin >> N >> x11 >> y11 >> x22 >> y22;
for (long long int i = 1; i <= N; i++) {
scanf("%lld %lld", &x, &y);
long long int a = uzaklik(x11, y11, x, y);
long long int b = uzaklik(x22, y22, x, y);
uz1.push_back(pair<long long int, long long int>(a, i));
uz2.push_back(pair<long long int, long long int>(b, i));
}
sort(uz1.begin(), uz1.end());
sort(uz2.begin(), uz2.end());
long long int minn = -1;
for (int i = uz1.size() - 1; i >= 0; i--) {
long long int r1 = 0, r2 = 0;
r1 = uz1[i].first;
memset(used, 0, sizeof used);
for (long long int j = i; j >= 0; j--) {
used[uz1[j].second] = 1;
}
for (long long int j = uz2.size() - 1; j >= 0; j--) {
if (!used[uz2[j].second]) {
r2 = uz2[j].first;
break;
}
}
if (minn == -1 || r1 + r2 < minn) minn = r1 + r2;
}
minn = min(minn, uz2[uz2.size() - 1].first);
cout << minn << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
int i, n;
cin >> n;
if (n % 4 == 2 || n % 4 == 3) {
cout << -1;
return 0;
}
if (n % 2 == 1) a[(n + 1) / 2] = (n + 1) / 2;
for (int i = 1; i <= n / 2; i += 2) {
a[i] = i + 1;
a[i + 1] = n - i + 1;
a[n - i] = i;
a[n - i + 1] = n - i;
}
cout << a[1];
for (int i = 2; i <= n; i++) cout << " " << a[i];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
long long A[100], B[100];
long long e, f, g, h;
bool check(long long x, long long y) {
if (y < (g + h) / 2 - (x - e)) return 0;
if (y < g + (x - (e + f) / 2)) return 0;
if (y > (g + h) / 2 + (x - e)) return 0;
if (y > h - (x - (e + f) / 2)) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i <= 8; ++i) cin >> A[i], A[i] *= 20;
for (int i = 1; i <= 8; ++i) cin >> B[i], B[i] *= 20;
int ans = 0;
long long a = A[1], b = A[1];
for (int i = 1; i <= 7; i += 2) a = min(a, A[i]), b = max(b, A[i]);
long long c = A[2], d = A[2];
for (int i = 2; i <= 8; i += 2) c = min(c, A[i]), d = max(d, A[i]);
e = B[1], f = B[1];
for (int i = 1; i <= 7; i += 2) e = min(e, B[i]), f = max(f, B[i]);
g = B[2], h = B[2];
for (int i = 2; i <= 8; i += 2) g = min(g, B[i]), h = max(h, B[i]);
for (long long i = a; i <= b; i += 1) {
for (long long j = c; j <= d; j += 1) {
if (check(i, j)) ans = 1;
}
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200500;
struct state {
int len, link;
map<char, int> next;
};
state st[N];
int sz, last;
void sa_init() {
last = st[0].len = 0;
sz = 1;
st[0].link = -1;
}
void sa_extend(char c) {
int k = sz++, p;
st[k].len = st[last].len + 1;
for (p = last; p != -1 && !st[p].next.count(c); p = st[p].link)
st[p].next[c] = k;
if (p == -1)
st[k].link = 0;
else {
int q = st[p].next[c];
if (st[p].len + 1 == st[q].len)
st[k].link = q;
else {
int w = sz++;
st[w].len = st[p].len + 1;
st[w].next = st[q].next;
st[w].link = st[q].link;
for (; p != -1 && st[p].next[c] == q; p = st[p].link) st[p].next[c] = w;
st[q].link = st[k].link = w;
}
}
last = k;
}
string s;
long long dp[N];
bool t[N];
long long f(int i) {
if (dp[i] != -1) return dp[i];
long long &r = dp[i] = t[i];
for (auto p : st[i].next) r += f(p.second);
return r;
}
void solve() {
sa_init();
memset(dp, -1, sizeof dp);
for (int i = 0, qwerty = ((int)(s).size()); i < qwerty; i++) sa_extend(s[i]);
int x = last;
while (x) {
t[x] = 1;
x = st[x].link;
}
f(0);
long long r = 0;
for (int i = 1, qwerty = sz; i < qwerty; i++)
r += f(i) * f(i) * (st[i].len - st[st[i].link].len);
while (last) {
t[last] = 0;
last = st[last].link;
}
for (int i = 0, qwerty = sz; i < qwerty; i++) st[i].next.clear();
cout << r << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tn;
cin >> tn;
for (int i = 0, qwerty = tn; i < qwerty; i++) {
cin >> s;
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> r, p, a;
vector<int> v;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
r[x]++;
p[y]++;
v.push_back(x);
v.push_back(y);
if (x == y) p[y]--;
}
int ans = 1e9 + 10;
int need = (n + 1) / 2;
for (int i = 0; i < v.size(); i++) {
int x = v[i];
if (r[x] >= need)
ans = 0;
else if (r[x] + p[x] >= need)
ans = min(ans, need - r[x]);
}
if (ans == 1e9 + 10) ans = -1;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m;
int ans[55][55];
bool query(int x1, int y1, int x2, int y2) {
cout << "?"
<< " " << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
bool x;
cin >> x;
return x;
}
int main() {
memset(ans, 0, sizeof(ans, -1));
cin >> n;
ans[1][1] = 1, ans[2][3] = 0, ans[n][n] = 0;
ans[1][2] = ans[2][3] ^ (!query(1, 2, 2, 3));
ans[2][1] = ans[2][3] ^ (!query(2, 1, 2, 3));
for (i = 3; i <= n; i++) ans[1][i] = ans[1][i - 2] ^ (!query(1, i - 2, 1, i));
for (i = 2; i <= n; i++) ans[2][i] = ans[1][i - 1] ^ (!query(1, i - 1, 2, i));
for (i = 3; i <= n; i++)
for (i0 = 1; i0 <= n; i0++)
if (i != n || i0 != n)
ans[i][i0] = ans[i - 2][i0] ^ (!query(i - 2, i0, i, i0));
bool p = 0, f = 0;
for (i = 1; i + 2 <= n && !f; i += 2) {
for (i0 = 1; i0 + 2 <= n && !f; i0 += 2) {
if (ans[i][i0] == 1 && ans[i + 2][i0 + 2] == 0) {
f = 1;
if (query(i, i0, i + 1, i0 + 2))
p = (ans[i + 1][i0 + 2] != ans[i][i0]);
else {
if (query(i, i0 + 1, i + 2, i0 + 2))
p = (ans[i + 2][i0 + 2] != ans[i][i0 + 1]);
else {
if (ans[i][i0 + 2] == 0)
p = (ans[i][i0 + 1] != 1);
else
p = (ans[i + 1][i0 + 2] != 0);
}
}
}
}
}
cout << "!" << endl;
for (i = 1; i <= n; i++) {
for (i0 = 1; i0 <= n; i0++) {
if ((i + i0) % 2) ans[i][i0] ^= p;
cout << ans[i][i0];
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int f[200010], fi[200010];
const int MOD = 1e9 + 7;
int add(long long a, long long b) { return (a + b) % MOD; }
int mul(long long a, long long b) { return (a * b) % MOD; }
int fp(long long a, int b) {
if (b == 0) return 1;
int tp = fp(a, b >> 1);
tp = mul(tp, tp);
if (b & 1)
return mul(tp, a);
else
return tp;
}
int comb(int n, int k) {
if (k > n) return 0;
return mul(f[n], mul(fi[n - k], fi[k]));
}
int h, w, n, dp[2010];
vector<pair<int, int> > v;
int main() {
f[0] = fi[0] = 1;
for (int i = 1; i <= 200002; i++) {
f[i] = mul(i, f[i - 1]);
fi[i] = fp(f[i], MOD - 2);
}
scanf("%d%d%d", &h, &w, &n);
v.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &v[i].first, &v[i].second);
}
sort(v.begin(), v.end());
v.emplace_back(h, w);
for (int i = 0; i <= n; i++) {
dp[i] = comb(v[i].first + v[i].second - 2, v[i].first - 1);
for (int j = 0; j < i; j++) {
if (v[j].first <= v[i].first && v[j].second <= v[i].second) {
dp[i] =
add(dp[i],
-mul(comb(v[i].first + v[i].second - (v[j].first + v[j].second),
v[i].first - v[j].first),
dp[j]));
if (dp[i] < 0) dp[i] += MOD;
}
}
}
printf("%d\n", dp[n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mice[100001];
int cake[100001];
int d[100001];
int fab(int x) { return x > 0 ? x : -x; }
int main() {
int n, m, y0, y1, i, ans, x;
while (cin >> n >> m) {
cin >> y0 >> y1;
for (i = 1; i <= n; i++) scanf("%d", &mice[i]);
for (i = 1; i <= m; i++) scanf("%d", &cake[i]);
if (m == 0) {
cout << n << endl;
continue;
}
x = 1;
memset(d, -1, sizeof(d));
ans = 0;
for (i = 1; i <= n; i++) {
while (x + 1 <= m && mice[i] >= cake[x + 1]) x++;
if (x == m) {
if (d[x] == -1) {
d[x] = fab(mice[i] - cake[x]);
} else {
if (d[x] == fab(mice[i] - cake[x])) continue;
d[x] = min(d[x], fab(mice[i] - cake[x]));
ans++;
}
continue;
}
if (mice[i] < cake[x]) {
if (d[x] != -1) ans++;
d[x] = cake[x] - mice[i];
continue;
}
if (fab(mice[i] - cake[x]) < fab(mice[i] - cake[x + 1])) {
if (d[x] == -1) {
d[x] = fab(mice[i] - cake[x]);
continue;
}
if (d[x] == fab(mice[i] - cake[x])) continue;
d[x] = min(d[x], fab(mice[i] - cake[x]));
ans++;
} else if (fab(mice[i] - cake[x]) == fab(mice[i] - cake[x + 1])) {
if (d[x] == -1 || d[x] == fab(mice[i] - cake[x]))
d[x] = fab(mice[i] - cake[x]);
else
d[x + 1] = fab(mice[i] - cake[x]);
} else {
if (d[x + 1] == -1)
d[x + 1] = fab(mice[i] - cake[x + 1]);
else {
ans++;
d[x + 1] = fab(mice[i] - cake[x + 1]);
}
}
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
long long n, a[N], b[N], tmp, ans, sl, mmin;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) b[i] = a[i];
b[1]++;
b[2]++;
ans = b[2] - b[1];
sl = 2;
mmin = 9999999999999LL;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[1]++;
b[2]--;
ans = b[2] - b[1];
sl = 2;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[1]++;
ans = b[2] - b[1];
sl = 1;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[1]--;
b[2]++;
ans = b[2] - b[1];
sl = 2;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[1]--;
b[2]--;
ans = b[2] - b[1];
sl = 2;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[1]--;
ans = b[2] - b[1];
sl = 1;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[2]++;
ans = b[2] - b[1];
sl = 1;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
b[2]--;
ans = b[2] - b[1];
sl = 1;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
for (int i = 1; i <= n; i++) b[i] = a[i];
ans = b[2] - b[1];
sl = 0;
for (int i = 2; i <= n - 1; i++) {
if (b[i + 1] - b[i] != ans) {
tmp = b[i + 1] + 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
tmp = b[i + 1] - 1;
if (tmp - b[i] == ans) {
b[i + 1] = tmp;
sl++;
continue;
} else {
sl = 9999999999999LL;
break;
}
}
}
}
mmin = min(mmin, sl);
if (mmin == 9999999999999LL)
cout << -1;
else
cout << mmin;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const long long INF = 2e9 + 13;
const long long MOD = 998244353;
int a, b;
vector<int> tA;
vector<int> tB;
bool can(int x) {
long long tot = ((long long)(x) * (x + 1) / 2LL);
vector<int> v;
tA.clear();
tB.clear();
for (int i = 1; i <= x; i++) v.push_back(i);
long long tmp = a;
for (int i = v.size() - 1; i >= 0; i--) {
if (tmp >= v[i]) {
tmp -= v[i];
tA.push_back(v[i]);
tot -= v[i];
} else
tB.push_back(v[i]);
}
if (tot <= b) {
return true;
}
return false;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
int l = 0;
int ans = 0;
int r = 65000;
while (l <= r) {
int md = (l + r) / 2;
if (can(md)) {
l = md + 1;
ans = md;
} else
r = md - 1;
}
can(ans);
cout << tA.size() << endl;
for (int x : tA) cout << x << ' ';
cout << endl;
cout << tB.size() << endl;
for (int x : tB) cout << x << ' ';
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 233333;
long long suml = 0, n, s;
struct node {
int l, r;
} e[maxn];
bool cmp(node a, node b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
int vis[maxn];
bool check(int x) {
long long now = suml;
int cnt = 0;
for (int i = n; i >= 1; i--) {
if (e[i].l >= x)
cnt++;
else if (e[i].r >= x) {
cnt++;
now += (x - e[i].l);
}
if (cnt == (n + 1) / 2) {
if (now <= s)
return true;
else
return false;
}
}
return false;
}
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> s;
int l, r = -999;
suml = 0;
for (int i = 1; i <= n; i++) {
cin >> e[i].l >> e[i].r;
r = max(r, e[i].r);
suml += e[i].l;
}
sort(e + 1, e + 1 + n, cmp);
int mid = (n + 1) / 2;
l = e[mid].l;
int ct = 1;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
l = mid + 1;
else
r = mid - 1;
}
int ans = r;
if (check(l)) ans = max(ans, l);
if (check(l + 1)) ans = max(ans, l + 1);
if (check(mid)) ans = max(ans, mid);
if (check(mid + 1)) ans = max(ans, mid + 1);
if (check(r + 1)) ans = max(ans, r + 1);
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 5;
const long long naxN = 2e2 + 5;
long long fact[naxN], inv_fact[naxN];
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2)
res = (res * a) % 1000000007, n--;
else
a = (a * a) % 1000000007, n /= 2;
}
return res % 1000000007;
}
void init() {
fact[0] = inv_fact[0] = 1;
for (long long i = 1; i < naxN; i++) {
fact[i] = (i * fact[i - 1]) % 1000000007;
inv_fact[i] = power(fact[i], 1000000007 - 2) % 1000000007;
}
}
long long ncr(long long a, long long b) {
if (a < 0 || b < 0 || a < b) return 0;
return (fact[a] % 1000000007 * inv_fact[b] % 1000000007 * inv_fact[a - b] %
1000000007) %
1000000007;
}
long long dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
long long dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
long long par[30];
long long R[30];
long long find(long long a) {
if (par[a] < 0) return a;
return par[a] = find(par[a]);
}
void merge(long long a, long long b) {
a = find(a);
b = find(b);
if (a == b) return;
if (R[a] >= R[b]) {
par[b] = a;
R[a] += R[b];
} else {
par[a] = b;
R[b] += R[a];
}
}
const long long maxN = 1e5 + 5;
void solve() {
long long n;
cin >> n;
map<long long, vector<pair<long long, long long>>> sx, sy;
vector<pair<long long, long long>> points;
for (long long i = 1; i <= n; i++) {
long long a, b;
cin >> a >> b;
points.push_back({a, b});
sx[a].push_back({a, b});
sy[b].push_back({a, b});
}
long long cnt = 0;
for (long long i = 0; i < (long long)points.size(); i++) {
long long u = 0, d = 0, r = 0, l = 0;
long long a = points[i].first, b = points[i].second;
for (long long j = 0; j < (long long)sx[a].size(); j++) {
long long y = sx[a][j].second;
if (y > b) u = 1;
if (y < b) d = 1;
}
for (long long j = 0; j < (long long)sy[b].size(); j++) {
long long x = sy[b][j].first;
if (x > a) r = 1;
if (x < a) l = 1;
}
if (u && d && r && l) cnt++;
}
cout << cnt << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(6);
long long T = 1;
while (T--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = LLONG_MAX;
void solve() {
long long n, tmp, mx = 0, ans = 0;
cin >> n;
vector<pair<long long, long long>> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i].second;
v[i].first = 0;
for (long long j = 0; j < v[i].second; j++) {
cin >> tmp;
v[i].first = max(tmp, v[i].first);
mx = max(tmp, mx);
}
}
for (long long i = 0; i < n; i++) {
ans += (mx - v[i].first) * v[i].second;
}
cout << ans << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
namespace SAT2 {
vector<int> v[200000 + 5], V[200000 + 5];
int n, b[200000 + 5], dn, q[200000 + 5], mark[200000 + 5], num, yes[200000 + 5];
void init(int sz) {
for (int i = 1; i <= sz; ++i)
v[i].clear(), V[i].clear(), mark[i] = b[i] = yes[i] = 0;
dn = num = 0;
n = sz;
}
void ins(int f, int t) {
v[f].push_back(t);
v[((t & 1) ? t + 1 : t - 1)].push_back(((f & 1) ? f + 1 : f - 1));
V[t].push_back(f);
V[((f & 1) ? f + 1 : f - 1)].push_back(((t & 1) ? t + 1 : t - 1));
}
void dfs(int x) {
b[x] = 1;
for (int i = 0; i < v[x].size(); ++i)
if (!b[v[x][i]]) dfs(v[x][i]);
q[++dn] = x;
}
void rdfs(int x) {
mark[x] = num;
for (int i = 0; i < V[x].size(); ++i)
if (!mark[V[x][i]]) rdfs(V[x][i]);
}
bool Solve() {
for (int i = 1; i <= n; ++i)
if (!b[i]) dfs(i);
for (int i = n; i; --i)
if (!mark[q[i]]) ++num, rdfs(q[i]);
for (int i = 1; i <= n; ++i)
if (mark[i] == mark[((i & 1) ? i + 1 : i - 1)]) return false;
for (int i = 1; i <= n; ++i)
yes[mark[i] > mark[((i & 1) ? i + 1 : i - 1)] ? i
: ((i & 1) ? i + 1 : i - 1)] =
1;
return true;
}
} // namespace SAT2
int n, a, b, s[100000 + 5];
map<int, int> mp;
int main() {
n = read();
a = read();
b = read();
SAT2::init(2 * n);
for (int i = 1; i <= n; ++i) mp[s[i] = read()] = i;
for (int i = 1; i <= n; ++i) {
int t1 = mp[a - s[i]], t2 = mp[b - s[i]];
if (t1)
SAT2::ins(2 * i - 1, 2 * t1 - 1);
else
SAT2::ins(2 * i - 1, 2 * i);
if (t2)
SAT2::ins(2 * i, 2 * t2);
else
SAT2::ins(2 * i, 2 * i - 1);
}
if (!SAT2::Solve()) return 0 * puts("NO");
puts("YES");
for (int i = 1; i <= n; ++i) printf(SAT2::yes[2 * i - 1] ? "0 " : "1 ");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
data = (data << 1) + (data << 3) + (ch ^ 48), ch = getchar();
return data * w;
}
int T, n, f[100005][2], g[2];
vector<int> v[100005];
const int mod = 1e9 + 7;
void dfs(int x) {
f[x][1] = 1;
for (auto y : v[x]) {
dfs(y);
int f0 = f[x][0], f1 = f[x][1];
f[x][0] = (1ll * f0 * (1 + f[y][0]) + 1ll * f1 * f[y][1]) % mod;
f[x][1] = (1ll * f0 * f[y][1] + 1ll * f1 * (1 + f[y][0])) % mod;
}
f[x][0] = (f[x][0] << 1) % mod;
f[x][1] = (f[x][1] << 1) % mod;
for (int p = 0; p <= 1; p++) {
memset(g, 0, sizeof(g));
g[0] = 1;
for (auto y : v[x]) {
int g0 = g[0], g1 = g[1];
g[0] = (g[0] + 1ll * f[y][p] * g0 * (p == 0) +
1ll * f[y][p] * g1 * (p == 1)) %
mod;
g[1] = (g[1] + 1ll * f[y][p] * g0 * (p == 1) +
1ll * f[y][p] * g1 * (p == 0)) %
mod;
}
f[x][p ^ 1] = (f[x][p ^ 1] - g[p] + mod) % mod;
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 2; i <= n; i++) v[read()].push_back(i);
for (int i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
dfs(1);
cout << (f[1][0] + f[1][1]) % mod << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
using pii = pair<long long, long long>;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const long long mxN = 1e5;
long long n;
long long a[mxN];
void solve() {
cin >> n;
for (long long i = (long long)0; i < (long long)(n); i++) cin >> a[i];
long long sum = n;
for (long long i = (long long)1; i < (long long)(n); i++) {
if (a[i] == a[i - 1]) {
long long ct = 1;
while ((i < n) && (a[i] == a[i - 1])) {
i++;
ct++;
}
ct *= ct - 1;
ct /= 2;
sum += ct;
}
}
cout << sum << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, p, a[205][205], fa[205 * 205], mod, num[205 * 205], g[205][205],
ans;
vector<pair<long long, long long> > q1, q2;
char s[205][205];
long long gfa(long long x) { return x == fa[x] ? x : fa[x] = gfa(fa[x]); }
void upd(long long &x, long long y) { x = (x + y) % mod; }
void solve() {
for (long long i = 1; i <= p; ++i) fa[i] = i;
for (auto i : q1) {
long long x = i.first, y = i.second;
x = gfa(x);
y = gfa(y);
if (x == y) return;
fa[x] = y;
}
long long w = 0;
memset(num, 0, sizeof num);
for (long long i = 1; i <= p; ++i)
if (fa[i] == i) num[i] = ++w;
if (w > 201) return;
memset(g, 0, sizeof g);
for (auto i : q2) {
long long x = i.first, y = i.second;
x = gfa(x);
y = gfa(y);
++g[num[x]][num[y]];
++g[num[y]][num[x]];
}
for (long long i = 1; i <= w; ++i) {
g[i][i] = 0;
for (long long j = 1; j <= w; ++j)
if (i != j) {
g[i][i] += g[i][j];
g[i][j] *= -1;
}
}
long long sum = 1;
for (long long i = 1; i < w; ++i) {
for (long long j = i + 1; j < w; ++j)
while (g[j][i]) {
swap(g[j], g[i]);
sum *= -1;
long long t = g[j][i] / g[i][i];
for (long long k = i; k < w; ++k) {
upd(g[j][k], -g[i][k] * t);
}
}
sum = sum * g[i][i] % mod;
}
upd(ans, sum);
}
void ins() {
q1.clear();
q2.clear();
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= m; ++j) {
if (s[i][j] == '/') {
long long x = a[i - 1][j], y = a[i][j - 1];
if (x && y) q1.push_back(make_pair(x, y));
}
if (s[i][j] == '\\') {
long long x = a[i - 1][j - 1], y = a[i][j];
if (x && y) q1.push_back(make_pair(x, y));
}
if (s[i][j] == '*') {
long long x = a[i - 1][j], y = a[i][j - 1];
if (x && y) q2.push_back(make_pair(x, y));
x = a[i - 1][j - 1], y = a[i][j];
if (x && y) q2.push_back(make_pair(x, y));
}
}
}
}
int main() {
scanf("%lld%lld%lld", &n, &m, &mod);
for (long long i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
for (long long i = 0; i <= n; ++i)
for (long long j = 0; j <= m; ++j)
if ((i + j) % 2 == 0) a[i][j] = ++p;
ins();
solve();
memset(a, 0, sizeof a);
p = 0;
for (long long i = 0; i <= n; ++i)
for (long long j = 0; j <= m; ++j)
if ((i + j) % 2 == 1) a[i][j] = ++p;
ins();
solve();
printf("%lld\n", (ans + mod) % mod);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
const int MOD = 1e9 + 7;
const int oo = 1e9;
int n;
int s[N];
vector<int> G[N];
int arr[N];
long long pa[N];
long long im[N];
long long total = 0;
void dfs1(int u, int p) {
if (s[u] == 1) {
im[u]++;
total++;
} else {
pa[u]++;
}
for (int i = 0; i < int(G[u].size()); i++) {
int v = G[u][i];
if (v != p) {
dfs1(v, u);
total += 1LL * pa[u] * im[v] + im[u] * pa[v];
if (s[u] == 1) {
im[u] += pa[v];
pa[u] += im[v];
} else {
im[u] += im[v];
pa[u] += pa[v];
}
}
}
}
void find_cnt() {
memset(pa, 0, sizeof pa);
memset(im, 0, sizeof im);
total = 0;
dfs1(1, -1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
long long res = 0;
for (int i = 0; i < 22; i++) {
memset(s, 0, sizeof s);
for (int j = 1; j <= n; j++) {
if (arr[j] & (1 << i)) {
s[j] = 1;
}
}
find_cnt();
res += total * (1LL << i);
}
cout << res << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r;
cin >> n >> l >> r;
long long min = pow(2, l) - 1 + n - l;
long long max = pow(2, r) - 1 + (n - r) * pow(2, r - 1);
cout << min << " " << max;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long frac[100005];
long long a[100005];
vector<int> leaf;
vector<int> v[100005];
bool mark[100005];
long long sum = 0;
bool SetFrac(int now, long long upto) {
if (v[now].size() == 1 && mark[v[now][0]]) {
if (upto > sum) return false;
frac[now] = upto;
return true;
}
mark[now] = true;
for (int i = 0; i < v[now].size(); i++)
if (!mark[v[now][i]]) {
if (!SetFrac(v[now][i], upto * (v[now].size() - (now != 1))))
return false;
}
return true;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n - 1; i++) {
int u, u2;
cin >> u >> u2;
v[u].push_back(u2);
v[u2].push_back(u);
}
for (int i = 2; i <= n; i++)
if (v[i].size() == 1) {
leaf.push_back(i);
if (a[i] == 0) {
cout << sum << endl;
return 0;
}
}
if (!SetFrac(1, 1)) {
cout << sum << endl;
return 0;
}
long long Max = -1;
for (int i = 0; i < leaf.size(); i++) {
if (Max == -1 || a[leaf[i]] * frac[leaf[i]] < Max)
Max = a[leaf[i]] * frac[leaf[i]];
}
long long Lcm = frac[leaf[0]];
for (int i = 1; i < leaf.size() && Lcm < Max; i++)
Lcm = lcm(Lcm, frac[leaf[i]]);
long long ans = 0;
long long root = Max / Lcm * Lcm;
for (int i = 0; i < leaf.size(); i++)
ans += a[leaf[i]] - root / frac[leaf[i]];
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> hozon[26];
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int a = 0; a < k; a++) {
hozon[s[a] - 'a'].push_back(a);
}
for (int a = 0; a < 26; a++) hozon[a].push_back(1000000);
for (int a = 0; a < n; a++) {
string t;
cin >> t;
long long sum = 0;
int m = t.size();
for (int b = 0; b < m; b++) {
int p = t[b] - 'a';
if (hozon[p].size() == 1)
sum += (long long)m;
else {
int q = lower_bound(hozon[p].begin(), hozon[p].end(), b) -
hozon[p].begin() - 1;
sum += (long long)min(abs(hozon[p][q] - b), abs(hozon[p][q + 1] - b));
}
}
cout << sum << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void dfs(int v, vector<bool>& used, vector<vector<int>>& g) {
used[v] = 1;
for (int& i : g[v]) {
if (used[i]) continue;
dfs(i, used, g);
}
}
void getans(vector<bool>& used, int n) {
int cnt = 0;
for (int i = 1; i <= n; i++) {
cnt += used[i];
}
cout << "YES\n" << cnt << " " << n - cnt << "\n";
for (int i = 1; i <= n; i++) {
if (used[i]) cout << i << " ";
}
cout << "\n";
for (int i = 1; i <= n; i++) {
if (!used[i]) cout << i << " ";
}
cout << "\n";
}
void bober() {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n + 1), rg(n + 1);
for (int i = 1, x, y; i <= m; i++) {
cin >> x >> y;
if (x == y) continue;
g[x].push_back(y);
rg[y].push_back(x);
}
vector<bool> used(n + 1);
dfs(1, used, g);
if (*min_element(used.begin() + 1, used.end()) == 0) {
getans(used, n);
return;
}
used.assign(n + 1, 0);
dfs(1, used, rg);
int v = 0;
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
v = i;
break;
}
if (!v) {
cout << "NO\n";
return;
}
used.assign(n + 1, 0);
dfs(v, used, g);
getans(used, n);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
bober();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int arr[100];
int ans = 0;
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for (i = 0; i < n; i++) {
int t = 0;
for (j = i; j < n; j++) {
t ^= arr[j];
if (t > ans) ans = t;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string number;
cin >> number;
bool possible = true;
for (int i = 0; i < number.size();) {
if (number[i] == '1' && number[i + 1] == '4' && number[i + 2] == '4') {
i += 3;
continue;
} else if (number[i] == '1' && number[i + 1] == '4') {
i += 2;
continue;
} else if (number[i] == '1') {
i++;
continue;
} else {
possible = false;
break;
}
}
if (possible) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> a;
int call(int n, int m, int x, int y) {
int i, j, ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m;) {
if (a[i][j] == '.') {
if (j < m - 1 && a[i][j + 1] == '.') {
ans += y;
j += 2;
} else {
ans += x;
j++;
}
} else
j++;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t, n, m, x, y, i;
cin >> t;
while (t--) {
cin >> n >> m >> x >> y;
a.resize(n);
for (i = 0; i < n; i++) cin >> a[i];
if (2 * x < y)
cout << call(n, m, x, 2 * x);
else
cout << call(n, m, x, y);
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int Get() {
char c;
while (c = getchar(), (c < '0' || c > '9') && (c != '-'))
;
bool Flag = (c == '-');
if (Flag) c = getchar();
int X = 0;
while (c >= '0' && c <= '9') {
X = X * 10 + c - 48;
c = getchar();
}
return Flag ? -X : X;
}
void Output(int X) {
if (X < 0) {
putchar('-');
X = -X;
}
int Len = 0, Data[10];
while (X) {
Data[Len++] = X % 10;
X /= 10;
}
if (!Len) Data[Len++] = 0;
while (Len--) putchar(Data[Len] + 48);
putchar('\n');
}
const int S = 80;
int main() {
static int DP[2][S * 2 + 1][S * 2 + 1];
memset(DP, 0, sizeof(DP));
DP[0][S][S] = Get();
static int Ans[S * 2 + 1][S * 2 + 1];
for (int i = 1; i <= 10000; i++) {
memset(DP[i & 1], 0, sizeof(DP[i & 1]));
for (int j = 0; j <= S * 2; j++)
for (int k = 0; k <= S * 2; k++) {
int T = DP[~i & 1][j][k] / 4;
if (T) {
DP[i & 1][j + 1][k] += T;
DP[i & 1][j - 1][k] += T;
DP[i & 1][j][k + 1] += T;
DP[i & 1][j][k - 1] += T;
}
DP[i & 1][j][k] += DP[~i & 1][j][k] % 4;
}
bool Find = false;
for (int j = 0; !Find && j <= S * 2; j++)
for (int k = 0; !Find && k <= S * 2; k++)
if (DP[0][j][k] != DP[1][j][k]) Find = true;
if (!Find) {
for (int j = 0; j <= S * 2; j++)
for (int k = 0; k <= S * 2; k++) Ans[j][k] = DP[i & 1][j][k];
break;
}
}
int M = Get();
while (M--) {
int X = Get(), Y = Get();
if (X < -S || X > S || Y < -S || Y > S)
Output(0);
else
Output(Ans[X + S][Y + S]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int work(int x) {
int sum = 0;
while (x != 0) {
if (x % 2 == 1) sum++;
x /= 2;
}
return sum;
}
int n, m, p, t, x, a[100005];
bool flag[2000000];
int s, dq;
int c[100];
int ans;
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; ++i) {
scanf("%d", &t);
for (int j = 1; j <= t; ++j) {
scanf("%d", &x);
a[x] = i;
}
}
s = (1 << m) - 1;
memset(flag, true, sizeof(flag));
t = p;
for (int i = 1; i <= n; ++i) {
c[a[i]]++;
dq |= 1 << (a[i] - 1);
if (i > t) {
c[a[i - t]]--;
if (c[a[i - t]] == 0) dq ^= 1 << (a[i - t] - 1);
}
if (i >= t) {
dq ^= s;
flag[dq] = false;
dq ^= s;
}
}
ans = 19950920;
for (int i = s; i >= 0; --i) {
if (flag[i])
ans = min(ans, work(i));
else {
for (int j = 1; j <= m; ++j) {
if ((i & (1 << (j - 1))) == 0) continue;
flag[i - (1 << (j - 1))] = false;
}
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int N = 800800;
int n;
std::string s;
int c[N][26], tot = 1;
std::set<int> set[N];
inline void ins(std::string& s, int i) {
int x = 1;
for (char u : s) x = c[x][u - 'a'] ?: c[x][u - 'a'] = ++tot;
set[x].insert(i);
}
int match[N];
long long res = 0;
inline void dfs(int x, int dep = 0) {
for (int i = 0; i < 26; ++i)
if (c[x][i]) {
dfs(c[x][i], dep + 1);
if (set[c[x][i]].size() > set[x].size()) set[x].swap(set[c[x][i]]);
set[x].insert(set[c[x][i]].begin(), set[c[x][i]].end());
}
for (; set[x].size() && *set[x].begin() < 0 && *set[x].rbegin() > 0;) {
match[*set[x].rbegin()] = -*set[x].begin();
set[x].erase(set[x].begin());
set[x].erase(--set[x].end());
res += dep;
}
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = (1), iend = (n); i <= iend; ++i) cin >> s, ins(s, i);
for (int i = (1), iend = (n); i <= iend; ++i) cin >> s, ins(s, -i);
dfs(1);
cout << res << '\n';
for (int i = (1), iend = (n); i <= iend; ++i) {
cout << i << ' ' << match[i] << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[100009];
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if ((a.first - a.second) == (b.first - b.second)) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
return a.first - a.second > b.first - b.second;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int i, j, n;
long long ans = 0;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n + 1, comp);
for (i = 1; i <= n; i++) {
ans += a[i].first * (i - 1) + a[i].second * (n - i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int h, m;
cin >> h >> m;
if (m > 0) {
h += 1;
m = 60 - m;
}
h = 24 - h;
cout << (h * 60) + m << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10;
set<pair<long long, int> > s;
set<long long> dis[maxn];
vector<pair<int, int> > g[maxn];
int d[maxn];
int main() {
int n, m, a, b, c, tur = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(make_pair(c, b));
g[b].push_back(make_pair(c, a));
}
for (int i = 1; i <= n; i++) {
d[i] = (1 << 30);
scanf("%d", &a);
for (int j = 0; j < a; j++) {
scanf("%d", &b);
dis[i].insert(b);
}
}
s.insert(make_pair(tur, 1));
d[1] = tur;
while (s.size()) {
int v = s.begin()->second;
s.erase(make_pair(d[v], v));
tur = d[v];
while (dis[v].find(tur) != dis[v].end()) tur++;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i].second, dd = g[v][i].first;
if (d[u] > tur + dd) {
s.erase(make_pair(d[u], u));
d[u] = tur + dd;
s.insert(make_pair(d[u], u));
}
}
}
if (d[n] == (1 << 30))
printf("-1\n");
else
printf("%d\n", d[n]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int INF = 1e18;
const long long int N = 1e6 + 20;
vector<long long int> g[N];
long long int vis[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tc = 1;
while (tc--) {
long long int n, curr, W;
cin >> n >> curr >> W;
vector<pair<long long int, long long int>> v;
for (long long int i = 1; i < n; i++) {
long long int t, w;
cin >> t >> w;
v.push_back({t, w});
}
sort(v.begin(), v.end());
long long int i = n - 2, ans = n;
;
multiset<long long int> ms;
while (1) {
while (i >= 0 and v[i].first > curr) {
ms.insert(v[i].second - v[i].first + 1);
i--;
}
ans = min(ans, (long long int)ms.size() + 1);
curr -= *ms.begin();
if (curr < 0 || ms.empty()) {
break;
}
ms.erase(ms.begin());
}
cout << ans << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (a[j] > a[j + 1]) {
swap(a[j], a[j + 1]);
cout << j + 1 << " " << j + 2 << endl;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 1;
int n, m, k, in, a, b, ver, edg, ans, mx, all;
vector<int> cap, arr[MAX];
bool vis[MAX];
void dfs(int v) {
++ver;
edg += arr[v].size();
vis[v] = true;
for (auto it : arr[v])
if (!vis[it]) dfs(it);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0; i < k; ++i) cin >> in, cap.push_back(in);
for (int i = 0; i < m; ++i)
cin >> a >> b, arr[a].push_back(b), arr[b].push_back(a);
for (auto it : cap) {
ver = 0, edg = 0;
dfs(it);
ans += ver * (ver - 1) / 2;
if (ver > mx) mx = ver;
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) ans += mx, ++mx;
cout << ans - m;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
;
multiset<int, greater<int>> so, se;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
if (a % 2) {
so.insert(a);
} else {
se.insert(a);
}
}
bool odd = 0;
if (so.size() > se.size()) odd = 1;
while (true) {
if (odd) {
if (so.size() == 0) break;
so.erase(so.begin());
odd = 0;
} else {
if (se.size() == 0) break;
se.erase(se.begin());
odd = 1;
}
}
long long sum = 0;
while (so.size() > 0) {
sum += (*so.begin());
so.erase(so.begin());
}
while (se.size() > 0) {
sum += (*se.begin());
se.erase(se.begin());
}
cout << sum << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ni() {
int val;
scanf("%i", &val);
return val;
}
int64_t nll() {
int64_t val;
scanf("%I64d", &val);
return val;
}
char nc() {
char val;
do {
scanf("%c", &val);
} while (val == ' ' || val == '\r' || val == '\n');
return val;
}
char ncs() {
char val;
do {
scanf("%c", &val);
} while (false);
return val;
}
string ns() {
static char buff[1024 * 2000];
scanf("%s", buff);
return string{buff};
}
int64_t gcd(int64_t a, int64_t b) {
while (b) {
auto tmp = a % b;
a = b;
b = tmp;
}
return a;
}
const int64_t max_n = 3 * 1000 * 100 + 1;
template <typename T>
inline int sign(const T& val) {
return val < 0 ? -1 : (val > 0 ? +1 : 0);
}
void ret(bool res) {
if (res)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
int main() {
auto n = ni(), l = ni();
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) a[i] = ni();
for (int i = 0; i < n; ++i) b[i] = ni();
vector<int> ad(n), bd(n);
for (int i = 0; i < n; ++i) {
if (i + 1 < n) {
ad[i] = a[1 + i] - a[i];
bd[i] = b[1 + i] - b[i];
} else {
ad[i] = l - a[i] + a[0];
bd[i] = l - b[i] + b[0];
}
}
for (int s = 0; s < n; ++s) {
if (ad == bd) ret(true);
bd.insert(bd.begin(), bd.back());
bd.pop_back();
}
ret(false);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 998244353;
int n, m;
long long arr[200100];
vector<long long> xorbasis() {
long long bas[64];
for (int i = 0; i < 64; i++) bas[i] = -1;
unordered_map<long long, int> lo;
for (int i = 0; i < 55; i++) {
lo[1LL << i] = i;
}
for (int i = 0; i < n; i++) {
long long v = arr[i];
while (v) {
int dig = lo[v & -v];
if (~bas[dig]) {
v ^= bas[dig];
} else {
bas[dig] = v;
break;
}
}
}
vector<long long> b;
for (int i = 0; i < 55; i++) {
if (bas[i] >= 0) {
b.push_back(bas[i]);
}
}
return b;
}
long long pcnt(long long v) {
int c = 0;
while (v) {
if (v % 2) c++;
v /= 2;
}
return c;
}
int pc[3010];
long long A[3010][25], B[3010];
long long ans[55];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
}
vector<long long> bas = xorbasis();
vector<long long> bl, bh;
for (long long &v : bas) {
if ((v & -v) >= (1LL << 24))
bh.push_back(v);
else
bl.push_back(v);
}
for (int i = 0; i < (1 << bl.size()); i++) {
long long x = 0;
for (int j = 0; j < bl.size(); j++) {
if (i >> j & 1) x ^= bl[j];
}
long long v = pcnt(x & ((1LL << 24) - 1));
A[x >> 24][v]++;
}
for (int i = 0; i < (1 << bh.size()); i++) {
long long x = 0;
for (int j = 0; j < bh.size(); j++) {
if (i >> j & 1) x ^= bh[j];
}
B[x >> 24]++;
}
for (int i = 1; i < (1 << 11); i++) pc[i] = pc[i & (i - 1)] + 1;
for (int i = 0; i < (1 << 11); i++) {
for (int v = 0; v <= 24; v++) {
for (int j = 0; j < (1 << 11); j++) {
ans[pc[i ^ j] + v] += A[i][v] * B[j];
}
}
}
long long pp = 1;
for (int i = 0; i < n - (int)bas.size(); i++) {
pp = pp * 2 % MOD;
}
for (int i = 0; i <= m; i++) {
ans[i] = ans[i] % MOD * pp % MOD;
}
for (int i = 0; i <= m; i++) printf("%lld ", ans[i] % MOD);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int x[77], y[77], r[77];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", x + i, y + i, r + i);
for (int i = 1; i < n; i++) printf("(");
for (int i = 1; i <= n; i++) {
if (i > 1) printf("+");
printf("(%d*((1-abs((t-%d)))+abs((abs((t-%d))-1))))", x[i] / 2, i, i);
if (i > 1) printf(")");
}
puts("");
for (int i = 1; i < n; i++) printf("(");
for (int i = 1; i <= n; i++) {
if (i > 1) printf("+");
printf("(%d*((1-abs((t-%d)))+abs((abs((t-%d))-1))))", y[i] / 2, i, i);
if (i > 1) printf(")");
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, mid, ans, n, k, p, o, cnt, cc, fa[505050], s[505050], last, now;
vector<int> h[505050];
long long check(long long x) {
p = 1;
o = 1;
cnt = 0;
cc = 0;
for (int i = 1; i <= n; i++) {
cc++;
cnt += o;
if (cnt > k) return k + 1;
if (cc == p) cc = 0, p = p * x, o++;
}
return cnt;
}
long long calc(long long x, long long o, long long n) {
long long ret = 0;
while (n) {
x = x * r;
long long gt = min(n, x);
o++;
n -= gt;
ret += o * gt;
}
return ret;
}
int main() {
cin >> n >> k;
if (k > n * (n + 1) / 2) {
puts("No");
return 0;
}
if (k == n * (n + 1) / 2) {
puts("Yes");
for (int i = 1; i < n; i++) printf("%d ", i);
puts("");
return 0;
}
if (k < 2 * n - 1) {
puts("No");
return 0;
}
l = 1;
r = n - 1;
while (r - l > 1) {
mid = (l + r) >> 1;
if (check(mid) > k)
l = mid;
else
r = mid;
}
last = 1;
now = 1;
o = 2;
k -= 3;
h[1].push_back(1);
h[2].push_back(2);
for (int i = 3; i <= n; i++) {
if (now == last * r || calc(now, o, n - i + 1) <= k)
last = now, now = 1, o++;
else
now++;
k -= o;
h[o].push_back(i);
s[i] = o;
}
for (int i = 2; i <= n; i++) {
assert(h[i].size() <= r * h[i - 1].size());
for (int j = 0; j < h[i].size(); j++) fa[h[i][j]] = h[i - 1][j / r];
}
puts("Yes");
for (int i = 2; i <= n; i++) printf("%d ", fa[i]);
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int c, sum;
cin >> c >> sum;
if (c >= sum) {
cout << sum << '\n';
continue;
}
cout << ((sum / c) * (sum / c) * (c - (sum % c)) +
(sum / c + 1) * (sum / c + 1) * (sum % c))
<< '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, l = 0, m = 1, r = 2;
cin >> n >> k;
n = n % 6;
for (int i = n; i >= 1; i--) {
if (i % 2 == 1) {
int t = l;
l = m;
m = t;
} else {
int t = r;
r = m;
m = t;
}
}
if (k == l)
cout << "0";
else if (k == m)
cout << "1";
else
cout << "2";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i, j, ct = 0, cross = 0, k = 0;
cin >> n;
int a[n + 2][n + 2];
char ch[n + 2][n + 2];
for (i = 0; i <= n + 1; i++) {
for (j = 0; j <= n + 1; j++) {
ch[i][j] = '1';
a[i][j] = 0;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
cin >> ch[i][j];
if (ch[i][j] == '#') cross++;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (ch[i][j] == '#' && a[i][j] == 0) {
if ((a[i + 1][j] == 0 && a[i - 1][j] == 0 && a[i][j + 1] == 0 &&
a[i][j - 1] == 0) &&
(ch[i + 1][j] == '#' && ch[i - 1][j] == '#' &&
ch[i][j + 1] == '#' && ch[i][j - 1] == '#')) {
a[i + 1][j]++;
a[i - 1][j]++;
a[i][j + 1]++;
a[i][j - 1]++;
a[i][j]++;
}
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (a[i][j] == 1) k++;
}
}
if (k == cross)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5 + 10;
int cnt[505][505];
int x[Maxn], y[Maxn], s[Maxn];
int tmp;
int d[Maxn];
void update(int now, int k, int val) {
int bl = x[k] + y[k];
int l = (now + x[k]) % bl;
int r = (now + x[k] + y[k] - 1) % bl;
if (l <= r)
for (int i = l; i <= r; i++) cnt[bl][i] += val;
else {
for (int i = 0; i <= r; i++) cnt[bl][i] += val;
for (int i = l; i < bl; i++) cnt[bl][i] += val;
}
return;
}
int query(int t) {
int res = 0;
for (int i = 2; i <= tmp; i++) res += cnt[i][t % i];
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
}
tmp = ceil(sqrt(m));
int ans = 0;
for (int i = 1; i <= m; i++) {
int op, k;
scanf("%d %d", &op, &k);
if (op == 1) {
if (x[k] + y[k] > tmp) {
for (int j = i + x[k]; j <= m; j += x[k] + y[k]) {
d[j]++;
if (j + y[k] <= m) d[j + y[k]]--;
}
} else
update(i, k, 1);
s[k] = i;
} else {
if (x[k] + y[k] > tmp) {
for (int j = s[k] + x[k]; j <= m; j += x[k] + y[k]) {
d[j]--;
if (j + y[k] <= m) d[j + y[k]]++;
if (i > j && i <= j + y[k]) ans--;
}
} else
update(s[k], k, -1);
}
ans += d[i];
printf("%d\n", ans + query(i));
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct laptop {
int q, p;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
laptop a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i].p >> a[i].q;
}
sort(a, a + n, [](laptop a, laptop b) { return a.p > b.p; });
int q = a[0].q;
for (int i = 1; i < n; ++i) {
if (a[i].q > q) {
cout << "Happy Alex\n";
return 0;
}
q = min(q, a[i].q);
}
cout << "Poor Alex\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t, i, j, k, it;
cin >> t;
for (it = 0; it < t; it++) {
long long r, c;
cin >> r >> c;
string s[r];
for (j = 0; j < r; j++) cin >> s[j];
long long ch0 = 1, ch1 = 1, ch2 = 1, ch3 = 1, ch4 = 1;
for (j = 0; j < r; j++) {
for (k = 0; k < c; k++)
if (s[j][k] != 'A') {
ch0 = 0;
break;
}
if (ch0 == 0) break;
}
if (ch0) {
cout << "0"
<< "\n";
continue;
}
for (i = 0; i < r; i++)
if (s[i][0] != 'A') {
ch1 = 0;
break;
}
if (ch1) {
cout << "1"
<< "\n";
continue;
}
ch1 = 1;
for (i = 0; i < r; i++)
if (s[i][c - 1] != 'A') {
ch1 = 0;
break;
}
if (ch1) {
cout << "1"
<< "\n";
continue;
}
ch1 = 1;
for (i = 0; i < c; i++)
if (s[0][i] != 'A') {
ch1 = 0;
break;
}
if (ch1) {
cout << "1"
<< "\n";
continue;
}
ch1 = 1;
for (i = 0; i < c; i++)
if (s[r - 1][i] != 'A') {
ch1 = 0;
break;
}
if (ch1) {
cout << "1"
<< "\n";
continue;
}
if (s[0][0] == 'A' || (s[0][c - 1] == 'A') || s[r - 1][0] == 'A' ||
s[r - 1][c - 1] == 'A') {
cout << "2"
<< "\n";
continue;
}
for (i = 0; i < r; i++) {
long long tmp = 1;
for (j = 0; j < c; j++)
if (s[i][j] != 'A') {
tmp = 0;
break;
}
if (tmp == 1) {
ch2 = 0;
break;
}
}
if (ch2 == 0) {
cout << "2"
<< "\n";
continue;
}
ch2 = 1;
for (i = 0; i < c; i++) {
long long tmp = 1;
for (j = 0; j < r; j++)
if (s[j][i] != 'A') {
tmp = 0;
break;
}
if (tmp == 1) {
ch2 = 0;
break;
}
}
if (ch2 == 0) {
cout << "2"
<< "\n";
continue;
}
ch3 = 0;
for (i = 0; i < r; i++)
if (s[i][0] == 'A' || s[i][c - 1] == 'A') {
ch3 = 1;
continue;
}
for (i = 0; i < c; i++)
if (s[0][i] == 'A' || s[r - 1][i] == 'A') {
ch3 = 1;
continue;
}
if (ch3) {
cout << "3"
<< "\n";
continue;
}
long long chm = 0;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++)
if (s[i][j] == 'A') {
chm = 1;
break;
}
if (chm == 1) break;
}
if (chm)
cout << "4"
<< "\n";
else
cout << "MORTAL"
<< "\n";
}
}
| 5 |
#define _CRT_SECURE_NO_WARNINGS
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iostream>
#include <vector>
#include <cstdio>
#include <map>
#include <set>
using namespace std;
//-----------------------------------------------
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
#define sq(x) (x) * (x)
#define fr first
#define sc second
//-----------------------------------------------
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pli = pair<ll, int>;
const int N = 200 * 1000 + 5;
const ll mod = 1000000007;
const ll mod3 = 998244353;
const ll INFL = 1000000000 * 1ll * 1000000000 + 500000;
const ll INF = 1000000000;
const ld pi = acosl(-1.0);
int n;
void input() {
cin >> n;
}
void solve(int testId) {
if (n == 1) {
cout << 0 << endl;
}
else if (n == 2) {
cout << 1 << endl;
}
else if (n == 3) {
cout << 2 << endl;
}
else {
cout << 2 + n % 2 << endl;
}
}
int main() {
int testcases = 1;
scanf("%d", &testcases);
for (int testId = 1; testId <= testcases; testId++) {
input();
solve(testId);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
struct seg {
double x, y, theta;
seg() {}
seg(double _x, double _y, double _theta) {
x = _x;
y = _y;
theta = _theta;
while (theta < 0) theta += 2 * PI;
while (theta > 2 * PI) theta -= 2 * PI;
}
seg operator+(seg s) {
double cs = cos(theta);
double sn = sin(theta);
double sx = s.x * cs - s.y * sn;
double sy = s.x * sn + s.y * cs;
return seg(x + sx, y + sy, theta + s.theta);
}
} s[4 * 300010];
int n, m;
void init(int i, int l, int r) {
if (l == r) {
s[i] = seg(1, 0, 0);
return;
}
int mid = (l + r) / 2;
init(2 * i, l, mid);
init(2 * i + 1, mid + 1, r);
s[i] = s[2 * i] + s[2 * i + 1];
}
void extend(int i, int l, int r, int pos, double len) {
if (l > pos || r < pos) return;
if (l == r) {
double curlen = hypot(s[i].x, s[i].y);
len += curlen;
s[i].x *= len / curlen;
s[i].y *= len / curlen;
return;
}
int mid = (l + r) / 2;
extend(2 * i, l, mid, pos, len);
extend(2 * i + 1, mid + 1, r, pos, len);
s[i] = s[2 * i] + s[2 * i + 1];
}
void rotate(int i, int l, int r, int pos, double angle) {
if (l > pos || r < pos) return;
if (l == r) {
double curlen = hypot(s[i].x, s[i].y);
s[i].theta += angle;
while (s[i].theta < 0) s[i].theta += 2 * PI;
while (s[i].theta > 2 * PI) s[i].theta -= 2 * PI;
s[i].x = curlen * cos(s[i].theta);
s[i].y = curlen * sin(s[i].theta);
return;
}
int mid = (l + r) / 2;
rotate(2 * i, l, mid, pos, angle);
rotate(2 * i + 1, mid + 1, r, pos, angle);
s[i] = s[2 * i] + s[2 * i + 1];
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
init(1, 1, n);
while (m--) {
int x, y, z;
cin >> x >> y >> z;
if (x == 1) {
extend(1, 1, n, y, z);
} else {
double theta = -PI / 180 * z;
rotate(1, 1, n, y, theta);
}
cout << fixed << setprecision(8);
cout << s[1].x << ' ' << s[1].y << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 10000000;
string suff[205], pref[205], fib[205], mid[205];
void init() {
fib[1] = suff[1] = pref[1] = "0";
fib[2] = suff[2] = pref[2] = "1";
int done = 0;
for (int i = 3; i <= 201; i++) {
if (!done) {
fib[i] = fib[i - 2] + fib[i - 1];
pref[i] = fib[i];
suff[i] = fib[i];
} else {
suff[i] = suff[i - 1];
pref[i] = pref[i - 2];
}
if (fib[i].size() > 400) done = 1;
}
}
long long kmp(string &t, string &s) {
s = t + "%" + s;
int n = s.size(), m = t.size();
vector<int> p(n, 0);
long long ans = 0;
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 and s[j] != s[i]) {
j = p[j - 1];
}
if (s[j] == s[i]) j++;
p[i] = j;
if (p[i] == m) ans++;
}
return ans;
}
long long occur(string &t, int n) {
vector<long long> com(n + 1, 0);
int m = t.size();
if (m > 1) {
for (int i = 2; i <= n; i++) {
int sz = suff[i - 1].size();
string common = suff[i - 1].substr(max(sz - (m - 1), 0), min(m - 1, sz)) +
pref[i].substr(0, min(m - 1, (int)pref[i].size()));
com[i] = kmp(t, common);
}
}
vector<long long> dp(n + 2, 0);
if (t == "0") dp[1] = 1;
if (t == "1") dp[2] = 1;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2] + com[i - 1];
dp[i] = min(INF, dp[i]);
}
return dp[n];
}
bool eq(string &s, string &t) {
if (s.size() < t.size()) return 0;
for (int i = s.size() - 1, j = t.size() - 1; i >= 0, j >= 0; i--, j--) {
if (s[i] != t[j]) return 0;
}
return 1;
}
int main() {
init();
int n, m;
long long k;
cin >> n >> k >> m;
n++;
string res;
for (int i = 1; i <= m; i++) {
res.push_back('0');
long long cnt = occur(res, n);
if (cnt < k) {
k -= cnt;
res.pop_back();
res.push_back('1');
}
k -= eq(suff[n], res);
if (!k) {
cout << res << "\n";
return 0;
}
}
cout << res << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename... T>
void print1(T... t) {
((cout << t << " "), ...);
}
template <typename... T>
void print2(T... t) {
vector<vector<long long>> ans = {t...};
for (long long i = 0; i < (long long)ans.size(); i++) {
if (i != 0)
cout << "\t\t";
else
cout << "\t";
for (long long j = 0; j < (long long)ans[i].size(); j++) {
cout << ans[i][j] << " ";
}
if (i != (long long)ans.size() - 1) cout << endl;
}
}
template <typename T>
void printV(T vec) {
for (int i = 0; i < (long long)vec.size(); i++)
cout << vec[i] << " " << flush;
cout << endl;
}
const int INF = 1e9 + 5;
template <typename T>
void itR(T map) {
for (auto itr = map.begin(); itr != map.end(); itr++) {
cout << " [ "
"itr->first, itr->second"
<< " : ";
print1(itr->first, itr->second);
cout << "]" << endl;
;
}
cout << endl;
}
long long solve() {
long long n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
long long dp[n1 + 1][n2 + 1][2];
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
dp[0][0][1] = 1;
for (long long i = 0; i <= n1; i++) {
for (long long j = 0; j <= n2; j++) {
if (i == 0 and j == 0) {
dp[i][j][0] = 1;
dp[i][j][1] = 1;
} else {
for (long long temp = 1; temp <= min(i, k1); temp++) {
dp[i][j][0] += dp[i - temp][j][1] % 100000000;
}
for (int temp = 1; temp <= min(j, k2); temp++) {
dp[i][j][1] += dp[i][j - temp][0] % 100000000;
}
}
}
}
return (dp[n1][n2][0] + dp[n1][n2][1]) % 100000000;
}
int main() {
cout << setprecision(50);
ios::sync_with_stdio(0);
cin.tie(0);
long long ans = solve();
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long L, H, b;
double a;
void work() {
if (L > H) swap(L, H);
if (b > 90) b = 180 - b;
a = b * acos(-1.0) / 180.0;
double tan = 2 * atan(double(L) / double(H));
if (tan <= a) {
double p = L / sin(a);
printf("%.15lf\n", L * p);
return;
}
double x = cos(a) + 1, y = sin(a);
double det = x * x - y * y, p1 = x * L - y * H, p2 = x * H - y * L;
double A = p1 / det, B = p2 / det;
x -= 1.0;
double s = L * H - A * x * y * A - B * B * x * y;
printf("%.15lf\n", s);
}
int main() {
while (cin >> L >> H >> b) work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
struct dta {
int t, d, p, id;
};
using namespace std;
bool operator<(const dta &x, const dta &y) {
return (x.d < y.d || (x.d == y.d && x.t < y.t));
}
int n, trace[110][110 * 20], F[110][110 * 20], res;
dta A[110];
vector<int> resa;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &A[i].t, &A[i].d, &A[i].p);
for (int i = 1; i <= n; i++) A[i].id = i;
sort(A + 1, A + 1 + n);
memset(trace, 0, sizeof(trace));
memset(F, 0, sizeof(F));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= A[i].d - 1; j++) {
F[i][j] = F[i - 1][j];
trace[i][j] = j;
if (j - A[i].t >= 0 && F[i - 1][j - A[i].t] + A[i].p > F[i][j]) {
F[i][j] = F[i - 1][j - A[i].t] + A[i].p;
trace[i][j] = j - A[i].t;
}
}
int tmax = 0;
res = 0;
for (int i = 1; i <= A[n].d; i++) {
if (tmax < F[n][i]) tmax = F[n][i], res = i;
}
int xcur = n, ycur = res;
while (xcur > 0) {
if (trace[xcur][ycur] != ycur) resa.push_back(A[xcur].id);
ycur = trace[xcur][ycur];
xcur--;
}
printf("%d\n%d\n", tmax, resa.size());
if (!resa.empty()) {
reverse(resa.begin(), resa.end());
for (int i = 0; i <= resa.size() - 1; i++) printf("%d ", resa[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
const int INF = 1000000000;
const long long MOD = 1000000000 + 7;
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << a + b;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int menor = 10000;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
if (k % tmp == 0) {
menor = (k / tmp < menor) ? k / tmp : menor;
}
}
cout << menor << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int n,m,a[7],b[7],c[7][7],i,p[7],j;
int f[7][15625];
struct str{
int p[7],c;
};
vector<str> g[7];
void dfs(int x,int i,int s,int w)
{
if(i>m)
{
if(s)
return;
str tmp;
memset(tmp.p,0,sizeof(tmp.p));
int i;
for(i=1;i<=m;++i)
tmp.p[i]=p[i];
tmp.c=w;
g[x].push_back(tmp);
return;
}
int j;
p[i]=0;
dfs(x,i+1,s,w);
for(j=1;j<=s;++j)
{
p[i]=j;
dfs(x,i+1,s-j,w+c[x][i]);
}
}
int DP(int i,int e)
{
if(i>n)
return 0;
if(f[i][e]!=-1)
return f[i][e];
f[i][e]=1<<30;
int j,p[7],tp=e;
for(j=m;j>=1;--j)
{
p[j]=tp%5;
tp/=5;
}
for(auto it:g[i])
{
int ss=0;
for(j=1;j<=m;++j)
{
if(p[j]+it.p[j]>b[j])
break;
ss=ss*5+p[j]+it.p[j];
}
if(j>m)
f[i][e]=min(f[i][e],DP(i+1,ss)+it.c);
}
return f[i][e];
}
int main()
{
scanf("%d %d",&n,&m);
for(i=1;i<=n;++i)
scanf("%d",&a[i]);
for(i=1;i<=m;++i)
scanf("%d",&b[i]);
for(i=1;i<=n;++i)
for(j=1;j<=m;++j)
scanf("%d",&c[i][j]);
for(i=1;i<=n;++i)
dfs(i,1,a[i],0);
memset(f,-1,sizeof(f));
cout<<(DP(1,0)<(1<<30)?DP(1,0):-1);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, sum1, sum2, num1, num2;
int main() {
cin >> n >> m;
sum1 = n;
sum2 = m;
while (sum1 != 0 && sum2 != 0) {
if (sum1 >= 2 * sum2) {
num1 = sum1 / (2 * sum2);
sum1 -= num1 * (2 * sum2);
} else if (sum2 >= 2 * sum1) {
num2 = sum2 / (2 * sum1);
sum2 -= num2 * (2 * sum1);
} else
break;
}
cout << sum1 << " " << sum2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
void solve() {
long long int n, k, x;
cin >> n;
string s[n - 2];
vector<long long int> a(7);
for (long long int i = 0; i < n - 2; i++) {
cin >> s[i];
}
bool ok = 0;
for (long long int i = 1; i < n - 2; i++) {
if (s[i][0] == s[i - 1][1]) {
continue;
} else {
ok = 1;
k = i - 1;
break;
}
}
if (!ok) {
for (long long int i = 0; i < n - 3; i++) {
cout << s[i][0];
}
cout << s[n - 3][0] << s[n - 3][1];
cout << 'a' << "\n";
} else {
for (long long int i = 0; i <= k; i++) {
cout << s[i][0];
}
cout << s[k][1];
for (long long int i = k + 1; i < n - 3; i++) {
cout << s[i][0];
}
cout << s[n - 3][0] << s[n - 3][1] << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010];
long long cant[100010];
long long k, n;
bool isinclude(long long mid) {
vector<long long> v(100003, 0);
vector<long long> w(100003, 0);
if (mid - k >= n - k - mid) {
for (long long i = k; i < mid; i++) v[a[i]]++;
for (long long i = mid; i < n - k; i++) w[a[i]]++;
bool contenido = 1;
for (long long i = 0; i < 100003; i++)
if (w[i] > v[i]) {
contenido = 0;
break;
}
return contenido;
}
bool todook = 1;
bool morado = 1;
for (long long i = n - k - 1; i >= n - mid; i--) w[a[i]]++;
for (long long i = k; i <= mid - 1; i++) v[a[i]]++;
for (long long i = mid; i < n - mid; i++)
if (i < n - 1 - i && a[i] != a[n - 1 - i]) todook = 0;
for (long long i = 0; i < 100003; i++)
if (v[i] != w[i]) morado = 0;
return morado && todook;
}
bool isinclude_2(long long mid) {
vector<long long> v(100003, 0);
vector<long long> w(100003, 0);
if (n - k - mid - 1 >= mid - k + 1) {
for (long long i = k; i <= mid; i++) v[a[i]]++;
for (long long i = mid + 1; i < n - k; i++) w[a[i]]++;
bool contenido = 1;
for (int i = 0; i < 100003; i++)
if (v[i] > w[i]) {
contenido = 0;
break;
}
return contenido;
}
bool todobom = 1;
bool morado = 1;
for (long long i = k; i < n - mid - 1; i++) v[a[i]]++;
for (long long i = mid + 1; i < n - k; i++) w[a[i]]++;
for (long long i = n - mid; i < mid; i++)
if (i < n - 1 - i && a[i] != a[n - 1 - i]) todobom = 0;
for (long long i = 0; i < 100003; i++)
if (v[i] != w[i]) {
morado = 0;
break;
}
return morado && todobom;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
k = 0;
for (long long i = 0; i < n; i++) {
if (i < n - 1 - i && a[i] == a[n - 1 - i])
k = i + 1;
else
break;
}
bool es = 1;
bool okini = 1;
for (long long i = k; i < n - k; i++) cant[a[i]]++;
long long total = 0;
for (long long i = 0; i < 100010; i++)
if (cant[i] % 2 == 1) total++;
if (total >= 2) es = 0;
long long ans1 = 0;
long long ans2 = 0;
long long lo1 = k, hi1 = n - k - 1;
while (lo1 < hi1) {
long long mid = (lo1 + hi1) / 2;
if (isinclude(mid))
hi1 = mid;
else
lo1 = mid + 1;
}
ans1 = n - lo1 - k + 1;
long long lo2 = k, hi2 = n - k - 1;
while (lo2 < hi2) {
long long mid = (lo2 + hi2 + 1) / 2;
if (isinclude_2(mid))
lo2 = mid;
else
hi2 = mid - 1;
}
ans2 = lo2 - k + 2;
long long res = 0;
if (es) res = (ans1 + ans2 - 1) + k * (ans1 + ans2) + k * k;
if ((n - 2 * k) <= 1) res = n * (n + 1) / 2;
cout << res << endl;
return 0;
}
| 8 |
#include <iostream>
#include <cstring>
#include <vector>
#include <list>
#include <set>
using namespace std;
const int MAXN = 500 + 10;
const int MOD = 998244353;
int cnt[MAXN];
void merase(list<vector<int>> &x, const list<vector<int>>::iterator &val) {
vector<int> temp = *val;
for (auto i = x.begin(); i != x.end();) {
bool flag = true;
for (int j = 0; j < (*i).size(); ++j) {
if (temp[j] == (*i)[j]) {
i = x.erase(i);
flag = false;
break;
}
}
if (flag) ++i;
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n, ans = 1;
set<int> ans_num;
list<vector<int> > input;
cin >> n;
for (int i = 0; i < n << 1; ++i) {
input.push_back(vector<int>(n + 1));
input.back()[0] = i + 1;
for (int j = 1; j <= n; ++j) {
cin >> input.back()[j];
}
}
for (int num = 0; num < n; ++num) {
for (int i = 1; i <= n; ++i) {
int flag = 0;
memset(cnt, 0, sizeof(cnt));
for (auto j = input.begin(); j != input.end(); ++j) {
++cnt[(*j)[i]];
}
for (int j = 1; j <= n; ++j) {
if (cnt[j] == 1) {
flag = j;
break;
}
}
if (flag) {
for (auto j = input.begin(); j != input.end(); ++j) {
if ((*j)[i] == flag) {
ans_num.insert((*j)[0]);
merase(input, j);
break;
}
}
break;
}
}
if (ans_num.size() != num + 1) {
ans = (ans << 1) % MOD;
ans_num.insert(input.front()[0]);
merase(input, input.begin());
}
}
cout << ans << endl;
for (auto i : ans_num) cout << i << " ";
cout << endl;
}
// system("pause");
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
string St;
int n, p[maxn], ch[maxn];
bool mark[maxn];
int bj[maxn];
void Prework() {
memset(mark, 0, sizeof(mark));
for (int i = 2; i != maxn; i++)
if (!mark[i]) {
for (int j = i + i; j < maxn; j += i) mark[j] = true;
}
mark[2] = true;
for (int i = n; i > 2; i--)
if (!mark[i] && i * 2 <= n) mark[i] = true;
}
int main() {
cin >> St;
n = St.length();
Prework();
memset(ch, 0, sizeof(ch));
memset(bj, 0, sizeof(bj));
for (int i = 0; i != n; i++) ++ch[St[i] - 'a'];
bool ans = false;
int sum = 0, now = 0;
for (int i = 0; i != n; i++) sum += mark[i + 1];
for (int k = 0; k != 26; k++)
if (ch[k] >= sum) {
printf("YES\n");
ch[k] -= sum;
for (int i = 1; i <= n; i++)
if (mark[i])
printf("%c", 'a' + k);
else {
while (ch[now] == 0 && now < 26) now++;
printf("%c", 'a' + now);
--ch[now];
}
printf("\n");
ans = true;
break;
}
if (!ans) printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, m, x, y;
cin >> n >> d >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
if ((y <= -x + 2 * n - d) && (y >= -x + d) && (y <= x + d) &&
(y >= x - d)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, n, m, it = 0, ar[26], flag = -1, cnt = 0;
cin >> n;
int ans = 0;
char c;
string second;
for (i = 0; i < 26; i++) ar[i] = 1;
for (i = 0; i < n; i++) {
cin >> c >> second;
if (i == n - 1) break;
if (flag == 1) {
if (c != '.') ans++;
continue;
}
if (c == '.')
for (j = 0; j < second.size(); j++) ar[second[j] - 'a'] = 0;
else if (c == '!') {
map<int, bool> mapp;
for (j = 0; j < second.size(); j++) mapp[second[j] - 'a'] = 1;
for (j = 0; j < 26; j++)
if (ar[j] == 1 && mapp[j])
;
else
ar[j] = 0;
} else
ar[second[0] - 'a'] = 0;
int cnt = 0;
for (j = 0; j < 26; j++) cnt += ar[j];
if (cnt == 1) flag = 1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 3;
vector<long long> p;
bool vis[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (int i = 2; i <= N; i++) {
if (vis[i]) continue;
p.push_back(i);
for (int j = 2 * i; j <= N; j += i) {
vis[j] = true;
}
}
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long x = (long long)sqrt(n);
int it = upper_bound(p.begin(), p.end(), x) - p.begin();
int it1 = upper_bound(p.begin(), p.end(), n) - p.begin();
it1;
cout << it1 - it + 1;
cout << "\n";
}
return 0;
}
| 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;
long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
long long int ans[n + 1][3];
ans[0][0] = ans[0][2] = ans[0][1] = 0;
for (int i = 0; i < n; i++) {
ans[i + 1][0] = max(ans[i][1], ans[i][2]);
ans[i + 1][1] =
max(ans[i][0], ans[i][2]) + ((arr[i] == 1 || arr[i] == 3) ? 1 : 0);
ans[i + 1][2] =
max(ans[i][0], ans[i][1]) + ((arr[i] == 2 || arr[i] == 3) ? 1 : 0);
}
cout << n - max({ans[n][0], ans[n][1], ans[n][2]}) << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool compare(const pair<int, int>& i, const pair<int, int>& j) {
return i.second < j.second;
}
bool isPrime(long long int j) {
if (j == 2) return true;
if (j % 2 == 0) return false;
for (long long int i = 3; i * i <= j; i = i + 2)
if (j % i == 0) return false;
return true;
}
bool isSubSequence(string str1, string str2, int m, int n) {
int j = 0;
for (int i = 0; i < n && j < m; i++)
if (str1[j] == str2[i]) j++;
return (j == m);
}
long long int exponentiation(long long int base, long long int exp) {
if (exp == 0) return 1;
if (exp == 1) return base % 998244353;
long long int t = exponentiation(base, exp / 2);
t = (t * t) % 998244353;
if (exp % 2 == 0)
return t;
else
return ((base % 998244353) * t) % 998244353;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int arr[n];
long long int o = 0, e = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] % 2 == 0)
e++;
else
o++;
}
if (e > o) {
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 1) {
cout << i + 1;
break;
}
}
} else {
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 0) {
cout << i + 1;
break;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<pair<int, int>> res;
string s2;
int n2 = n - 2 * (k - 1);
for (int i = 0; i < 2 * (k - 1); ++i) {
if (i % 2) {
s2.push_back(')');
} else {
s2.push_back('(');
}
}
for (int i = 0; i < n2; ++i) {
if (i < n2 / 2) {
s2.push_back('(');
} else {
s2.push_back(')');
}
}
for (int i = 0; i < n; ++i) {
if (s[i] != s2[i]) {
for (int j = i + 1; j < n; ++j) {
if (s[j] == s2[i]) {
reverse(s.begin() + i, s.begin() + j + 1);
res.push_back({i, j});
break;
}
}
}
}
cout << res.size() << "\n";
for (const auto &p : res) {
cout << p.first + 1 << " " << p.second + 1 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string ss, s, temp, s1, s2;
int main() {
cin >> s1 >> s2 >> s;
ss = s;
for (int i = 0; i < (int)s.size(); i++)
for (int j = 0; j < 26; j++) {
s[i] = tolower(s[i]);
if (s[i] == s1[j]) {
if (isupper(ss[i])) {
s[i] = toupper(s2[j]);
cout << s[i];
} else
cout << s2[j];
break;
} else if (isdigit(ss[i])) {
cout << ss[i];
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d;
long long calc(long long x) {
if (x < 0) return 0;
long long ret = (d - 1) * b * (x + 1);
ret += (x * (x + 1) / 2) * d * b;
ret -= (x + 1) * a;
return -ret;
}
int main() {
int testcase;
scanf("%d", &testcase);
while (testcase--) {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
if (c < d) {
if (a <= b * c) {
printf("%lld\n", a);
} else {
printf("-1\n");
}
} else {
long long x = c / d - 1;
long long y = c % d + 1;
long long temp = (d - 1) * b + y * b + x * b * d;
if (temp < a) {
printf("-1\n");
} else {
long long le = 0;
long long ri = x;
long long ans = -1;
while (le <= ri) {
long long mid = (le + ri) / 2;
if (mid * b * d + (d - 1) * b <= a) {
ans = mid;
le = mid + 1;
} else {
ri = mid - 1;
}
}
if (ans == -1)
printf("%lld\n", a);
else {
printf("%lld\n", max(calc(ans) + max(0ll, a - (ans + 1) * b),
calc(ans - 1) + max(0ll, a - ans * b)));
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long inf = 2e9;
void solve() {
long long n;
cin >> n;
vector<long long> m(n);
for (long long i = 0; i < n; ++i) {
cin >> m[i];
}
vector<long long> L(n, -1), R(n, n);
vector<long long> vec;
for (long long i = 0; i < n; ++i) {
while (vec.size() > 0 && m[vec.back()] > m[i]) {
vec.pop_back();
}
if (vec.size() > 0) L[i] = vec.back();
vec.push_back(i);
}
vec.clear();
for (long long i = n - 1; i >= 0; --i) {
while (vec.size() > 0 && m[vec.back()] > m[i]) {
vec.pop_back();
}
if (vec.size() > 0) R[i] = vec.back();
vec.push_back(i);
}
vector<long long> l(n, 0), r(n, 0);
long long min_el = inf;
for (long long i = 0; i < n; ++i) {
if (m[i] < min_el) {
l[i] = (i + 1) * m[i];
min_el = m[i];
} else {
l[i] = l[L[i]] + (i - L[i]) * m[i];
}
}
min_el = inf;
for (long long i = n - 1; i >= 0; --i) {
if (m[i] < min_el) {
r[i] = (n - i) * m[i];
min_el = m[i];
} else {
r[i] = r[R[i]] + (n - i - (n - R[i])) * m[i];
}
}
long long best = 0;
for (long long i = 0; i < n; ++i) {
if (l[i] + r[i] - m[i] > l[best] + r[best] - m[best]) {
best = i;
}
}
vector<long long> ans(n, 0);
ans[best] = m[best];
min_el = m[best];
for (long long i = best + 1; i < n; ++i) {
if (m[i] > min_el) {
ans[i] = min_el;
} else {
ans[i] = m[i];
min_el = m[i];
}
}
min_el = m[best];
for (long long i = best - 1; i >= 0; --i) {
if (m[i] > min_el) {
ans[i] = min_el;
} else {
ans[i] = m[i];
min_el = m[i];
}
}
for (auto i : ans) cout << i << ' ';
cout << '\n';
}
signed main() {
fastio();
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<int> a;
vector<int> b;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.insert(x);
}
set<int>::iterator i = a.begin();
for (; i != a.end(); i++) {
b.push_back((*i));
}
if (b[0] > 1) {
cout << 1;
return 0;
} else {
for (int i = 0; i < b.size(); i++) {
if (b[i] + 1 != b[i + 1]) {
cout << b[i] + 1;
return 0;
}
if (i == b.size() - 1) {
cout << b[b.size() - 1] + 1;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct node {
int a, b, c, d;
} a[15], b[15];
int flag[20];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].a, &a[i].b);
if (a[i].a > a[i].b) swap(a[i].a, a[i].b);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &b[i].a, &b[i].b);
if (b[i].a > b[i].b) swap(b[i].a, b[i].b);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i].a == b[j].a && a[i].b != b[j].b) {
flag[a[i].a] = 1;
a[i].c = 1;
b[j].c = 1;
}
if (a[i].a != b[j].a && a[i].b == b[j].b) {
flag[a[i].b] = 1;
a[i].d = 1;
b[j].d = 1;
}
if (a[i].a == b[j].b && a[i].b != b[j].a) {
flag[a[i].a] = 1;
a[i].c = 1;
b[j].d = 1;
}
if (a[i].b == b[j].a && a[i].a != b[j].b) {
flag[a[i].b] = 1;
a[i].d = 1;
b[j].c = 1;
}
}
}
int cnt = 0;
for (int i = 0; i <= 9; i++) cnt += flag[i];
for (int i = 1; i <= n; i++)
if (a[i].c && a[i].d) {
ans = -1;
break;
}
for (int i = 1; i <= m; i++)
if (b[i].c && b[i].d) {
ans = -1;
break;
}
if (ans != -1) {
if (cnt != 1)
printf("0\n");
else
for (int i = 0; i <= 9; i++)
if (flag[i]) {
printf("%d\n", i);
break;
}
} else
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j;
cin >> n;
map<long long, long long> mk;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
mk[a[i]] = 1;
}
cin >> m;
long long b[m];
for (i = 0; i < m; i++) {
cin >> b[i];
mk[b[i]] = 1;
}
long long flag = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
long long s = a[i] + b[j];
if (mk[s] != 1) {
flag = 1;
cout << a[i] << " " << b[j] << endl;
break;
}
}
if (flag == 1) break;
}
}
| 0 |
#include <bits/stdc++.h>
long long power(long long a, long long b, long long mod);
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 5;
int n, k;
long long S;
int a[N];
long long ans;
long long pro[20];
int num;
map<long long, long long> ma[30];
void INIT() {
ans = 0;
for (int i = 0; i <= k; i++) ma[i].clear();
}
void dfs(int pos, long long sum, int use, int op) {
if (op == 1) {
if (pos > num) {
ma[use][sum]++;
} else {
dfs(pos + 1, sum, use, op);
if (sum + a[pos] <= S) dfs(pos + 1, sum + a[pos], use, op);
if (a[pos] <= 18 && sum + pro[a[pos]] <= S && use + 1 <= k)
dfs(pos + 1, sum + pro[a[pos]], use + 1, op);
}
} else {
if (pos == num) {
ans += ma[k - use][S - sum];
} else {
dfs(pos - 1, sum, use, op);
if (sum + a[pos] <= S) dfs(pos - 1, sum + a[pos], use, op);
if (a[pos] <= 18 && sum + pro[a[pos]] <= S && use + 1 <= k)
dfs(pos - 1, sum + pro[a[pos]], use + 1, op);
}
}
}
void solve() {
INIT();
for (int i = 1; i <= n; i++) cin >> (a[i]);
num = n / 2;
dfs(1, 0, 0, 1);
for (int i = 0; i <= k - 1; i++) {
for (auto t : ma[i]) {
ma[i + 1][t.first] += t.second;
}
}
dfs(n, 0, 0, 2);
cout << (ans) << '\n';
}
int main() {
ios::sync_with_stdio(false);
pro[0] = 1;
for (int i = 1; i <= 18; i++) pro[i] = pro[i - 1] * i;
while (cin >> n >> k >> S) {
solve();
}
return 0;
}
long long power(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % mod;
a = a * a % mod;
b = b / 2;
}
return ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, m1, h2, m2;
scanf("%d:%d", &h1, &m1);
scanf("%d:%d", &h2, &m2);
int a = m2 - m1, b = h2 - h1, t = (b * 60 + a) / 2,
h = h1 + t / 60 + (m1 + t % 60) / 60, m = (m1 + t % 60) % 60;
if (h < 10) cout << 0;
cout << h << ":";
if (m < 10) cout << 0;
cout << m;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, sum, a[100005], pos, ans;
bool check(long long mid) {
long long cnt = 1LL, ope = mid, tot = mid;
for (int i = 1; i <= pos; i++) {
ope--;
tot--;
if (ope <= 0) ope = tot, cnt++;
if (ope >= a[i])
ope -= a[i];
else {
cnt += (a[i] - ope) / tot + ((a[i] - ope) % tot == 0LL ? 0LL : 1LL);
ope = (tot - (a[i] - ope) % tot) % tot;
}
if (cnt > k) return false;
}
return true;
}
int main(void) {
scanf("%I64d%I64d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
if (a[i]) pos = i;
}
long long l = pos + 1, r = 1000000000000000LL;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
r = mid - 1, ans = mid;
} else {
l = mid + 1;
}
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[20], s[20], n, minimum, maximum, diff, contor;
int succesor(int k) {
if (s[k] < 1) {
s[k]++;
return 1;
}
return 0;
}
int solutie(int k) { return k == n; }
void determina(int k) {
int minn = INT_MAX, maxx = INT_MIN, suma = 0;
for (int i = 1; i <= k; i++) {
if (s[i] == 1) {
suma += v[i];
minn = min(minn, v[i]);
maxx = max(maxx, v[i]);
}
}
if (suma >= minimum && suma <= maximum && (maxx - minn) >= diff) {
contor++;
}
}
void back(int k) {
s[k] = -1;
while (succesor(k))
if (solutie(k)) {
determina(k);
if (k < n) back(k + 1);
} else
back(k + 1);
}
int main() {
cin >> n >> minimum >> maximum >> diff;
for (int i = 1; i <= n; i++) cin >> v[i];
back(1);
cout << contor;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isperfect(long long n) {
long long y = sqrt(n);
if (n % y == 0 && y * y == n) return true;
return false;
}
bool comp(int a, int b) { return a > b; }
long long powi(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a;
b = b >> 1;
a = a * a;
}
return ans;
}
bool isprime(long long n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
bool prime[10000000];
void seive() {
prime[1] = true;
for (int i = 2; i * i < 10000000; i++) {
if (prime[i]) continue;
for (int j = i * i; j < 10000000; j += i) {
prime[j] = true;
}
}
}
bool ispalin(long long n) {
long long ans = 0;
int i = n;
while (n > 0) {
int k = n % 10;
ans = 10 * ans + k;
n = n / 10;
}
return (i == ans);
}
long long rev(long long n) {
long long t = 1;
while (t <= n) t *= 10;
return (t - 1 - n) * n;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long l, r;
cin >> l >> r;
long long ans = max(rev(l), rev(r));
long long repeat = 5;
for (int i = 0; i < 9; i++) {
if (l <= repeat && repeat <= r) {
ans = max(ans, rev(repeat));
}
repeat *= 10;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int a[3];
cin >> a[0] >> a[1] >> a[2];
int ans = a[0] / 3 + a[1] / 3 + a[2] / 3;
if (a[0] * a[1] * a[2] == 0) {
cout << ans;
return 0;
}
for (int(i) = (0); (i) <= (int)(2); (i)++) a[i] = a[i] % 3;
sort(a, a + 3);
if (a[0] != 0)
ans += min(a[0], a[1], a[2]);
else {
if (a[1] == 1)
ans += 0;
else if (a[1] == 2)
ans += 1;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dirX[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dirY[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const long long MOD = 998244353;
const long long mod = 1e9 + 7;
const long long N = 1e2 + 7;
const long long llinf = INT64_MAX;
const int intinf = INT32_MAX;
vector<pair<int, int> > v;
int n;
char arr[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) cin >> arr[i][j];
long long flag1 = 0, flag2 = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (arr[i][j] == '.') {
flag1++;
break;
}
}
}
for (long long j = 0; j < n; j++) {
for (long long i = 0; i < n; i++) {
if (arr[i][j] == '.') {
flag2++;
break;
}
}
}
if (flag1 < n && flag2 < n) return cout << -1, 0;
if (flag1 == n) {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (arr[i][j] == '.') {
v.push_back({i + 1, j + 1});
break;
}
}
}
} else if (flag2 == n) {
for (long long j = 0; j < n; j++) {
for (long long i = 0; i < n; i++) {
if (arr[i][j] == '.') {
v.push_back({i + 1, j + 1});
break;
}
}
}
}
for (auto e : v) {
cout << e.first << " " << e.second << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[1005] = {}, orig[1005];
bool bad[1005] = {};
vector<int> loc, l, r, resl, resr;
bool is_sorted() {
for (int i = 0; i + 1 < loc.size(); i++)
if (loc[i] > loc[i + 1]) return 0;
return 1;
}
bool arr_is_sorted() {
for (int i = 0; i < n; i++)
if (arr[i + 1] < arr[i]) return 0;
return 1;
}
void dfs(int depth) {
if (depth > 3) return;
if (is_sorted()) {
for (int i = 0; i < depth; i++) {
int a = find(arr, arr + n, l[i]) - arr,
b = find(arr, arr + n, r[i]) - arr;
if (a > b) swap(a, b);
for (int j = a; j <= (a + b) / 2; j++) swap(arr[j], arr[b - (j - a)]);
resl.push_back(a);
resr.push_back(b);
}
if (arr_is_sorted()) {
cout << depth << '\n';
while (resl.size()) {
cout << resl.back() << " " << resr.back() << '\n';
resl.pop_back();
resr.pop_back();
}
exit(0);
} else {
resl.clear();
resr.clear();
for (int i = 0; i <= n; i++) arr[i] = orig[i];
}
}
for (int i = 0; i < loc.size(); i++) {
for (int j = i + 1; j < loc.size(); j++) {
for (int k = i; k <= (i + j) / 2; k++) swap(loc[k], loc[j - (k - i)]);
l.push_back(loc[i]);
r.push_back(loc[j]);
dfs(depth + 1);
l.pop_back();
r.pop_back();
for (int k = i; k <= (i + j) / 2; k++) swap(loc[k], loc[j - (k - i)]);
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
n++;
arr[n] = n;
for (int i = 0; i <= n; i++) orig[i] = arr[i];
for (int i = 0; i < n; i++) {
if (abs(arr[i + 1] - arr[i]) != 1) {
bad[i] = 1;
bad[i + 1] = 1;
}
}
for (int i = 1; i < n; i++)
if (bad[i]) loc.push_back(arr[i]);
dfs(0);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a;
map<int, int> prime, dp;
int dfs(int state) {
if (state == 0) return 0;
if (dp.count(state)) return dp[state];
set<int> cur;
int res = 0, tmp = 0, mx = 0;
int mask = state;
for (int i = 29; i >= 0; i--) {
if ((state >> i) & 1) {
mx = i;
break;
}
}
for (int i = 0; i <= mx; i++) {
int nt = ((state >> (i + 1)) | tmp);
cur.insert(dfs(nt));
if ((state >> i) & 1) {
tmp |= (1 << i);
state ^= (1 << i);
}
}
while (cur.find(res) != cur.end()) res++;
return dp[mask] = res;
}
int main() {
int n, a;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
for (int j = 2; j * j <= a; j++) {
if (a % j == 0) {
int cnt = 0;
while (a % j == 0) {
cnt++;
a /= j;
}
prime[j] |= (1 << (cnt - 1));
}
}
if (a > 1) prime[a] |= 1;
}
int ans = 0;
for (auto its : prime) {
ans ^= dfs(its.second);
}
if (ans > 0)
printf("Mojtaba\n");
else
printf("Arpa\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, w, len, val[100005], c[100005];
double p[100005];
struct node {
double t1, t2;
bool operator<(const node &b) const {
return t1 == b.t1 ? t2 > b.t2 : t1 < b.t1;
}
} a[100005];
int ask(int x) {
int ret = 0;
while (x) {
ret += c[x];
x -= x & -x;
}
return ret;
}
void add(int x) {
while (x <= len) {
c[x]++;
x += x & -x;
}
}
int main() {
scanf("%d%d", &n, &w);
for (int x, v, i = 1; i <= n; i++) {
scanf("%d%d", &x, &v);
a[i] = (node){1.0 * (v - w) / x, 1.0 * (v + w) / x};
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) p[i] = a[i].t2;
sort(p + 1, p + 1 + n);
len = unique(p + 1, p + 1 + n) - p - 1;
for (int i = 1; i <= n; i++)
val[i] = lower_bound(p + 1, p + 1 + len, a[i].t2) - p;
long long ans = 0;
for (int i = n; i >= 1; i--) {
ans += ask(val[i]);
add(val[i]);
}
printf("%I64d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
long double x[100002], y[100002];
inline long double xl(register int a, register int b) {
if (x[b] == x[a]) return 1e18;
return (y[b] - y[a]) / (x[b] - x[a]);
}
inline long double F(register long double x) { return x > 0 ? x : -x; }
bool ia;
signed main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%d%d", &a, &b);
x[i] = a;
y[i] = b;
}
if (n & 1) {
puts("NO");
return 0;
}
x[n + 1] = x[1], y[n + 1] = y[1];
for (register int i = 1; i <= n / 2; ++i) {
if (F(xl(i, i + 1) - xl(i + n / 2, i + n / 2 + 1)) > 1e-12) {
puts("NO");
return 0;
}
if (F(y[i + 1] - y[i]) != F(y[i + n / 2 + 1] - y[i + n / 2])) {
puts("NO");
return 0;
}
if (F(x[i + 1] - x[i]) != F(x[i + n / 2 + 1] - x[i + n / 2])) {
puts("NO");
return 0;
}
}
puts("YES");
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MOD = 777777777;
const long long INF = 1e18;
const long long N = 77777 + 10;
int seg[4 * N][4][4];
int a[N];
bool isval[4][4];
vector<pair<int, int>> valid;
void update(int id, int lq, int rq, int x, int l, int r) {
if (lq >= r || rq <= l) return;
if (lq <= l && r <= rq) {
a[lq] = x;
memset(seg[id], 0, sizeof seg[id]);
if (a[lq] == 0) {
for (int i = 1; i <= 3; i++) {
seg[id][i][i] = 1;
}
} else {
seg[id][a[lq]][a[lq]] = 1;
}
return;
}
long long mid = ((l + r) >> 1);
update(id << 1, lq, rq, x, l, mid);
update(id << 1 | 1, lq, rq, x, mid, r);
memset(seg[id], 0, sizeof seg[id]);
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
for (pair<int, int> u : valid) {
seg[id][i][j] =
((1ll * seg[id << 1][i][u.first] * seg[id << 1 | 1][u.second][j]) +
seg[id][i][j]) %
MOD;
}
}
}
return;
}
int n, q;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cin >> isval[i][j];
if (isval[i][j]) valid.push_back({i, j});
}
}
for (int i = 1; i <= n; i++) {
update(1, i, i + 1, 0, 1, n + 1);
}
for (int i = 0; i < q; i++) {
long long ind, x;
cin >> ind >> x;
update(1, ind, ind + 1, x, 1, n + 1);
long long ans = 0;
for (int j = 1; j <= 3; j++) {
for (int j1 = 1; j1 <= 3; j1++) {
ans += seg[1][j][j1];
ans %= MOD;
}
}
cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct pkt {
int x, y;
};
const int INF = 1000000000;
int main() {
ios_base::sync_with_stdio(0);
int n, m, k;
cin >> n >> k;
vector<string> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
m = a[0].size();
pkt f[50][50][4][2];
vector<vector<bool> > odw(n, vector<bool>(m, false));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!odw[i][j] && a[i][j] != '0') {
int minix = i, maxix = i;
int miniy = j, maxiy = j;
while (maxix < n && a[maxix][j] == a[i][j]) ++maxix;
--maxix;
while (maxiy < m && a[i][maxiy] == a[i][j]) ++maxiy;
--maxiy;
for (int l = minix; l <= maxix; ++l) {
for (int o = miniy; o <= maxiy; ++o) {
odw[l][o] = true;
f[l][o][0][0] = {minix - 1, maxiy};
f[l][o][0][1] = {minix - 1, miniy};
f[l][o][1][0] = {maxix, maxiy + 1};
f[l][o][1][1] = {minix, maxiy + 1};
f[l][o][2][0] = {maxix + 1, miniy};
f[l][o][2][1] = {maxix + 1, maxiy};
f[l][o][3][0] = {minix, miniy - 1};
f[l][o][3][1] = {maxix, miniy - 1};
}
}
}
}
}
pkt akt = {0, 0};
int kier1 = 1, kier2 = 1;
for (int i = 0; i < k; ++i) {
pkt nast = f[akt.x][akt.y][kier1][kier2];
if (nast.x >= 0 && nast.x < n && nast.y >= 0 && nast.y < m &&
a[nast.x][nast.y] != '0')
akt = nast;
else {
if (kier2 == 1)
kier2 = 0;
else {
kier2 = 1;
kier1 = (kier1 + 1) % 4;
}
}
}
cout << a[akt.x][akt.y];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
string str;
cin >> str;
int len = str.size();
for (int i = 0; i < len; i++) {
for (int j = i + 1; j <= len; j++) {
string t = "";
for (int k = 0; k < i; k++) t += str[k];
for (int k = j; k < len; k++) t += str[k];
if (t == "CODEFORCES") {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const int N = 1e6 + 5;
const int L = 21;
int dp[L][N];
int pow2[N];
void pre() {
for (int i = 2; i < N; i++) {
dp[1][i] = 1;
}
for (int i = 1; i < L - 1; i++) {
for (int j = 2; j < N; j++) {
for (int k = j + j; k < N; k += j) {
dp[i + 1][k] += dp[i][j];
if (dp[i + 1][k] >= Mod) dp[i + 1][k] -= Mod;
}
}
}
pow2[0] = 1;
for (int i = 1; i < N; i++) {
pow2[i] = (pow2[i - 1] * 2) % Mod;
}
return;
}
int fact[N], ifact[N];
int binpow(int a, int n) {
if (n == 0) return 1;
int temp = binpow(a, n / 2);
temp = (temp * 1LL * temp) % Mod;
if (n & 1) return (temp * 1LL * a) % Mod;
return temp;
}
int inverseMod(int x) { return binpow(x, Mod - 2); }
void pre1() {
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (fact[i - 1] * 1LL * i) % Mod;
}
ifact[N - 1] = inverseMod(fact[N - 1]);
for (int i = N - 2; i >= 0; i--) {
ifact[i] = (ifact[i + 1] * 1LL * (i + 1)) % Mod;
}
}
inline int ncr(int n, int r) {
if (r >= 0 && r <= n) {
int ret = fact[n];
ret = (ret * 1LL * ifact[r]) % Mod;
ret = (ret * 1LL * ifact[n - r]) % Mod;
return ret;
}
return 0;
}
int get(int x, int y) {
if (x == 1) {
return pow2[y - 1];
}
int z = min(20, y);
long long ans = 0;
for (int k = 1; k <= z; k++) {
long long tmp = (ncr(y, k) * 1LL * dp[k][x]) % Mod;
tmp = (tmp * 1LL * pow2[y - 1]) % Mod;
ans = (ans + tmp) % Mod;
}
return (int)ans;
}
int main() {
pre();
pre1();
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
int ans = get(x, y);
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int main() {
cin >> n >> a >> b;
cout << min(n - a, b + 1);
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
#define REP( x,y ) for( int x=0; x<(y); ++x )
#define FORD( x,y,z ) for( int x=y; x>=(z); --x )
#define FOR(x,b,e) for( int x = b; x <= (e); ++x )
#define SIZE(v) (int)v.size()
#define ALL(c) c.begin(),c.end()
#define VAR(v,n) __typeof(n) v=(n)
#define FOREACH(i,c) for( VAR(i,c.begin());i!=c.end();++i )
#define PB push_back
#define MP make_pair
#define ST first
#define ND second
#define WRITE( V ){ FOREACH(it,V) cerr << *it << ", "; cerr << endl; }
#define DEBUG_NOW_AND_HERE true
#define DEBUG(x) if( DEBUG_NOW_AND_HERE ) cerr << #x << ": " << x << endl;
typedef long long LL;
typedef vector<int> VI;
typedef vector< VI > VVI;
typedef vector<VVI> VVVI;
typedef vector<double> VD;
typedef vector< VD > VVD;
typedef vector<bool> VB;
typedef vector< VB > VVB;
typedef pair<int,int> PII;
typedef vector<PII> VPII;
typedef vector<VPII> VVPII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class _T, class _E>
ostream& operator<<( ostream& str, const pair<_T,_E> & pair){
str << "(" << pair.first << "," << pair.second << ")";
return str;
}
template<class _T>
ostream& operator<<( ostream& str, const vector<_T> & vec ){
int ile = 0;
str << "{";
for( auto p : vec ){
if(ile > 0) str << ", ";
ile++;
str << p;
}
str << "}";
return str;
}
/*
void solve(){
int N, K;
cin >> N >> K;
VPII V(N);
VI H(N);
for(int i=0; i<N; i++){
cin >> H[i];
V[i].first = H[i];
V[i].second = i;
}
sort( ALL(V), [](PII a, PII b){return a.first>b.first;} );
DEBUG(V);
constexpr int INF = 1e9;
bool can = true;
VI h(N,-1);
for(int i=0; i<N; i++){
int x = V[i].second;
int m = INF;
int M = -1;
if(x>0 && h[x-1] != -1){
m = min( h[x-1], m );
M = max( h[x-1]+K-1,M );
}
if(x+1<N && h[x+1] != -1){
m = min( h[x+1], m );
M = max( h[x+1]+K-1,M );
}
DEBUG(m);
DEBUG(M);
if( M == -1 ){
h[x] = H[x];
cerr << "placing " << x << " on height " << h[x] << endl;
continue;
}
if( H[x] + 2*K-1 < m || H[x] > M+K-1 ){
can = false;
break;
}
else{
h[x] = max( H[x], m-K+1 );
h[x] = max( h[x], optymalizacja
)
}
cerr << "placing " << x << " on height " << h[x] << endl;
}
DEBUG(h);
DEBUG(H);
if( h[0] != H[0] || h.back() != H.back() ) can = false;
if(can) cout << "YES" << endl;
else cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int l_zest;
cin >> l_zest;
while(l_zest--){
solve();
}
return 0;
}*/
int N;
VI countCycles4(VVI& V ){
int N = V.size();
int E = 0;
for(auto& v : V) E += v.size();
E >>= 1;
int sq = sqrt(E);
sq >>= 2;
VI large, small;
VB inLarge(N,false);
for( int i=0; i<::N; i++ ){
if( V[i].size() >= sq ){
large.push_back(i);
inLarge[i] = true;
}
else small.push_back(i);
}
// number of cycles with one of the nodes in a large set.
long long res_large = 0;
// now check all pairs of large sets.
VB was(N,false);
VB to_check(N,true);
VI order = large;
order.insert(order.end(), ALL(small));
/**
* In this loop we count all cycles, that contain some 'large node'.
*/
for( int i=0; i<large.size(); i++ ){
int d = order[i];
for(int t : V[d]) if(to_check[t]){
was[t] = true;
}
for( int j=i+1; j<::N; j++ ){
int d2 = order[j];
int prev = -1;
for( int t : V[d2] ){
if( to_check[t] && was[t] ){
if(prev != -1){
return {d,prev,d2,t};
}
prev = t;
}
}
}
for(int t : V[d]) if(to_check[t]) was[t] = false;
to_check[d] = false;
}
// now calculate all cycles with all 4 small nodes
VVPII cnt(N);
for( int d : small ){
for( int i=0; i<V[d].size(); i++ ){
int t1 = V[d][i];
if(inLarge[t1]) continue;
for( int j=i+1; j<V[d].size(); j++ ){
int t2 = V[d][j];
if(inLarge[t2]) continue;
if(t1<t2) cnt[t1].emplace_back(t2,d);
else cnt[t2].emplace_back(t1,d);
}
}
}
// for(int i=0; i<N; i++) sort(ALL(cnt[i]));
VI prev(N,-1);
fill(ALL(was),false);
for( int i=0; i<N; i++ ){
for( PII p : cnt[i] ){
int a = p.first;
if( was[a] ) return {i,p.second, a,prev[a]};
was[a] = true;
prev[a] = p.second;
}
for(PII p : cnt[i]){
int a = p.first;
prev[a] = -1;
was[a] = false;
}
}
return {};
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int l_zest;
cin >> l_zest;
while(l_zest--){
cin >> N;
VVI V(N);
int S = 0;
for(int i=0; i<N; i++){
int k;
cin >> k;
S += k;
V[i] = VI(k);
for(int j=0; j<k; j++) cin >> V[i][j];
}
unordered_set<int> zb;
for(auto & v : V) zb.insert(v.begin(), v.end());
unordered_map<int,int> mapper;
int ccc = 0;
for(auto t : zb) mapper[t] = ccc++;
VVI W(N+ccc);
for( int i=0; i<V.size(); i++ ){
for( int &t : V[i] ){
t = mapper[t];
W[i].push_back(N+t);
W[N+t].push_back(i);
}
}
auto cyc = countCycles4(W);
if(cyc.empty()) cout << "-1" << endl;
else{
// DEBUG(cyc);
for(int d : cyc) if( d < N ) cout << d+1 << " ";
cout << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
vector<long long> pr;
vector<bool> er(x + 2, true);
er[1] = false;
for (long long i = 2; i < x + 2; i++) {
if (er[i]) {
pr.push_back(i);
for (long long j = i * i; j < x + 2; j += i) er[j] = false;
}
}
set<long long> x1;
long long y = x;
for (long long i = 0; i < pr.size(); i++) {
if (x % pr[i] == 0) {
for (long long j = x - pr[i] + 1; j <= x; j++) x1.insert(j);
}
}
long long ans = 1e18;
for (auto i = x1.begin(); i != x1.end(); i++) {
long long v = *i, y = *i;
for (long long p = 0; p < pr.size() && pr[p] * pr[p] <= y && v != 1; p++) {
if (v % pr[p] == 0) {
if (y - pr[p] + 1 >= 3) ans = min(ans, y - pr[p] + 1);
while (v % pr[p] == 0) {
v /= pr[p];
}
}
}
if (v != 1)
if (y - v + 1 >= 3) ans = min(ans, y - v + 1);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, nd, an, te, t1;
cin >> n;
t = n;
nd = an = 0;
t1 = 1;
while (t != 0) {
nd++;
te = t % 10;
if (te == 7) {
an += t1;
}
t1 *= 2;
t /= 10;
}
if (nd == 1) {
if (n == 4) {
cout << "1\n";
} else {
cout << "2\n";
}
} else {
int ans = 0;
int tw = 2;
for (int i = 1; i < nd; i++) {
ans += tw;
tw *= 2;
}
cout << ans + an + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e7 + 10;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> vis(n + 2);
vector<int> res(n + 2);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
vis[x]++;
}
int mi = 0, mx = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) {
i += 2;
mi++;
}
}
for (int i = 1; i <= n; i++) {
if (vis[i] >= 3)
res[i - 1] = res[i + 1] = res[i] = 1;
else if (vis[i] >= 2) {
if (res[i - 1] == 1)
res[i + 1] = res[i] = 1;
else
res[i - 1] = res[i] = 1;
} else if (vis[i] >= 1) {
if (res[i - 1] == 1 && res[i] == 1)
res[i + 1] = 1;
else if (res[i - 1] == 1)
res[i] = 1;
else
res[i - 1] = 1;
}
}
for (int i = 0; i <= n + 1; i++) mx += res[i];
cout << mi << " " << mx << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n == 2) {
cout << 2 << ' ' << 1 << ' ' << 2;
fflush(stdout);
return 0;
}
int x1 = 1;
int x2 = n;
int h;
while (x1 < x2) {
cout << 1 << ' ' << (x1 + x2) / 2 << ' ' << (x1 + x2) / 2 + 1 << endl;
fflush(stdout);
string t;
cin >> t;
if (t == "NIE") {
x1 = (x1 + x2) / 2 + 1;
} else {
x2 = (x1 + x2) / 2;
}
}
h = x2;
x1 = 1;
x2 = h;
while (x1 < x2) {
cout << 1 << ' ' << (x1 + x2 - 1) / 2 << ' ' << (x1 + x2 - 1) / 2 + 1
<< endl;
fflush(stdout);
string t;
cin >> t;
if (t == "NIE") {
x1 = (x1 + x2 - 1) / 2 + 1;
} else {
x2 = (x1 + x2 - 1) / 2;
}
}
if (x2 != h) {
cout << 2 << ' ' << x2 << ' ' << h << endl;
fflush(stdout);
return 0;
}
x1 = h + 1;
x2 = n;
while (x1 < x2) {
cout << 1 << ' ' << (x1 + x2) / 2 + 1 << ' ' << (x1 + x2) / 2 << endl;
fflush(stdout);
string t;
cin >> t;
if (t == "NIE") {
x2 = (x1 + x2) / 2;
} else {
x1 = (x1 + x2) / 2 + 1;
}
}
cout << 2 << ' ' << x2 << ' ' << h << endl;
fflush(stdout);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 1, mod = 1000000007;
vector<long long int> adj[N];
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int pro = 1, temp, t, n, i, m, k, j, l, r, mid, x, y, z, rem,
carry = 0, ind, ans = 0, mx = -LONG_LONG_MAX,
mn = LONG_LONG_MAX, cnt = 0, curr = 0, prev, sum = 0, flag = 0,
i1 = -1, i2 = -1;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (n < 2 || m >= (n * (n - 1)) / 2) {
return cout << "NO", 0;
}
cout << "YES\n";
long long int a[n + 1], b[n + 1];
for (i = 1; i <= n; i++) {
b[i] = 1;
}
curr = 2;
for (i = 1; i <= n; i++) {
flag = 0;
for (auto it : adj[i]) {
if (b[it] == b[i]) {
flag = 1;
b[it] = curr;
}
}
if (flag) {
curr++;
}
}
vector<pair<long long int, long long int> > v;
v.push_back({-1, 0});
for (i = 1; i <= n; i++) {
v.push_back({b[i], i});
}
sort(v.begin(), v.end());
for (i = 1; i <= n; i++) {
a[v[i].second] = i;
}
for (i = 1; i <= n; i++) {
cout << a[i] << ' ';
}
cout << endl;
for (i = 1; i <= n; i++) {
cout << b[i] << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
struct Tree {
int l, r, len, sum[2];
};
Tree tree[1000010 << 2];
void build(int le, int ri, int rt) {
tree[rt].l = le, tree[rt].r = ri, tree[rt].len = ri - le + 1;
tree[rt].sum[0] = 0;
tree[rt].sum[1] = 0;
if (ri == le)
return;
else {
int m = (le + ri) >> 1;
build(le, m, rt << 1);
build(m + 1, ri, rt << 1 | 1);
}
}
void update(int rt, int fd, int fa) {
if (tree[rt].l == tree[rt].r && fd == tree[rt].l) {
if (fa + tree[rt].sum[0] >= a)
tree[rt].sum[0] = a;
else
tree[rt].sum[0] += fa;
if (fa + tree[rt].sum[1] >= b)
tree[rt].sum[1] = b;
else
tree[rt].sum[1] += fa;
return;
}
int m = (tree[rt].l + tree[rt].r) >> 1;
if (fd <= m)
update(rt * 2, fd, fa);
else
update(rt * 2 + 1, fd, fa);
for (int i = 0; i < 2; i++)
tree[rt].sum[i] = tree[rt * 2].sum[i] + tree[rt * 2 + 1].sum[i];
}
int query(int L, int R, int le, int ri, int rt, int f) {
if (L > R) return 0;
if (L <= le && R >= ri) return tree[rt].sum[f];
int m = (le + ri) >> 1;
int res = 0;
if (L <= m) res += query(L, R, le, m, rt << 1, f);
if (R > m) res += query(L, R, m + 1, ri, rt << 1 | 1, f);
return res;
}
int main() {
int flag, na, d, p;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
build(1, n, 1);
for (int i = 0; i < q; i++) {
scanf("%d", &flag);
if (flag == 1) {
scanf("%d %d", &d, &na);
update(1, d, na);
} else {
scanf("%d", &p);
printf("%d\n", query(1, p - 1, 1, n, 1, 1) + query(p + k, n, 1, n, 1, 0));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[5001] = {0}, count = 0, i, x;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
a[x] = 1;
}
for (i = 1; i <= n; i++) {
if (a[i] == 0) count++;
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m, x, res, mod = 1e9 + 7;
cin >> n >> m >> x;
long long rem = x % 3;
if (rem == 1)
res = n;
else if (rem == 2)
res = m;
else
res = m - n;
rem = x / 3 + (x % 3 != 0);
if (rem % 2 == 0) res = -res;
res %= mod;
if (res < 0) res += mod;
cout << res << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100001;
vector<pair<int, int> > g[nmax], t[nmax];
int n, q, ans[nmax], c, l[nmax], r[nmax], d[nmax], sa[3 * nmax], sb[3 * nmax],
col[nmax * 3];
bool dd[nmax];
int modul = 1000000007;
void build(int s, int ll, int rr) {
if (ll == rr) {
sa[s] = d[ll];
sb[s] = ((long long)(d[ll]) * d[ll]) % modul;
return;
}
build(2 * s, ll, (ll + rr) / 2);
build(2 * s + 1, (ll + rr) / 2 + 1, rr);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
void dfs(int i) {
l[i] = ++c;
for (int j = 0; j < g[i].size(); j++)
if (l[g[i][j].first] == 0) {
d[c + 1] = (d[l[i]] + g[i][j].second) % modul;
dfs(g[i][j].first);
}
r[i] = c;
}
void progress(int s, int ll, int rr) {
if (ll == rr || col[s] == 0) return;
int p = col[s];
col[2 * s] = (col[2 * s] + p) % modul;
int uu = ((long long)p * (long long)((ll + rr) / 2 - ll + 1)) % modul;
sb[2 * s] =
(sb[2 * s] +
((long long)p * (uu + (2 * sa[2 * s]) % modul) % modul) % modul) %
modul;
sa[2 * s] = (sa[2 * s] + uu) % modul;
col[2 * s + 1] = (col[2 * s + 1] + p) % modul;
uu = ((long long)p * (long long)(rr - (ll + rr) / 2)) % modul;
sb[2 * s + 1] =
(sb[2 * s + 1] +
((long long)p * (uu + (2 * sa[2 * s + 1]) % modul) % modul) % modul) %
modul;
sa[2 * s + 1] = (sa[2 * s + 1] + uu) % modul;
col[s] = 0;
}
void update(int s, int ll, int rr, int u, int v, int p) {
if (rr < u || v < ll) return;
progress(s, ll, rr);
if (u <= ll && rr <= v) {
int uu = ((long long)p * (long long)(rr - ll + 1)) % modul;
sb[s] = (sb[s] +
((long long)p * (long long)(uu + (2 * sa[s]) % modul) % modul) %
modul) %
modul;
sa[s] = (sa[s] + uu) % modul;
if (ll != rr) col[s] = p;
return;
}
update(s * 2, ll, (ll + rr) / 2, u, v, p);
update(s * 2 + 1, (ll + rr) / 2 + 1, rr, u, v, p);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
int get(int s, int ll, int rr, int u, int v) {
if (rr < u || v < ll) return 0;
progress(s, ll, rr);
if (u <= ll && rr <= v) return sb[s];
return (get(2 * s, ll, (ll + rr) / 2, u, v) +
get(2 * s + 1, (ll + rr) / 2 + 1, rr, u, v)) %
modul;
}
void solve(int i) {
dd[i] = true;
for (int j = 0; j < t[i].size(); j++) {
pair<int, int> u = t[i][j];
ans[u.second] = ((2 * get(1, 1, n, l[u.first], r[u.first])) % modul -
get(1, 1, n, 1, n) + modul) %
modul;
}
for (int j = 0; j < g[i].size(); j++) {
pair<int, int> u = g[i][j];
if (!dd[u.first]) {
update(1, 1, n, 1, n, u.second);
update(1, 1, n, l[u.first], r[u.first],
(modul - (2 * u.second) % modul) % modul);
solve(u.first);
update(1, 1, n, 1, n, (modul - u.second) % modul);
update(1, 1, n, l[u.first], r[u.first], (2 * u.second) % modul);
}
}
}
int main() {
scanf("%d", &n);
int x, y, z;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
g[x].push_back(pair<int, int>(y, z));
g[y].push_back(pair<int, int>(x, z));
}
scanf("%d", &q);
dfs(1);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
t[x].push_back(pair<int, int>(y, i));
}
solve(1);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c;
cin >> r >> c;
vector<string> v(r);
for (int i = 0; i < r; i++) {
cin >> v[i];
}
int ans = 0;
for (int i = 0; i < r; i++) {
int ct = 0;
bool a = true;
for (int j = 0; j < c; j++) {
if (v[i][j] == '.') {
ct++;
}
if (v[i][j] == 'S') a = false;
}
if (a) {
ans += ct;
for (int j = 0; j < c; j++)
if (v[i][j] == '.') v[i][j] = '*';
}
}
for (int i = 0; i < c; i++) {
int ct = 0;
bool a = true;
for (int j = 0; j < r; j++) {
if (v[j][i] == '.') {
ct++;
}
if (v[j][i] == 'S') a = false;
}
if (a) ans += ct;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
int i, j, lp;
int V[4010];
int ANS = 1;
int DP[4010][4010];
int main() {
cin >> N;
for (i = 1; i <= N; i++) cin >> V[i];
for (i = 1; i <= N; i++) {
lp = 0;
for (j = 0; j < i; j++) {
DP[i][j] = 1 + DP[j][lp];
ANS = max(ANS, DP[i][j]);
if (V[j] == V[i]) lp = j;
}
}
cout << ANS << '\n';
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.