solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int x, y, z, a, b, c;
cin >> x >> y >> z;
if (x == y && x >= z) {
cout << "YES\n";
cout << x << " " << 1 << " " << z << "\n";
return;
}
if (z == y && z >= x) {
cout << "YES\n";
cout << y << " " << 1 << " " << x << "\n";
return;
}
if (x == z && x >= y) {
cout << "YES\n";
cout << z << " " << 1 << " " << y << "\n";
return;
}
cout << "NO\n";
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, a[maxn];
long long b[maxn];
vector<int> v[maxn];
long long sum[maxn << 2], rn[maxn << 2], lz[maxn << 2];
inline void pushup(int x) {
int ls = x << 1, rs = ls + 1;
sum[x] = sum[ls] + sum[rs];
rn[x] = rn[rs];
}
inline void pushdown(int x, int l, int r) {
int ls = x << 1, rs = ls + 1, mid = l + r >> 1;
if (lz[x]) {
lz[ls] = lz[rs] = lz[x];
sum[ls] = (mid - l + 1) * lz[x];
rn[ls] = lz[x];
sum[rs] = (r - mid) * lz[x];
rn[rs] = lz[x];
lz[x] = 0;
}
}
void build(int x, int l, int r) {
if (l == r) {
sum[x] = l;
rn[x] = l;
lz[x] = 0;
return;
}
int mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushup(x);
}
int getles(int x, int l, int r, int k) {
if (l == r) {
return sum[x] <= k ? l : l - 1;
}
pushdown(x, l, r);
int mid = l + r >> 1, ls = x << 1;
if (rn[ls] <= k)
return getles(x << 1 | 1, mid + 1, r, k);
else
return getles(x << 1, l, mid, k);
}
void modify(int x, int l, int r, int L, int R, int k) {
if (L <= l && r <= R) {
lz[x] = k;
sum[x] = (r - l + 1ll) * k;
rn[x] = k;
return;
}
pushdown(x, l, r);
int mid = l + r >> 1;
if (L <= mid) modify(x << 1, l, mid, L, R, k);
if (mid < R) modify(x << 1 | 1, mid + 1, r, L, R, k);
pushup(x);
}
int main() {
scanf("%d", &n);
int maxa = 0;
for (int i = (1); i <= (n); i++) {
scanf("%d", &a[i]);
maxa = max(maxa, a[i]);
for (int j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
v[j].push_back(i);
if (j * j != a[i]) v[a[i] / j].push_back(i);
}
}
}
if (n <= 2) {
puts("0");
return 0;
}
for (int i = (1); i <= (maxa); i++)
if (v[i].size()) sort(v[i].begin(), v[i].end());
build(1, 1, n);
long long ans = 0;
b[maxa] = (long long)n * n + n - sum[1];
for (int i = (maxa); i >= (2); i--) {
if (v[i].size() > 1) {
int k = v[i].size();
int x = getles(1, 1, n, n + 1);
if (v[i][1] + 1 <= x) modify(1, 1, n, v[i][1] + 1, x, n + 1);
x = getles(1, 1, n, v[i][k - 1]);
int r = min(x, v[i][1]);
if (v[i][0] + 1 <= r) modify(1, 1, n, v[i][0] + 1, r, v[i][k - 1]);
x = getles(1, 1, n, v[i][k - 2]);
r = min(x, v[i][0]);
if (1 <= r) modify(1, 1, n, 1, r, v[i][k - 2]);
}
b[i - 1] = (long long)n * n + n - sum[1];
ans += (b[i] - b[i - 1]) * i;
}
ans += b[1] - 3;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
set<int> isi[100010];
int tab[100010];
map<int, int> mp;
int main() {
int n, m, k;
cin >> n >> k >> m;
memset(tab, 0, sizeof(tab));
mp.clear();
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
isi[a % m].insert(a);
tab[a % m]++;
mp[a]++;
}
for (int i = 0; i < m; i++) {
if (tab[i] >= k) {
cout << "Yes\n";
vector<int> ans;
ans.clear();
for (set<int>::iterator it = isi[i].begin(); it != isi[i].end(); ++it) {
for (int j = 1; j <= mp[*it]; j++) {
ans.push_back(*it);
}
}
for (int j = 0; j < k; j++) {
if (j == k - 1)
cout << ans[j] << "\n";
else
cout << ans[j] << " ";
}
return 0;
}
}
cout << "No\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, n, k, a1, a2, a3;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
if (i % 3 == 0) a1 = a1 + k;
if (i % 3 == 1) a2 = a2 + k;
if (i % 3 == 2) a3 = a3 + k;
}
if (a1 > a2 && a1 > a3) cout << "chest";
if (a2 > a1 && a2 > a3) cout << "biceps";
if (a3 > a1 && a3 > a2) cout << "back";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
long long m = n, len = 0, res = 0;
int cnt = 1;
while (m) {
len++;
if (m & 1) res++;
a[cnt++] = m % 2;
m = m / 2;
}
cnt = cnt - 1;
if (k != 1)
printf("%lld\n", (long long)pow(2, cnt) - 1);
else
printf("%lld\n", n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m), prefix(n + 1);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) cin >> b[i];
prefix[0] = 0;
for (long long i = 1; i < n + 1; i++) prefix[i] = prefix[i - 1] + a[i - 1];
auto ind = prefix.begin();
for (long long i = 0; i < m; i++) {
ind = lower_bound(ind, prefix.end(), b[i]);
cout << ind - prefix.begin() << " "
<< b[i] - prefix[ind - prefix.begin() - 1] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
struct graph {
vector<int> deg;
bitset<N> con[N];
int n;
graph(int n) : n(n) {}
void add_edge(int a, int b) { con[a][b] = con[b][a] = 1; }
pair<set<int>, set<int>> partition() {
set<int> A, B;
for (int i = 1; i <= n; i++) A.insert(i);
int node = 0;
for (int i = 1; i <= n; i++)
if (con[i].count() & 1) node = i;
if (node == 0) return {A, {}};
A.clear();
bitset<N> temp = con[node];
con[node].reset();
for (int i = 1; i <= n; i++) {
con[i][node] = 0;
if (temp[i]) {
con[i] ^= temp;
con[i][i] = 0;
}
}
pair<set<int>, set<int>> part = partition();
A = part.first, B = part.second;
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++)
if (temp[i]) {
cnt1 ^= A.count(i);
cnt2 ^= B.count(i);
}
if (cnt1 == 0 && !A.count(node)) {
A.insert(node);
B.erase(node);
} else if (cnt1 == 1 && A.count(node)) {
B.insert(node);
A.erase(node);
}
con[node] = temp;
for (int i = 1; i <= n; i++)
if (temp[i]) con[i][node] = 1;
for (int i = 1; i <= n; i++) {
if (temp[i]) {
con[i] ^= temp;
con[i][i] = 0;
}
}
return {A, B};
}
};
int main() {
int t, n = 0, m = 0;
scanf("%d", &(t));
while (t--) {
scanf("%d", &(n));
scanf("%d", &(m));
graph g(n);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d", &(x));
scanf("%d", &(y));
g.add_edge(x, y);
}
pair<set<int>, set<int>> part = g.partition();
printf("%d\n", (part.second.empty()) ? 1 : 2);
for (int i = 1; i <= n; i++) {
if (part.first.count(i))
printf("%d ", 1);
else
printf("%d ", 2);
}
printf("\n");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1E9 + 7;
const int N = 4E5 + 5;
struct data {
int l, r, k;
} q[N];
int n, m, k, tot, L, g[2], f[N][2], F[N][2], to[N][2], l[N];
long long w, w0;
bool flag[N][2];
map<int, bool> o;
int comp(data a, data b) { return a.l < b.l; }
void add(int x) {
if (o[x]) return;
o[x] = 1;
l[++tot] = x;
}
long long get(int n) {
if (!n) return 1;
long long ans = get(n / 2);
ans = ans * ans % MOD;
if (n & 1) ans = ans * 2 % MOD;
return ans;
}
void updata(int &a, int b) { a = (a + b) % MOD; }
int main() {
cin >> L >> n >> m;
if (!n && !m) {
cout << get(L);
return 0;
}
for (int i = 1; i <= n + m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
if (i > n) q[i].k = 1;
add(q[i].l);
add(q[i].r);
}
n += m;
sort(l + 1, l + tot + 1);
sort(q + 1, q + n + 1, comp);
for (int i = 1; i <= n; i++) {
q[i].l = lower_bound(l + 1, l + tot + 1, q[i].l) - l;
q[i].r = lower_bound(l + 1, l + tot + 1, q[i].r) - l;
if (q[i].l == q[i].r) flag[q[i].l][q[i].k ^ 1] = 1;
}
k = n;
g[0] = g[1] = tot + 1;
for (int i = tot; i; i--) {
for (; k && q[k].l >= i; k--) g[q[k].k] = min(g[q[k].k], q[k].r);
to[i][0] = g[0];
to[i][1] = g[1];
}
for (int i = 0; i <= 1; i++) {
g[i] = 1;
F[to[1][i ^ 1]][i] = 1;
}
for (int i = 1; i <= tot; i++) {
for (int j = 0; j <= 1; j++) {
g[j] = (g[j] - F[i][j] + MOD) % MOD;
updata(f[i][j], g[j]);
}
for (int j = 0; j <= 1; j++)
if (w = f[i][j]) {
w0 = get(l[i + 1] - l[i] - 1);
updata(g[j], w * (w0 - 1) % MOD);
updata(F[to[i + 1][j ^ 1]][j], w * (w0 - 1) % MOD);
updata(g[j ^ 1], w * w0 % MOD);
updata(F[to[i + 1][j]][j ^ 1], w * w0 % MOD);
}
}
cout << get(l[1] - 1 + L - l[tot]) * (f[tot][0] + f[tot][1]) % MOD;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 240;
double P, opt[2][2][maxn][1 << 9];
int x, k, p, t, mask;
int main() {
scanf("%d%d%d", &x, &k, &p);
P = (double)p / 100;
mask = (1 << 9) - 1;
t = (x ^ (x & mask)) >> 9;
int sum0 = 0, sum1 = 0, sum, st = 0;
while (t > 0 && (t & 1) == 0) {
sum0++;
t >>= 1;
}
t = (x ^ (x & mask)) >> 9;
while (t > 0 && (t & 1) == 1) {
sum1++;
t >>= 1;
}
for (int i = 0; i <= k; i++)
for (int u = 0; u < (1 << 9); u++)
for (int j = 0; j < maxn; j++) opt[0][0][j][u] = opt[0][1][j][u] = 0.0;
if (sum0 > 0) {
opt[0][0][sum0][x & mask] = 1.0;
} else {
opt[0][1][sum1][x & mask] = 1.0;
}
for (int i = 0; i < k; i++) {
for (int u = 0; u < (1 << 9); u++)
for (int j = 0; j < maxn; j++)
opt[1 - st][0][j][u] = opt[1 - st][1][j][u] = 0.0;
for (int u = 0; u < (1 << 9); u++)
for (int j = 0; j < maxn; j++) {
if (opt[st][0][j][u] > 0) {
if (((u + 1) & mask) == (u + 1)) {
opt[1 - st][0][j][u + 1] += opt[st][0][j][u] * (1 - P);
} else {
opt[1 - st][1][1][(u + 1) & mask] += opt[st][0][j][u] * (1 - P);
}
if (((u << 1) & mask) == (u << 1)) {
opt[1 - st][0][j + 1][u << 1] += opt[st][0][j][u] * P;
} else {
opt[1 - st][1][1][(u << 1) & mask] += opt[st][0][j][u] * P;
}
}
if (opt[st][1][j][u] > 0) {
if (((u + 1) & mask) == (u + 1)) {
opt[1 - st][1][j][u + 1] += opt[st][1][j][u] * (1 - P);
} else {
opt[1 - st][0][j][(u + 1) & mask] += opt[st][1][j][u] * (1 - P);
}
if (((u << 1) & mask) == (u << 1)) {
opt[1 - st][0][1][u << 1] += opt[st][1][j][u] * P;
} else {
opt[1 - st][1][j + 1][(u << 1) & mask] += opt[st][1][j][u] * P;
}
}
}
st = 1 - st;
}
double ans = 0.0;
for (int j = 0; j < maxn; j++) {
ans += opt[st][0][j][0] * (j + 9) + opt[st][1][j][0] * 9;
for (int u = 1; u < (1 << 9); u++) {
for (t = u, sum = 0; t > 0 && (t & 1) == 0; t >>= 1, sum++)
;
ans += (opt[st][1][j][u] + opt[st][0][j][u]) * sum;
}
}
printf("%lf\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double P[105];
int main() {
int i, j, k, n;
double p, c, t;
vector<double> v;
cin >> n;
for (i = 0; i < n; i++) cin >> P[i];
sort(P, P + n);
p = P[n - 1];
for (i = 0; i < n; i++) {
c = 0;
for (j = i; j < n; j++) {
t = 1;
for (k = i; k < n; k++) {
if (j != k)
t *= (1 - P[k]);
else
t *= P[k];
}
c += t;
}
p = max(p, c);
}
cout << fixed << setprecision(12) << p;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int mul(long long int x, long long int y) {
long long int ans = 1;
while (y > 0) {
if (y & 1) ans = (ans * x) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return ans;
};
long long int dp[5005][1005][2], ans1[1005], ans2[1005];
int main() {
long long int aa, bb, n, m, i, j;
cin >> n >> m;
string str, tmp, str1, str2;
map<string, long long int> mp;
for (i = 1; i <= n; i++) {
cin >> str >> tmp;
mp[str] = i;
cin >> str1;
if (str1[0] == '1' || str1[0] == '0')
for (j = 1; j <= m; j++) dp[i][j][0] = dp[i][j][1] = str1[j - 1] - '0';
else {
cin >> tmp >> str2;
for (j = 1; j <= m; j++) {
if (str1[0] == '?')
aa = 0;
else
aa = dp[mp[str1]][j][0];
if (str2[0] == '?')
bb = 0;
else
bb = dp[mp[str2]][j][0];
if (tmp[0] == 'X')
dp[i][j][0] = aa ^ bb;
else if (tmp[0] == 'A')
dp[i][j][0] = aa & bb;
else
dp[i][j][0] = aa | bb;
if (str1[0] == '?')
aa = 1;
else
aa = dp[mp[str1]][j][1];
if (str2[0] == '?')
bb = 1;
else
bb = dp[mp[str2]][j][1];
if (tmp[0] == 'X')
dp[i][j][1] = aa ^ bb;
else if (tmp[0] == 'A')
dp[i][j][1] = aa & bb;
else
dp[i][j][1] = aa | bb;
}
}
}
for (j = 1; j <= m; j++) {
aa = 0, bb = 0;
for (i = 1; i <= n; i++) {
if (dp[i][j][0]) ++aa;
if (dp[i][j][1]) ++bb;
}
if (aa <= bb)
ans1[j] = 0;
else
ans1[j] = 1;
if (aa >= bb)
ans2[j] = 0;
else
ans2[j] = 1;
}
for (i = 1; i <= m; i++) cout << ans1[i];
cout << "\n";
for (i = 1; i <= m; i++) cout << ans2[i];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
double a, b;
cin >> a >> b;
double total = 2.0 * a * b, fav = a * b;
if (b == 0) {
cout << 1.0 << '\n';
continue;
} else if (a == 0) {
cout << 0.5 << '\n';
continue;
}
double inter, temp;
inter = 4.0 * b;
if (inter < a) {
temp = (0.5 * (a * (a / (4.0)))) -
(0.5 * (a - (4.0) * b) * ((a / (4.0)) - b));
} else {
temp = (0.5 * a * (a / (4.0)));
}
fav += temp;
double ans;
ans = fav / total;
cout.precision(12);
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
int x = abs(a - b), res = x / 5, cnt = 0;
cnt += res;
x -= res * 5;
res = x / 2;
cnt += res;
x -= res * 2;
cnt += x;
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, m;
char mp[505][505];
int sx, sy, ex, ey;
int go[][2] = {-1, 0, 0, 1, 1, 0, 0, -1};
int isin(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m)
return 1;
else
return 0;
}
bool bfs() {
queue<pair<int, int> > Q;
Q.push(make_pair(sx, sy));
pair<int, int> t;
int x, y, nx, ny;
while (!Q.empty()) {
t = Q.front();
Q.pop();
x = t.first;
y = t.second;
for (int i = 0; i < 4; i++) {
nx = x + go[i][0];
ny = y + go[i][1];
if (isin(nx, ny)) {
if (nx == ex && ny == ey) {
if (mp[nx][ny] == 'X') {
return true;
} else {
mp[nx][ny] = 'X';
Q.push(make_pair(nx, ny));
}
} else if (mp[nx][ny] == '.') {
mp[nx][ny] = 'X';
Q.push(make_pair(nx, ny));
}
}
}
}
return false;
}
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
scanf("%d%d%d%d", &sx, &sy, &ex, &ey);
sx--, sy--, ex--, ey--;
printf("%s\n", bfs() ? "YES" : "NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T mx(T n) {
return n;
}
template <class T, typename... Args>
T mx(T n, Args... args) {
return max(n, mx(args...));
}
template <class T>
T mn(T n) {
return n;
}
template <class T, typename... Args>
T mn(T n, Args... args) {
return min(n, mn(args...));
}
template <class T>
T gcd(T n) {
return n;
}
template <class T, typename... Args>
T gcd(T n, Args... args) {
return __gcd(n, gcd(args...));
}
const int mod = 1e9 + 7;
long long pw(long long a, long long b, long long mod) {
long long ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ans;
}
int main(void) {
int n;
cin >> n;
++n;
long long ans = 1;
for (int i = n + 1; i <= 2 * n; ++i) ans = (ans * i) % mod;
long long m = 1;
for (int i = 1; i <= n; ++i) m = (m * i) % mod;
m = pw(m, mod - 2, mod);
ans = (ans * m) % mod;
return cout << (ans + mod - 1) % mod << '\n', 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
ostream& operator<<(ostream& os, const vector<long long>& a) {
for (int i = 0; i < a.size(); i++) os << a[i] << " ";
return os;
}
ostream& operator<<(ostream& os, const pair<long long, long long>& a) {
os << a.first << " " << a.second;
return os;
}
ostream& operator<<(ostream& os, const vector<int>& a) {
for (int i = 0; i < a.size(); i++) os << a[i] << " ";
return os;
}
istream& operator>>(istream& is, pair<long long, long long>& a) {
is >> a.first >> a.second;
return is;
}
struct Point {
long long x, y;
Point() {
x = 0;
y = 0;
}
long long operator^(const Point& a) const { return (x * a.y - y * a.x); }
};
Point operator-(const Point& a, const Point& b) {
Point p;
p.x = a.x - b.x;
p.y = a.y - b.y;
return p;
}
istream& operator>>(istream& is, Point& a) {
cin >> a.x >> a.y;
return is;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<Point> points(n);
for (int i = 0; i < n; i++) cin >> points[i];
string st;
cin >> st;
cerr << "finished reading" << endl;
long long ind = 0;
for (long long i = 1; i < n; i++) {
if (points[i].y < points[ind].y) ind = i;
}
vector<long long> answ;
answ.push_back(ind);
cerr << "found staring point" << endl;
vector<bool> used(n);
used[ind] = 1;
for (long long i = 0; i < n - 2; i++) {
long long curInd = -1;
for (long long j = 0; j < n; j++) {
if (used[j]) continue;
if (curInd == -1) {
curInd = j;
continue;
}
Point lastVector = (points[curInd] - points[answ[answ.size() - 1]]);
Point newVector = (points[j] - points[answ[answ.size() - 1]]);
if (st[i] == 'L')
curInd = ((lastVector ^ newVector) > 0 ? curInd : j);
else
curInd = ((lastVector ^ newVector) < 0 ? curInd : j);
}
answ.push_back(curInd);
used[curInd] = 1;
}
cerr << "calculated answ" << endl;
for (long long i = 0; i < n; i++)
if (!used[i]) answ.push_back(i);
for (int i = 0; i < n; i++) cout << answ[i] + 1 << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
struct person {
int r, num, k;
person() {}
person(int r, int k, int num) : r(r), k(k), num(num) {}
};
bool operator<(person a, person b) {
if (a.r != b.r) return a.r < b.r;
return a.num < b.num;
}
struct song {
int l, r, num;
song() {}
song(int a, int b, int num) : l(a), r(b), num(num) {}
};
bool operator<(song a, song b) {
if (a.l != b.l) return a.l < b.l;
if (a.r != b.r) return a.r > b.r;
return a.num < b.num;
}
int main() {
int n;
scanf("%d", &n);
song a[n];
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].num = i;
}
sort(a, a + n);
int m;
scanf("%d", &m);
map<int, vector<person>> open;
for (int i = 0; i < m; i++) {
int l, r, k;
scanf("%d%d%d", &l, &r, &k);
open[l].push_back(person(r, k, i + 1));
}
vector<int> ans(n, -1);
set<person> s;
auto j = open.begin();
for (int i = 0; i < n; i++) {
while (j != open.end()) {
if (j->first > a[i].l) break;
for (person p : j->second) s.insert(p);
j++;
}
auto p = s.lower_bound(person(a[i].r, -1e9, -1e9));
if (p == s.end()) {
printf("NO");
return 0;
}
ans[a[i].num] = p->num;
person tmp = *p;
s.erase(p);
if (p->k == 1) continue;
tmp.k--;
s.insert(tmp);
}
printf("YES\n");
for (int i : ans) printf("%d ", i);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int inf_int = 2e9;
long long inf_ll = 2e18;
const double pi = 3.1415926535898;
long long binpow(long long a, long long n) {
if (n == 0) {
return 1;
}
long long res = 1;
while (n) {
if (n % 2 == 1) {
res *= a;
}
a *= a;
n /= 2;
}
return res;
}
int a, b, c;
int s(int x) {
int res = 0;
while (x != 0) {
res += x % 10;
x /= 10;
}
return res;
}
int cnt;
vector<int> ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> c;
cnt = 0;
if (a == 1) {
int x = max(c + 1, 1);
if ((x - c) % b != 0) {
x = ((x - c) / b + 1) * b + c;
}
for (; x < 10000000; x += b) {
if ((x - c) / b == s(x)) {
cnt++;
ans.push_back(x);
}
}
cout << cnt;
if (cnt != 0) {
cout << endl;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
if (i != ans.size() - 1) {
cout << " ";
}
}
return 0;
}
for (long long i = 1;; i++) {
long long y = binpow(i, (long long)a);
long long x = (long long)b * y + (long long)c;
if (x > 1000000000) break;
if (x < 1) continue;
if (i == s(x)) {
cnt++;
ans.push_back(x);
}
}
cout << cnt;
if (cnt != 0) cout << endl;
for (int i = 0; i < cnt; i++) {
cout << ans[i];
if (i != ans.size() - 1) {
cout << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int64_t MAX_N = 1000;
struct Point {
int64_t x, y;
Point() {}
Point(int64_t _x, int64_t _y) : x(_x), y(_y) {}
};
struct Vertex {
int64_t comp;
std::vector<int64_t> v;
};
Point a[MAX_N + 5];
std::map<int64_t, std::vector<std::pair<int64_t, int64_t> > > ver, hor;
Vertex g[MAX_N + 5];
int64_t get_dist(Point p, Point q) {
if (p.x != q.x && p.y != q.y) {
return -1;
}
return (p.x == q.x ? abs(p.y - q.y) : abs(p.x - q.x));
}
void dfs(int64_t u, int64_t comp) {
g[u].comp = comp;
for (auto &v : g[u].v) {
if (g[v].comp == -1) {
dfs(v, comp);
}
}
}
bool check(int64_t n, int64_t t) {
for (int64_t i = 1; i <= n; i++) {
g[i].v.clear();
g[i].comp = -1;
}
for (auto &x : hor) {
for (int64_t i = 1; i < x.second.size(); i++) {
if (x.second[i].first - x.second[i - 1].first <= t) {
g[x.second[i].second].v.push_back(x.second[i - 1].second);
g[x.second[i - 1].second].v.push_back(x.second[i].second);
}
}
}
for (auto &x : ver) {
for (int64_t i = 1; i < x.second.size(); i++) {
if (x.second[i].first - x.second[i - 1].first <= t) {
g[x.second[i].second].v.push_back(x.second[i - 1].second);
g[x.second[i - 1].second].v.push_back(x.second[i].second);
}
}
}
int64_t comps = 0;
for (int64_t i = 1; i <= n; i++) {
if (g[i].comp == -1) {
dfs(i, comps++);
}
}
if (comps == 1) {
return true;
}
if (comps == 2) {
for (int64_t i = 1; i <= n; i++) {
for (int64_t j = i + 1; j <= n; j++) {
if (g[i].comp == g[j].comp) {
continue;
}
int64_t d = get_dist(a[i], a[j]);
if (d != -1 && d <= (int64_t)2 * t) {
return true;
}
if (abs(a[i].x - a[j].x) <= t && abs(a[i].y - a[j].y) <= t) {
return true;
}
}
}
return false;
}
if (comps == 3) {
for (auto &x : ver) {
for (int64_t j = 1; j < x.second.size(); j++) {
int64_t p = x.second[j - 1].second, q = x.second[j].second;
if (g[p].comp == g[q].comp) {
continue;
}
for (int64_t i = 1; i <= n; i++) {
if (a[i].y <= a[p].y || a[i].y >= a[q].y) {
continue;
}
if (a[i].x == a[p].x) {
continue;
}
if (abs(a[i].x - a[p].x) <= t && g[i].comp != g[p].comp &&
g[i].comp != g[q].comp) {
if (abs(a[i].y - a[p].y) <= t && abs(a[i].y - a[q].y) <= t) {
return true;
}
}
}
}
}
for (auto &x : hor) {
for (int64_t j = 1; j < x.second.size(); j++) {
int64_t p = x.second[j - 1].second, q = x.second[j].second;
if (get_dist(a[p], a[q]) > (int64_t)2 * t) {
continue;
}
if (g[p].comp == g[q].comp) {
continue;
}
for (int64_t i = 1; i <= n; i++) {
if (a[i].x <= a[p].x || a[i].x >= a[q].x) {
continue;
}
if (a[i].y == a[p].y) {
continue;
}
if (abs(a[i].y - a[p].y) <= t && g[i].comp != g[p].comp &&
g[i].comp != g[q].comp) {
if (abs(a[i].x - a[p].x) <= t && abs(a[i].x - a[q].x) <= t) {
return true;
}
}
}
}
}
return false;
}
if (comps == 4) {
for (auto &h : ver) {
for (int64_t i = 1; i < h.second.size(); i++) {
int64_t p = h.second[i - 1].second, q = h.second[i].second;
if (g[p].comp == g[q].comp) {
continue;
}
for (auto &v : hor) {
if (v.first <= a[p].y || v.first >= a[q].y) {
continue;
}
for (int64_t j = 1; j < v.second.size(); j++) {
int64_t pp = v.second[j - 1].second, qq = v.second[j].second;
if (g[pp].comp == g[qq].comp) {
continue;
}
if (g[pp].comp == g[p].comp || g[pp].comp == g[q].comp) {
continue;
}
if (g[qq].comp == g[p].comp || g[qq].comp == g[q].comp) {
continue;
}
Point aux = Point(h.first, v.first);
if (get_dist(aux, a[p]) <= t && get_dist(aux, a[q]) <= t &&
get_dist(aux, a[pp]) <= t && get_dist(aux, a[qq]) <= t) {
return true;
}
}
}
}
}
return false;
}
return false;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int64_t n;
std::cin >> n;
for (int64_t i = 1; i <= n; i++) {
std::cin >> a[i].x >> a[i].y;
ver[a[i].x].push_back({a[i].y, i});
hor[a[i].y].push_back({a[i].x, i});
}
for (auto &x : ver) {
std::sort(x.second.begin(), x.second.end());
}
for (auto &x : hor) {
std::sort(x.second.begin(), x.second.end());
}
int64_t low = 0, high = 2e9, ans = -1;
while (low <= high) {
int64_t mid = ((int64_t)low + high) / 2;
if (check(n, mid)) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
std::cout << ans << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> x;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int s;
cin >> s;
int q;
for (int i = 1; i < n; ++i) {
cin >> q;
x.push(q);
}
int licz = 0;
while (s <= x.top()) {
q = x.top();
x.pop();
--q;
++s;
x.push(q);
++licz;
}
cout << licz << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, ans;
vector<int> q;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> x;
q.push_back(x);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> x;
for (int z = 0; z < k; z++) {
if (q[z] == x) {
ans += z + 1;
q.erase(q.begin() + z);
q.insert(q.begin(), x);
break;
}
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int h[100001], n, i, s = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> h[i];
s = s + n + h[0];
for (i = 0; i < n - 1; i++) {
if (h[i] > h[i + 1]) {
s = s + h[i] - h[i + 1];
h[i] = h[i + 1];
}
if (h[i] < h[i + 1]) s = s + h[i + 1] - h[i];
s++;
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int sign(double x) { return x < -1E-6 ? -1 : x > 1E-6; }
double sqr(double x) { return x * x; }
typedef struct point {
double x, y;
} point;
double dist(point a, point b) { return hypot(a.x - b.x, a.y - b.y); }
double cross(point a, point b, point c) {
return (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
}
double dot(point p, point a, point b) {
return (a.x - p.x) * (b.x - p.x) + (a.y - p.y) * (b.y - p.y);
}
double delta_angle(point a, point b, point c) {
return acos(dot(b, a, c) / (dist(a, b) * dist(b, c)));
}
point *__o;
int angle_cmp(point *p, point *q) {
int c;
if (c = sign(cross(*__o, *p, *q))) return -c;
return sign(dist(*p, *__o) - dist(*q, *__o));
}
point stack[100000];
int convex_hull(point *ps, int n) {
int i, k, top;
point q;
k = 0;
for (i = 1; i < n; i++)
if (sign(ps[i].y - ps[k].y) < 0 ||
sign(ps[i].y - ps[k].y) == 0 && ps[i].x < ps[k].x)
k = i;
q = ps[k];
ps[k] = ps[0];
ps[0] = q;
__o = &ps[0];
qsort(ps + 1, n - 1, sizeof(point),
(int (*)(const void *, const void *))angle_cmp);
top = 0;
for (i = 0; i < n; i++) {
while (top >= 2 && sign(cross(stack[top - 2], stack[top - 1], ps[i])) <= 0)
top--;
stack[top++] = ps[i];
}
memcpy(ps, stack, sizeof(point) * top);
return top;
}
double cccr(point A, point B, point C) {
double a, b, c, cos_B, sin_B, R;
a = dist(B, C);
b = dist(A, C);
c = dist(A, B);
cos_B = (a * a + c * c - b * b) / (2 * a * c);
sin_B = sqrt(1.0 - cos_B * cos_B);
return b / sin_B / 2.0;
}
int too_straight(point A, point B, point C, double r) {
return sign(dot(B, A, C)) < 0 && sign(cccr(A, B, C) - r) > 0;
}
double area_bow(double r, double l) {
double tri = l * sqrt(sqr(r) - sqr(l / 2)) / 2;
double theta = 2 * asin(l / (r + r));
double sector = theta * r * r / 2;
return sector - tri;
}
double area_polygon(const point a[], int n) {
int i, j;
double area = 0.0;
for (j = 0, i = n - 1; j < n; i = j++)
area += a[i].x * a[j].y - a[i].y * a[j].x;
return fabs(area) / 2;
}
void die() { *(char *)NULL = 0; }
int main() {
static point ps[100000];
int n;
double r;
double ans, R, Rmin;
int i, j, k, z, top, s, ch;
scanf("%d %lf", &n, &r);
for (i = 0; i < n; i++) scanf("%lf %lf", &ps[i].x, &ps[i].y);
if (n == 1) {
puts("0");
} else if (n == 2) {
ans = area_bow(r, dist(ps[0], ps[1])) * 2.0;
printf("%.9lf\n", ans);
} else {
n = convex_hull(ps, n);
top = 0;
for (i = 0; i < n; i++) {
while (top >= 2 && too_straight(stack[top - 2], stack[top - 1], ps[i], r))
top--;
stack[top++] = ps[i];
}
s = 0;
ch = 1;
while (ch) {
ch = 0;
while (top - s >= 3 &&
too_straight(stack[top - 2], stack[top - 1], stack[s], r))
top--, ch = 1;
while (top - s >= 3 &&
too_straight(stack[top - 1], stack[s], stack[s + 1], r))
s++, ch = 1;
}
memcpy(stack, stack + s, sizeof(stack[0]) * (top -= s));
ans = area_polygon(stack, top);
for (i = 0, j = 1 % top; i < top; i++, j = (j + 1) % top) {
ans += area_bow(r, dist(stack[i], stack[j]));
}
printf("%.9lf\n", ans);
if (top >= 3)
for (i = 0, j = 1 % top, k = 2 % top; i < top;
i++, j = (j + 1) % top, k = (k + 1) % top)
if (too_straight(stack[i], stack[j], stack[k], r)) die();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[112345];
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long mx = -1;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
mx = max(mx, a[i]);
}
long long cur = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == mx) {
cur++;
} else {
cur = 0;
}
ans = max(cur, ans);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-6;
template <class T, class U>
ostream& operator<<(ostream& o, const pair<T, U>& v) {
return o << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "{";
for (int i = 0; i < (int)((int)((v).size())); ++i)
o << (i ? ", " : "") << v[i];
return o << "}";
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
int s2i(string& a) {
stringstream ss(a);
int r;
ss >> r;
return r;
}
int n;
int in[1 << 20];
int dp[21][1 << 20];
const long long mod = 1e9 + 7;
long long modpow(long long p, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = (ret * p) % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
const int bit = 20;
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", in + i);
++dp[0][in[i]];
}
for (int i = 0; i < bit; ++i) {
for (int j = 0; j < (int)(1 << bit); ++j) {
if (j & (1 << i)) dp[i + 1][j ^ (1 << i)] += dp[i][j];
dp[i + 1][j] += dp[i][j];
}
}
long long ans = 0;
for (int i = 0; i < (1 << bit); ++i) {
if (__builtin_popcountll(i) % 2)
ans -= modpow(2, dp[bit][i], mod);
else
ans += modpow(2, dp[bit][i], mod);
}
cout << (ans % mod + mod) % mod << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
long long in;
vector<long long> vec;
map<long long, int> freq;
set<long long> st;
scanf("%i %i", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%I64d", &in);
vec.push_back(in);
}
for (int i = 0; i < k; i++) {
++freq[vec[i]];
}
for (auto itr = freq.begin(); itr != freq.end(); itr++) {
if (itr->second == 1) st.insert(itr->first);
}
if (st.size())
printf("%I64d\n", *st.rbegin());
else
printf("Nothing\n");
for (int i = k; i < n; i++) {
++freq[vec[i]];
if (freq[vec[i]] == 1)
st.insert(vec[i]);
else
st.erase(vec[i]);
--freq[vec[i - k]];
if (freq[vec[i - k]] == 1)
st.insert(vec[i - k]);
else
st.erase(vec[i - k]);
if (st.size())
printf("%I64d\n", *st.rbegin());
else
printf("Nothing\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9;
const int mod = 998244353;
int a[maxn];
map<long long, int> mp;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long ans = 0, sum = 0;
mp[0] = 1;
for (int i = 0; i < n; i++) {
sum += a[i];
mp[sum]++;
if (m == 1)
ans += mp[sum - 1];
else if (m == -1)
ans += mp[sum - 1] + mp[sum + 1];
else {
for (long long j = 1; j <= 1e14; j *= m) ans += mp[sum - j];
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(long long a, long long b) { return a > b; }
int main() {
long long n;
cin >> n;
long long br[2];
cin >> br[0] >> br[1];
sort(br, br + 2);
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, cmp);
double res = 0;
long long p = 0;
for (long long i = 0; i < 2; i++) {
long long sum = 0;
for (long long j = 0; j < br[i]; j++) {
sum += arr[p];
p++;
}
res += double(sum) / br[i];
}
cout << fixed << setprecision(15) << res << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int prime[] = {1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}, a[20];
long long ans = 1e18;
inline double qpow(double x, long long y) {
double res = 1;
while (y) {
if (y & 1) res *= x;
x *= x;
y >>= 1;
}
return res;
}
void dfs(int x, int now) {
if (now == 1) {
double res = 1;
for (int i = 1; i < x; i++) res = res * qpow(prime[i], a[i] - 1);
if (res <= 1e18) ans = min(ans, (long long)res);
return;
}
for (int i = now; i >= 2; i--)
if (now % i == 0) a[x] = i, dfs(x + 1, now / i);
}
int main() {
int n;
scanf("%d", &n);
dfs(1, n);
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n;
bool f = true;
std::cin >> n;
std::vector<int> v(n);
for (int i = 0; i < n; ++i) {
std::cin >> v[i];
while (!(v[i] % 3)) v[i] /= 3;
while (!(v[i] % 2)) v[i] /= 2;
}
for (int i = 1; i < n; ++i)
if (v[0] != v[i]) {
f = !f;
break;
}
if (f)
std::cout << "Yes";
else
std::cout << "No";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 4009;
long long i, j, n, m, s, mx, x[MX], y[MX], b[MX], a[MX][MX];
int main() {
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
b[x[i]]++;
b[y[i]]++;
a[x[i]][y[i]] = 1;
a[y[i]][x[i]] = 1;
}
mx = MX * MX * MX;
s = mx;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (a[i][x[j]] == 1 && a[i][y[j]] == 1)
s = min(s, b[i] + b[x[j]] + b[y[j]] - 6);
if (s < 0 || s == mx)
cout << -1;
else
cout << s;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, cur;
string ans;
deque<string> d;
int t;
void solve(int pos) {
if (d.empty()) {
if (pos <= 2 || n != cur) {
cout << "Error occurred";
exit(0);
}
}
if (d.front() == "pair") {
t++;
d.pop_front();
ans += "pair<";
solve(1);
ans += ",";
solve(2);
ans += ">";
} else {
t++;
cur++;
ans += "int";
d.pop_front();
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
string s;
while (cin >> s) d.push_back(s);
int k = d.size();
solve(0);
if (n == cur && t == k)
cout << ans;
else
cout << "Error occurred";
exit(EXIT_SUCCESS);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, z, a, b, q;
long long BIT[2][400001];
long long sum(long long c, long long i) {
long long k = 0;
while (i > 0) {
k += BIT[c][i];
i -= i & -i;
}
return k;
}
void add(long long c, long long i, long long k) {
while (i < 400001) {
BIT[c][i] += k;
i += i & -i;
}
}
long long orders[400001];
int main() {
cin >> n >> z >> a >> b >> q;
for (long long i = 0; i < 400001; i++) {
orders[i] = 0;
BIT[0][i] = BIT[1][i] = 0;
}
for (long long i = 0; i < q; i++) {
long long ty;
cin >> ty;
if (ty == 1) {
long long day, ord;
cin >> day >> ord;
add(0, day, min(b, ord + orders[day]) - min(b, orders[day]));
add(1, day, min(a, ord + orders[day]) - min(a, orders[day]));
orders[day] += ord;
} else if (ty == 2) {
long long p;
cin >> p;
cout << sum(0, p - 1) - sum(1, p + z - 1) + sum(1, n) << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > num;
int pos[100005], vis[100005];
vector<vector<int> > record, v2, v3;
bool cmp1(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
bool cmp2(const vector<int> &a, const vector<int> &b) {
return a.size() > b.size();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, t;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
num.emplace_back(i + 1, t);
}
sort(num.begin(), num.end(), cmp1);
for (int i = 0; i < n; i++) pos[num[i].first] = i + 1;
t = 1;
vector<int> vec;
while (t <= n) {
while (!vis[t]) {
vec.push_back(t);
vis[t] = 1;
t = pos[t];
}
if (vec.size() > 1) record.push_back(vec);
vec.clear();
t++;
}
sort(record.begin(), record.end(), cmp2);
int cnt = 0, cnt2 = 0, cnt3 = 0;
for (int i = 0; i < record.size(); i++) {
if (record[i].size() == 4 || record[i].size() == 5)
cnt++;
else if (record[i].size() > 5) {
cnt += record[i].size() / 4;
int k = record[i].size() % 4;
if (k == 2)
cnt2++;
else if (k == 3)
cnt3++;
} else if (record[i].size() == 2)
cnt2++;
else
cnt3++;
}
if (cnt2 >= cnt3) {
cnt += cnt3;
cnt2 -= cnt3;
cnt += (cnt2 + 1) / 2;
} else {
cnt += cnt2;
cnt3 -= cnt2;
cnt += cnt3 / 3 * 2;
cnt += cnt3 % 3;
}
cout << cnt << endl;
for (int i = 0; i < record.size(); i++) {
if (record[i].size() == 4 || record[i].size() == 5) {
cout << record[i].size() << endl;
for (int j = 0; j < record[i].size(); j++) cout << record[i][j] << ' ';
cout << endl;
int k = record[i].size();
for (int j = 1; j <= k; j++) cout << record[i][j % k] << ' ';
cout << endl;
} else if (record[i].size() > 5) {
int k = record[i].size();
int sign = 1;
while (k >= 5) {
cout << "5" << endl;
cout << record[i][0] << ' ';
for (int j = sign; j < sign + 4; j++) cout << record[i][j] << ' ';
cout << endl;
for (int j = sign; j < sign + 4; j++) cout << record[i][j] << ' ';
cout << record[i][0] << endl;
sign += 4;
k -= 4;
}
t = record[i].size();
if (k == 2) {
vec.clear();
vec.push_back(record[i][0]);
vec.push_back(record[i][t - 1]);
v2.push_back(vec);
} else if (k == 3) {
vec.clear();
vec.push_back(record[i][t - 2]);
vec.push_back(record[i][t - 1]);
vec.push_back(record[i][0]);
v3.push_back(vec);
} else if (k == 4) {
cout << "4" << endl;
cout << record[i][0] << ' ';
for (int j = t - 3; j < t; j++) cout << record[i][j] << ' ';
cout << endl;
for (int j = t - 3; j < t; j++) cout << record[i][j] << ' ';
cout << record[i][0] << endl;
}
} else if (record[i].size() == 2)
v2.push_back(record[i]);
else
v3.push_back(record[i]);
}
for (int i = 0; i < min(v2.size(), v3.size()); i++) {
cout << "5" << endl;
cout << v2[i][0] << ' ' << v2[i][1] << ' ' << v3[i][0] << ' ' << v3[i][1]
<< ' ' << v3[i][2] << endl;
cout << v2[i][1] << ' ' << v2[i][0] << ' ' << v3[i][1] << ' ' << v3[i][2]
<< ' ' << v3[i][0] << endl;
}
if (v2.size() == v3.size()) return 0;
if (v2.size() > v3.size()) {
t = v3.size();
while (t < v2.size()) {
if (v2.size() > 1 && t < v2.size() - 1) {
cout << "4" << endl;
cout << v2[t][0] << ' ' << v2[t][1] << ' ' << v2[t + 1][0] << ' '
<< v2[t + 1][1] << endl;
cout << v2[t][1] << ' ' << v2[t][0] << ' ' << v2[t + 1][1] << ' '
<< v2[t + 1][0] << endl;
t += 2;
} else {
cout << "2" << endl;
cout << v2[t][0] << ' ' << v2[t][1] << endl;
cout << v2[t][1] << ' ' << v2[t][0] << endl;
t += 1;
}
}
} else {
t = v2.size();
while (t < v3.size()) {
if (v3.size() > 2 && t < v3.size() - 2) {
cout << "5" << endl;
cout << v3[t][0] << ' ' << v3[t][1] << ' ' << v3[t][2] << ' '
<< v3[t + 1][0] << ' ' << v3[t + 1][1] << endl;
cout << v3[t][1] << ' ' << v3[t][2] << ' ' << v3[t][0] << ' '
<< v3[t + 1][1] << ' ' << v3[t + 1][0] << endl;
cout << "5" << endl;
cout << v3[t + 1][0] << ' ' << v3[t + 1][2] << ' ' << v3[t + 2][0]
<< ' ' << v3[t + 2][1] << ' ' << v3[t + 2][2] << endl;
cout << v3[t + 1][2] << ' ' << v3[t + 1][0] << ' ' << v3[t + 2][1]
<< ' ' << v3[t + 2][2] << ' ' << v3[t + 2][0] << endl;
t += 3;
} else {
cout << "3" << endl;
cout << v3[t][0] << ' ' << v3[t][1] << ' ' << v3[t][2] << endl;
cout << v3[t][1] << ' ' << v3[t][2] << ' ' << v3[t][0] << endl;
t++;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int Y[5];
int dp[66000][1001];
int B[14] = {0, 3, 6, 12, 15, 119, 238, 4095, 7, 14, 255, 15, 127, 239};
int D[14] = {0};
void solve() {
int n;
cin >> n;
for (int i = 1; i < 5; i++) cin >> Y[i];
char A[4][n];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < n; j++) cin >> A[i][j];
}
for (int i = 1; i < 4; i++) {
D[i] = Y[2];
}
D[4] = 2 * Y[2];
D[5] = Y[3];
D[6] = Y[3];
D[7] = Y[4];
D[8] = 2 * Y[2];
D[9] = 2 * Y[2];
D[10] = 2 * Y[3];
D[11] = 3 * Y[2];
D[12] = Y[2] + Y[3];
D[13] = D[12];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 1 << 12; j++) {
dp[j][i] = 1e9;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 1 << 12; j++) {
for (int k = 0; k < 14; k++) {
int lol = j;
lol |= B[k];
int a = (j / 16);
a |= B[k];
int val = 0;
for (int l = 0; l < 4; l++) {
if (A[l][i] == '*') {
int uu = (1 << l) & lol;
if (uu == 0) {
val += Y[1];
}
}
}
val += D[k];
dp[a][i + 1] = min(dp[a][i + 1], dp[j][i] + val);
}
}
}
int ans = 1e9;
for (int i = 0; i < 1 << 12; i++) {
ans = min(dp[i][n], ans);
}
cout << ans;
}
int main() {
int t;
t = 1;
while (t--) solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b);
unsigned long long int gcd(unsigned long long int a, unsigned long long int b);
int prime(long long int n);
long long int power(long long int x, long long int y);
long long int nCr(long long int n, long long int r, long long int p);
long long int sum(long long int n) { return (n * (n + 1)) / 2; }
void solve() {
long long int n, x, y, ans = 0;
cin >> n >> x >> y;
string a;
cin >> a;
for (int i = n - x; i < n - y - 1; i++) {
ans += a[i] - '0';
}
if (a[n - y - 1] == '0') ans++;
for (int i = n - y; i < n; i++) {
ans += a[i] - '0';
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1, p = 0;
while (t-- && ++p) {
solve();
}
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
if (a == 1 || b == 1) return 1;
if (b == 0) return a;
return gcd(b, a % b);
}
int prime(long long int n) {
int flag = 1;
for (long long int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
flag = 0;
break;
}
}
return flag;
}
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2) % 1000000007;
if (y % 2 == 0)
return (temp * temp) % 1000000007;
else
return (((x * temp) % 1000000007) * temp) % 1000000007;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
char a[10][10];
int ans;
int main() {
boost();
for (int i = 1; i <= 8; i++)
for (int j = 1; j <= 8; j++) cin >> a[i][j];
for (int j = 1; j <= 8; j++) {
int cnt = 0;
for (int i = 1; i <= 8; i++)
if (a[i][j] == 'B') cnt++;
if (cnt == 8) {
ans++;
for (int i = 1; i <= 8; i++) a[i][j] = 'W';
}
}
for (int i = 1; i <= 8; i++) {
int cnt = 0;
for (int j = 1; j <= 8; j++)
if (a[i][j] == 'B') cnt++;
if (cnt) {
ans++;
for (int j = 1; j <= 8; j++) a[i][j] = 'W';
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5, maxl = 20;
bool mark[maxn];
long long sum = 0, cmp, d[maxn];
pair<long long, long long> par[maxn][maxl];
vector<pair<long long, long long> > adj[maxn];
struct Type_Dsu {
long long par[maxn], h[maxn];
void make_set(long long x) {
par[x] = x;
h[x] = 0;
}
long long findpar(long long x) {
return par[x] = (x == par[x] ? x : findpar(par[x]));
}
bool merge(long long x, long long y) {
x = findpar(x);
y = findpar(y);
if (x == y) return false;
if (d[x] > d[y]) swap(x, y);
par[x] = y;
h[y] += (h[x] == h[y]);
return true;
}
bool same(long long x, long long y) { return (findpar(x) == findpar(y)); }
} dsu;
struct Edge {
long long fi, se, w;
};
vector<Edge> edges;
void input() {
long long n, m;
cin >> n >> m;
cmp = n;
for (long long i = 0; i < n; i++) dsu.make_set(i);
for (long long i = 0; i < m; i++) {
long long fi, se, w;
cin >> fi >> se >> w;
fi--;
se--;
Edge edg;
edg.fi = fi;
edg.se = se;
edg.w = w;
edges.push_back(edg);
}
}
bool comp(Edge a, Edge b) { return (a.w < b.w); }
void mst() {
sort(edges.begin(), edges.end(), comp);
for (long long i = 0; i < edges.size(); i++) {
long long fi = edges[i].fi, se = edges[i].se, w = edges[i].w;
if (!dsu.same(fi, se)) {
cmp--;
sum += w;
dsu.merge(fi, se);
adj[fi].push_back(make_pair(w, se));
adj[se].push_back(make_pair(w, fi));
}
}
}
void dfs(long long x) {
mark[x] = true;
for (long long i = 0; i < adj[x].size(); i++) {
long long child = adj[x][i].second, w = adj[x][i].first;
if (mark[child]) continue;
par[child][0] = make_pair(x, w);
d[child] = d[x] + 1;
for (long long j = 1; j < maxl; j++) {
long long p = par[par[child][j - 1].first][j - 1].first;
long long maxe = max(par[child][j - 1].second,
par[par[child][j - 1].first][j - 1].second);
par[child][j] = make_pair(p, maxe);
}
dfs(child);
}
}
pair<long long, long long> findpar(long long x, long long d) {
long long p = x, maxe = 0;
for (long long i = 0; i < maxl; i++)
if ((d >> i) & 1) {
maxe = max(maxe, par[p][i].second);
p = par[p][i].first;
}
return make_pair(p, maxe);
}
long long lca(long long x, long long y) {
long long maxe = 0;
if (d[x] > d[y]) swap(x, y);
maxe = findpar(y, d[y] - d[x]).second;
y = findpar(y, d[y] - d[x]).first;
if (x == y) return maxe;
for (long long i = maxl - 1; i >= 0; i--)
if (par[x][i].first != par[y][i].first) {
maxe = max(maxe, par[x][i].second);
maxe = max(maxe, par[y][i].second);
x = par[x][i].first;
y = par[y][i].first;
}
maxe = max(maxe, par[x][0].second);
maxe = max(maxe, par[y][0].second);
return maxe;
}
void output() {
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long A, B;
cin >> A >> B;
A--;
B--;
cout << endl;
if (cmp > 2) cout << -1 << endl;
if (cmp == 2)
if (dsu.same(A, B))
cout << -1 << endl;
else
cout << sum << endl;
if (cmp == 1) cout << sum - lca(A, B) << endl;
}
}
int main() {
input();
mst();
dfs(0);
output();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
long long C[MAXN][MAXN];
long long dp[4 * MAXN][MAXN][MAXN];
int n, k;
inline long long add(long long x, long long y) {
return (x + y >= 1000000007) ? x + y - 1000000007 : x + y;
}
inline long long mul(long long x, long long y) { return (x * y) % 1000000007; }
int main() {
scanf("%d%d", &n, &k);
k /= 50;
int ones = 0, twos = 0;
int x;
for (int i = 0; i < (int)(n); i++) {
scanf("%d", &x);
if (x == 50)
ones++;
else
twos++;
}
memset(C, 0, sizeof C);
C[0][0] = C[1][0] = C[1][1] = 1;
for (int i = 2; i < MAXN; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = add(C[i - 1][j], C[i - 1][j - 1]);
}
memset(dp, 0, sizeof dp);
dp[0][ones][twos] = 1;
for (int t = 0; t < 4 * MAXN - 1; t++) {
for (int i = 0; i <= ones; i++) {
for (int j = 0; j <= twos; j++) {
if (dp[t][i][j] == 0) continue;
if (i == 0 && j == 0 && dp[t][i][j] != 0) {
printf("%d\n%I64d\n", t, dp[t][i][j]);
return 0;
}
if (t % 2 == 0) {
for (int ti = 0; ti <= i; ti++) {
if (k - ti < 0) break;
for (int tj = 0; tj <= j; tj++) {
if (k - ti - 2 * tj < 0) break;
if (ti == 0 && tj == 0) continue;
dp[t + 1][i - ti][j - tj] =
add(dp[t + 1][i - ti][j - tj],
mul(mul(dp[t][i][j], C[i][ti]), C[j][tj]));
}
}
} else {
for (int ti = 0; ti <= ones - i; ti++) {
if (k - ti < 0) break;
for (int tj = 0; tj <= twos - j; tj++) {
if (k - ti - 2 * tj < 0) break;
if (ti == 0 && tj == 0) continue;
dp[t + 1][i + ti][j + tj] =
add(dp[t + 1][i + ti][j + tj],
mul(mul(dp[t][i][j], C[ones - i][ti]), C[twos - j][tj]));
}
}
}
}
}
}
printf("-1\n0\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fail() {
cout << "Impossible\n";
exit(0);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int64_t a[2][2];
cin >> a[0][0] >> a[0][1] >> a[1][0] >> a[1][1];
int64_t z = -1, o = -1;
const int64_t maxn = 1e6;
for (int64_t i = 0; i <= maxn; i++) {
if (i * (i - 1) / 2 == a[0][0]) z = i;
if (i * (i - 1) / 2 == a[1][1]) o = i;
}
if (z == -1 || o == -1) fail();
int64_t O = o, Z = z;
int64_t AA[2][2];
AA[0][0] = a[0][0];
AA[0][1] = a[0][1];
AA[1][0] = a[1][0];
AA[1][1] = a[1][1];
for (int64_t A = 0; A <= (a[0][0] == 0); A++)
for (int64_t B = 0; B <= (a[1][1] == 0); B++) {
int64_t a[2][2] = {{AA[0][0], AA[0][1]}, {AA[1][0], AA[1][1]}};
int64_t z = Z - A;
int64_t o = O - B;
int64_t n = o + z;
if (n > maxn || n == 0) continue;
string s;
for (int64_t i = 0; i < n; i++) {
if (o <= a[0][1] && z > 0) {
a[0][1] -= o;
z--;
s += "0";
} else {
a[1][0] -= z;
o--;
s += "1";
}
}
if (a[0][1] == 0 && a[1][0] == 0 && o == 0 && z == 0) {
cout << s << "\n";
return 0;
}
}
fail();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long p, d, resp;
int qtd;
long long twilightsparkleisbestpony[20];
long long get(int x) {
return ((p / twilightsparkleisbestpony[x]) * twilightsparkleisbestpony[x]) -
1LL;
}
bool test(int x) { return ((p + 1LL) % twilightsparkleisbestpony[x]) == 0LL; }
int main() {
cin.sync_with_stdio(false);
twilightsparkleisbestpony[0] = 1LL;
for (int i = 1; i < 19; ++i)
twilightsparkleisbestpony[i] = (twilightsparkleisbestpony[i - 1] << 3) +
(twilightsparkleisbestpony[i - 1] << 1);
cin >> p >> d;
qtd = 0;
for (int i = 0; i < 18; ++i) {
if (test(i) || ((p - get(i)) <= d)) qtd = i;
}
if (test(qtd))
cout << p << endl;
else
cout << get(qtd) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool sortcol(const vector<long long int>& v1, const vector<long long int>& v2) {
if (v1[0] == v2[0]) {
return v1[1] < v2[1];
}
return v1[0] < v2[0];
}
int main() {
long long int n, a;
cin >> n;
vector<vector<long long int>> ar;
for (int i = 0; i < n; i++) {
cin >> a;
ar.push_back(vector<long long int>());
ar[i].push_back(a);
cin >> a;
ar[i].push_back(a);
}
sort(ar.begin(), ar.end(), sortcol);
a = ar[0][1];
for (int i = 0; i < n; i++) {
if (a > ar[i][1]) {
a = ar[i][0];
} else {
a = ar[i][1];
}
}
cout << a;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n;
int main() {
cin >> n;
int lx = INF, rx = -INF, ly = INF, ry = -INF, lz = INF, rz = -INF;
for (int i = (1); i <= (n); ++i) {
string s;
cin >> s;
int x = 0, y = 0;
for (char c : s) {
if (c == 'B')
++x;
else
++y;
}
lx = min(lx, x), rx = max(rx, x);
ly = min(ly, y), ry = max(ry, y);
lz = min(lz, x - y), rz = max(rz, x - y);
}
int ans = INF, ax = 0, ay = 0, az = 0;
auto calc = [&]() {
int l = 0, r = lz - (lx - ry), mid;
auto check = [&](int a) {
return lx + a + a >= rx && lx - ry + a + a + a >= rz && ry - a - a <= ly;
};
if (check(r) == 0) return INF;
while (l < r) mid = (l + r) >> 1, check(mid) ? r = mid : l = mid + 1;
return l;
};
for (int _ = (1); _ <= (6); ++_) {
assert(lx <= rx && ly <= ry && lz <= rz);
int v = calc();
if (v < ans) {
ans = v;
ax = lx + v, ay = ry - v, az = ax - ay;
}
int Lx = ly, Rx = ry, Ly = -rz, Ry = -lz, Lz = lx, Rz = rx;
lx = Lx, rx = Rx, ly = Ly, ry = Ry, lz = Lz, rz = Rz;
int Ax = ay, Ay = -az, Az = ax;
ax = Ax, ay = Ay, az = Az;
}
cout << ans << endl;
for (int i = (1); i <= (ax); ++i) cout << 'B';
for (int i = (1); i <= (ay); ++i) cout << 'N';
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string kata, kat, tmp;
int i, j, t;
bool val, cek;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> kata;
cin >> kat;
kata.length() < kat.length() ? cek = 0 : cek = 1;
if (cek == 0) {
cout << 0 << "\n";
return 0;
}
for (i = 0; i <= kata.length() - kat.length(); i++) {
val = 1;
for (j = i; j < i + kat.length(); j++) {
if (val == 0) break;
kata[j] != kat[j - i] ? val = 0 : val = val;
if (val == 0) break;
}
(val) ? t++ : t = t;
val ? i += kat.length() - 1 : i = i;
}
cout << t << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, x, player1, player2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
player1 = 1;
player2 = 2;
cin >> n;
while (n-- && cin >> x) {
if (x != player1 && x != player2) return cout << "NO" << endl, 0;
;
int val = 1 + 2 + 3 - player1 - player2;
if (x == player1)
player2 = val;
else
player1 = val;
}
cout << "YES" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, c[((long long)401 * 1000)], mark[((long long)401 * 1000)];
vector<int> v[4];
multiset<long long> s, del;
long long sum_s, sz;
void add(int x) {
s.insert(x);
sum_s += x;
if (s.size() <= sz) return;
auto it = s.end();
it--;
sum_s -= *it;
del.insert(*it);
s.erase(it);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
int ex;
scanf("%d", &ex);
for (int i = 0; i < ex; i++) {
int x;
scanf("%d", &x);
mark[x] |= 1;
}
if (ex < k) return cout << -1, 0;
scanf("%d", &ex);
for (int i = 0; i < ex; i++) {
int x;
scanf("%d", &x);
mark[x] |= 2;
}
if (ex < k) return cout << -1, 0;
for (int i = 1; i <= n; i++) v[mark[i]].push_back(c[i]);
for (int i = 0; i < 4; i++) sort(v[i].begin(), v[i].end());
long long ans = ((long long)2e18), res = 0;
int i = max({0, k - min((int)v[1].size(), (int)v[2].size()),
m - (int)v[0].size() - (int)v[1].size() - (int)v[2].size()}),
maxi = min((int)v[3].size(), m);
if (i <= k)
sz = m - 2 * k + i;
else
sz = m - i;
if (sz < 0) i -= sz, sz = 0;
if (i > maxi) return cout << -1, 0;
for (int j = 0; j < k - i; j++) res += v[1][j], res += v[2][j];
for (int j = 0; j < i; j++) res += v[3][j];
for (auto u : v[0]) add(u);
for (int j = (int)v[1].size() - 1; j >= max(0, k - i); j--) add(v[1][j]);
for (int j = (int)v[2].size() - 1; j >= max(0, k - i); j--) add(v[2][j]);
if (s.size() == sz) ans = res + sum_s;
i++;
for (; i <= maxi; i++) {
res += v[3][i - 1];
if (i <= k)
res -= v[1][k - i], res -= v[2][k - i], add(v[2][k - i]),
add(v[1][k - i]);
;
if (i <= k)
sz++;
else {
sz--;
if (sz < 0) break;
if (sz < s.size()) {
auto it = s.end();
it--;
sum_s -= *it;
del.insert(*it);
s.erase(it);
}
}
if (del.size()) {
long long ex = *del.begin();
del.erase(del.begin());
add(ex);
}
if (s.size() == sz) ans = min(ans, res + sum_s);
}
if (ans > (long long)1e18) return cout << -1, 0;
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 2e5 + 5;
int n, a[MAXN], b[MAXN], m;
int nxt[MAXN];
inline void build(int str[]) {
int j = 0;
nxt[1] = 0;
for (int i = 2; i <= m; ++i) {
while (j && str[i] != str[j + 1]) j = nxt[j];
if (str[i] == str[j + 1]) ++j;
nxt[i] = j;
}
}
int main() {
scanf("%d%d", &n, &m);
if (m == 1) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= m; ++i) scanf("%d", b + i);
for (int i = 1; i <= n; ++i) a[i] -= a[i + 1];
for (int i = 1; i <= m; ++i) b[i] -= b[i + 1];
--n;
--m;
build(b);
int j = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
while (j && a[i] != b[j + 1]) j = nxt[j];
if (a[i] == b[j + 1]) ++j;
if (j == m) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int par[1000009], a[1000009];
long long mod = 1000000007;
inline int parent(int pos) {
if (par[pos] != pos) {
par[pos] = parent(par[pos]);
}
return par[pos];
}
int main() {
long long p, k;
scanf("%lld", &p);
scanf("%lld", &k);
if (k == 0) {
long long ans = 1;
for (int i = 0; i < p - 1; i++) {
ans = ans * p;
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
for (int i = 0; i <= p; i++) {
par[i] = i;
}
for (long long i = 0; i < p; i++) {
long long x = (i * k) % p;
int p1 = parent(i);
int p2 = parent(x);
if (p1 != p2) {
par[p1] = p2;
}
}
for (int i = 0; i < p; i++) {
int x = parent(i);
a[x] = 1;
}
int cnt = 0;
for (int i = 0; i < p; i++) {
if (a[i]) {
cnt++;
}
}
if (k != 1) cnt--;
long long ans = 1;
for (int i = 0; i < cnt; i++) {
ans = ans * p;
ans %= mod;
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, int> res;
int ask(int m) {
int l = m;
int r = m + n / 2;
cout << "? " << l << endl;
int x, y;
cin >> x;
cout << "? " << r << endl;
cin >> y;
return x - y;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
while (cin >> n) {
int first = ask(1);
if (first == 0) {
cout << "! 1" << endl;
return 0;
}
if (abs(first) & 1) {
cout << "! -1" << endl;
return 0;
}
res[1] = first;
res[n / 2 + 1] = -first;
int l = 1, r = n / 2 + 1, ans = -1;
while (l < r) {
int m = (l + r) >> 1;
res[m] = ask(m);
if (res[m] == 0) {
ans = m;
break;
} else if ((long long)res[m] * res[l] < 0)
r = m;
else
l = m;
}
cout << "! " << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
long long x, y, m, r = 0, d, aux;
scanf("%I64d%I64d%I64d", &x, &y, &m);
if (x > y) {
aux = x;
x = y;
y = aux;
}
if (y >= m) {
printf("0\n");
return 0;
}
if (y <= 0) {
printf("-1\n");
return 0;
}
while (y < m) {
d = (y - x) / y + 1;
r += d;
if (m - y * d <= x) break;
x += y * d;
aux = x;
x = y;
y = aux;
}
printf("%I64d\n", r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, an[30010][6];
char a[110][110];
signed main() {
cin >> t;
while (t--) {
scanf("%lld%lld", &n, &m);
for (long long i = 0; i < n; i++) {
scanf("%s", a[i]);
}
long long ans = 0;
for (long long i = 0; i + 2 < n; i++) {
for (long long j = 0; j < m - 1; j++) {
if (a[i][j] == '0' && a[i + 1][j] == '1') {
an[++ans][0] = i + 1;
an[ans][1] = j;
an[ans][2] = i;
an[ans][3] = j + 1;
an[ans][4] = i + 1;
an[ans][5] = j + 1;
a[i + 1][j] = '0';
a[i][j + 1] = 1 - (a[i][j + 1] - '0') + '0';
a[i + 1][j + 1] = 1 - (a[i + 1][j + 1] - '0') + '0';
} else if (a[i][j] == '1' && a[i + 1][j] == '0') {
an[++ans][0] = i;
an[ans][1] = j;
an[ans][2] = i;
an[ans][3] = j + 1;
an[ans][4] = i + 1;
an[ans][5] = j + 1;
a[i][j] = '0';
a[i][j + 1] = 1 - (a[i][j + 1] - '0') + '0';
a[i + 1][j + 1] = 1 - (a[i + 1][j + 1] - '0') + '0';
} else if (a[i][j] == '1' && a[i + 1][j] == '1') {
an[++ans][0] = i + 1;
an[ans][1] = j;
an[ans][2] = i;
an[ans][3] = j;
an[ans][4] = i;
an[ans][5] = j + 1;
a[i + 1][j] = '0';
a[i][j] = '0';
a[i][j + 1] = 1 - (a[i][j + 1] - '0') + '0';
}
}
if (a[i][m - 1] == '0' && a[i + 1][m - 1] == '1') {
a[i + 1][m - 1] = '0';
a[i + 2][m - 1] = 1 - (a[i + 2][m - 1] - '0') + '0';
a[i + 2][m - 2] = 1 - (a[i + 2][m - 2] - '0') + '0';
an[++ans][0] = i + 1;
an[ans][1] = m - 1;
an[ans][2] = i + 2;
an[ans][3] = m - 1;
an[ans][4] = i + 2;
an[ans][5] = m - 2;
} else if (a[i][m - 1] == '1' && a[i + 1][m - 1] == '0') {
a[i][m - 1] = '0';
a[i + 2][m - 1] = 1 - (a[i + 2][m - 1] - '0') + '0';
an[++ans][0] = i;
an[ans][1] = m - 1;
an[ans][2] = i + 1;
an[ans][3] = m - 1;
an[ans][4] = i + 1;
an[ans][5] = m - 2;
an[++ans][0] = i + 2;
an[ans][1] = m - 1;
an[ans][2] = i + 1;
an[ans][3] = m - 1;
an[ans][4] = i + 1;
an[ans][5] = m - 2;
} else if (a[i][m - 1] == '1' && a[i + 1][m - 1] == '1') {
a[i][m - 1] = '0';
a[i + 1][m - 1] = '0';
a[i + 2][m - 1] = 1 - (a[i + 2][m - 1] - '0') + '0';
a[i + 2][m - 2] = 1 - (a[i + 2][m - 2] - '0') + '0';
an[++ans][0] = i;
an[ans][1] = m - 1;
an[ans][2] = i + 1;
an[ans][3] = m - 1;
an[ans][4] = i + 1;
an[ans][5] = m - 2;
an[++ans][0] = i + 2;
an[ans][1] = m - 1;
an[ans][2] = i + 2;
an[ans][3] = m - 2;
an[ans][4] = i + 1;
an[ans][5] = m - 2;
}
}
for (long long j = 0; j < m - 1; j++) {
long long i = n - 2;
if (a[i][j] == '0' && a[i + 1][j] == '1') {
an[++ans][0] = i + 1;
an[ans][1] = j;
an[ans][2] = i;
an[ans][3] = j + 1;
an[ans][4] = i + 1;
an[ans][5] = j + 1;
a[i + 1][j] = '0';
a[i][j + 1] = 1 - (a[i][j + 1] - '0') + '0';
a[i + 1][j + 1] = 1 - (a[i + 1][j + 1] - '0') + '0';
} else if (a[i][j] == '1' && a[i + 1][j] == '0') {
an[++ans][0] = i;
an[ans][1] = j;
an[ans][2] = i;
an[ans][3] = j + 1;
an[ans][4] = i + 1;
an[ans][5] = j + 1;
a[i][j] = '0';
a[i][j + 1] = 1 - (a[i][j + 1] - '0') + '0';
a[i + 1][j + 1] = 1 - (a[i + 1][j + 1] - '0') + '0';
} else if (a[i][j] == '1' && a[i + 1][j] == '1') {
an[++ans][0] = i + 1;
an[ans][1] = j;
an[ans][2] = i;
an[ans][3] = j;
an[ans][4] = i;
an[ans][5] = j + 1;
a[i + 1][j] = '0';
a[i][j] = '0';
a[i][j + 1] = 1 - (a[i][j + 1] - '0') + '0';
}
}
if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 2;
an[ans][1] = m - 1;
an[ans][2] = n - 1;
an[ans][3] = m - 1;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 2][m - 1] = '0';
a[n - 1][m - 1] = '0';
a[n - 2][m - 2] = '0';
}
if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 1;
an[ans][1] = m - 1;
an[ans][2] = n - 1;
an[ans][3] = m - 2;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 1][m - 1] = '0';
a[n - 1][m - 2] = '1';
a[n - 2][m - 2] = '1';
} else if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 1;
an[ans][1] = m - 2;
an[ans][2] = n - 1;
an[ans][3] = m - 1;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 1][m - 2] = '0';
a[n - 1][m - 1] = '1';
a[n - 2][m - 2] = '1';
} else if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 2;
an[ans][1] = m - 1;
an[ans][2] = n - 1;
an[ans][3] = m - 1;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 2][m - 1] = '0';
a[n - 1][m - 1] = '1';
a[n - 2][m - 2] = '1';
} else if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 1;
an[ans][1] = m - 1;
an[ans][2] = n - 1;
an[ans][3] = m - 2;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 1][m - 1] = '1';
a[n - 1][m - 2] = '1';
a[n - 2][m - 2] = '0';
}
if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 2;
an[ans][1] = m - 1;
an[ans][2] = n - 1;
an[ans][3] = m - 2;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 2][m - 1] = '0';
a[n - 1][m - 2] = '1';
a[n - 2][m - 2] = '1';
} else if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 1;
an[ans][1] = m - 2;
an[ans][2] = n - 2;
an[ans][3] = m - 1;
an[ans][4] = n - 2;
an[ans][5] = m - 2;
a[n - 1][m - 2] = '0';
a[n - 2][m - 1] = '1';
a[n - 2][m - 2] = '1';
} else if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 2;
an[ans][1] = m - 1;
an[ans][2] = n - 2;
an[ans][3] = m - 2;
an[ans][4] = n - 1;
an[ans][5] = m - 1;
a[n - 2][m - 1] = '0';
a[n - 1][m - 1] = '1';
a[n - 2][m - 2] = '1';
} else if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 2;
an[ans][1] = m - 2;
an[ans][2] = n - 2;
an[ans][3] = m - 1;
an[ans][4] = n - 1;
an[ans][5] = m - 2;
a[n - 2][m - 1] = '1';
a[n - 1][m - 2] = '1';
a[n - 2][m - 2] = '0';
} else if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 2;
an[ans][1] = m - 2;
an[ans][2] = n - 2;
an[ans][3] = m - 1;
an[ans][4] = n - 1;
an[ans][5] = m - 1;
a[n - 2][m - 2] = '0';
a[n - 1][m - 1] = '1';
a[n - 2][m - 1] = '1';
} else if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 2;
an[ans][1] = m - 2;
an[ans][2] = n - 1;
an[ans][3] = m - 2;
an[ans][4] = n - 1;
an[ans][5] = m - 1;
a[n - 2][m - 2] = '0';
a[n - 1][m - 2] = '1';
a[n - 1][m - 1] = '1';
}
if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '0') {
an[++ans][0] = n - 2;
an[ans][1] = m - 2;
an[ans][2] = n - 2;
an[ans][3] = m - 1;
an[ans][4] = n - 1;
an[ans][5] = m - 2;
} else if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '0' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 2;
an[ans][1] = m - 2;
an[ans][2] = n - 2;
an[ans][3] = m - 1;
an[ans][4] = n - 1;
an[ans][5] = m - 1;
} else if (a[n - 2][m - 2] == '1' && a[n - 2][m - 1] == '0' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 2;
an[ans][1] = m - 2;
an[ans][2] = n - 1;
an[ans][3] = m - 1;
an[ans][4] = n - 1;
an[ans][5] = m - 2;
} else if (a[n - 2][m - 2] == '0' && a[n - 2][m - 1] == '1' &&
a[n - 1][m - 2] == '1' && a[n - 1][m - 1] == '1') {
an[++ans][0] = n - 1;
an[ans][1] = m - 1;
an[ans][2] = n - 2;
an[ans][3] = m - 1;
an[ans][4] = n - 1;
an[ans][5] = m - 2;
}
cout << ans << endl;
for (long long i = 1; i <= ans; i++) {
for (long long j = 0; j <= 5; j++) {
printf("%lld ", an[i][j] + 1);
}
puts("");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int& x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
struct OP {
long long a, b;
char ch;
void pr() { cout << a << " " << ch << " " << b << "\n"; }
} ops[MAXN];
int x, n, m;
long long have[MAXN];
long long make(long long a, long long b, char ch) {
ops[n++] = {a, b, ch};
if (ch == '^') {
have[m++] = a ^ b;
} else {
have[m++] = a + b;
}
return have[m - 1];
}
long long basis[60], sz;
void insert(long long xx, vector<OP>& now) {
bool ok = false;
for (int b = 59; ~b; --b) {
if (xx >> b & 1) {
if (!basis[b]) {
basis[b] = xx;
++sz;
ok = true;
}
now.push_back({xx, basis[b], '^'});
xx ^= basis[b];
}
}
if (!ok) {
now.clear();
for (OP& op : now) make(op.a, op.b, op.ch);
}
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int r(int a, int b) { return a + rng() % (b - a + 1); }
void solve(bool codeforces = true) {
memset(basis, 0, sizeof basis);
n = m = sz = 0;
if (codeforces) cin >> x;
vector<OP> now;
insert(x, now);
have[m++] = x;
make(x, x, '+');
set<array<int, 3>> seen;
while (!basis[0]) {
int a, b;
a = r(0, m - 1);
b = r(0, m - 1);
if (a > b) {
swap(a, b);
}
char ch = "^+"[r(1, 100) <= 60];
if (seen.count({a, b, ch})) continue;
long long y = ch == '+' ? have[a] + have[b] : (have[a] ^ have[b]);
if (y >= (1LL << 60)) continue;
if (!have[a] || !have[b]) continue;
now.clear();
insert(y, now);
if (!now.empty()) {
make(have[a], have[b], ch);
for (OP& op : now) make(op.a, op.b, op.ch);
}
seen.insert({a, b, ch});
}
cerr << n << "\n";
cout << n << "\n";
for (int i = 0; i < n; i++) {
ops[i].pr();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 250000 + 10;
vector<int> lis[MAXN * 4];
long long d[MAXN], r[MAXN];
int F[MAXN], G[MAXN], first, second, n, T, s[MAXN * 4];
pair<long long, int> coorX[MAXN * 4];
pair<int, int> coorY[MAXN * 4];
int tx, ty, rankx[MAXN * 4], ranky[MAXN * 4];
pair<int, int> p[MAXN], q[MAXN], tmp[MAXN];
int Read() {
char ch = getchar();
while (!(ch >= '0' && ch <= '9') && ch != '-') ch = getchar();
int first = 0, p = 1;
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') first = first * 10 + ch - '0', ch = getchar();
return first * p;
}
long long sqr(int first) { return (long long)first * first; }
int lowbit(int first) { return first & -first; }
void Insert(int first, int p) {
for (; first <= T; first += lowbit(first)) lis[first].push_back(p);
}
double X;
void init() {
first = Read();
second = Read();
F[0] = Read();
r[0] = Read();
n = Read();
r[0] = sqr(r[0]);
coorX[++tx] = make_pair(r[0], 0);
coorY[++ty] = make_pair(F[0], 0);
for (int i = 1; i <= n; ++i) {
int xx, yy, rr;
xx = Read();
yy = Read();
G[i] = Read();
F[i] = Read();
rr = Read();
coorX[++tx] = make_pair(sqr(xx - first) + sqr(yy - second), i * 2 - 1);
coorX[++tx] = make_pair(sqr(rr), i * 2);
coorY[++ty] = make_pair(G[i], i * 2 - 1),
coorY[++ty] = make_pair(F[i], i * 2);
d[i] = sqr(xx - first) + sqr(yy - second);
r[i] = sqr(rr);
}
sort(coorX + 1, coorX + tx + 1);
sort(coorY + 1, coorY + ty + 1);
rankx[coorX[1].second] = 1;
for (int i = 2; i <= tx; ++i)
rankx[coorX[i].second] =
rankx[coorX[i - 1].second] + (coorX[i].first != coorX[i - 1].first);
T = rankx[coorX[tx].second];
ranky[coorY[1].second] = 1;
for (int i = 2; i <= ty; ++i)
ranky[coorY[i].second] =
ranky[coorY[i - 1].second] + (coorY[i].first != coorY[i - 1].first);
q[0] = make_pair(rankx[0], ranky[0]);
for (int i = 1; i <= n; ++i)
p[i] = make_pair(rankx[i * 2 - 1], ranky[i * 2 - 1]),
q[i] = make_pair(rankx[i * 2], ranky[i * 2]),
tmp[i] = make_pair(p[i].second, i);
sort(tmp + 1, tmp + n + 1);
for (int i = 1; i <= n; ++i) Insert(p[tmp[i].second].first, tmp[i].second);
}
int head, tail, que[MAXN];
bool sel[MAXN];
void Query(const pair<int, int>& q) {
for (int first = q.first; first; first -= lowbit(first))
for (; s[first] < (int)lis[first].size() &&
q.second >= p[lis[first][s[first]]].second;
++s[first])
if (!sel[lis[first][s[first]]]) {
sel[lis[first][s[first]]] = true;
que[++tail] = lis[first][s[first]];
}
}
void solve() {
head = 0, tail = 1;
que[1] = 0;
while (head < tail) Query(q[que[++head]]);
int CC = 0;
for (int i = 1; i <= n; ++i) CC += sel[i];
cout << CC << endl;
}
int main() {
init();
solve();
fclose(stdin);
fclose(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int mod(int i, int p) { return (i + p) % p; }
const int MAXN = 36;
int n, m;
set<vector<int>> poss;
int mtry[11][MAXN];
int c[15];
void dfsGen(int v[], int d, int ucnt, int ccnt) {
if (d == n) {
if (ucnt == ccnt) {
vector<int> nv;
for (int i = 0; i < n; i++) {
nv.push_back(v[i]);
}
poss.insert(nv);
}
return;
}
int p = n - 1 - d;
if (!(ccnt <= ucnt + p + 1)) {
return;
}
if (ucnt < ccnt) {
v[d] = mtry[0][d];
dfsGen(v, d + 1, ucnt + 1, ccnt);
}
v[d] = !mtry[0][d];
dfsGen(v, d + 1, ucnt, ccnt);
}
int eqcmp(int a[], const vector<int>& b) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) {
cnt++;
}
}
return cnt;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
string s;
cin >> s >> c[i];
for (int j = 0; j < n; j++) {
mtry[i][j] = s[j] - '0';
}
}
int v[MAXN];
dfsGen(v, 0, 0, c[0]);
for (int i = 1; i < m; i++) {
auto it = poss.begin();
for (; it != poss.end();) {
int ocnt = eqcmp(mtry[i], *it);
if (c[i] != ocnt) {
poss.erase(it++);
} else {
++it;
}
}
}
cout << poss.size() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, ile_cykli, ile;
int id_cykl[100007], stos[100007];
vector<int> v[100007], cykle[100007];
bool bylo[100007], wazne[100007], czy_bonus[100007];
void dfs(int x, int f) {
bylo[x] = true;
stos[ile++] = x;
for (__typeof((v[x]).begin()) it = ((v[x]).begin()); it != (v[x]).end(); it++)
if (*it != f) {
if (bylo[*it]) {
if (!id_cykl[*it]) {
++ile_cykli;
int pom = 1;
while (stos[ile - pom] != *it) {
id_cykl[stos[ile - pom]] = ile_cykli;
cykle[ile_cykli].push_back(stos[ile - pom]);
++pom;
}
id_cykl[stos[ile - pom]] = ile_cykli;
cykle[ile_cykli].push_back(stos[ile - pom]);
}
} else
dfs(*it, x);
}
--ile;
}
bool dfs2(int x, int f) {
for (__typeof((v[x]).begin()) it = ((v[x]).begin()); it != (v[x]).end(); it++)
if (*it != f) {
if (id_cykl[*it] || wazne[*it] || dfs2(*it, x)) wazne[x] = true;
}
return wazne[x];
}
void kaktus(int n) {
for (int i = 1; i <= (n); i++)
if (!bylo[i]) {
ile = 0;
dfs(i, 0);
}
for (int i = 1; i <= (n); i++)
if (id_cykl[i]) dfs2(i, 0);
}
int dfs3(int x, int f) {
int res = 0, ile_razem = 0, ile_bonus = 0;
bool czy_bonusx = false;
if (!id_cykl[x]) {
cykle[++ile_cykli].push_back(x);
id_cykl[x] = ile_cykli;
}
for (__typeof((cykle[id_cykl[x]]).begin()) it = ((cykle[id_cykl[x]]).begin());
it != (cykle[id_cykl[x]]).end(); it++) {
int pom_ile_bonus = 0, pom_ile_razem = 0;
for (__typeof((v[*it]).begin()) it2 = ((v[*it]).begin());
it2 != (v[*it]).end(); it2++)
if (*it2 != f && id_cykl[*it2] != id_cykl[x]) {
res += dfs3(*it2, *it);
pom_ile_bonus += czy_bonus[*it2];
pom_ile_razem++;
}
res += (pom_ile_razem + 1) / 2 - pom_ile_bonus;
ile_bonus += (pom_ile_razem & 1);
if (*it == x && (pom_ile_razem & 1)) czy_bonusx = true;
if (pom_ile_razem) ++ile_razem;
}
if ((int)cykle[id_cykl[x]].size() == 1) {
czy_bonus[x] = ile_bonus >= 1;
return res;
} else {
int result = res + 1;
if (ile_razem >= 2) {
--result;
czy_bonus[x] = czy_bonusx;
} else {
if (!(ile_razem == 1 && ile_bonus == 0 && v[x].size() > 3))
czy_bonus[x] = (ile_razem >= 1);
}
return result;
}
return -1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
kaktus(n);
int x = dfs3(1, 0);
printf("%d %d\n", x, m);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long x, n;
cin >> x >> n;
if (n == 0) {
cout << x << endl;
continue;
}
long long xxx = n - 1;
long long t2 = xxx % 4;
long long temp = (xxx / 4);
long long n1, n2, n3, n4;
if (t2 == 0) {
n1 = n2 = n3 = n4 = temp;
} else if (t2 == 1) {
n1 = temp + 1;
n2 = n3 = n4 = temp;
} else if (t2 == 2) {
n1 = n2 = (temp + 1);
n3 = n4 = temp;
} else if (t2 == 3) {
n1 = n2 = n3 = (temp + 1);
n4 = temp;
}
long long s1 = (n1 * (4 * n1)) / 2;
long long s2 = (n2 * (2 + 4 * n2)) / 2;
long long s3 = (n3 * (4 + 4 * n3)) / 2;
long long s4 = (n4 * (6 + 4 * n4)) / 2;
if (x % 2 == 0) {
x += s1 + s2;
x -= (1 + s3 + s4);
} else {
x += (1 + s3 + s4);
x -= (s1 + s2);
}
cout << x << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int mod = 1000000007;
const double PI = acos(-1.0);
struct node {
int x, y;
node() {}
node(int xx, int yy) {
x = xx;
y = yy;
}
};
int a[105];
int b[105];
int c[105];
char s[105][105];
bool vis[105][105];
int n, m, k;
int ans;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
struct aa {
vector<node> v;
int l;
bool operator<(const aa b) const { return l > b.l; }
};
priority_queue<aa> q;
int main() {
int tt, ca = 1;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) {
if (s[i][0] == '.') {
s[i][0] = '#';
queue<node> que;
node t;
t.x = i;
t.y = 0;
que.push(t);
while (!que.empty()) {
t = que.front();
que.pop();
for (int j = 0; j < 4; j++) {
int x = t.x + dx[j];
int y = t.y + dy[j];
if (x < 0 || x >= n << y < 0 || y >= m) continue;
if (s[x][y] != '.') continue;
s[x][y] = '#';
que.push(node{x, y});
}
}
}
}
for (int i = 0; i < n; i++) {
if (s[i][m - 1] == '.') {
s[i][m - 1] = '#';
queue<node> que;
node t;
t.x = i;
t.y = m - 1;
que.push(t);
while (!que.empty()) {
t = que.front();
que.pop();
for (int j = 0; j < 4; j++) {
int x = t.x + dx[j];
int y = t.y + dy[j];
if (x < 0 || x >= n << y < 0 || y >= m) continue;
if (s[x][y] != '.') continue;
s[x][y] = '#';
que.push(node{x, y});
}
}
}
}
for (int i = 0; i < m; i++) {
if (s[0][i] == '.') {
s[0][i] = '#';
queue<node> que;
node t;
t.x = 0;
t.y = i;
que.push(t);
while (!que.empty()) {
t = que.front();
que.pop();
for (int j = 0; j < 4; j++) {
int x = t.x + dx[j];
int y = t.y + dy[j];
if (x < 0 || x >= n << y < 0 || y >= m) continue;
if (s[x][y] != '.') continue;
s[x][y] = '#';
que.push(node{x, y});
}
}
}
}
for (int i = 0; i < m; i++) {
if (s[n - 1][i] == '.') {
s[n - 1][i] = '#';
queue<node> que;
node t;
t.x = n - 1;
t.y = i;
que.push(t);
while (!que.empty()) {
t = que.front();
que.pop();
for (int j = 0; j < 4; j++) {
int x = t.x + dx[j];
int y = t.y + dy[j];
if (x < 0 || x >= n << y < 0 || y >= m) continue;
if (s[x][y] != '.') continue;
s[x][y] = '#';
que.push(node{x, y});
}
}
}
}
int xxx = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != '.') continue;
s[i][j] = '#';
xxx++;
aa p;
queue<node> que;
node t;
t.x = i;
t.y = j;
que.push(t);
p.v.push_back(t);
;
p.l = 1;
while (!que.empty()) {
t = que.front();
que.pop();
for (int kk = 0; kk < 4; kk++) {
int x = t.x + dx[kk];
int y = t.y + dy[kk];
if (x < 0 || x >= n << y < 0 || y >= m) continue;
if (s[x][y] != '.') continue;
s[x][y] = '#';
que.push(node{x, y});
p.v.push_back(node(x, y));
;
p.l++;
}
}
q.push(p);
}
}
for (int i = 0; xxx - i > k; i++) {
aa p = q.top();
q.pop();
ans += p.l;
for (int j = 0; j < p.v.size(); j++) {
int x = p.v[j].x;
int y = p.v[j].y;
s[x][y] = '*';
}
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '*')
printf("*");
else
printf(".");
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int f[3][300005], n, k, q[1000005];
int main() {
scanf("%d%d", &n, &k);
memset(f, 127, sizeof(f));
f[0][0] = 0;
int opt = 0;
for (int i = 1; i <= k; i++) {
opt = !opt;
int l, r, h = 1, t = 0;
scanf("%d%d", &l, &r);
for (int j = 0; j <= r; j++) {
if (j <= n) {
while (h <= t && f[!opt][j] <= f[!opt][q[t]]) t--;
q[++t] = j;
}
while (h <= t && q[h] < j - (r - l)) h++;
f[opt][j] = min(f[!opt][j], f[!opt][q[h]] + 2);
}
h = 1, t = 0;
for (int j = r; j >= 0; j--) {
if (r - j <= n) {
while (h <= t && f[!opt][r - j] <= f[!opt][q[t]]) t--;
q[++t] = r - j;
}
while (h <= t && q[h] < l - j) h++;
f[opt][j] = min(f[opt][j], f[!opt][q[h]] + 1);
}
}
if (f[opt][n] > 1000000)
printf("Hungry");
else
printf("Full\n%d", f[opt][n]);
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define sz(s) (int)s.size()
#define f first
#define s second
#define pb push_back
#define all(s) s.begin(), s.end()
#define vi vector<int>
#define vvi vector<vi>
#define ll long long
#define vll vector<ll>
#define ii pair<int, int>
#define vii vector<ii>
#define vvii vector<vii>
const int INF = 1e9 + 7;
const int mod = INF;
const int N = 1e6 + 7;
const int T = 1 << 20;
#define ld long double
int n, k;
void solve(){
cin >> n;
vector<set<int> > sasiedzi(1 << n);
for(int i = 0; i < n * (1 << (n - 1)); i++){
int a, b;
cin >> a >> b;
sasiedzi[a].insert(b);
sasiedzi[b].insert(a);
}
vector<int> perm(1 << n);
vector<int> used(1 << n);
perm[0] = 0;
used[0] = 1;
int cnt = 0;
for(auto & u : sasiedzi[0]){
perm[(1 << cnt)] = u;
used[u] = 1;
cnt++;
}
for(int i = 1; i < (1 << n); i++){
if(perm[i] == 0){
assert(__builtin_popcount(i) >= 2);
int a = -1, b = -1;
for(int bit = 0; bit < n; bit++){
if(i & (1 << bit)){
a = bit;
break;
}
}
for(int bit = a + 1; bit < n; bit++){
if(i & (1 << bit)){
b = bit;
break;
}
}
assert(a >= 0 and b >= 0);
//
int A = i ^ (1 << a);
int B = i ^ (1 << b);
bool found = 0;
for(auto & u : sasiedzi[perm[A]]){
if(!used[u] and sasiedzi[perm[B]].count(u)){
perm[i] = u;
used[u] = 1;
found = true;
break;
}
}
assert(found);
}
}
for(int i = 0; i < (1 << n); i++)
cout << perm[i] << ' ';
cout << '\n';
if(__builtin_popcount(n) > 1){
cout << -1 << '\n';
}
else{
vi kolor(1 << n);
for(int i = 0; i < (1 << n); i++){
int col = 0;
for(int j = 0; j < n; j++)
if(i & (1 << j))
col ^= j;
kolor[perm[i]] = col;
}
for(auto & u : kolor)
cout << u << ' ';
cout << '\n';
}
}
signed main(){
ios::sync_with_stdio(0);
cin.tie(0);
int test = 1;
cin >> test;
// cout << setprecision(10) << fixed;
for(int i = 0; i < test; i++)
solve();
}
| 9 |
#include <bits/stdc++.h>
const long long N = 1000006;
using namespace std;
const long long MOD = 1000000009LL;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T power(T x, T y, long long m = MOD) {
T ans = 1;
while (y > 0) {
if (y & 1LL) ans = (ans * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return ans % m;
}
int32_t main() {
long long n, m, k;
cin >> n >> m >> k;
long long free = (n / k) * (k - 1) + n % k;
if (m <= free) {
cout << m;
return 0;
}
long long rem = m - free;
long long a = power(2LL, rem) - 1LL;
if (a < 0) a += MOD;
a = (a * 2LL) % MOD;
long long ans = (k * a) % MOD;
long long trem = free - rem * (k - 1);
ans = (ans + trem) % MOD;
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int MOD = 998244353;
int main() {
int w, h;
scanf("%d%d", &w, &h);
int res = 4;
for (int i = (1); i < (w); ++i) res = res * 2 % MOD;
for (int i = (1); i < (h); ++i) res = res * 2 % MOD;
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int checkVowel(char s) {
string v = "aeiou";
for (int i = 0; i < 5; i++) {
if (s == v[i]) {
return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
if (n != m) {
cout << "No" << endl;
} else {
for (int i = 0; i < n; ++i) {
int x = checkVowel(s[i]);
int y = checkVowel(t[i]);
if (x != y) {
cout << "No" << endl;
return 0;
break;
}
}
cout << "Yes" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
long long n, m, dx, dy;
int x[N];
int ans[N];
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &m, &dx, &dy);
for (int i = 0; i < n; ++i) {
x[(dy * i) % n] = (dx * i) % n;
}
for (int i = 0; i < m; ++i) {
int tx, ty;
scanf("%d%d", &tx, &ty);
tx = (tx - x[ty] + n) % n;
++ans[tx];
}
int bst = 0;
int bstX = 0;
for (int i = 0; i < n; ++i) {
if (ans[i] > bst) {
bst = ans[i];
bstX = i;
}
}
printf("%d %d\n", bstX, 0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
void read(Tp &x) {
x = 0;
int fh = 1;
char ch = 1;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= fh;
}
const int maxn = 100000 + 7;
const int maxm = 200000 + 7;
const int INF = 0x3f3f3f3f;
int n, m, d, dp[maxn], dp2[maxn];
bool mark[maxn];
int Head[maxn], Next[maxm], to[maxm], tot;
void addedge(int x, int y) {
to[++tot] = y, Next[tot] = Head[x], Head[x] = tot;
}
void add(int x, int y) {
addedge(x, y);
addedge(y, x);
}
void Init(void) {
read(n);
read(m);
read(d);
for (int i = 1, x; i <= m; i++) {
read(x);
mark[x] = true;
}
for (int i = 1, x, y; i < n; i++) {
read(x);
read(y);
add(x, y);
}
}
void dfs(int x, int fa) {
dp[x] = dp2[x] = INF;
for (int i = Head[x]; i; i = Next[i]) {
int y = to[i];
if (y == fa) continue;
dfs(y, x);
if (dp[y] != INF) {
if (dp[x] == INF)
dp[x] = dp[y] + 1;
else {
if (dp[y] + 1 > dp[x]) {
dp2[x] = dp[x];
dp[x] = dp[y] + 1;
} else if (dp2[x] == INF)
dp2[x] = dp[y] + 1;
else
dp2[x] = max(dp2[x], dp[y] + 1);
}
}
}
if (dp[x] == INF)
if (mark[x]) dp[x] = 0;
}
int ans;
void dfs2(int x, int fa, int mov) {
if (mov == INF && mark[fa]) mov = 1;
if ((dp[x] <= d || dp[x] == INF) && (mov <= d || mov == INF)) {
++ans;
}
for (int i = Head[x]; i; i = Next[i]) {
int y = to[i];
if (y == fa) continue;
if (dp[x] == dp[y] + 1) {
if (mov == INF && dp2[x] != INF)
dfs2(y, x, dp2[x] + 1);
else if (mov != INF && dp2[x] == INF)
dfs2(y, x, mov + 1);
else if (mov == INF && dp2[x] == INF)
dfs2(y, x, INF);
else
dfs2(y, x, max(dp2[x], mov) + 1);
} else {
if (mov == INF && dp[x] != INF)
dfs2(y, x, dp[x] + 1);
else if (mov != INF && dp[x] == INF)
dfs2(y, x, mov + 1);
else if (mov == INF && dp[x] == INF)
dfs2(y, x, INF);
else
dfs2(y, x, max(dp[x], mov) + 1);
}
}
}
void Work(void) {
dfs(1, 0);
dfs2(1, 0, INF);
printf("%d\n", ans);
}
int main(void) {
Init();
Work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, pair<int, int> > m;
unordered_map<string, int> city;
int n;
string s[1000][2];
string res[1000];
bool visited[1000];
bool possible(string t) {
if (m.find(t) == m.end())
return true;
else if (m[t].second == false)
return false;
int i = m[t].first;
if (visited[i]) return false;
visited[i] = true;
if (t == s[i][0].substr(0, 3)) {
string temp = s[i][0].substr(0, 2);
temp += s[i][1][0];
if (possible(temp)) {
m.erase(t);
m[temp] = make_pair(i, 0);
res[i] = temp;
return true;
}
}
return false;
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> s[i][0] >> s[i][1];
city[s[i][0].substr(0, 3)]++;
}
memset(visited, false, sizeof(visited));
memset(visited, false, sizeof(visited));
for (long long i = 0; i < n; i++) {
string t = s[i][0].substr(0, 3);
if (city[t] <= 1 && possible(t)) {
m[t] = make_pair(i, 1);
res[i] = t;
continue;
} else {
t = s[i][0].substr(0, 2);
t += s[i][1][0];
if (possible(t)) {
m[t] = make_pair(i, 0);
res[i] = t;
continue;
}
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (long long i = 0; i < n; i++) cout << res[i] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void search(int n) {
int i = sqrt(n);
set<int> s = {0};
int mid;
while (i >= 1) {
if (s.count(n / i) == 0) {
s.insert(n / i);
}
if (s.count(i) == 0) {
s.insert(i);
}
mid = i / 2;
if (mid == 0) break;
if (n / mid == n / i + 1) {
i = mid - 1;
if (s.count(n / mid) == 0) {
s.insert(n / mid);
}
} else
i--;
}
cout << s.size() << "\n";
for (auto it = s.begin(); it != s.end(); ++it) cout << *it << " ";
cout << "\n";
return;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
search(n);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
using LL = long long;
void solve() {
int n;
cin >> n;
cout << 2 << endl;
for (LL i = 2; i <= n; ++i) {
cout << i * i * i + 2 * i * i + 1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
int s[105][105];
string p[105];
int n, m;
vector<pair<long long, long long> > a, b;
void fun(int x, int y) {
a.clear();
b.clear();
if (s[x][y] == 0)
a.push_back({x, y});
else
b.push_back({x, y});
if (s[x][y + 1] == 0)
a.push_back({x, y + 1});
else
b.push_back({x, y + 1});
if (s[x + 1][y] == 0)
a.push_back({x + 1, y});
else
b.push_back({x + 1, y});
if (s[x + 1][y + 1] == 0)
a.push_back({x + 1, y + 1});
else
b.push_back({x + 1, y + 1});
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, tt = 1;
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 0; i < (n); i++) cin >> p[i];
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) s[i][j] = p[i][j] - '0';
vector<pair<long long, long long> > v;
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 0) continue;
if (j + 1 < m) {
v.push_back({i, j});
s[i][j] ^= 1;
v.push_back({i + 1, j});
s[i + 1][j] ^= 1;
v.push_back({i + 1, j + 1});
s[i + 1][j + 1] ^= 1;
} else {
v.push_back({i, j});
s[i][j] ^= 1;
v.push_back({i + 1, j});
s[i + 1][j] ^= 1;
v.push_back({i + 1, j - 1});
s[i + 1][j - 1] ^= 1;
}
}
}
int i = n - 2;
for (int j = 0; j < m - 2; j++) {
if (s[i][j] == 0 && s[i + 1][j] == 0) continue;
if (s[i][j] == 1 && s[i + 1][j] == 1) {
v.push_back({i, j});
s[i][j] ^= 1;
v.push_back({i + 1, j});
s[i + 1][j] ^= 1;
v.push_back({i + 1, j + 1});
s[i + 1][j + 1] ^= 1;
} else if (s[i][j] == 1) {
v.push_back({i, j});
s[i][j] ^= 1;
v.push_back({i, j + 1});
s[i][j + 1] ^= 1;
v.push_back({i + 1, j + 1});
s[i + 1][j + 1] ^= 1;
} else if (s[i + 1][j] == 1) {
v.push_back({i + 1, j});
s[i + 1][j] ^= 1;
v.push_back({i, j + 1});
s[i][j + 1] ^= 1;
v.push_back({i + 1, j + 1});
s[i + 1][j + 1] ^= 1;
}
}
for (int i = n - 2; i < n; i++)
for (int j = m - 2; j < m; j++) {
if (i + 1 < n && j + 1 < m) {
fun(i, j);
if (a.size() == 4) continue;
if (b.size() == 4) {
int cnt = 0;
for (auto x : b) {
v.push_back(x);
s[x.first][x.second] ^= 1;
cnt++;
if (cnt == 3) break;
}
j--;
} else if (a.size() == 3) {
int cnt = 0;
for (auto x : a) {
v.push_back(x);
s[x.first][x.second] ^= 1;
cnt++;
if (cnt == 2) break;
}
for (auto x : b) {
v.push_back(x);
s[x.first][x.second] ^= 1;
break;
}
j--;
} else if (b.size() == 3) {
for (auto x : b) {
v.push_back(x);
s[x.first][x.second] ^= 1;
}
} else {
for (auto x : a) {
v.push_back(x);
s[x.first][x.second] ^= 1;
}
for (auto x : b) {
v.push_back(x);
s[x.first][x.second] ^= 1;
break;
}
j--;
}
}
}
int sz = v.size();
if (sz / 3 <= n * m) {
cout << sz / 3 << endl;
for (int i = 0; i < sz; i += 3) {
cout << v[i].first + 1 << " " << v[i].second + 1 << " ";
cout << v[i + 1].first + 1 << " " << v[i + 1].second + 1 << " ";
cout << v[i + 2].first + 1 << " " << v[i + 2].second + 1 << endl;
}
} else {
cout << "sz"
<< " -> " << sz << endl;
;
cout << "\"FUCk\""
<< " -> "
<< "FUCk" << endl;
;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
int x, y, l, r;
l = r = 0;
while (T--) {
cin >> x >> y;
if (x < 0) l++;
if (x > 0) r++;
}
if (l <= 1 || r <= 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int same(int a, int x) {
int cnt[10] = {0}, cnt2[10] = {0};
while (a) {
cnt[a % 10]++;
a /= 10;
}
while (x) {
cnt2[x % 10]++;
x /= 10;
}
for (int i = 0; i < 10; i++)
if (cnt[i] > 0 && cnt2[i] > 0) return 1;
return 0;
}
int main() {
int x;
scanf("%d", &x);
int cnt = 0;
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) {
int a = i, b = x / i;
if (same(a, x)) cnt++;
if (a != b)
if (same(b, x)) cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, q, lca_record[14][14];
long long dp[14][8192 + 3];
pair<int, int> edge[14];
bool check(int root, int root1, int mask1, int mask2) {
for (int i = 1; i <= m; ++i) {
int ui = edge[i].first, vi = edge[i].second;
if ((ui == root && vi == root1) || (ui == root1 && vi == root)) continue;
if ((mask1 >> (ui - 1)) & 1)
if ((mask2 >> (vi - 1)) & 1) return 0;
swap(ui, vi);
if ((mask1 >> (ui - 1)) & 1)
if ((mask2 >> (vi - 1)) & 1) return 0;
}
int mask = mask1 | mask2;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (lca_record[i][j]) {
if (((mask1 >> (i - 1)) & 1) && ((mask2 >> (j - 1)) & 1)) {
if (lca_record[i][j] != root) {
return 0;
}
}
swap(i, j);
if (((mask1 >> (i - 1)) & 1) && ((mask2 >> (j - 1)) & 1)) {
if (lca_record[i][j] != root) return 0;
}
swap(i, j);
}
mask -= (1 << (root - 1));
while (mask) {
if (mask & 1) {
if (mask2 & 1) {
return 1;
} else
return 0;
}
if (mask2 & 1) return 0;
mask2 >>= 1;
mask >>= 1;
}
return 1;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
int ui, vi;
scanf("%d %d", &ui, &vi);
edge[i] = make_pair(ui, vi);
}
for (int i = 0; i < q; ++i) {
int ui, vi, a;
scanf("%d %d %d", &ui, &vi, &a);
if (ui == vi && ui != a) {
puts("0");
return 0;
}
if (lca_record[ui][vi]) {
if (lca_record[ui][vi] != a) {
puts("0");
return 0;
}
continue;
}
lca_record[ui][vi] = lca_record[vi][ui] = a;
}
for (int i = 1; i <= n; ++i) dp[i][1 << (i - 1)] = 1;
for (int mask = 1; mask <= (1 << (n)) - 1; ++mask) {
if ((mask - 1) & mask) {
for (int s = mask; s; s = (s - 1) & mask) {
if (s == mask) continue;
int s2 = mask xor s;
for (int r1 = 1; r1 <= n; ++r1)
if ((s >> (r1 - 1)) & 1)
;
else
for (int r2 = 1; r2 <= n; ++r2)
if (((s2 >> (r1 - 1)) & 1) && ((s >> (r2 - 1)) & 1)) {
if (check(r1, r2, s2, s)) {
dp[r1][mask] += dp[r2][s] * dp[r1][s2];
}
}
}
}
}
cout << dp[1][(1 << n) - 1] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
int main() {
int n;
cin >> n;
vector<int> v(n), p(n);
vector<vector<int> > neighbours(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
if (i + v[i] < n) {
neighbours[i].push_back(i + v[i]);
neighbours[i + v[i]].push_back(i);
}
if (i - v[i] >= 0) {
neighbours[i].push_back(i - v[i]);
neighbours[i - v[i]].push_back(i);
}
}
vector<int> vis(n, -1);
queue<int> toProcess;
int idx = 0;
int cur;
for (int i = 0; i < n; i++) {
if (vis[i] == -1) {
toProcess.push(i);
vis[i] = idx;
while (!toProcess.empty()) {
cur = toProcess.front();
toProcess.pop();
for (int j = 0; j < neighbours[cur].size(); j++) {
if (vis[neighbours[cur][j]] == -1) {
vis[neighbours[cur][j]] = idx;
toProcess.push(neighbours[cur][j]);
}
}
}
idx++;
}
}
for (int i = 0; i < n; i++) {
if (vis[i] != vis[p[i] - 1]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v1, v2, t, d, ans = 0;
cin >> v1 >> v2 >> t >> d;
for (int i = 1; i <= t; i++) {
ans += min(v1 + (i - 1) * d, v2 + (t - i) * d);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int tot, cnt;
int fir[N], dep[N], col[N], h[N];
struct edge {
int to;
int nxt;
} e[2 * N];
inline void add(int x, int y) {
e[++tot].to = y;
e[tot].nxt = fir[x];
fir[x] = tot;
e[++tot].to = x;
e[tot].nxt = fir[y];
fir[y] = tot;
}
inline void dfs(int p, int fa) {
dep[p] = dep[fa] + 1;
for (int i = fir[p]; i; i = e[i].nxt)
if (e[i].to != fa) dfs(e[i].to, p);
col[p] = cnt, h[cnt] = max(h[cnt], dep[p]);
}
struct tree {
int val[4 * N];
inline void pushdown(int p) {
if (val[p]) {
val[p * 2] += val[p];
val[p * 2 + 1] += val[p];
val[p] = 0;
}
}
inline void change(int p, int left, int right, int l, int r, int c) {
if (l > r) return;
if (l <= left && r >= right) {
val[p] += c;
return;
}
pushdown(p);
int mid = (left + right) / 2;
if (l <= mid) change(p * 2, left, mid, l, r, c);
if (r > mid) change(p * 2 + 1, mid + 1, right, l, r, c);
}
inline int query(int p, int left, int right, int pos) {
if (left == right) return val[p];
pushdown(p);
int mid = (left + right) / 2;
if (pos <= mid)
return query(p * 2, left, mid, pos);
else
return query(p * 2 + 1, mid + 1, right, pos);
}
} t1, t2;
int main() {
int n, m, opt, a, b, c, maxn = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b);
}
for (int i = fir[1]; i; i = e[i].nxt) {
int q = e[i].to;
cnt++, dfs(q, 1);
maxn = max(maxn, h[cnt]);
}
n = cnt * maxn + 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &opt, &a);
if (opt) {
if (a == 1) {
printf("%d\n", t1.query(1, 1, n, 1) + t2.query(1, 1, n, 1));
continue;
}
int id1 = 1 + (col[a] - 1) * maxn + dep[a];
int id2 = 1 + (dep[a] - 1) * cnt + col[a];
printf("%d\n", t1.query(1, 1, n, id1) + t2.query(1, 1, n, id2));
} else {
scanf("%d%d", &c, &b);
if (a == 1) {
t2.change(1, 1, n, 1, min(1 + b * cnt, n), c);
continue;
}
int id1 = 1 + (col[a] - 1) * maxn + dep[a];
int id2 = 1 + (col[a] - 1) * maxn + (b - dep[a]);
int len = 1 + col[a] * maxn;
if (dep[a] > b)
t1.change(1, 1, n, id1 - b, min(id1 + b, len), c);
else {
t1.change(1, 1, n, id2 + 1, min(id1 + b, len), c);
t2.change(1, 1, n, 1, min(1 + (b - dep[a]) * cnt, n), c);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005, P = 998244353;
using ll = long long;
namespace Poly {
int rev[N], lim, d;
ll wn[N + 1], inv[N];
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % P;
a = a * a % P;
b >>= 1;
}
return ret;
}
void init(int n) {
inv[1] = 1;
for (int i = 2; i <= n; i++) inv[i] = ll(P - P / i) * inv[P % i] % P;
}
void FFTinit(int n) {
int lst = lim;
wn[0] = lim = 1;
d = 0;
while (lim < n) lim <<= 1, ++d;
if (lim == lst) return;
for (int i = 0; i < lim; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (d - 1));
int g = qpow(3, (P - 1) / lim);
for (int i = 1; i <= lim; i++) wn[i] = wn[i - 1] * g % P;
}
void FFT(int a[], int fl) {
for (int i = 0; i < lim; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int s = 1; s < lim; s <<= 1) {
int wnp = lim / s / 2;
for (int i = 0; i < lim; i += s * 2)
for (int j = 0; j < s; j++) {
int x = a[i + j],
y = a[i + j + s] * wn[fl == 1 ? wnp * j : lim - wnp * j] % P;
a[i + j] = (x + y) % P;
a[i + j + s] = (x + P - y) % P;
}
}
if (fl == -1)
for (int i = 0; i < lim; i++) a[i] = a[i] * inv[lim] % P;
}
template <typename T>
inline void clearArr(T a[], int cnt) {
memset(a, 0, sizeof(T) * cnt);
}
using Poly = int[N];
void Add(Poly a, Poly b, int n, int m, Poly c) {
clearArr(c, max(n, m));
for (int i = 0; i < n; i++) c[i] = a[i];
for (int i = 0; i < m; i++) c[i] = (c[i] + b[i]) % P;
}
void Mul(Poly a, Poly b, int n, int m, Poly c) {
FFTinit(n + m - 1);
static int ta[N], tb[N];
for (int i = 0; i < n; i++) ta[i] = a[i];
for (int i = 0; i < m; i++) tb[i] = b[i];
clearArr(ta + n, lim - n);
FFT(ta, 1);
clearArr(tb + m, lim - m);
FFT(tb, 1);
for (int i = 0; i < lim; i++) ta[i] = ll(ta[i]) * tb[i] % P;
FFT(ta, -1);
for (int i = 0; i < n + m - 1; i++) c[i] = ta[i];
}
void Dev(Poly a, int n, Poly b) {
b[n - 1] = 0;
for (int i = 1; i < n; i++) b[i - 1] = ll(a[i]) * i % P;
}
void Inte(Poly a, int n, Poly b) {
b[0] = 0;
for (int i = 1; i < n; i++) b[i] = ll(a[i - 1]) * inv[i] % P;
}
void Inv(Poly a, int n, Poly b) {
if (n == 1) {
b[0] = qpow(a[0], P - 2);
return;
}
Inv(a, (n + 1) / 2, b);
static int ta[N];
FFTinit(n * 2);
clearArr(b + (n + 1) / 2, lim - (n + 1) / 2);
for (int i = 0; i < n; i++) ta[i] = a[i];
clearArr(ta + n, lim - n);
FFT(ta, 1);
FFT(b, 1);
for (int i = 0; i < lim; i++)
b[i] = b[i] * (P + 2 - ta[i] * 1ll * b[i] % P) % P;
FFT(b, -1);
}
inline void Ln(Poly a, int n, Poly b) {
static int ta[N], tb[N];
Dev(a, n, ta);
Inv(a, n, tb);
Mul(ta, tb, n, n, ta);
Inte(ta, n, b);
}
void Exp(Poly a, int n, Poly b) {
if (n == 1) {
b[0] = 1;
return;
}
Exp(a, (n + 1) / 2, b);
static int ta[N], tb[N];
clearArr(b + (n + 1) / 2, n - (n + 1) / 2);
Ln(b, n, tb);
FFTinit(n * 2);
for (int i = 0; i < n; i++) ta[i] = a[i];
clearArr(ta + n, lim - n);
clearArr(b + n, lim - n);
clearArr(tb + n, lim - n);
FFT(ta, 1);
FFT(tb, 1);
FFT(b, 1);
for (int i = 0; i < lim; i++) b[i] = b[i] * (P + 1ll - tb[i] + ta[i]) % P;
FFT(b, -1);
}
void Pow(Poly a, int n, int kk, Poly b) {
static int tmp[N];
Ln(a, n, tmp);
for (int i = 0; i < n; i++) tmp[i] = ll(tmp[i]) * kk % P;
Exp(tmp, n, b);
}
inline void Sqrt(Poly a, int n, Poly b) { Pow(a, n, inv[2], b); }
} // namespace Poly
int n, m;
Poly::Poly f, g, h;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
++m;
Poly::init(N - 1);
int t1;
for (int i = 1; i <= n; i++) cin >> t1, g[t1] = 1;
for (int i = 0; i < m; i++) g[i] *= 4, g[i] = -g[i];
++g[0];
Poly::Sqrt(g, m, h);
++h[0];
Poly::Inv(h, m, f);
for (int i = 1; i < m; i++) f[i] = f[i] * 2 % P, cout << f[i] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long INF = 1e9 + 228;
const long long MAXN = 3500 + 228;
long long a[MAXN];
signed main() {
fast_io();
long long t;
cin >> t;
for (long long test = 0; test < t; test++) {
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
k = min(k, m - 1);
long long dist = n - m;
long long ans = 0;
for (long long pref = 0; pref <= k; pref++) {
long long ans_cur = INF;
for (long long i = pref; i + dist < n - (k - pref); i++) {
ans_cur = min(ans_cur, max(a[i], a[i + dist]));
}
ans = max(ans, ans_cur);
}
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1505;
const long double EPS = 1e-6;
inline int sgn(double x) { return std::fabs(x) < EPS ? 0 : (x > 0 ? 1 : -1); }
struct point {
double x, y;
int id;
point() {}
point(double x, double y) : x(x), y(y) { id = 0; }
inline point operator-(const point &t) { return point(x - t.x, y - t.y); }
inline double operator*(const point &t) const { return x * t.y - y * t.x; }
inline bool operator<(const point &t) const {
return !sgn(x - t.x) ? y < t.y : x < t.x;
}
inline bool operator==(const point &t) const {
return !sgn(x - t.x) && !sgn(y - t.y);
}
inline double len() { return std::sqrt(x * x + y * y); }
inline void print() { printf("%f %f\n", x, y); }
} P[MAX_N], PP;
bool comp(point a, point b) {
return !sgn((a - PP) * (b - PP)) ? ((a - PP).len() < (b - PP).len())
: (a - PP) * (b - PP) > 0;
}
vector<int> g[MAX_N];
int n;
int ans[MAX_N];
int siz[MAX_N];
void dfs(int v, int last) {
siz[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == last) continue;
dfs(u, v);
siz[v] += siz[u];
}
}
int idx;
inline void DFS(int v, int last, int l, int r) {
std::sort(P + l, P + r + 1);
PP = P[l];
std::sort(P + l + 1, P + r + 1, comp);
ans[P[l].id] = v;
int t = l + 1;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == last) continue;
DFS(u, v, t, t + siz[u] - 1);
t += siz[u];
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
cin >> P[i].x >> P[i].y;
P[i].id = i;
}
dfs(1, 0);
DFS(1, 0, 1, n);
for (int i = 1; i <= n; i++) cout << ans[i] << " \n"[i == n];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long x, y;
long long fast(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % 1000000007;
x = x * x % 1000000007;
y >>= 1;
}
return ans;
}
int main() {
cin >> n;
long long a = 1, b = 1;
for (int i = n + 1; i < 2 * n; i++) a = a * i % 1000000007;
for (int i = 2; i <= n - 1; i++) b = b * i % 1000000007;
long long k = fast(b, 1000000007 - 2);
cout << (a * 2 * k - n + 1000000007) % 1000000007;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dx4[4] = {0, 1, 0, -1};
long long dy4[4] = {1, 0, -1, 0};
long long dy8[8] = {1, 1, 1, 0, -1, -1, -1, 0};
long long dx8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
long long n, m;
bool check(long long x, long long y) {
return (x >= 0 && x < n && y >= 0 && y < m);
}
bool vis[57][57];
char grid[57][57];
bool cycle(long long x, long long y, long long px, long long py) {
vis[x][y] = true;
for (long long i = 0; i < 4; i++) {
long long nx = x + dx4[i];
long long ny = y + dy4[i];
if (check(nx, ny) == false) continue;
if (grid[nx][ny] != grid[x][y]) continue;
if (vis[nx][ny] == false) {
if (cycle(nx, ny, x, y)) return true;
} else if (nx != px || ny != py)
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> grid[i][j];
vis[i][j] = false;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vis[i][j] == false) {
if (cycle(i, j, -1, -1)) {
cout << "Yes";
return 0;
}
}
}
}
cout << "No";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string str;
cin >> n >> str;
unordered_map<char, int> mp;
for (auto& a : str) mp[::tolower(a)]++;
if (mp.size() == 26)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long t;
cin >> t;
while (t--) {
long n;
cin >> n;
long a[n];
for (int i = 0; i < (n); i++) cin >> a[i];
vector<vector<long>> sum(201, vector<long>(n + 1, 0));
vector<vector<long>> pos(201);
for (int i = 0; i < (n); i++) {
for (int j = 1; j <= 200; j++) sum[j][i + 1] = sum[j][i];
sum[a[i]][i + 1]++;
pos[a[i]].push_back(i);
}
long ans = 0;
for (int i = 1; i <= 200; i++) {
ans = max(ans, (long)pos[i].size());
for (int k = 0; k < ((long)(pos[i].size()) / 2); k++) {
int l = pos[i][k] + 1;
int r = pos[i][(long)pos[i].size() - k - 1] - 1;
long maxfreq = 0;
for (int j = 1; j <= 200; j++) {
long val = sum[j][r + 1] - sum[j][l];
ans = max(ans, val + 2 * (k + 1));
}
}
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double esp = 0.00000001;
long long int ar[100005];
int main() {
long long int n;
cin >> n;
ar[0] = 0;
ar[1] = 0;
ar[2] = 0;
for (int i = 3; i <= n; i++) {
set<long long int> grundy;
for (long long int j = 2;; j++) {
long long int temp = j * (j + 1) / 2;
temp = i - temp;
if (temp < 0) break;
if (temp % j) continue;
temp = temp / j;
long long int val = ar[temp + j] ^ ar[temp];
if (val == 0 && i == n) {
cout << j << endl;
return 0;
}
grundy.insert(val);
}
long long int ret = 0;
for (set<long long int>::iterator it = grundy.begin(); it != grundy.end();
it++) {
if (*it != ret) break;
ret++;
}
ar[i] = ar[i - 1] ^ ret;
}
cout << "-1\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<vector<long long>>> cc;
vector<vector<long long>> matrix_multiply(vector<vector<long long>> a,
vector<vector<long long>> b) {
long long x = a.size(), y = a[0].size(), z = b[0].size(), i, j, k;
vector<vector<long long>> ans(x, vector<long long>(z, 0));
for (i = 0; i < x; i++) {
for (j = 0; j < z; j++)
for (k = 0; k < y; k++)
ans[i][j] = (ans[i][j] + a[i][k] * b[k][j]) % 1000000007;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, b, k, x, d, i, j, MAXLEVEL = 40, ans;
cin >> n >> b >> k >> x;
vector<long long> ct(10, 0);
for (i = 0; i < n; i++) {
cin >> d;
ct[d]++;
}
vector<vector<long long>> a(1, vector<long long>(x, 0)),
transfer(x, vector<long long>(x, 0)), xx;
for (i = 0; i < x; i++) {
for (j = 1; j <= 9; j++) {
transfer[i][(i * 10 + j) % x] =
(transfer[i][(i * 10 + j) % x] + ct[j]) % 1000000007;
}
}
a[0][0] = 1;
xx = transfer;
for (i = 0; i < MAXLEVEL; i++) {
if ((1LL << i) & b) a = matrix_multiply(a, xx);
xx = matrix_multiply(xx, xx);
}
ans = a[0][k];
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long Inf = 1ll << 60ll;
namespace io {
char buf[(1 << 23)], *p1 = buf, *p2 = buf, c;
int f;
template <typename T>
T read() {
T x = 0;
f = 0;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(c))
(c == '-') && (f = 1),
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin),
p1 == p2)
? EOF
: *p1++);
while (isdigit(c))
x = x * 10 + (c & 15),
c = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin), p1 == p2)
? EOF
: *p1++);
return f ? -x : x;
}
} // namespace io
int n, m, nxt[1000005], ban[1000005];
int main() {
scanf("%d%d", &n, &m);
char s[n + 5][m + 5];
bool a[n + 5][m + 5];
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; ++i)
if (s[i][1] == '.') a[i][1] = 1;
for (int i = 1; i <= m; ++i)
if (s[1][i] == '.') a[1][i] = 1;
for (int i = 2; i <= n; ++i) {
for (int j = 2; j <= m; ++j) {
if (s[i][j] == 'X') continue;
a[i][j] = 1;
}
}
for (int i = 2; i <= n; ++i) {
for (int j = 2; j <= m; ++j) {
if (!a[i - 1][j] && !a[i][j - 1]) ban[j] = 1;
}
}
int cur = m + 1;
nxt[m + 1] = inf;
for (int i = m; i; --i) {
if (ban[i]) cur = i;
nxt[i] = cur;
}
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x + 1 <= y && nxt[x + 1] <= y)
puts("NO");
else
puts("YES");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int N = 1e6 + 10;
const int M = 1e5 + 10;
const int mod = 1e9 + 7;
struct node {
int a, b;
bool operator<(const node &t) const { return b > t.b; }
};
long long ksm_mod(long long a, long long p) {
long long ans = 1;
while (p) {
if (p & 1) {
ans = ans * a % mod;
}
a = a * a % mod;
p >>= 1;
}
return ans;
}
long long ksm(long long a, long long b) {
long long ans = 1, base = a;
while (b) {
if (b & 1) ans *= base;
base *= base;
b >>= 1;
}
return ans;
}
char a[100001], b[100001], c[100001];
void solve() {
while (cin >> a >> b) {
int len = strlen(a);
for (int i = 0; i < len; i++) {
if (a[i] != b[i])
c[i] = '1';
else if (a[i] == b[i])
c[i] = '0';
}
for (int i = 0; i < len; i++) cout << c[i];
}
}
signed main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100100;
long long a[N];
int main() {
long long n, A, B;
cin >> n >> A >> B;
long long Sum = 0;
for (long long i = 0; i < n; i++) scanf("%I64d", a + i), Sum += a[i];
sort(a + 1, a + n, greater<long long>());
long long Ans = 1;
while (A * a[0] < Sum * B) Sum -= a[Ans++];
cout << Ans - 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long ans = 0;
unordered_map<int, int> m1;
unordered_map<int, int> m2;
while (n--) {
int x, y;
cin >> x >> y;
m1[x - y]++;
m2[x + y]++;
}
for (auto it = m1.begin(); it != m1.end(); it++) {
int x = it->second;
ans += (x * (x - 1)) / 2;
}
for (auto it = m2.begin(); it != m2.end(); it++) {
int x = it->second;
ans += (x * (x - 1)) / 2;
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline void read(_T &_x) {
int _t, _flag = 0;
while ((_t = getchar()) != '-' && (_t < '0' || _t > '9'))
;
if (_t == '-') _flag = 1, _t = getchar();
_x = _t - '0';
while ((_t = getchar()) >= '0' && _t <= '9') _x = _x * 10 + _t - '0';
if (_flag) _x = -_x;
}
const int MAX_N = 2000 + 10;
const long long MOD = 1e9 + 7;
;
int n, d;
struct Edge {
int v, next;
Edge() {}
Edge(int _v, int _next) { v = _v, next = _next; }
} edge[MAX_N << 1];
int head[MAX_N], kk = 1, w[MAX_N];
void addedge(int u, int v) {
edge[kk] = Edge(v, head[u]);
head[u] = kk++;
}
void read_data() {
read(d);
read(n);
for (int i = 1; i <= n; ++i) read(w[i]);
for (int i = 1; i < n; ++i) {
int a, b;
read(a);
read(b);
addedge(a, b);
addedge(b, a);
}
}
long long dfs(int now, int fa, int rt) {
long long ret = 1;
for (int i = head[now]; i; i = edge[i].next) {
int v = edge[i].v;
if (v == fa || w[rt] < w[v] || (w[v] == w[rt] && v < rt) ||
w[rt] - w[v] > d)
continue;
ret *= (dfs(v, now, rt) + 1), ret %= MOD;
}
return ret;
}
int main() {
read_data();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += dfs(i, 0, i), ans %= MOD;
}
printf("%I64d\n", ans % MOD);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a, b;
char s[100100];
vector<int> f;
void solve() {
cin >> s;
n = strlen(s);
int l = 0, r = 0, x = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') l++;
if (s[i] == ')') r++;
if (s[i] == '#') x++;
}
int sum = l - r;
if (sum < x) {
cout << -1;
return;
}
int k = sum;
int t = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') l++, f.push_back(1);
if (s[i] == ')') r++, f.push_back(-1);
if (s[i] == '#') {
t++;
if (t < x) {
f.push_back(-1);
k--;
} else {
for (int j = 1; j <= k; j++) f.push_back(-1);
}
}
}
int now = 0;
for (int i = 0; i < f.size(); i++) {
now += f[i];
if (now < 0) {
cout << -1;
return;
}
}
if (now != 0) {
cout << -1;
return;
}
for (int i = 1; i <= x; i++) {
if (i < x) {
cout << 1 << endl;
sum--;
} else
cout << sum << endl;
}
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 100005;
int n;
long long a[N], sum[N];
long long l, r;
long long A, B, C;
long long cal(long long k) {
int i = std::lower_bound(a + 1, a + n + 1, k) - a - 1;
long long begin = i * k - sum[i], end = sum[n] - sum[i] - k * (n - i);
if (end > begin)
return begin * C + (end - begin) * B;
else
return end * C + (begin - end) * A;
}
int main() {
scanf("%d%lld%lld%lld", &n, &A, &B, &C);
C = std::min(C, A + B);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
std::sort(a + 1, a + n + 1);
l = a[1], r = a[n];
for (int i = 1; i <= n + 1; i++) sum[i] = a[i] + sum[i - 1];
while (l + 50 < r) {
long long lmid = (l * 2ll + r) / 3, rmid = (l + r * 2ll) / 3;
if (cal(lmid) < cal(rmid))
r = rmid;
else
l = lmid;
}
for (int i = l; i <= r; i++)
if (cal(i) < cal(l)) l = i;
printf("%lld", cal(l));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double a[100005], ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, p;
cin >> n >> p;
for (long long int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
a[i] = 1.0 - (r / p - (l - 1) / p) * 1.0 / (r - l + 1) * 1.0;
}
for (long long int i = 0; i < n; i++) {
ans += (1.0 - 1.0 * a[i] * a[(i + 1) % n] * 1.0) * 2000.0;
}
cout << fixed << setprecision(12) << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
int x[212345], y[212345], z[212345], lon;
bool ok(int a, int b, int c) {
int na, nb, nc;
if (lon == 2 && a == 2) return true;
na = lon / 3;
nb = lon / 3;
nc = lon / 3;
if (lon % 3 > 0) ++na;
if (lon % 3 > 1) ++nb;
if ((a == na) && (b == nb) && (c == nc)) return true;
return false;
}
int main() {
string s;
getline(cin, s);
for (int i = 0; i < s.length(); ++i) {
if (s[i] == 'x') x[i + 1] = 1;
if (s[i] == 'y') y[i + 1] = 1;
if (s[i] == 'z') z[i + 1] = 1;
x[i + 1] += x[i];
y[i + 1] += y[i];
z[i + 1] += z[i];
}
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int l, r, X, Y, Z;
scanf("%d%d", &l, &r);
X = x[r] - x[l - 1];
Y = y[r] - y[l - 1];
Z = z[r] - z[l - 1];
lon = r - l + 1;
if (ok(X, Z, Y) || ok(Y, X, Z) || ok(Z, Y, X))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
const long long mod = 1e9 + 7;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0', c = getchar();
return x * f;
}
double ans;
struct BIT {
long long tr[N];
long long Bmax;
long long lb(long long x) { return (-x) & x; }
void init(long long n) {
Bmax = n;
for (long long i = 0; i <= n; i++) tr[i] = 0;
}
long long query(long long x) {
if (x <= 0) return 0;
long long res = 0;
while (x) {
res += tr[x];
x -= lb(x);
}
return res;
}
void update(long long x, long long w) {
if (x <= 0) return;
while (x <= Bmax) {
tr[x] += w;
x += lb(x);
}
}
} t1, t2;
int a[N];
int main() {
long long n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) {
ans += (double)1.00 * i * (i - 1) / 4.00 * (n - i + 1);
}
t1.init(n);
t2.init(n);
for (long long i = 1; i <= n; i++) {
long long o1 = t1.query(n) - t1.query(a[i]);
long long o2 = t2.query(n) - t2.query(a[i]);
t1.update(a[i], 1);
t2.update(a[i], i);
ans += (double)(1.00 * n * (n + 1) * o1 * 0.5 - 1.00 * (n - i + 1) * o2);
}
printf("%.10lf", ans / (1.00 * n * (n + 1) / 2));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, b, c, j, k, n, i;
cin >> t;
while (t--) {
string s;
cin >> s;
n = s.size();
k = 0;
j = 0;
c = 0;
for (i = 0; i < n; i++) {
if (s[i] == '+')
c++;
else {
c--;
if ((c + j) < 0) {
k += (i + 1);
j++;
}
}
}
cout << k + n << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using db = double;
int m;
int A[34];
int f[34][64][2000];
int n;
vi a;
char s[64][64];
void win(int x, int y) {
s[x][y] = '1';
s[y][x] = '0';
}
int main() {
cin >> m;
for (int i = 1; i <= m; ++i) cin >> A[i];
sort(A + 1, A + m + 1);
f[0][0][0] = true;
for (int i = 0; i <= m; ++i)
for (int j = i; j <= 61; ++j)
for (int k = 0; k < 2000; ++k)
if (f[i][j][k]) {
if (i > 0 && k + A[i] >= (j + 1) * j / 2 && k + A[i] <= 1830)
f[i][j + 1][k + A[i]] = 1;
if (i + 1 <= m && k + A[i + 1] >= (j + 1) * j / 2 &&
k + A[i + 1] <= 1830)
f[i + 1][j + 1][k + A[i + 1]] = 2;
}
int J = 0;
for (int i = m; i <= 61; ++i)
if (f[m][i][i * (i - 1) / 2]) {
J = i;
break;
}
if (!J) {
puts("=(");
return 0;
}
int I = m;
int K = J * (J - 1) / 2;
while (J) {
a.push_back(A[I]);
if (f[I][J][K] == 1)
K -= A[I];
else
K -= A[I], --I;
--J;
}
n = a.size();
for (int i = 0; i < n; ++i) s[i][i] = '0';
sort(a.begin(), a.end());
vector<pair<int, int>> p;
for (int i = 0; i < n; ++i) p.push_back({a[i], i});
for (int i = n - 1; i > 0; --i) {
for (int j = 0; j < i; ++j)
if (p[i].first)
--p[i].first, win(p[i].second, p[j].second);
else
--p[j].first, win(p[j].second, p[i].second);
sort(p.begin(), p.begin() + i);
}
cout << n << endl;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%c", s[i][j]);
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
namespace RA {
int r(int p) { return 1ll * rand() * rand() % p; }
int r(int L, int R) { return r(R - L + 1) + L; }
} // namespace RA
const int N = 2e6 + 5, M = N;
int n, m;
struct qxx {
int nex, t;
} e[M];
int h[N], le;
void add_path(int f, int t) { e[++le] = {h[f], t}, h[f] = le; }
int use[N], totuse, ban[N], g[N], tag[N];
vector<int> a2;
void dfs(int u) {
assert(use[u] == 0);
int id = ++totuse;
use[u] = id;
a2.push_back(u);
for (int i = h[u]; i; i = e[i].nex) {
int v = e[i].t;
if (!use[v]) use[v] = id;
}
for (int i = h[u]; i; i = e[i].nex) {
int v = e[i].t;
if (use[v] == id && !tag[v]) {
tag[v] = 1;
for (int j = h[v]; j; j = e[j].nex) {
int z = e[j].t;
if (!use[z]) dfs(z);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
add_path(a, b);
}
for (int i = (1); i <= (n); ++i) add_path(n + 1, i);
add_path(n + 2, n + 1);
dfs(n + 2);
reverse(a2.begin(), a2.end());
vector<int> a;
for (auto x : a2) {
if (ban[x]) continue;
if (x <= n) a.push_back(x);
ban[x] = 1;
for (int i = h[x]; i; i = e[i].nex) {
const int v = e[i].t;
ban[v] = 1;
}
}
cout << a.size() << endl;
for (auto x : a) cout << x << " ";
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b, k;
cin >> n >> a >> b >> k;
int r[n];
for (int i = 0; i < n; ++i) {
cin >> r[i];
}
int need[n];
for (int i = 0; i < n; ++i) {
int n1 = r[i] / (a + b);
r[i] %= (a + b);
if (r[i] == 0) {
r[i] += b + a;
}
long long ans = 0;
ans += ((r[i] / a) + min(1, r[i] % a)) - 1;
need[i] = ans;
}
sort(need, need + n);
long long sum = 0;
bool fl = 1;
for (int i = 0; i < n && sum <= k; ++i) {
sum += need[i];
if (sum > k) {
cout << i << endl;
fl = 0;
break;
}
}
if (fl) {
cout << n;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char str[500010];
int main() {
while (~scanf("%d%s", &n, str)) {
if (n <= 3) {
printf("%d\n", n);
continue;
}
int flag = 0, cnt = 0, cou = 0;
for (int i = 0; i < n;) {
int re = i;
while (i < n && str[re] == str[i]) {
i++;
}
cnt++;
if (flag) {
continue;
}
if (i - re > 2) {
cnt += 2;
flag = 1;
} else if (i - re == 2) {
if (cou > 0) {
cnt += 2;
flag = 1;
}
cou = 2;
}
}
if (!flag && cou) {
cnt++;
}
printf("%d\n", cnt);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC target("avx,tune=native")
using namespace std;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-6;
const long long mod = 1000000007;
inline string getstr(string &s, long long l, long long r) {
string ret = "";
for (long long i = l; i <= r; i++) ret.push_back(s[i]);
return ret;
}
long long modpow(long long x, long long y, long long md = mod) {
if (y == 0) return 1;
long long ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
long long n, color[5005], sz[5005], par[5005], dep[5005];
vector<pair<long long, long long> > g[5005];
void dfs(long long x, long long p, long long d, long long col) {
par[x] = p;
sz[x] = 1;
color[x] = col;
dep[x] = d;
for (long long i = 0; i < g[x].size(); i++) {
long long to = g[x][i].first, co = g[x][i].second;
if (to != p) {
dfs(to, x, d + co, col);
sz[x] += sz[to];
}
}
}
long long Min[2];
bool debug = false;
void dfs2(long long x, long long p, long long size_all, long long delta) {
Min[color[x]] = min(Min[color[x]], delta);
for (long long i = 0; i < g[x].size(); i++) {
long long to = g[x][i].first, co = g[x][i].second;
if (to != p) {
dfs2(to, x, size_all, delta - (2 * sz[to] - size_all) * g[x][i].second);
}
}
}
long long solve(long long x, long long y, long long v) {
dfs(x, y, 0, 1);
dfs(y, x, 0, 0);
long long ans = v * sz[x] * sz[y];
for (long long i = 1; i <= n; i++)
if (i != x && i != y) {
ans +=
(dep[i] - dep[par[i]]) * sz[i] * ((color[i] ? sz[x] : sz[y]) - sz[i]);
}
memset(Min, 0x3f3f3f3f3f3f3f3f, sizeof Min);
long long sum = 0;
for (long long i = 1; i <= n; i++) {
if (color[i] == 1) {
sum += dep[i];
}
}
dfs2(x, y, sz[x], sum);
sum = 0;
for (long long i = 1; i <= n; i++) {
if (color[i] == 0) {
sum += dep[i];
}
}
dfs2(y, x, sz[y], sum);
ans += Min[0] * sz[x] + Min[1] * sz[y];
return ans;
}
signed main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
g[x].push_back(make_pair(y, z));
g[y].push_back(make_pair(x, z));
}
long long ans = 1e18;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < g[i].size(); j++) {
long long x = i, y = g[i][j].first;
if (x < y) ans = min(ans, solve(x, y, g[i][j].second));
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct aa {
int x, y;
bool operator<(const aa &b) { return x < b.x; }
};
bool cmp(int a, int b) { return a > b; }
int bsearch(int *a, int n, int k);
int main() {
int n, a[1000], ma = 0, mi = INT_MAX;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
ma = max(ma, a[i] - a[i - 1]);
}
for (int i = 2; i < n; i++) {
mi = min(mi, a[i] - a[i - 2]);
}
cout << max(ma, mi);
return 0;
}
int bsearch(int *a, int n, int k) {
int l = 0, h = n;
while (l < h) {
int m = (l + h) / 2;
if (a[m] == k)
return m;
else if (a[m] > k)
h = m;
else
l = m + 1;
}
return l;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.